development/git
development/git
1
0
Fork 0
mirror of https://github.com/git/git synced 2024-06-30 22:54:27 +00:00
Code Issues Projects Releases Wiki Activity

Merge branch 'cp/unit-test-reftable-pq' into seen

Browse Source 
The tests for "pq" part of reftable library got rewritten to use
the unit test framework.

* cp/unit-test-reftable-pq:
  t-reftable-pq: add tests for merged_iter_pqueue_top()
  t-reftable-pq: add test for index based comparison
  t-reftable-pq: make merged_iter_pqueue_check() callable by reference
  t-reftable-pq: make merged_iter_pqueue_check() static
  t: move reftable/pq_test.c to the unit testing framework
  reftable: change the type of array indices to 'size_t' in reftable/pq.c
  reftable: remove unncessary curly braces in reftable/pq.c
This commit is contained in:
Junio C Hamano 2024-06-27 16:30:58 -07:00
commit 1a916f1c46
6 changed files with 166 additions and 96 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Makefile
View File

@ -1342,6 +1342,7 @@ UNIT_TEST_PROGRAMS += t-mem-pool
UNIT_TEST_PROGRAMS += t-oidtree
UNIT_TEST_PROGRAMS += t-prio-queue
UNIT_TEST_PROGRAMS += t-reftable-basics
UNIT_TEST_PROGRAMS += t-reftable-pq
UNIT_TEST_PROGRAMS += t-reftable-tree
UNIT_TEST_PROGRAMS += t-strbuf
UNIT_TEST_PROGRAMS += t-strcmp-offset
@ -2683,7 +2684,6 @@ REFTABLE_OBJS += reftable/writer.o
REFTABLE_TEST_OBJS += reftable/block_test.o
REFTABLE_TEST_OBJS += reftable/dump.o
REFTABLE_TEST_OBJS += reftable/merged_test.o
REFTABLE_TEST_OBJS += reftable/pq_test.o
REFTABLE_TEST_OBJS += reftable/record_test.o
REFTABLE_TEST_OBJS += reftable/readwrite_test.o
REFTABLE_TEST_OBJS += reftable/stack_test.o

29
reftable/pq.c
View File

