Rename SORT_* to DLOGUTIL_SORT_*

Change-Id: I5ddf6b95b4abf24dfaecd464b94015c7bdeb51f5

11 files changed, 80 insertions, 80 deletions

diff --git a/include/queued_entry.h b/include/queued_entry.h
index f310b469..8a5e78c5 100644
--- a/include/queued_entry.h
+++ b/include/queued_entry.h
@@ -28,12 +28,12 @@ struct log_config;
  * @brief sorting order
  */
 enum dlogutil_sorting_order {
-	SORT_SENT_MONO = 0,
-	SORT_SENT_REAL,
-	SORT_RECV_MONO,
-	SORT_RECV_REAL,
-	SORT_MAX,
-	SORT_DEFAULT,
+	DLOGUTIL_SORT_SENT_MONO = 0,
+	DLOGUTIL_SORT_SENT_REAL,
+	DLOGUTIL_SORT_RECV_MONO,
+	DLOGUTIL_SORT_RECV_REAL,
+	DLOGUTIL_SORT_MAX,
+	DLOGUTIL_SORT_DEFAULT,
 };
 
 
diff --git a/src/logger/logger.c b/src/logger/logger.c
index 63f0fe81..fbb19a5a 100644
--- a/src/logger/logger.c
+++ b/src/logger/logger.c
@@ -819,7 +819,7 @@ int service_reader_file(struct reader* reader)
 			if (!log_should_print_line(reader->filter, &entry.header))
 				return 0;
 
-			logfile_write_with_rotation(&entry.header, &reader->file, SORT_SENT_REAL);
+			logfile_write_with_rotation(&entry.header, &reader->file, DLOGUTIL_SORT_SENT_REAL);
 		}
 	}
 
diff --git a/src/shared/logconfig.c b/src/shared/logconfig.c
index 31b84d0a..13635113 100644
--- a/src/shared/logconfig.c
+++ b/src/shared/logconfig.c
@@ -386,16 +386,16 @@ void log_config_foreach(const struct log_config *config, configIter iter, void *
 
 enum dlogutil_sorting_order get_order_from_config(const struct log_config *conf)
 {
-	enum dlogutil_sorting_order ret = SORT_RECV_MONO;
+	enum dlogutil_sorting_order ret = DLOGUTIL_SORT_RECV_MONO;
 
 	const char *const sort_str = log_config_get(conf, "sort_by");
 	if (sort_str) {
 		if (!strcmp(sort_str, "sent_real"))
-			ret = SORT_SENT_REAL;
+			ret = DLOGUTIL_SORT_SENT_REAL;
 		else if (!strcmp(sort_str, "recv_real"))
-			ret = SORT_RECV_REAL;
+			ret = DLOGUTIL_SORT_RECV_REAL;
 		else if (!strcmp(sort_str, "sent_mono"))
-			ret = SORT_SENT_MONO;
+			ret = DLOGUTIL_SORT_SENT_MONO;
 	}
 
 	return ret;
@@ -408,9 +408,9 @@ enum dlogutil_sorting_order get_proper_sort_by(enum dlogutil_sorting_order sort_
 	*sorting_needed = false;
 
 	if (!is_pipe)
-		return SORT_SENT_REAL; // the Android logger only provides this one timestamp and sorts on it, so let's use it
+		return DLOGUTIL_SORT_SENT_REAL; // the Android logger only provides this one timestamp and sorts on it, so let's use it
 
-	if (sort_by == SORT_DEFAULT)
+	if (sort_by == DLOGUTIL_SORT_DEFAULT)
 		return source_sorting; // pick the compatible sorting to make things easier
 
 	*sorting_needed = (sort_by != source_sorting); // if everything is sorted by the source, we don't have to
diff --git a/src/shared/logprint.c b/src/shared/logprint.c
index a19c7281..3b4ae585 100644
--- a/src/shared/logprint.c
+++ b/src/shared/logprint.c
@@ -579,19 +579,19 @@ enum dlogutil_sorting_order get_format_sorting(log_print_format format)
 	case FORMAT_RAW:
 	case FORMAT_BRIEF:
 	case FORMAT_JSON:
-		return SORT_DEFAULT;
+		return DLOGUTIL_SORT_DEFAULT;
 
 	case FORMAT_KERNELTIME:
-		return SORT_SENT_MONO;
+		return DLOGUTIL_SORT_SENT_MONO;
 
 	case FORMAT_TIME:
 	case FORMAT_THREADTIME:
 	case FORMAT_LONG:
-		return SORT_SENT_REAL;
+		return DLOGUTIL_SORT_SENT_REAL;
 
 	case FORMAT_RWTIME:
 	case FORMAT_RECV_REALTIME:
-		return SORT_RECV_REAL;
+		return DLOGUTIL_SORT_RECV_REAL;
 
 	default: assert(false); // LCOV_EXCL_LINE
 	}
diff --git a/src/shared/queued_entry_timestamp.c b/src/shared/queued_entry_timestamp.c
index 67cf8ca9..4c05b935 100644
--- a/src/shared/queued_entry_timestamp.c
+++ b/src/shared/queued_entry_timestamp.c
@@ -61,19 +61,19 @@ bool log_entry_is_earlier(const enum dlogutil_sorting_order sort_by, const struc
 
 	int32_t r_sec, r_nsec, l_sec, l_nsec;
 	switch (sort_by) {
-	case SORT_RECV_REAL:
+	case DLOGUTIL_SORT_RECV_REAL:
 		r_sec = rhs->sec_recv_real;
 		r_nsec = rhs->nsec_recv_real;
 		l_sec = lhs->sec_recv_real;
 		l_nsec = lhs->nsec_recv_real;
 		break;
-	case SORT_RECV_MONO:
+	case DLOGUTIL_SORT_RECV_MONO:
 		r_sec = rhs->sec_recv_mono;
 		r_nsec = rhs->nsec_recv_mono;
 		l_sec = lhs->sec_recv_mono;
 		l_nsec = lhs->nsec_recv_mono;
 		break;
-	case SORT_SENT_REAL:
+	case DLOGUTIL_SORT_SENT_REAL:
 		r_sec = rhs->sec_sent_real;
 		r_nsec = rhs->nsec_sent_real;
 		l_sec = lhs->sec_sent_real;
@@ -102,19 +102,19 @@ struct timespec dlogutil_entry_ts(const struct dlogutil_entry *le, enum dlogutil
 	struct timespec ret;
 
 	switch (stamp_type) {
-	case SORT_SENT_MONO:
+	case DLOGUTIL_SORT_SENT_MONO:
 		ret.tv_sec = le->sec_sent_mono;
 		ret.tv_nsec = le->nsec_sent_mono;
 		break;
-	case SORT_SENT_REAL:
+	case DLOGUTIL_SORT_SENT_REAL:
 		ret.tv_sec = le->sec_sent_real;
 		ret.tv_nsec = le->nsec_sent_real;
 		break;
-	case SORT_RECV_MONO:
+	case DLOGUTIL_SORT_RECV_MONO:
 		ret.tv_sec = le->sec_recv_mono;
 		ret.tv_nsec = le->nsec_recv_mono;
 		break;
-	case SORT_RECV_REAL:
+	case DLOGUTIL_SORT_RECV_REAL:
 		ret.tv_sec = le->sec_recv_real;
 		ret.tv_nsec = le->nsec_recv_real;
 		break;
@@ -128,12 +128,12 @@ struct timespec dlogutil_entry_ts(const struct dlogutil_entry *le, enum dlogutil
 clockid_t get_proper_clock(enum dlogutil_sorting_order sort_by)
 {
 	switch (sort_by) {
-	case SORT_SENT_MONO:
-	case SORT_RECV_MONO:
+	case DLOGUTIL_SORT_SENT_MONO:
+	case DLOGUTIL_SORT_RECV_MONO:
 		return CLOCK_MONOTONIC;
 
-	case SORT_SENT_REAL:
-	case SORT_RECV_REAL:
+	case DLOGUTIL_SORT_SENT_REAL:
+	case DLOGUTIL_SORT_RECV_REAL:
 		return CLOCK_REALTIME;
 
 	default: assert(false); // LCOV_EXCL_LINE
diff --git a/src/shared/sort_vector.c b/src/shared/sort_vector.c
index 1975902e..02901600 100644
--- a/src/shared/sort_vector.c
+++ b/src/shared/sort_vector.c
@@ -40,7 +40,7 @@ void sort_vector_init(struct sort_vector *logs)
 	logs->dump = DLOGUTIL_MODE_CONTINUOUS;
 	logs->size = DEFAULT_SORT_BUFFER_SIZE;
 	logs->timeout = DEFAULT_SORT_TIMEOUT;
-	logs->sort_by = SORT_SENT_MONO;
+	logs->sort_by = DLOGUTIL_SORT_SENT_MONO;
 	logs->old_logs_dumped = 0;
 }
 
diff --git a/src/tests/log_file.c b/src/tests/log_file.c
index b6762f30..c9e2fd5b 100644
--- a/src/tests/log_file.c
+++ b/src/tests/log_file.c
@@ -36,7 +36,7 @@ int __wrap_rename(const char *oldpath, const char *newpath)
 
 struct timespec __wrap_dlogutil_entry_ts(const struct dlogutil_entry *le, enum dlogutil_sorting_order stamp_type)
 {
-	assert(stamp_type == SORT_SENT_MONO);
+	assert(stamp_type == DLOGUTIL_SORT_SENT_MONO);
 	assert(le == (struct dlogutil_entry *) 0xBA5EBALL);
 	return (struct timespec) {
 		.tv_sec = 3333,
@@ -166,18 +166,18 @@ int main()
 	lf.prev_sec = 4444;
 	lf.prev_nsec = 6666;
 	log_print_log_line_ret = -1;
-	assert(logfile_write_with_rotation((struct dlogutil_entry *) 0xBA5EBALL, &lf, SORT_SENT_MONO));
+	assert(logfile_write_with_rotation((struct dlogutil_entry *) 0xBA5EBALL, &lf, DLOGUTIL_SORT_SENT_MONO));
 	assert(lf.prev_sec == 4444);
 	assert(lf.prev_nsec == 6666);
 
 	log_print_log_line_ret = 1;
 	fail_snprintf = true;
-	assert(!logfile_write_with_rotation((struct dlogutil_entry *) 0xBA5EBALL, &lf, SORT_SENT_MONO));
+	assert(!logfile_write_with_rotation((struct dlogutil_entry *) 0xBA5EBALL, &lf, DLOGUTIL_SORT_SENT_MONO));
 	assert(lf.prev_sec == 3333);
 	assert(lf.prev_nsec == 9999);
 
 	fail_snprintf = false;
-	assert(!logfile_write_with_rotation((struct dlogutil_entry *) 0xBA5EBALL, &lf, SORT_SENT_MONO));
+	assert(!logfile_write_with_rotation((struct dlogutil_entry *) 0xBA5EBALL, &lf, DLOGUTIL_SORT_SENT_MONO));
 	custom_memcpy = false;
 
 	logfile_free(&lf);
diff --git a/src/tests/logprint.c b/src/tests/logprint.c
index 9e9555e7..975b4926 100644
--- a/src/tests/logprint.c
+++ b/src/tests/logprint.c
@@ -632,17 +632,17 @@ void check_get_format_sorting()
 		log_print_format format;
 		enum dlogutil_sorting_order sorting;
 	} expected_sorting[] = {
-		{FORMAT_TAG          , SORT_DEFAULT  },
-		{FORMAT_PROCESS      , SORT_DEFAULT  },
-		{FORMAT_THREAD       , SORT_DEFAULT  },
-		{FORMAT_RAW          , SORT_DEFAULT  },
-		{FORMAT_BRIEF        , SORT_DEFAULT  },
-		{FORMAT_TIME         , SORT_SENT_REAL},
-		{FORMAT_THREADTIME   , SORT_SENT_REAL},
-		{FORMAT_KERNELTIME   , SORT_SENT_MONO},
-		{FORMAT_LONG         , SORT_SENT_REAL},
-		{FORMAT_RWTIME       , SORT_RECV_REAL},
-		{FORMAT_RECV_REALTIME, SORT_RECV_REAL},
+		{FORMAT_TAG          , DLOGUTIL_SORT_DEFAULT  },
+		{FORMAT_PROCESS      , DLOGUTIL_SORT_DEFAULT  },
+		{FORMAT_THREAD       , DLOGUTIL_SORT_DEFAULT  },
+		{FORMAT_RAW          , DLOGUTIL_SORT_DEFAULT  },
+		{FORMAT_BRIEF        , DLOGUTIL_SORT_DEFAULT  },
+		{FORMAT_TIME         , DLOGUTIL_SORT_SENT_REAL},
+		{FORMAT_THREADTIME   , DLOGUTIL_SORT_SENT_REAL},
+		{FORMAT_KERNELTIME   , DLOGUTIL_SORT_SENT_MONO},
+		{FORMAT_LONG         , DLOGUTIL_SORT_SENT_REAL},
+		{FORMAT_RWTIME       , DLOGUTIL_SORT_RECV_REAL},
+		{FORMAT_RECV_REALTIME, DLOGUTIL_SORT_RECV_REAL},
 	};
 
 	for (size_t i = 0; i < NELEMS(expected_sorting); ++i) {
diff --git a/src/tests/logutil.c b/src/tests/logutil.c
index 4efdc56c..08931460 100644
--- a/src/tests/logutil.c
+++ b/src/tests/logutil.c
@@ -89,29 +89,29 @@ int main()
 	};
 
 	int callback_local_ret;
-	assert(process_log(&ent, ts, SORT_SENT_MONO, callback,
+	assert(process_log(&ent, ts, DLOGUTIL_SORT_SENT_MONO, callback,
 		(void *)0xDDD, 1, &callback_local_ret));
 	assert(written_logs == 1);
 	assert(callback_local_ret == 0);
-	assert(process_log(&ent, ts, SORT_SENT_REAL, callback,
+	assert(process_log(&ent, ts, DLOGUTIL_SORT_SENT_REAL, callback,
 		(void *)0xDDD, 1, &callback_local_ret));
 	assert(written_logs == 2);
 	assert(callback_local_ret == 0);
-	assert(!process_log(&ent, ts, SORT_RECV_MONO, callback,
+	assert(!process_log(&ent, ts, DLOGUTIL_SORT_RECV_MONO, callback,
 		(void *)0xDDD, 1, &callback_local_ret));
 	assert(written_logs == 2);
 	assert(callback_local_ret == 0);
-	assert(!process_log(&ent, ts, SORT_RECV_REAL, callback,
+	assert(!process_log(&ent, ts, DLOGUTIL_SORT_RECV_REAL, callback,
 		(void *)0xDDD, 1, &callback_local_ret));
 	assert(written_logs == 2);
 	assert(callback_local_ret == 0);
 
 	callback_ret = 77;
-	assert(!process_log(&ent, ts, SORT_RECV_MONO, callback,
+	assert(!process_log(&ent, ts, DLOGUTIL_SORT_RECV_MONO, callback,
 		(void *)0xDDD, 1, &callback_local_ret));
 	assert(written_logs == 2);
 	assert(callback_local_ret == 0);
-	assert(process_log(&ent, ts, SORT_SENT_MONO, callback,
+	assert(process_log(&ent, ts, DLOGUTIL_SORT_SENT_MONO, callback,
 		(void *)0xDDD, 1, &callback_local_ret));
 	assert(written_logs == 3);
 	assert(callback_local_ret == 77);
@@ -119,7 +119,7 @@ int main()
 
 	struct sort_vector sv;
 	sort_vector_init(&sv);
-	sv.sort_by = SORT_SENT_MONO;
+	sv.sort_by = DLOGUTIL_SORT_SENT_MONO;
 	sv.timeout = 60;
 	sv.dump = DLOGUTIL_MODE_CONTINUOUS;
 	sv.size = DEFAULT_SORT_BUFFER_SIZE;
@@ -177,8 +177,8 @@ int main()
 	for (int i = 0; i < 10; ++i) {
 		fds[i] = &fd_stor[i];
 	}
-	assert(!find_earliest_log(fds, 0, SORT_SENT_MONO));
-	assert(find_earliest_log(fds, 10, SORT_SENT_MONO) == fds[8]);
+	assert(!find_earliest_log(fds, 0, DLOGUTIL_SORT_SENT_MONO));
+	assert(find_earliest_log(fds, 10, DLOGUTIL_SORT_SENT_MONO) == fds[8]);
 
 	while (!sort_vector_empty(&sv))
 		sort_vector_pop(&sv);
diff --git a/src/tests/queued_entry.c b/src/tests/queued_entry.c
index d35492d7..3d8132c2 100644
--- a/src/tests/queued_entry.c
+++ b/src/tests/queued_entry.c
@@ -27,20 +27,20 @@ int __wrap_clock_gettime(clockid_t clk_id, struct timespec *tp)
 
 int main()
 {
-	assert(get_proper_clock(SORT_SENT_MONO) == CLOCK_MONOTONIC);
-	assert(get_proper_clock(SORT_SENT_REAL) == CLOCK_REALTIME);
-	assert(get_proper_clock(SORT_RECV_MONO) == CLOCK_MONOTONIC);
-	assert(get_proper_clock(SORT_RECV_REAL) == CLOCK_REALTIME);
+	assert(get_proper_clock(DLOGUTIL_SORT_SENT_MONO) == CLOCK_MONOTONIC);
+	assert(get_proper_clock(DLOGUTIL_SORT_SENT_REAL) == CLOCK_REALTIME);
+	assert(get_proper_clock(DLOGUTIL_SORT_RECV_MONO) == CLOCK_MONOTONIC);
+	assert(get_proper_clock(DLOGUTIL_SORT_RECV_REAL) == CLOCK_REALTIME);
 
 	struct log_config conf = {NULL, NULL};
 	const struct {
 		const char *const str;
 		enum dlogutil_sorting_order order;
 	} ordering[] = {
-		{ "sent_real", SORT_SENT_REAL },
-		{ "sent_mono", SORT_SENT_MONO },
-		{ "recv_real", SORT_RECV_REAL },
-		{ "recv_mono", SORT_RECV_MONO },
+		{ "sent_real", DLOGUTIL_SORT_SENT_REAL },
+		{ "sent_mono", DLOGUTIL_SORT_SENT_MONO },
+		{ "recv_real", DLOGUTIL_SORT_RECV_REAL },
+		{ "recv_mono", DLOGUTIL_SORT_RECV_MONO },
 	};
 	for (size_t i = 0; i < NELEMS(ordering); ++i) {
 		log_config_set(&conf, "sort_by", ordering[i].str);
@@ -58,16 +58,16 @@ int main()
 		 .sec_recv_real = 7,
 		.nsec_recv_real = 8,
 	};
-	ts = dlogutil_entry_ts(&le, SORT_SENT_MONO);
+	ts = dlogutil_entry_ts(&le, DLOGUTIL_SORT_SENT_MONO);
 	assert(ts.tv_sec  == le. sec_sent_mono);
 	assert(ts.tv_nsec == le.nsec_sent_mono);
-	ts = dlogutil_entry_ts(&le, SORT_RECV_REAL);
+	ts = dlogutil_entry_ts(&le, DLOGUTIL_SORT_RECV_REAL);
 	assert(ts.tv_sec  == le. sec_recv_real);
 	assert(ts.tv_nsec == le.nsec_recv_real);
-	ts = dlogutil_entry_ts(&le, SORT_SENT_REAL);
+	ts = dlogutil_entry_ts(&le, DLOGUTIL_SORT_SENT_REAL);
 	assert(ts.tv_sec  == le. sec_sent_real);
 	assert(ts.tv_nsec == le.nsec_sent_real);
-	ts = dlogutil_entry_ts(&le, SORT_RECV_MONO);
+	ts = dlogutil_entry_ts(&le, DLOGUTIL_SORT_RECV_MONO);
 	assert(ts.tv_sec  == le. sec_recv_mono);
 	assert(ts.tv_nsec == le.nsec_recv_mono);
 
diff --git a/src/tests/test_logger_log_storage.c b/src/tests/test_logger_log_storage.c
index df7043bf..723e5d3d 100644
--- a/src/tests/test_logger_log_storage.c
+++ b/src/tests/test_logger_log_storage.c
@@ -79,17 +79,17 @@ void test_add_logs(log_storage *s1, unsigned cnt, unsigned sec_base, bool inc, u
 		if (set_check)
 			check_sec = sec_to_set;
 		switch (log_storage_get_sorting_order(s1)) {
-		case SORT_RECV_REAL: {
+		case DLOGUTIL_SORT_RECV_REAL: {
 			struct dlogutil_entry_with_msg e1 = LE_RR(STR1, sec_to_set, nsec);
 			assert(log_storage_add_new_entry(s1, &e1.header));
 			break;
 		}
-		case SORT_RECV_MONO: {
+		case DLOGUTIL_SORT_RECV_MONO: {
 			struct dlogutil_entry_with_msg e1 = LE_RM(STR1, sec_to_set, nsec);
 			assert(log_storage_add_new_entry(s1, &e1.header));
 			break;
 		}
-		case SORT_SENT_REAL: {
+		case DLOGUTIL_SORT_SENT_REAL: {
 			struct dlogutil_entry_with_msg e1 = LE_SR(STR1, sec_to_set, nsec);
 			assert(log_storage_add_new_entry(s1, &e1.header));
 			break;
@@ -113,13 +113,13 @@ void test_reader_get_new_entry(log_storage_reader *r, unsigned sec_to_check)
 	assert(s);
 	int32_t entry_sec;
 	switch (log_storage_get_sorting_order(s)) {
-	case SORT_RECV_REAL:
+	case DLOGUTIL_SORT_RECV_REAL:
 		entry_sec = le->sec_recv_real;
 		break;
-	case SORT_RECV_MONO:
+	case DLOGUTIL_SORT_RECV_MONO:
 		entry_sec = le->sec_recv_mono;
 		break;
-	case SORT_SENT_REAL:
+	case DLOGUTIL_SORT_SENT_REAL:
 		entry_sec = le->sec_sent_real;
 		break;
 	default:
@@ -146,7 +146,7 @@ int main()
 	{
 		const int CNT = 1000;
 
-		log_storage *s1 = log_storage_create(1, SORT_SENT_MONO);
+		log_storage *s1 = log_storage_create(1, DLOGUTIL_SORT_SENT_MONO);
 		assert(s1);
 		assert(log_storage_get_capacity(s1) == 1);
 
@@ -197,7 +197,7 @@ int main()
 	/************* TEST 2 ***************/
 	/* Basic test checking normal operation - add entries, read entries */
 	{
-		log_storage *s1 = log_storage_create(1000000, SORT_SENT_MONO);
+		log_storage *s1 = log_storage_create(1000000, DLOGUTIL_SORT_SENT_MONO);
 		assert(s1);
 		callback_count = 0;
 
@@ -249,7 +249,7 @@ int main()
 		const int CNT = 1000;
 		callback_count = 0;
 
-		for (int i = 0; i < SORT_MAX; i++) {
+		for (int i = 0; i < DLOGUTIL_SORT_MAX; i++) {
 			log_storage *s = log_storage_create(1000000, i);
 			assert(s);
 			log_storage_reader *r = log_storage_new_reader(s, false, dont_call_this_callback, NULL);
@@ -275,7 +275,7 @@ int main()
 	{
 		const int CNT = 1000;
 		callback_count = 0;
-		log_storage *s1 = log_storage_create(1000000, SORT_SENT_MONO);
+		log_storage *s1 = log_storage_create(1000000, DLOGUTIL_SORT_SENT_MONO);
 		assert(s1);
 		log_storage_reader *r1 = log_storage_new_reader(s1, false, callback_check_sec, NULL);
 		log_storage_reader *r2 = log_storage_new_reader(s1, false, dont_call_this_callback, NULL);
@@ -309,7 +309,7 @@ int main()
 	{
 		const int CNT = 1000;
 		callback_count = 0;
-		log_storage *s1 = log_storage_create(1000000, SORT_SENT_MONO);
+		log_storage *s1 = log_storage_create(1000000, DLOGUTIL_SORT_SENT_MONO);
 		assert(s1);
 		log_storage_reader *r1 = log_storage_new_reader(s1, false, callback_count_inc, NULL);
 		log_storage_reader *r2 = log_storage_new_reader(s1, false, callback_count_inc, NULL);
@@ -362,7 +362,7 @@ int main()
 	{
 		const int CNT = 1000;
 		callback_count = 0;
-		log_storage *s1 = log_storage_create(1000000, SORT_SENT_MONO);
+		log_storage *s1 = log_storage_create(1000000, DLOGUTIL_SORT_SENT_MONO);
 		assert(s1);
 		log_storage_reader *r1 = log_storage_new_reader(s1, true, dont_call_this_callback, NULL);
 		assert(r1);
@@ -434,7 +434,7 @@ int main()
 	/************* TEST 6 ***************/
 	/* Test basic bookkeeping */
 	{
-		log_storage *const s1 = log_storage_create(10000, SORT_SENT_MONO);
+		log_storage *const s1 = log_storage_create(10000, DLOGUTIL_SORT_SENT_MONO);
 		log_storage_reader *const r1 = log_storage_new_reader(s1, false, callback_count_inc, NULL);
 
 		struct dlogutil_entry_with_msg le1 = LE_RR(STR1, 123, 456);
@@ -456,11 +456,11 @@ int main()
 	/* Test syscall failure handling */
 	{
 		fail_malloc = true;
-		log_storage *s1 = log_storage_create(10000, SORT_SENT_MONO);
+		log_storage *s1 = log_storage_create(10000, DLOGUTIL_SORT_SENT_MONO);
 		assert(!s1);
 		fail_malloc = false;
 
-		s1 = log_storage_create(10000, SORT_SENT_MONO);
+		s1 = log_storage_create(10000, DLOGUTIL_SORT_SENT_MONO);
 		assert(s1);
 
 		log_storage_reader *const r1 = log_storage_new_reader(s1, false, callback_count_inc, NULL);