bam_hdr_t * setup_test_4(merged_header_t *merged_hdr) {
    const char* t4_init_text =
        "@HD\tVN:1.4\tSO:unknown\n"
        "@SQ\tSN:fish\tLN:133\tSP:frog\n"
        "@RG\tID:fish\tPU:out\n";

    return setup_test(t4_init_text, init_refs, NELE(init_refs),
                      test_4_trans_text, test_4_refs, NELE(test_4_refs),
                      merged_hdr);
}
bam_hdr_t * setup_test_5(merged_header_t *merged_hdr) {
    const char* t5_init_text =
        "@HD\tVN:1.4\tSO:unknown\n"
        "@SQ\tSN:fish\tLN:133\tSP:frog\n"
        "@RG\tID:fish\tPU:out\n"
        "@PG\tXX:dummyx\tID:fish\tDS:out\n"
        "@PG\tPP:fish\tID:hook\tDS:out\n";

    return setup_test(t5_init_text, init_refs, NELE(init_refs),
                      test_5_trans_text, test_5_refs, NELE(test_5_refs),
                      merged_hdr);
}
예제 #3
0
파일: hts_endian.c 프로젝트: atks/vt
int t_double(int verbose) {
    uint8_t buf[9];
    size_t i;
    int errors = 0;

    for (i = 0; i < NELE(tests_double); i++) {
        double f;

        if (verbose) {
            fprintf(stderr, "%s %.15g\n",
                    to_hex(tests_double[i].u8, 8), tests_double[i].d);
        }

        f = le_to_double(tests_double[i].u8);
        if (f != tests_double[i].d) {
            fprintf(stderr, "Failed %s => %.15g; expected %.15g\n",
                    to_hex(tests_double[i].u8, 8), f, tests_double[i].d);
            errors++;
        }

        f = le_to_double(tests_double[i].u8_unaligned + 1);
        if (f != tests_double[i].d) {
            fprintf(stderr, "Failed unaligned %s => %.15g; expected %.15g\n",
                    to_hex(tests_double[i].u8_unaligned + 1, 8),
                    f, tests_double[i].d);
            errors++;
        }

        double_to_le(tests_double[i].d, buf);
        if (memcmp(tests_double[i].u8, buf, 8) != 0) {
            fprintf(stderr, "Failed %.15g => %s; expected %s\n",
                    tests_double[i].d,
                    to_hex(buf, 8), to_hex(tests_double[i].u8, 8));
        }

        double_to_le(tests_double[i].d, buf + 1);
        if (memcmp(tests_double[i].u8, buf + 1, 8) != 0) {
            fprintf(stderr, "Failed unaligned %.15g => %s; expected %s\n",
                    tests_double[i].d,
                    to_hex(buf + 1, 8), to_hex(tests_double[i].u8, 8));
        }
    }
    return errors;
}
예제 #4
0
파일: hts_endian.c 프로젝트: atks/vt
int t_float(int verbose) {
    uint8_t buf[9];
    size_t i;
    int errors = 0;

    for (i = 0; i < NELE(tests_float); i++) {
        float f;

        if (verbose) {
            fprintf(stderr, "%s %g\n",
                    to_hex(tests_float[i].u8, 4), tests_float[i].f);
        }

        f = le_to_float(tests_float[i].u8);
        if (f != tests_float[i].f) {
            fprintf(stderr, "Failed %s => %g; expected %g\n",
                    to_hex(tests_float[i].u8, 4), f, tests_float[i].f);
            errors++;
        }

        f = le_to_float(tests_float[i].u8_unaligned + 1);
        if (f != tests_float[i].f) {
            fprintf(stderr, "Failed unaligned %s => %g; expected %g\n",
                    to_hex(tests_float[i].u8_unaligned + 1, 4),
                    f, tests_float[i].f);
            errors++;
        }

        float_to_le(tests_float[i].f, buf);
        if (memcmp(tests_float[i].u8, buf, 4) != 0) {
            fprintf(stderr, "Failed %g => %s; expected %s\n",
                    tests_float[i].f,
                    to_hex(buf, 4), to_hex(tests_float[i].u8, 4));
        }

        float_to_le(tests_float[i].f, buf + 1);
        if (memcmp(tests_float[i].u8, buf + 1, 4) != 0) {
            fprintf(stderr, "Failed unaligned %g => %s; expected %s\n",
                    tests_float[i].f,
                    to_hex(buf + 1, 4), to_hex(tests_float[i].u8, 4));
        }
    }
    return errors;
}
bam_hdr_t * setup_test_6(merged_header_t *merged_hdr) {
    return setup_test(init_text, init_refs, NELE(init_refs),
                      test_6_trans_text, test_6_refs, NELE(test_6_refs),
                      merged_hdr);
}
예제 #6
0
파일: hts_endian.c 프로젝트: atks/vt
static int t64_bit(int verbose) {
    uint8_t buf[9];
    size_t i;
    int errors = 0;

    for (i = 0; i < NELE(tests_64_bit); i++) {
        uint64_t u64;
        int64_t  i64;

        if (verbose) {
            fprintf(stderr, "%s %20"PRId64" %20"PRIu64"\n",
                    to_hex(tests_64_bit[i].u8, 8),
                    tests_64_bit[i].i64, tests_64_bit[i].u64);
        }

        u64 = le_to_u64(tests_64_bit[i].u8);
        if (u64 != tests_64_bit[i].u64) {
            fprintf(stderr, "Failed %s => %"PRIu64"; expected %"PRIu64"\n",
                    to_hex(tests_64_bit[i].u8, 8), u64, tests_64_bit[i].u64);
            errors++;
        }

        i64 = le_to_i64(tests_64_bit[i].u8);
        if (i64 != tests_64_bit[i].i64) {
            fprintf(stderr, "Failed %s => %"PRId64"; expected %"PRId64"\n",
                    to_hex(tests_64_bit[i].u8, 8), i64, tests_64_bit[i].i64);
            errors++;
        }

        u64 = le_to_u64(tests_64_bit[i].u8_unaligned + 1);
        if (u64 != tests_64_bit[i].u64) {
            fprintf(stderr,
                    "Failed unaligned %s => %"PRIu64"; expected %"PRIu64"\n",
                    to_hex(tests_64_bit[i].u8_unaligned + 1, 8),
                    u64, tests_64_bit[i].u64);
            errors++;
        }

        i64 = le_to_i64(tests_64_bit[i].u8_unaligned + 1);
        if (i64 != tests_64_bit[i].i64) {
            fprintf(stderr,
                    "Failed unaligned %s => %"PRId64"; expected %"PRId64"\n",
                    to_hex(tests_64_bit[i].u8_unaligned + 1, 8),
                    i64, tests_64_bit[i].i64);
            errors++;
        }

        u64_to_le(tests_64_bit[i].u64, buf);
        if (memcmp(buf, tests_64_bit[i].u8, 8) != 0) {
            fprintf(stderr, "Failed %"PRIu64" => %s; expected %s\n",
                    tests_64_bit[i].u64,
                    to_hex(buf, 8), to_hex(tests_64_bit[i].u8, 8));
            errors++;
        }

        i64_to_le(tests_64_bit[i].i64, buf);
        if (memcmp(buf, tests_64_bit[i].u8, 8) != 0) {
            fprintf(stderr, "Failed %"PRId64" => %s; expected %s\n",
                    tests_64_bit[i].i64,
                    to_hex(buf, 8), to_hex(tests_64_bit[i].u8, 8));
            errors++;
        }

        u64_to_le(tests_64_bit[i].u64, buf + 1);
        if (memcmp(buf + 1, tests_64_bit[i].u8, 8) != 0) {
            fprintf(stderr, "Failed unaligned %"PRIu64" => %s; expected %s\n",
                    tests_64_bit[i].u64,
                    to_hex(buf + 1, 8), to_hex(tests_64_bit[i].u8, 8));
            errors++;
        }

        i64_to_le(tests_64_bit[i].i64, buf + 1);
        if (memcmp(buf + 1, tests_64_bit[i].u8, 8) != 0) {
            fprintf(stderr, "Failed unaligned %"PRId64" => %s; expected %s\n",
                    tests_64_bit[i].i64,
                    to_hex(buf + 1, 8), to_hex(tests_64_bit[i].u8, 8));
            errors++;
        }
    }

    return errors;
}
예제 #7
0
파일: hts_endian.c 프로젝트: atks/vt
static int t32_bit(int verbose) {
    uint8_t buf[9];
    size_t i;
    int errors = 0;

    for (i = 0; i < NELE(tests_32_bit); i++) {
        uint32_t u32;
        int32_t  i32;

        if (verbose) {
            fprintf(stderr, "%s %11"PRId32" %11"PRIu32"\n",
                    to_hex(tests_32_bit[i].u8, 4),
                    tests_32_bit[i].i32, tests_32_bit[i].u32);
        }

        u32 = le_to_u32(tests_32_bit[i].u8);
        if (u32 != tests_32_bit[i].u32) {
            fprintf(stderr, "Failed %s => %"PRIu32"; expected %"PRIu32"\n",
                    to_hex(tests_32_bit[i].u8, 4), u32, tests_32_bit[i].u32);
            errors++;
        }
        i32 = le_to_i32(tests_32_bit[i].u8);
        if (i32 != tests_32_bit[i].i32) {
            fprintf(stderr, "Failed %s => %"PRId32"; expected %"PRId32"\n",
                    to_hex(tests_32_bit[i].u8, 4), i32, tests_32_bit[i].i32);
            errors++;
        }

        u32 = le_to_u32(tests_32_bit[i].u8_unaligned + 1);
        if (u32 != tests_32_bit[i].u32) {
            fprintf(stderr,
                    "Failed unaligned %s => %"PRIu32"; expected %"PRIu32"\n",
                    to_hex(tests_32_bit[i].u8_unaligned + 1, 4),
                    u32, tests_32_bit[i].u32);
            errors++;
        }
        i32 = le_to_i32(tests_32_bit[i].u8_unaligned + 1);
        if (i32 != tests_32_bit[i].i32) {
            fprintf(stderr,
                    "Failed unaligned %s => %"PRId32"; expected %"PRId32"\n",
                    to_hex(tests_32_bit[i].u8_unaligned + 1, 4),
                    i32, tests_32_bit[i].i32);
            errors++;
        }

        u32_to_le(tests_32_bit[i].u32, buf);
        if (memcmp(buf, tests_32_bit[i].u8, 4) != 0) {
            fprintf(stderr, "Failed %"PRIu32" => %s; expected %s\n",
                    tests_32_bit[i].u32,
                    to_hex(buf, 4), to_hex(tests_32_bit[i].u8, 4));
            errors++;
        }

        i32_to_le(tests_32_bit[i].i32, buf);
        if (memcmp(buf, tests_32_bit[i].u8, 4) != 0) {
            fprintf(stderr, "Failed %"PRId32" => %s; expected %s\n",
                    tests_32_bit[i].i32,
                    to_hex(buf, 4), to_hex(tests_32_bit[i].u8, 4));
            errors++;
        }

        u32_to_le(tests_32_bit[i].u32, buf + 1);
        if (memcmp(buf + 1, tests_32_bit[i].u8, 4) != 0) {
            fprintf(stderr, "Failed unaligned %"PRIu32" => %s; expected %s\n",
                    tests_32_bit[i].u32,
                    to_hex(buf + 1, 4), to_hex(tests_32_bit[i].u8, 4));
            errors++;
        }

        i32_to_le(tests_32_bit[i].i32, buf + 1);
        if (memcmp(buf + 1, tests_32_bit[i].u8, 4) != 0) {
            fprintf(stderr, "Failed unaligned %"PRId32" => %s; expected %s\n",
                    tests_32_bit[i].i32,
                    to_hex(buf + 1, 4), to_hex(tests_32_bit[i].u8, 4));
            errors++;
        }
    }

    return errors;
}
예제 #8
0
파일: hts_endian.c 프로젝트: atks/vt
static int t16_bit(int verbose) {
    uint8_t buf[9];
    size_t i;
    int errors = 0;

    for (i = 0; i < NELE(tests_16_bit); i++) {
        uint16_t u16;
        int16_t  i16;

        if (verbose) {
            fprintf(stderr, "%s %6"PRId16" %6"PRId16"\n",
                    to_hex(tests_16_bit[i].u8, 2),
                    tests_16_bit[i].i16, tests_16_bit[i].u16);
        }

        u16 = le_to_u16(tests_16_bit[i].u8);
        if (u16 != tests_16_bit[i].u16) {
            fprintf(stderr, "Failed %s => %"PRIu16"; expected %"PRIu16"\n",
                    to_hex(tests_16_bit[i].u8, 2), u16, tests_16_bit[i].u16);
            errors++;
        }

        i16 = le_to_i16(tests_16_bit[i].u8);
        if (i16 != tests_16_bit[i].i16) {
            fprintf(stderr, "Failed %s => %"PRId16"; expected %"PRId16"\n",
                    to_hex(tests_16_bit[i].u8, 2), i16, tests_16_bit[i].i16);
            errors++;
        }

        u16 = le_to_u16(tests_16_bit[i].u8_unaligned + 1);
        if (u16 != tests_16_bit[i].u16) {
            fprintf(stderr,
                    "Failed unaligned %s => %"PRIu16"; expected %"PRIu16"\n",
                    to_hex(tests_16_bit[i].u8_unaligned + 1, 2),
                    u16, tests_16_bit[i].u16);
            errors++;
        }

        i16 = le_to_i16(tests_16_bit[i].u8_unaligned + 1);
        if (i16 != tests_16_bit[i].i16) {
            fprintf(stderr,
                    "Failed unaligned %s => %"PRId16"; expected %"PRId16"\n",
                    to_hex(tests_16_bit[i].u8_unaligned + 1, 2),
                    i16, tests_16_bit[i].i16);
            errors++;
        }

        u16_to_le(tests_16_bit[i].u16, buf);
        if (memcmp(buf, tests_16_bit[i].u8, 2) != 0) {
            fprintf(stderr, "Failed %"PRIu16" => %s; expected %s\n",
                    tests_16_bit[i].u16,
                    to_hex(buf, 2), to_hex(tests_16_bit[i].u8, 2));
            errors++;
        }

        i16_to_le(tests_16_bit[i].i16, buf);
        if (memcmp(buf, tests_16_bit[i].u8, 2) != 0) {
            fprintf(stderr, "Failed %"PRId16" => %s; expected %s\n",
                    tests_16_bit[i].i16,
                    to_hex(buf, 2), to_hex(tests_16_bit[i].u8, 2));
            errors++;
        }

        u16_to_le(tests_16_bit[i].u16, buf + 1);
        if (memcmp(buf + 1, tests_16_bit[i].u8, 2) != 0) {
            fprintf(stderr, "Failed unaligned %"PRIu16" => %s; expected %s\n",
                    tests_16_bit[i].u16,
                    to_hex(buf + 1, 2), to_hex(tests_16_bit[i].u8, 2));
            errors++;
        }

        i16_to_le(tests_16_bit[i].i16, buf + 1);
        if (memcmp(buf + 1, tests_16_bit[i].u8, 2) != 0) {
            fprintf(stderr, "Failed unaligned %"PRId16" => %s; expected %s\n",
                    tests_16_bit[i].i16,
                    to_hex(buf + 1, 2), to_hex(tests_16_bit[i].u8, 2));
            errors++;
        }
    }

    return errors;
}
예제 #9
0
파일: sam.c 프로젝트: atks/vt
static int aux_fields1(void)
{
    static const char sam[] = "data:,"
"@SQ\tSN:one\tLN:1000\n"
"@SQ\tSN:two\tLN:500\n"
"r1\t0\tone\t500\t20\t8M\t*\t0\t0\tATGCATGC\tqqqqqqqq\tXA:A:k\tXi:i:37\tXf:f:" xstr(PI) "\tXd:d:" xstr(E) "\tXZ:Z:" HELLO "\tXH:H:" BEEF "\tXB:B:c,-2,0,+2\tB0:B:i,-2147483648,-1,0,1,2147483647\tB1:B:I,0,1,2147483648,4294967295\tB2:B:s,-32768,-1,0,1,32767\tB3:B:S,0,1,32768,65535\tB4:B:c,-128,-1,0,1,127\tB5:B:C,0,1,127,255\tBf:B:f,-3.14159,2.71828\tZZ:i:1000000\tF2:d:2.46801\tY1:i:-2147483648\tY2:i:-2147483647\tY3:i:-1\tY4:i:0\tY5:i:1\tY6:i:2147483647\tY7:i:2147483648\tY8:i:4294967295\n";

    // Canonical form of the alignment record above, as output by sam_format1()
    static const char r1[] = "r1\t0\tone\t500\t20\t8M\t*\t0\t0\tATGCATGC\tqqqqqqqq\tXi:i:37\tXf:f:3.14159\tXd:d:2.71828\tXZ:Z:" NEW_HELLO "\tXH:H:" BEEF "\tXB:B:c,-2,0,2\tB0:B:i,-2147483648,-1,0,1,2147483647\tB1:B:I,0,1,2147483648,4294967295\tB2:B:s,-32768,-1,0,1,32767\tB3:B:S,0,1,32768,65535\tB4:B:c,-128,-1,0,1,127\tB5:B:C,0,1,127,255\tBf:B:f,-3.14159,2.71828\tZZ:i:1000000\tF2:f:9.8765\tY1:i:-2147483648\tY2:i:-2147483647\tY3:i:-1\tY4:i:0\tY5:i:1\tY6:i:2147483647\tY7:i:2147483648\tY8:i:4294967295\tN0:i:-1234\tN1:i:1234\tN2:i:-2\tN3:i:3\tF1:f:4.5678\tN4:B:S,65535,32768,1,0\tN5:i:4242";

    samFile *in = sam_open(sam, "r");
    bam_hdr_t *header = sam_hdr_read(in);
    bam1_t *aln = bam_init1();
    uint8_t *p;
    kstring_t ks = { 0, 0, NULL };
    int64_t b0vals[5] = { -2147483648LL,-1,0,1,2147483647LL }; // i
    int64_t b1vals[4] = { 0,1,2147483648LL,4294967295LL };     // I
    int64_t b2vals[5] = { -32768,-1,0,1,32767 };           // s
    int64_t b3vals[4] = { 0,1,32768,65535 };               // S
    int64_t b4vals[5] = { -128,-1,0,1,127 };               // c
    int64_t b5vals[4] = { 0,1,127,255 };                   // C
    // NB: Floats not doubles below!
    // See https://randomascii.wordpress.com/2012/06/26/doubles-are-not-floats-so-dont-compare-them/
    float bfvals[2] = { -3.14159f, 2.71828f };

    int8_t n4v1[] = { -128, -64, -32, -16, -8, -4, -2, -1,
                      0, 1, 2, 4, 8, 16, 32, 64, 127 };
    uint32_t n4v2[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 1234, 5678, 1U << 31, 0 };
    int16_t n4v3[] = { -32768, -1, 0, 1, 32767 };
    float n4v4[] = { 0, 1, 2, 10, 20, 30, 1.5, -2.5 };
    uint8_t n4v5[] = { 0, 255 };
    int32_t n4v6[] = { -2147483647 - 1, 10, -1, 0, 1, 2147483647 };
    uint16_t n4v7[] = { 65535, 32768, 1, 0 };

    int32_t ival = -1234;
    uint32_t uval = 1234;
    float f1 = 4.5678;
    float f2 = 9.8765;

    size_t nvals, i;

    if (sam_read1(in, header, aln) >= 0) {
        if ((p = check_bam_aux_get(aln, "XA", 'A')) && bam_aux2A(p) != 'k')
            fail("XA field is '%c', expected 'k'", bam_aux2A(p));

        bam_aux_del(aln,p);
        if (bam_aux_get(aln,"XA"))
            fail("XA field was not deleted");

        if ((p = check_bam_aux_get(aln, "Xi", 'C')) && bam_aux2i(p) != 37)
            fail("Xi field is %"PRId64", expected 37", bam_aux2i(p));

        if ((p = check_bam_aux_get(aln, "Xf", 'f')) && fabs(bam_aux2f(p) - PI) > 1E-6)
            fail("Xf field is %.12f, expected pi", bam_aux2f(p));

        if ((p = check_bam_aux_get(aln, "Xd", 'd')) && fabs(bam_aux2f(p) - E) > 1E-6)
            fail("Xf field is %.12f, expected e", bam_aux2f(p));

        if ((p = check_bam_aux_get(aln, "XZ", 'Z')) && strcmp(bam_aux2Z(p), HELLO) != 0)
            fail("XZ field is \"%s\", expected \"%s\"", bam_aux2Z(p), HELLO);

        bam_aux_update_str(aln,"XZ",strlen(NEW_HELLO)+1,NEW_HELLO);
        if ((p = check_bam_aux_get(aln, "XZ", 'Z')) && strcmp(bam_aux2Z(p), NEW_HELLO) != 0)
            fail("XZ field is \"%s\", expected \"%s\"", bam_aux2Z(p), NEW_HELLO);


        if ((p = check_bam_aux_get(aln, "XH", 'H')) && strcmp(bam_aux2Z(p), BEEF) != 0)
            fail("XH field is \"%s\", expected \"%s\"", bam_aux2Z(p), BEEF);

        if ((p = check_bam_aux_get(aln, "XB", 'B'))
            && ! (memcmp(p, "Bc", 2) == 0
                  && memcmp(p + 2, "\x03\x00\x00\x00\xfe\x00\x02", 7) == 0))
            fail("XB field is %c,..., expected c,-2,0,+2", p[1]);

        check_int_B_array(aln, "B0", NELE(b0vals), b0vals);
        check_int_B_array(aln, "B1", NELE(b1vals), b1vals);
        check_int_B_array(aln, "B2", NELE(b2vals), b2vals);
        check_int_B_array(aln, "B3", NELE(b3vals), b3vals);
        check_int_B_array(aln, "B4", NELE(b4vals), b4vals);
        check_int_B_array(aln, "B5", NELE(b5vals), b5vals);

        nvals = NELE(bfvals);
        if ((p = check_bam_aux_get(aln, "Bf", 'B')) != NULL) {
            if (bam_auxB_len(p) != nvals)
                fail("Wrong length reported for Bf field, got %d, expected %zd\n",
                     bam_auxB_len(p), nvals);

            for (i = 0; i < nvals; i++) {
                if (bam_auxB2f(p, i) != bfvals[i]) {
                    fail("Wrong value from bam_auxB2f for Bf field index %zd, "
                         "got %f expected %f\n",
                         i, bam_auxB2f(p, i), bfvals[i]);
                }
            }
        }

        if ((p = check_bam_aux_get(aln, "ZZ", 'I')) && bam_aux2i(p) != 1000000)
            fail("ZZ field is %"PRId64", expected 1000000", bam_aux2i(p));

        if ((p = bam_aux_get(aln, "Y1")) && bam_aux2i(p) != -2147483647-1)
            fail("Y1 field is %"PRId64", expected -2^31", bam_aux2i(p));

        if ((p = bam_aux_get(aln, "Y2")) && bam_aux2i(p) != -2147483647)
            fail("Y2 field is %"PRId64", expected -2^31+1", bam_aux2i(p));

        if ((p = bam_aux_get(aln, "Y3")) && bam_aux2i(p) != -1)
            fail("Y3 field is %"PRId64", expected -1", bam_aux2i(p));

        if ((p = bam_aux_get(aln, "Y4")) && bam_aux2i(p) != 0)
            fail("Y4 field is %"PRId64", expected 0", bam_aux2i(p));

        if ((p = bam_aux_get(aln, "Y5")) && bam_aux2i(p) != 1)
            fail("Y5 field is %"PRId64", expected 1", bam_aux2i(p));

        if ((p = bam_aux_get(aln, "Y6")) && bam_aux2i(p) != 2147483647)
            fail("Y6 field is %"PRId64", expected 2^31-1", bam_aux2i(p));

        if ((p = bam_aux_get(aln, "Y7")) && bam_aux2i(p) != 2147483648LL)
            fail("Y7 field is %"PRId64", expected 2^31", bam_aux2i(p));

        if ((p = bam_aux_get(aln, "Y8")) && bam_aux2i(p) != 4294967295LL)
            fail("Y8 field is %"PRId64", expected 2^32-1", bam_aux2i(p));

        // Try appending some new tags
        if (bam_aux_append(aln, "N0", 'i', sizeof(ival), (uint8_t *) &ival) != 0)
            fail("Failed to append N0:i tag");

        if ((p = bam_aux_get(aln, "N0")) && bam_aux2i(p) != ival)
            fail("N0 field is %"PRId64", expected %d", bam_aux2i(p), ival);

        if (bam_aux_append(aln, "N1", 'I', sizeof(uval), (uint8_t *) &uval) != 0)
            fail("failed to append N1:I tag");

        if ((p = bam_aux_get(aln, "N1")) && bam_aux2i(p) != uval)
            fail("N1 field is %"PRId64", expected %u", bam_aux2i(p), uval);

        // Append tags with bam_aux_update_int()
        if (bam_aux_update_int(aln, "N2", -2) < 0)
            fail("failed to append N2:c tag");

        if (bam_aux_update_int(aln, "N3", 3) < 0)
            fail("failed to append N3:C tag");

        p = bam_aux_get(aln, "N2");
        if (!p)
            fail("failed to retrieve N2 tag");
        else if (*p != 'c' || bam_aux2i(p) != -2)
            fail("N2 field is %c:%"PRId64", expected c:-2", *p, bam_aux2i(p));

        p = bam_aux_get(aln, "N3");
        if (!p)
            fail("failed to retrieve N3 tag");
        else if (*p != 'C' || bam_aux2i(p) != 3)
            fail("N3 field is %c:%"PRId64", expected C:3", *p, bam_aux2i(p));

        // Try changing values with bam_aux_update_int()
        i = test_update_int(aln, "N2", 2, 'C', "N3", 3, 'C');
        if (i == 0) test_update_int(aln, "N2", 1234, 'S', "N3", 3, 'C');
        if (i == 0) test_update_int(aln, "N2", -1, 's', "N3", 3, 'C');
        if (i == 0) test_update_int(aln, "N2", 4294967295U, 'I', "N3", 3, 'C');
        if (i == 0) test_update_int(aln, "N2", -2, 'i', "N3", 3, 'C');

        // Append a value with bam_aux_update_float()
        if (bam_aux_update_float(aln, "F1", f1) < 0)
            fail("append F1:f tag");

        p = bam_aux_get(aln, "F1");
        if (!p)
            fail("retrieve F1 tag");
        else if (*p != 'f' || bam_aux2f(p) != f1)
            fail("F1 field is %c:%e, expected f:%e", *p, bam_aux2f(p), f1);

        // Change a double tag to a float
        if (bam_aux_update_float(aln, "F2", f2) < 0)
            fail("update F2 tag");

        p = bam_aux_get(aln, "F2");
        if (!p)
            fail("retrieve F2 tag");
        else if (*p != 'f' || bam_aux2f(p) != f2)
            fail("F2 field is %c:%e, expected f:%e", *p, bam_aux2f(p), f2);

        // Check the next one is intact too
        p = bam_aux_get(aln, "Y1");
        if (!p)
            fail("retrieve Y1 tag");
        else if (*p != 'i' && bam_aux2i(p) != -2147483647-1)
            fail("Y1 field is %"PRId64", expected -2^31", bam_aux2i(p));

        // bam_aux_update_array tests
        // append a new array
        i = test_update_array(aln, "N4", 'c', NELE(n4v1), n4v1, "\0\0", 0, 0);

        // Add a sentinal to check resizes work
        if (i == 0) i = test_update_int(aln, "N5", 4242, 'S', "\0\0", 0, 0);

        // alter the array tag a few times
        if (i == 0)
            i = test_update_array(aln, "N4", 'I', NELE(n4v2), n4v2,
                                  "N5", 4242, 'S');
        if (i == 0)
            i = test_update_array(aln, "N4", 's', NELE(n4v3), n4v3,
                                  "N5", 4242, 'S');
        if (i == 0)
            i = test_update_array(aln, "N4", 'f', NELE(n4v4), n4v4,
                                  "N5", 4242, 'S');
        if (i == 0)
            i = test_update_array(aln, "N4", 'c', NELE(n4v5), n4v5,
                                  "N5", 4242, 'S');
        if (i == 0)
            i = test_update_array(aln, "N4", 'i', NELE(n4v6), n4v6,
                                  "N5", 4242, 'S');
        if (i == 0)
            i = test_update_array(aln, "N4", 'S', NELE(n4v7), n4v7,
                                  "N5", 4242, 'S');

        if (sam_format1(header, aln, &ks) < 0)
            fail("can't format record");

        if (strcmp(ks.s, r1) != 0)
            fail("record formatted incorrectly: \"%s\"", ks.s);

        free(ks.s);
    }
    else fail("can't read record");

    bam_destroy1(aln);
    bam_hdr_destroy(header);
    sam_close(in);

    return 1;
}