@ -22,27 +22,21 @@ int pq_less(struct pq_entry *a, struct pq_entry *b)
struct pq_entry merged_iter_pqueue_remove(struct merged_iter_pqueue *pq)
{
int i = 0;
size_t i = 0;
struct pq_entry e = pq->heap[0];
pq->heap[0] = pq->heap[pq->len - 1];
pq->len--;
i = 0;
while (i < pq->len) {
int min = i;
int j = 2 * i + 1;
int k = 2 * i + 2;
if (j < pq->len && pq_less(&pq->heap[j], &pq->heap[i])) {
size_t min = i;
size_t j = 2 * i + 1;
size_t k = 2 * i + 2;
if (j < pq->len && pq_less(&pq->heap[j], &pq->heap[i]))
min = j;
}
if (k < pq->len && pq_less(&pq->heap[k], &pq->heap[min])) {
if (k < pq->len && pq_less(&pq->heap[k], &pq->heap[min]))
min = k;
}
if (min == i) {
if (min == i)
break;
}
SWAP(pq->heap[i], pq->heap[min]);
i = min;
}
@ -52,20 +46,17 @@ struct pq_entry merged_iter_pqueue_remove(struct merged_iter_pqueue *pq)
void merged_iter_pqueue_add(struct merged_iter_pqueue *pq, const struct pq_entry *e)
{
int i = 0;
size_t i = 0;
REFTABLE_ALLOC_GROW(pq->heap, pq->len + 1, pq->cap);
pq->heap[pq->len++] = *e;
i = pq->len - 1;
while (i > 0) {
int j = (i - 1) / 2;
if (pq_less(&pq->heap[j], &pq->heap[i])) {
size_t j = (i - 1) / 2;
if (pq_less(&pq->heap[j], &pq->heap[i]))
break;
}
SWAP(pq->heap[j], pq->heap[i]);
i = j;
}
}

1
reftable/pq.h
View File

@ -22,7 +22,6 @@ struct merged_iter_pqueue {
size_t cap;
};
void merged_iter_pqueue_check(struct merged_iter_pqueue pq);
struct pq_entry merged_iter_pqueue_remove(struct merged_iter_pqueue *pq);
void merged_iter_pqueue_add(struct merged_iter_pqueue *pq, const struct pq_entry *e);
void merged_iter_pqueue_release(struct merged_iter_pqueue *pq);

74
reftable/pq_test.c
View File

@ -1,74 +0,0 @@
/*
Copyright 2020 Google LLC
Use of this source code is governed by a BSD-style
license that can be found in the LICENSE file or at
https://developers.google.com/open-source/licenses/bsd
*/
#include "system.h"
#include "basics.h"
#include "constants.h"
#include "pq.h"
#include "record.h"
#include "reftable-tests.h"
#include "test_framework.h"
void merged_iter_pqueue_check(struct merged_iter_pqueue pq)
{
int i;
for (i = 1; i < pq.len; i++) {
int parent = (i - 1) / 2;
EXPECT(pq_less(&pq.heap[parent], &pq.heap[i]));
}
}
static void test_pq(void)
{
struct merged_iter_pqueue pq = { NULL };
struct reftable_record recs[54];
int N = ARRAY_SIZE(recs) - 1, i;
char *last = NULL;
for (i = 0; i < N; i++) {
struct strbuf refname = STRBUF_INIT;
strbuf_addf(&refname, "%02d", i);
reftable_record_init(&recs[i], BLOCK_TYPE_REF);
recs[i].u.ref.refname = strbuf_detach(&refname, NULL);
}
i = 1;
do {
struct pq_entry e = {
.rec = &recs[i],
};
merged_iter_pqueue_add(&pq, &e);
merged_iter_pqueue_check(pq);
i = (i * 7) % N;
} while (i != 1);
while (!merged_iter_pqueue_is_empty(pq)) {
struct pq_entry e = merged_iter_pqueue_remove(&pq);
merged_iter_pqueue_check(pq);
EXPECT(reftable_record_type(e.rec) == BLOCK_TYPE_REF);
if (last)
EXPECT(strcmp(last, e.rec->u.ref.refname) < 0);
last = e.rec->u.ref.refname;
}
for (i = 0; i < N; i++)
reftable_record_release(&recs[i]);
merged_iter_pqueue_release(&pq);
}
int pq_test_main(int argc, const char *argv[])
{
RUN_TEST(test_pq);
return 0;
}

1
t/helper/test-reftable.c
View File

@ -7,7 +7,6 @@ int cmd__reftable(int argc, const char **argv)
/* test from simple to complex. */
record_test_main(argc, argv);
block_test_main(argc, argv);
pq_test_main(argc, argv);
readwrite_test_main(argc, argv);
merged_test_main(argc, argv);
stack_test_main(argc, argv);

155
t/unit-tests/t-reftable-pq.c Normal file
View File

@ -0,0 +1,155 @@
/*
Copyright 2020 Google LLC
Use of this source code is governed by a BSD-style
license that can be found in the LICENSE file or at
https://developers.google.com/open-source/licenses/bsd
*/
#include "test-lib.h"
#include "reftable/constants.h"
#include "reftable/pq.h"
static void merged_iter_pqueue_check(const struct merged_iter_pqueue *pq)
{
for (size_t i = 1; i < pq->len; i++) {
size_t parent = (i - 1) / 2;
check(pq_less(&pq->heap[parent], &pq->heap[i]));
}
}
static int pq_entry_equal(struct pq_entry *a, struct pq_entry *b)
{
return !reftable_record_cmp(a->rec, b->rec) && (a->index == b->index);
}
static void test_pq_record(void)
{
struct merged_iter_pqueue pq = { 0 };
struct reftable_record recs[54];
size_t N = ARRAY_SIZE(recs) - 1, i;
char *last = NULL;
for (i = 0; i < N; i++) {
struct strbuf refname = STRBUF_INIT;
strbuf_addf(&refname, "%02"PRIuMAX, (uintmax_t)i);
reftable_record_init(&recs[i], BLOCK_TYPE_REF);
recs[i].u.ref.refname = strbuf_detach(&refname, NULL);
}
i = 1;
do {
struct pq_entry e = {
.rec = &recs[i],
};
merged_iter_pqueue_add(&pq, &e);
merged_iter_pqueue_check(&pq);
i = (i * 7) % N;
} while (i != 1);
while (!merged_iter_pqueue_is_empty(pq)) {
struct pq_entry top = merged_iter_pqueue_top(pq);
struct pq_entry e = merged_iter_pqueue_remove(&pq);
merged_iter_pqueue_check(&pq);
check(pq_entry_equal(&top, &e));
check(reftable_record_type(e.rec) == BLOCK_TYPE_REF);
if (last)
check_int(strcmp(last, e.rec->u.ref.refname), <, 0);
last = e.rec->u.ref.refname;
}
for (i = 0; i < N; i++)
reftable_record_release(&recs[i]);
merged_iter_pqueue_release(&pq);
}
static void test_pq_index(void)
{
struct merged_iter_pqueue pq = { 0 };
struct reftable_record recs[14];
char *last = NULL;
size_t N = ARRAY_SIZE(recs), i;
for (i = 0; i < N; i++) {
reftable_record_init(&recs[i], BLOCK_TYPE_REF);
recs[i].u.ref.refname = xstrdup("refs/heads/master");
}
for (i = 0; i < N; i++) {
struct pq_entry e = {
.rec = &recs[i],
.index = i,
};
merged_iter_pqueue_add(&pq, &e);
merged_iter_pqueue_check(&pq);
}
for (i = N - 1; !merged_iter_pqueue_is_empty(pq); i--) {
struct pq_entry top = merged_iter_pqueue_top(pq);
struct pq_entry e = merged_iter_pqueue_remove(&pq);
merged_iter_pqueue_check(&pq);
check(pq_entry_equal(&top, &e));
check(reftable_record_type(e.rec) == BLOCK_TYPE_REF);
check_int(e.index, ==, i);
if (last)
check_str(last, e.rec->u.ref.refname);
last = e.rec->u.ref.refname;
}
for (i = 0; i < N; i++)
reftable_record_release(&recs[i]);
merged_iter_pqueue_release(&pq);
}
static void test_merged_iter_pqueue_top(void)
{
struct merged_iter_pqueue pq = { 0 };
struct reftable_record recs[14];
size_t N = ARRAY_SIZE(recs), i;
for (i = 0; i < N; i++) {
reftable_record_init(&recs[i], BLOCK_TYPE_REF);
recs[i].u.ref.refname = xstrdup("refs/heads/master");
}
for (i = 0; i < N; i++) {
struct pq_entry e = {
.rec = &recs[i],
.index = i,
};
merged_iter_pqueue_add(&pq, &e);
merged_iter_pqueue_check(&pq);
}
for (i = N - 1; !merged_iter_pqueue_is_empty(pq); i--) {
struct pq_entry top = merged_iter_pqueue_top(pq);
struct pq_entry e = merged_iter_pqueue_remove(&pq);
merged_iter_pqueue_check(&pq);
check(pq_entry_equal(&top, &e));
check(reftable_record_equal(top.rec, &recs[i], GIT_SHA1_RAWSZ));
for (size_t j = 0; i < pq.len; j++) {
check(pq_less(&top, &pq.heap[j]));
check_int(top.index, >, j);
}
}
for (i = 0; i < N; i++)
reftable_record_release(&recs[i]);
merged_iter_pqueue_release(&pq);
}
int cmd_main(int argc, const char *argv[])
{
TEST(test_pq_record(), "pq works with record-based comparison");
TEST(test_pq_index(), "pq works with index-based comparison");
TEST(test_merged_iter_pqueue_top(), "merged_iter_pqueue_top works");
return test_done();
}