24243026519

Committed 10 Apr 2026 12:31PM UTC coverage: 82.48% (-2.5%) from 85.021%

Build # 24243026519

Build Type

push

github

Committed by

scokmen

Commit Message

ci: fixed ubuntu based analyzer errors

Coverage Stats

8 of 28 new or added lines in 6 files covered. (28.57%)

67 existing lines in 7 files now uncovered.

612 of 742 relevant lines covered (82.48%)

5562.42 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

80.95

/src/reader.c

#include <jp_memory.h>
#include <jp_poller.h>
#include <jp_queue.h>
#include <jp_reader.h>
#include <stdlib.h>
#include <unistd.h>

JP_ATTR_WEAK
jp_errno_t jp_reader_consume(jp_reader_ctx_t ctx) {
    jp_errno_t err        = 0;
    ssize_t read_len      = 0;
    jp_block_t* block     = NULL;
    void* target_buffer   = NULL;
    unsigned char* buffer = NULL;
    jp_poller_t* poller   = jp_poller_create(100, &err);

    if (err) {
        goto clean_up;
    }

    buffer = jp_mem_calloc(1, ctx.chunk_size);
    err    = jp_poller_poll(poller, ctx.input_stream);
    if (err) {
        goto clean_up;
    }

    while (true) {
        err = jp_poller_wait(poller);
        if (JP_ATTR_UNLIKELY(err == JP_EREAD_FAILED)) {
            break;
        }
        if (err == JP_ETRYAGAIN) {
            continue;
        }
        while (true) {
            err = jp_queue_push_uncommitted(ctx.queue, &block);
            if (JP_ATTR_UNLIKELY(err == JP_ESHUTTING_DOWN)) {
                goto clean_up;
            }
            target_buffer = err == JP_EMSG_SHOULD_DROP ? buffer : block->data;
            read_len      = read(ctx.input_stream, target_buffer, ctx.chunk_size);
            if (JP_ATTR_UNLIKELY(read_len == 0)) {
                goto clean_up;
            }
            if (read_len < 0) {
                if (errno == EINTR) {
                    continue;
                }
                if (JP_ERRNO_EAGAIN(errno)) {
                    break;
                }
                err = JP_ERRNO_RAISE_POSIX(JP_EREAD_FAILED, errno);
                goto clean_up;
            }
            if (err == 0) {
                block->length = (size_t) read_len;
                jp_queue_push_commit(ctx.queue);
            }
        }
    }

clean_up:
    if (err == 0 || JP_QUEUE_IS_GRACEFUL_ERR(err)) {
        err = 0;
    }
    JP_FREE(buffer);
    jp_poller_destroy(poller);
    jp_queue_finalize(ctx.queue);
    return err;
}

1	#include <jp_memory.h>
2	#include <jp_poller.h>
3	#include <jp_queue.h>
4	#include <jp_reader.h>
5	#include <stdlib.h>
6	#include <unistd.h>
7
8	JP_ATTR_WEAK
9	jp_errno_t jp_reader_consume(jp_reader_ctx_t ctx) {	10✔
10	jp_errno_t err = 0;	10✔
11	ssize_t read_len = 0;	10✔
12	jp_block_t* block = NULL;	10✔
13	void* target_buffer = NULL;	10✔
14	unsigned char* buffer = NULL;	10✔
15	jp_poller_t* poller = jp_poller_create(100, &err);	10✔
16
17	if (err) {	10✔
18	goto clean_up;	×
19	}
20
21	buffer = jp_mem_calloc(1, ctx.chunk_size);	10✔
22	err = jp_poller_poll(poller, ctx.input_stream);	10✔
23	if (err) {	10✔
UNCOV 24	goto clean_up;	×
25	}
26
27	while (true) {	1,777✔
28	err = jp_poller_wait(poller);	1,777✔
29	if (JP_ATTR_UNLIKELY(err == JP_EREAD_FAILED)) {	1,777✔
30	break;
31	}
32	if (err == JP_ETRYAGAIN) {	1,777✔
UNCOV 33	continue;	×
34	}
35	while (true) {	96,900✔
36	err = jp_queue_push_uncommitted(ctx.queue, &block);	96,900✔
37	if (JP_ATTR_UNLIKELY(err == JP_ESHUTTING_DOWN)) {	96,900✔
UNCOV 38	goto clean_up;	×
39	}
40	target_buffer = err == JP_EMSG_SHOULD_DROP ? buffer : block->data;	96,900✔
41	read_len = read(ctx.input_stream, target_buffer, ctx.chunk_size);	96,900✔
42	if (JP_ATTR_UNLIKELY(read_len == 0)) {	96,900✔
43	goto clean_up;	10✔
44	}
45	if (read_len < 0) {	96,890✔
46	if (errno == EINTR) {	1,767✔
UNCOV 47	continue;	×
48	}
49	if (JP_ERRNO_EAGAIN(errno)) {	1,767✔
50	break;
51	}
NEW 52	err = JP_ERRNO_RAISE_POSIX(JP_EREAD_FAILED, errno);	×
UNCOV 53	goto clean_up;	×
54	}
55	if (err == 0) {	95,123✔
56	block->length = (size_t) read_len;	95,111✔
57	jp_queue_push_commit(ctx.queue);	95,111✔
58	}
59	}
60	}
61
UNCOV 62	clean_up:	×
63	if (err == 0 \|\| JP_QUEUE_IS_GRACEFUL_ERR(err)) {	10✔
64	err = 0;	10✔
65	}
66	JP_FREE(buffer);	10✔
67	jp_poller_destroy(poller);	10✔
68	jp_queue_finalize(ctx.queue);	10✔
69	return err;	10✔
70	}

scokmen / jpipe / 24243026519

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous