kernel
/
git
mirror of https://git.kernel.org/pub/scm/git/git.git
1
0
Fork 0
Code Releases Activity

Merge branch 'jt/repo-struct-more-objinfo' 

More object database related information are shown in "git repo
structure" output.

* jt/repo-struct-more-objinfo:
  builtin/repo: add object disk size info to structure table
  builtin/repo: add disk size info to keyvalue stucture output
  builtin/repo: add inflated object info to structure table
  builtin/repo: add inflated object info to keyvalue structure output
  builtin/repo: humanise count values in structure output
  strbuf: split out logic to humanise byte values
  builtin/repo: group per-type object values into struct
main
Junio C Hamano 2025-12-30 12:58:19 +09:00
parent 7c7698a654 df1b071fed
commit 02e9bc3392
6 changed files with 335 additions and 102 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Documentation/git-repo.adoc
View File

@ -50,6 +50,8 @@ supported:
+
* Reference counts categorized by type
* Reachable object counts categorized by type
* Total inflated size of reachable objects by type
* Total disk size of reachable objects by type
+
The output format can be chosen through the flag `--format`. Three formats are
supported:

175
builtin/repo.c
View File

@ -2,6 +2,8 @@

#include "builtin.h"
#include "environment.h"
#include "hex.h"
#include "odb.h"
#include "parse-options.h"
#include "path-walk.h"
#include "progress.h"
@ -202,13 +204,19 @@ struct ref_stats {
size_t others;
};

struct object_stats {
struct object_values {
size_t tags;
size_t commits;
size_t trees;
size_t blobs;
};

struct object_stats {
struct object_values type_counts;
struct object_values inflated_sizes;
struct object_values disk_sizes;
};

struct repo_structure {
struct ref_stats refs;
struct object_stats objects;
@ -219,6 +227,7 @@ struct stats_table {

int name_col_width;
int value_col_width;
int unit_col_width;
};

/*
@ -226,6 +235,7 @@ struct stats_table {
*/
struct stats_table_entry {
char *value;
const char *unit;
};

static void stats_table_vaddf(struct stats_table *table,
@ -246,11 +256,18 @@ static void stats_table_vaddf(struct stats_table *table,

if (name_width > table->name_col_width)
table->name_col_width = name_width;
if (entry) {
if (!entry)
return;
if (entry->value) {
int value_width = utf8_strwidth(entry->value);
if (value_width > table->value_col_width)
table->value_col_width = value_width;
}
if (entry->unit) {
int unit_width = utf8_strwidth(entry->unit);
if (unit_width > table->unit_col_width)
table->unit_col_width = unit_width;
}
}

static void stats_table_addf(struct stats_table *table, const char *format, ...)
@ -269,7 +286,21 @@ static void stats_table_count_addf(struct stats_table *table, size_t value,
va_list ap;

CALLOC_ARRAY(entry, 1);
entry->value = xstrfmt("%" PRIuMAX, (uintmax_t)value);
humanise_count(value, &entry->value, &entry->unit);

va_start(ap, format);
stats_table_vaddf(table, entry, format, ap);
va_end(ap);
}

static void stats_table_size_addf(struct stats_table *table, size_t value,
const char *format, ...)
{
struct stats_table_entry *entry;
va_list ap;

CALLOC_ARRAY(entry, 1);
humanise_bytes(value, &entry->value, &entry->unit, HUMANISE_COMPACT);

va_start(ap, format);
stats_table_vaddf(table, entry, format, ap);
@ -281,9 +312,9 @@ static inline size_t get_total_reference_count(struct ref_stats *stats)
return stats->branches + stats->remotes + stats->tags + stats->others;
}

static inline size_t get_total_object_count(struct object_stats *stats)
static inline size_t get_total_object_values(struct object_values *values)
{
return stats->tags + stats->commits + stats->trees + stats->blobs;
return values->tags + values->commits + values->trees + values->blobs;
}

static void stats_table_setup_structure(struct stats_table *table,
@ -291,7 +322,9 @@ static void stats_table_setup_structure(struct stats_table *table,
{
struct object_stats *objects = &stats->objects;
struct ref_stats *refs = &stats->refs;
size_t object_total;
size_t inflated_object_total;
size_t object_count_total;
size_t disk_object_total;
size_t ref_total;

ref_total = get_total_reference_count(refs);
@ -302,34 +335,66 @@ static void stats_table_setup_structure(struct stats_table *table,
stats_table_count_addf(table, refs->remotes, " * %s", _("Remotes"));
stats_table_count_addf(table, refs->others, " * %s", _("Others"));

object_total = get_total_object_count(objects);
object_count_total = get_total_object_values(&objects->type_counts);
stats_table_addf(table, "");
stats_table_addf(table, "* %s", _("Reachable objects"));
stats_table_count_addf(table, object_total, " * %s", _("Count"));
stats_table_count_addf(table, objects->commits, " * %s", _("Commits"));
stats_table_count_addf(table, objects->trees, " * %s", _("Trees"));
stats_table_count_addf(table, objects->blobs, " * %s", _("Blobs"));
stats_table_count_addf(table, objects->tags, " * %s", _("Tags"));
stats_table_count_addf(table, object_count_total, " * %s", _("Count"));
stats_table_count_addf(table, objects->type_counts.commits,
" * %s", _("Commits"));
stats_table_count_addf(table, objects->type_counts.trees,
" * %s", _("Trees"));
stats_table_count_addf(table, objects->type_counts.blobs,
" * %s", _("Blobs"));
stats_table_count_addf(table, objects->type_counts.tags,
" * %s", _("Tags"));

inflated_object_total = get_total_object_values(&objects->inflated_sizes);
stats_table_size_addf(table, inflated_object_total,
" * %s", _("Inflated size"));
stats_table_size_addf(table, objects->inflated_sizes.commits,
" * %s", _("Commits"));
stats_table_size_addf(table, objects->inflated_sizes.trees,
" * %s", _("Trees"));
stats_table_size_addf(table, objects->inflated_sizes.blobs,
" * %s", _("Blobs"));
stats_table_size_addf(table, objects->inflated_sizes.tags,
" * %s", _("Tags"));

disk_object_total = get_total_object_values(&objects->disk_sizes);
stats_table_size_addf(table, disk_object_total,
" * %s", _("Disk size"));
stats_table_size_addf(table, objects->disk_sizes.commits,
" * %s", _("Commits"));
stats_table_size_addf(table, objects->disk_sizes.trees,
" * %s", _("Trees"));
stats_table_size_addf(table, objects->disk_sizes.blobs,
" * %s", _("Blobs"));
stats_table_size_addf(table, objects->disk_sizes.tags,
" * %s", _("Tags"));
}

static void stats_table_print_structure(const struct stats_table *table)
{
const char *name_col_title = _("Repository structure");
const char *value_col_title = _("Value");
int name_col_width = utf8_strwidth(name_col_title);
int value_col_width = utf8_strwidth(value_col_title);
int title_name_width = utf8_strwidth(name_col_title);
int title_value_width = utf8_strwidth(value_col_title);
int name_col_width = table->name_col_width;
int value_col_width = table->value_col_width;
int unit_col_width = table->unit_col_width;
struct string_list_item *item;
struct strbuf buf = STRBUF_INIT;

if (table->name_col_width > name_col_width)
name_col_width = table->name_col_width;
if (table->value_col_width > value_col_width)
value_col_width = table->value_col_width;
if (title_name_width > name_col_width)
name_col_width = title_name_width;
if (title_value_width > value_col_width + unit_col_width + 1)
value_col_width = title_value_width - unit_col_width;

strbuf_addstr(&buf, "| ");
strbuf_utf8_align(&buf, ALIGN_LEFT, name_col_width, name_col_title);
strbuf_addstr(&buf, " | ");
strbuf_utf8_align(&buf, ALIGN_LEFT, value_col_width, value_col_title);
strbuf_utf8_align(&buf, ALIGN_LEFT,
value_col_width + unit_col_width + 1, value_col_title);
strbuf_addstr(&buf, " |");
printf("%s\n", buf.buf);

@ -337,17 +402,20 @@ static void stats_table_print_structure(const struct stats_table *table)
for (int i = 0; i < name_col_width; i++)
putchar('-');
printf(" | ");
for (int i = 0; i < value_col_width; i++)
for (int i = 0; i < value_col_width + unit_col_width + 1; i++)
putchar('-');
printf(" |\n");

for_each_string_list_item(item, &table->rows) {
struct stats_table_entry *entry = item->util;
const char *value = "";
const char *unit = "";

if (entry) {
struct stats_table_entry *entry = item->util;
value = entry->value;
if (entry->unit)
unit = entry->unit;
}

strbuf_reset(&buf);
@ -355,6 +423,8 @@ static void stats_table_print_structure(const struct stats_table *table)
strbuf_utf8_align(&buf, ALIGN_LEFT, name_col_width, item->string);
strbuf_addstr(&buf, " | ");
strbuf_utf8_align(&buf, ALIGN_RIGHT, value_col_width, value);
strbuf_addch(&buf, ' ');
strbuf_utf8_align(&buf, ALIGN_LEFT, unit_col_width, unit);
strbuf_addstr(&buf, " |");
printf("%s\n", buf.buf);
}
@ -389,13 +459,31 @@ static void structure_keyvalue_print(struct repo_structure *stats,
(uintmax_t)stats->refs.others, value_delim);

printf("objects.commits.count%c%" PRIuMAX "%c", key_delim,
(uintmax_t)stats->objects.commits, value_delim);
(uintmax_t)stats->objects.type_counts.commits, value_delim);
printf("objects.trees.count%c%" PRIuMAX "%c", key_delim,
(uintmax_t)stats->objects.trees, value_delim);
(uintmax_t)stats->objects.type_counts.trees, value_delim);
printf("objects.blobs.count%c%" PRIuMAX "%c", key_delim,
(uintmax_t)stats->objects.blobs, value_delim);
(uintmax_t)stats->objects.type_counts.blobs, value_delim);
printf("objects.tags.count%c%" PRIuMAX "%c", key_delim,
(uintmax_t)stats->objects.tags, value_delim);
(uintmax_t)stats->objects.type_counts.tags, value_delim);

printf("objects.commits.inflated_size%c%" PRIuMAX "%c", key_delim,
(uintmax_t)stats->objects.inflated_sizes.commits, value_delim);
printf("objects.trees.inflated_size%c%" PRIuMAX "%c", key_delim,
(uintmax_t)stats->objects.inflated_sizes.trees, value_delim);
printf("objects.blobs.inflated_size%c%" PRIuMAX "%c", key_delim,
(uintmax_t)stats->objects.inflated_sizes.blobs, value_delim);
printf("objects.tags.inflated_size%c%" PRIuMAX "%c", key_delim,
(uintmax_t)stats->objects.inflated_sizes.tags, value_delim);

printf("objects.commits.disk_size%c%" PRIuMAX "%c", key_delim,
(uintmax_t)stats->objects.disk_sizes.commits, value_delim);
printf("objects.trees.disk_size%c%" PRIuMAX "%c", key_delim,
(uintmax_t)stats->objects.disk_sizes.trees, value_delim);
printf("objects.blobs.disk_size%c%" PRIuMAX "%c", key_delim,
(uintmax_t)stats->objects.disk_sizes.blobs, value_delim);
printf("objects.tags.disk_size%c%" PRIuMAX "%c", key_delim,
(uintmax_t)stats->objects.disk_sizes.tags, value_delim);

fflush(stdout);
}
@ -460,6 +548,7 @@ static void structure_count_references(struct ref_stats *stats,
}

struct count_objects_data {
struct object_database *odb;
struct object_stats *stats;
struct progress *progress;
};
@ -469,26 +558,53 @@ static int count_objects(const char *path UNUSED, struct oid_array *oids,
{
struct count_objects_data *data = cb_data;
struct object_stats *stats = data->stats;
size_t inflated_total = 0;
size_t disk_total = 0;
size_t object_count;

for (size_t i = 0; i < oids->nr; i++) {
struct object_info oi = OBJECT_INFO_INIT;
unsigned long inflated;
off_t disk;

oi.sizep = &inflated;
oi.disk_sizep = &disk;

if (odb_read_object_info_extended(data->odb, &oids->oid[i], &oi,
OBJECT_INFO_SKIP_FETCH_OBJECT |
OBJECT_INFO_QUICK) < 0)
continue;

inflated_total += inflated;
disk_total += disk;
}

switch (type) {
case OBJ_TAG:
stats->tags += oids->nr;
stats->type_counts.tags += oids->nr;
stats->inflated_sizes.tags += inflated_total;
stats->disk_sizes.tags += disk_total;
break;
case OBJ_COMMIT:
stats->commits += oids->nr;
stats->type_counts.commits += oids->nr;
stats->inflated_sizes.commits += inflated_total;
stats->disk_sizes.commits += disk_total;
break;
case OBJ_TREE:
stats->trees += oids->nr;
stats->type_counts.trees += oids->nr;
stats->inflated_sizes.trees += inflated_total;
stats->disk_sizes.trees += disk_total;
break;
case OBJ_BLOB:
stats->blobs += oids->nr;
stats->type_counts.blobs += oids->nr;
stats->inflated_sizes.blobs += inflated_total;
stats->disk_sizes.blobs += disk_total;
break;
default:
BUG("invalid object type");
}

object_count = get_total_object_count(stats);
object_count = get_total_object_values(&stats->type_counts);
display_progress(data->progress, object_count);

return 0;
@ -500,6 +616,7 @@ static void structure_count_objects(struct object_stats *stats,
{
struct path_walk_info info = PATH_WALK_INFO_INIT;
struct count_objects_data data = {
.odb = repo->objects,
.stats = stats,
};


110
strbuf.c
View File

@ -836,47 +836,83 @@ void strbuf_addstr_urlencode(struct strbuf *sb, const char *s,
strbuf_add_urlencode(sb, s, strlen(s), allow_unencoded_fn);
}

static void strbuf_humanise(struct strbuf *buf, off_t bytes,
int humanise_rate)
void humanise_count(size_t count, char **value, const char **unit)
{
if (bytes > 1 << 30) {
strbuf_addf(buf,
humanise_rate == 0 ?
/* TRANSLATORS: IEC 80000-13:2008 gibibyte */
_("%u.%2.2u GiB") :
/* TRANSLATORS: IEC 80000-13:2008 gibibyte/second */
_("%u.%2.2u GiB/s"),
(unsigned)(bytes >> 30),
(unsigned)(bytes & ((1 << 30) - 1)) / 10737419);
} else if (bytes > 1 << 20) {
unsigned x = bytes + 5243; /* for rounding */
strbuf_addf(buf,
humanise_rate == 0 ?
/* TRANSLATORS: IEC 80000-13:2008 mebibyte */
_("%u.%2.2u MiB") :
/* TRANSLATORS: IEC 80000-13:2008 mebibyte/second */
_("%u.%2.2u MiB/s"),
x >> 20, ((x & ((1 << 20) - 1)) * 100) >> 20);
} else if (bytes > 1 << 10) {
unsigned x = bytes + 5; /* for rounding */
strbuf_addf(buf,
humanise_rate == 0 ?
/* TRANSLATORS: IEC 80000-13:2008 kibibyte */
_("%u.%2.2u KiB") :
/* TRANSLATORS: IEC 80000-13:2008 kibibyte/second */
_("%u.%2.2u KiB/s"),
x >> 10, ((x & ((1 << 10) - 1)) * 100) >> 10);
if (count >= 1000000000) {
size_t x = count + 5000000; /* for rounding */
*value = xstrfmt(_("%u.%2.2u"), (unsigned)(x / 1000000000),
(unsigned)(x % 1000000000 / 10000000));
/* TRANSLATORS: SI decimal prefix symbol for 10^9 */
*unit = _("G");
} else if (count >= 1000000) {
size_t x = count + 5000; /* for rounding */
*value = xstrfmt(_("%u.%2.2u"), (unsigned)(x / 1000000),
(unsigned)(x % 1000000 / 10000));
/* TRANSLATORS: SI decimal prefix symbol for 10^6 */
*unit = _("M");
} else if (count >= 1000) {
size_t x = count + 5; /* for rounding */
*value = xstrfmt(_("%u.%2.2u"), (unsigned)(x / 1000),
(unsigned)(x % 1000 / 10));
/* TRANSLATORS: SI decimal prefix symbol for 10^3 */
*unit = _("k");
} else {
strbuf_addf(buf,
humanise_rate == 0 ?
/* TRANSLATORS: IEC 80000-13:2008 byte */
Q_("%u byte", "%u bytes", bytes) :
/* TRANSLATORS: IEC 80000-13:2008 byte/second */
Q_("%u byte/s", "%u bytes/s", bytes),
(unsigned)bytes);
*value = xstrfmt("%u", (unsigned)count);
*unit = NULL;
}
}

void humanise_bytes(off_t bytes, char **value, const char **unit,
unsigned flags)
{
int humanise_rate = flags & HUMANISE_RATE;

if (bytes > 1 << 30) {
*value = xstrfmt(_("%u.%2.2u"), (unsigned)(bytes >> 30),
(unsigned)(bytes & ((1 << 30) - 1)) / 10737419);
/* TRANSLATORS: IEC 80000-13:2008 gibibyte/second and gibibyte */
*unit = humanise_rate ? _("GiB/s") : _("GiB");
} else if (bytes > 1 << 20) {
unsigned x = bytes + 5243; /* for rounding */
*value = xstrfmt(_("%u.%2.2u"), x >> 20,
((x & ((1 << 20) - 1)) * 100) >> 20);
/* TRANSLATORS: IEC 80000-13:2008 mebibyte/second and mebibyte */
*unit = humanise_rate ? _("MiB/s") : _("MiB");
} else if (bytes > 1 << 10) {
unsigned x = bytes + 5; /* for rounding */
*value = xstrfmt(_("%u.%2.2u"), x >> 10,
((x & ((1 << 10) - 1)) * 100) >> 10);
/* TRANSLATORS: IEC 80000-13:2008 kibibyte/second and kibibyte */
*unit = humanise_rate ? _("KiB/s") : _("KiB");
} else {
*value = xstrfmt("%u", (unsigned)bytes);
if (flags & HUMANISE_COMPACT)
/* TRANSLATORS: IEC 80000-13:2008 byte/second and byte */
*unit = humanise_rate ? _("B/s") : _("B");
else
*unit = humanise_rate ?
/* TRANSLATORS: IEC 80000-13:2008 byte/second */
Q_("byte/s", "bytes/s", bytes) :
/* TRANSLATORS: IEC 80000-13:2008 byte */
Q_("byte", "bytes", bytes);
}
}

static void strbuf_humanise(struct strbuf *buf, off_t bytes, unsigned flags)
{
char *value;
const char *unit;

humanise_bytes(bytes, &value, &unit, flags);

/*
* TRANSLATORS: The first argument is the number string. The second
* argument is the unit string (i.e. "12.34 MiB/s").
*/
strbuf_addf(buf, _("%s %s"), value, unit);
free(value);
}

void strbuf_humanise_bytes(struct strbuf *buf, off_t bytes)
{
strbuf_humanise(buf, bytes, 0);
@ -884,7 +920,7 @@ void strbuf_humanise_bytes(struct strbuf *buf, off_t bytes)

void strbuf_humanise_rate(struct strbuf *buf, off_t bytes)
{
strbuf_humanise(buf, bytes, 1);
strbuf_humanise(buf, bytes, HUMANISE_RATE);
}

int printf_ln(const char *fmt, ...)

25
strbuf.h
View File

@ -367,6 +367,31 @@ void strbuf_addbuf_percentquote(struct strbuf *dst, const struct strbuf *src);
*/
void strbuf_add_percentencode(struct strbuf *dst, const char *src, int flags);

enum humanise_flags {
/*
* Use rate based units for humanised values.
*/
HUMANISE_RATE = (1 << 0),
/*
* Use compact "B" unit symbol instead of "byte/bytes" for humanised
* values.
*/
HUMANISE_COMPACT = (1 << 1),
};

/**
* Converts the given byte size into a downscaled human-readable value and
* corresponding unit as two separate strings.
*/
void humanise_bytes(off_t bytes, char **value, const char **unit,
unsigned flags);

/**
* Converts the given count into a downscaled human-readable value and
* corresponding unit as two separate strings.
*/
void humanise_count(size_t count, char **value, const char **unit);

/**
* Append the given byte size as a human-readable string (i.e. 12.23 KiB,
* 3.50 MiB).

7
t/helper/test-simple-ipc.c
View File

@ -603,7 +603,12 @@ int cmd__simple_ipc(int argc, const char **argv)
OPT_INTEGER(0, "bytecount", &cl_args.bytecount, N_("number of bytes")),
OPT_INTEGER(0, "batchsize", &cl_args.batchsize, N_("number of requests per thread")),

OPT_STRING(0, "byte", &bytevalue, N_("byte"), N_("ballast character")),
/*
* The "byte" string here is not marked for translation and
* instead relies on translation in strbuf.c:humanise_bytes() to
* avoid conflict with the plural form.
*/
OPT_STRING(0, "byte", &bytevalue, "byte", N_("ballast character")),
OPT_STRING(0, "token", &cl_args.token, N_("token"), N_("command token to send to the server")),

OPT_END()

118
t/t1901-repo-structure.sh
View File

@ -4,27 +4,54 @@ test_description='test git repo structure'

. ./test-lib.sh

object_type_disk_usage() {
disk_usage_opt="--disk-usage"

if test "$2" = "true"
then
disk_usage_opt="--disk-usage=human"
fi

if test "$1" = "all"
then
git rev-list --all --objects $disk_usage_opt
else
git rev-list --all --objects $disk_usage_opt \
--filter=object:type=$1 --filter-provided-objects
fi
}

test_expect_success 'empty repository' '
test_when_finished "rm -rf repo" &&
git init repo &&
(
cd repo &&
cat >expect <<-\EOF &&
| Repository structure | Value |
| -------------------- | ----- |
| * References | |
| * Count | 0 |
| * Branches | 0 |
| * Tags | 0 |
| * Remotes | 0 |
| * Others | 0 |
| | |
| * Reachable objects | |
| * Count | 0 |
| * Commits | 0 |
| * Trees | 0 |
| * Blobs | 0 |
| * Tags | 0 |
| Repository structure | Value |
| -------------------- | ------ |
| * References | |
| * Count | 0 |
| * Branches | 0 |
| * Tags | 0 |
| * Remotes | 0 |
| * Others | 0 |
| | |
| * Reachable objects | |
| * Count | 0 |
| * Commits | 0 |
| * Trees | 0 |
| * Blobs | 0 |
| * Tags | 0 |
| * Inflated size | 0 B |
| * Commits | 0 B |
| * Trees | 0 B |
| * Blobs | 0 B |
| * Tags | 0 B |
| * Disk size | 0 B |
| * Commits | 0 B |
| * Trees | 0 B |
| * Blobs | 0 B |
| * Tags | 0 B |
EOF

git repo structure >out 2>err &&
@ -34,12 +61,12 @@ test_expect_success 'empty repository' '
)
'

test_expect_success 'repository with references and objects' '
test_expect_success SHA1 'repository with references and objects' '
test_when_finished "rm -rf repo" &&
git init repo &&
(
cd repo &&
test_commit_bulk 42 &&
test_commit_bulk 1005 &&
git tag -a foo -m bar &&

oid="$(git rev-parse HEAD)" &&
@ -48,22 +75,35 @@ test_expect_success 'repository with references and objects' '
# Also creates a commit, tree, and blob.
git notes add -m foo &&

cat >expect <<-\EOF &&
| Repository structure | Value |
| -------------------- | ----- |
| * References | |
| * Count | 4 |
| * Branches | 1 |
| * Tags | 1 |
| * Remotes | 1 |
| * Others | 1 |
| | |
| * Reachable objects | |
| * Count | 130 |
| * Commits | 43 |
| * Trees | 43 |
| * Blobs | 43 |
| * Tags | 1 |
# The tags disk size is handled specially due to the
# git-rev-list(1) --disk-usage=human option printing the full
# "byte/bytes" unit string instead of just "B".
cat >expect <<-EOF &&
| Repository structure | Value |
| -------------------- | ---------- |
| * References | |
| * Count | 4 |
| * Branches | 1 |
| * Tags | 1 |
| * Remotes | 1 |
| * Others | 1 |
| | |
| * Reachable objects | |
| * Count | 3.02 k |
| * Commits | 1.01 k |
| * Trees | 1.01 k |
| * Blobs | 1.01 k |
| * Tags | 1 |
| * Inflated size | 16.03 MiB |
| * Commits | 217.92 KiB |
| * Trees | 15.81 MiB |
| * Blobs | 11.68 KiB |
| * Tags | 132 B |
| * Disk size | $(object_type_disk_usage all true) |
| * Commits | $(object_type_disk_usage commit true) |
| * Trees | $(object_type_disk_usage tree true) |
| * Blobs | $(object_type_disk_usage blob true) |
| * Tags | $(object_type_disk_usage tag) B |
EOF

git repo structure >out 2>err &&
@ -73,7 +113,7 @@ test_expect_success 'repository with references and objects' '
)
'

test_expect_success 'keyvalue and nul format' '
test_expect_success SHA1 'keyvalue and nul format' '
test_when_finished "rm -rf repo" &&
git init repo &&
(
@ -81,7 +121,7 @@ test_expect_success 'keyvalue and nul format' '
test_commit_bulk 42 &&
git tag -a foo -m bar &&

cat >expect <<-\EOF &&
cat >expect <<-EOF &&
references.branches.count=1
references.tags.count=1
references.remotes.count=0
@ -90,6 +130,14 @@ test_expect_success 'keyvalue and nul format' '
objects.trees.count=42
objects.blobs.count=42
objects.tags.count=1
objects.commits.inflated_size=9225
objects.trees.inflated_size=28554
objects.blobs.inflated_size=453
objects.tags.inflated_size=132
objects.commits.disk_size=$(object_type_disk_usage commit)
objects.trees.disk_size=$(object_type_disk_usage tree)
objects.blobs.disk_size=$(object_type_disk_usage blob)
objects.tags.disk_size=$(object_type_disk_usage tag)
EOF

git repo structure --format=keyvalue >out 2>err &&