* Initializes a `git_diff_options` with default values. Equivalent to
* creating an instance with GIT_DIFF_OPTIONS_INIT.
*
-* @param opts the `git_diff_options` instance to initialize.
-* @param version the version of the struct; you should pass
-* `GIT_DIFF_OPTIONS_VERSION` here.
+* @param opts The `git_diff_options` instance to initialize.
+* @param version Version of struct; pass `GIT_DIFF_OPTIONS_VERSION`
* @return Zero on success; -1 on failure.
*/
GIT_EXTERN(int) git_diff_init_options(
- git_diff_options* opts,
- int version);
+ git_diff_options *opts,
+ unsigned int version);
/**
* When iterating over a diff, callback that will be made per file.
* Initializes a `git_diff_find_options` with default values. Equivalent to
* creating an instance with GIT_DIFF_FIND_OPTIONS_INIT.
*
-* @param opts the `git_diff_find_options` instance to initialize.
-* @param version the version of the struct; you should pass
-* `GIT_DIFF_FIND_OPTIONS_VERSION` here.
+* @param opts The `git_diff_find_options` instance to initialize.
+* @param version Version of struct; pass `GIT_DIFF_FIND_OPTIONS_VERSION`
* @return Zero on success; -1 on failure.
*/
GIT_EXTERN(int) git_diff_find_init_options(
- git_diff_find_options* opts,
- int version);
+ git_diff_find_options *opts,
+ unsigned int version);
/** @name Diff Generator Functions
*
const git_diff_options *diff_opts);
/**
-* Initializes a `git_diff_format_email_options` with default values. Equivalent to
-* creating an instance with GIT_DIFF_FORMAT_EMAIL_OPTIONS_INIT.
+* Initializes a `git_diff_format_email_options` with default values.
*
-* @param opts the `git_diff_format_email_options` instance to initialize.
-* @param version the version of the struct; you should pass
-* `GIT_DIFF_FORMAT_EMAIL_OPTIONS_VERSION` here.
+* Equivalent to creating an instance with GIT_DIFF_FORMAT_EMAIL_OPTIONS_INIT.
+*
+* @param opts Uhe `git_diff_format_email_options` instance to initialize.
+* @param version Version of struct; pass `GIT_DIFF_FORMAT_EMAIL_OPTIONS_VERSION`
* @return Zero on success; -1 on failure.
*/
GIT_EXTERN(int) git_diff_format_email_init_options(
git_diff_format_email_options *opts,
- int version);
+ unsigned int version);
GIT_END_DECL
* Initializes a `git_status_options` with default values. Equivalent to
* creating an instance with GIT_STATUS_OPTIONS_INIT.
*
- * @param opts the `git_status_options` instance to initialize.
- * @param version the version of the struct; you should pass
- * `GIT_STATUS_OPTIONS_VERSION` here.
+ * @param opts The `git_status_options` instance to initialize.
+ * @param version Version of struct; pass `GIT_STATUS_OPTIONS_VERSION`
* @return Zero on success; -1 on failure.
*/
GIT_EXTERN(int) git_status_init_options(
- git_status_options* opts,
- int version);
+ git_status_options *opts,
+ unsigned int version);
/**
* A status entry, providing the differences between the file as it exists
#include "git2/common.h"
#include "git2/types.h"
#include "git2/oid.h"
+#include "git2/diff.h"
+#include "git2/status.h"
/**
* @file git2/sys/diff.h
const git_diff_line *line,
void *payload); /*< payload must be a `FILE *` */
+
+typedef struct {
+ unsigned int version;
+ size_t stat_calls;
+ size_t oid_calculations;
+} git_diff_perfdata;
+
+#define GIT_DIFF_PERFDATA_VERSION 1
+#define GIT_DIFF_PERFDATA_INIT {GIT_DIFF_PERFDATA_VERSION,0,0}
+
+/**
+ * Get performance data for a diff object.
+ *
+ * @param out Structure to be filled with diff performance data
+ * @param diff Diff to read performance data from
+ * @return 0 for success, <0 for error
+ */
+GIT_EXTERN(int) git_diff_get_perfdata(
+ git_diff_perfdata *out, const git_diff *diff);
+
+/**
+ * Get performance data for diffs from a git_status_list
+ */
+GIT_EXTERN(int) git_status_list_get_perfdata(
+ git_diff_perfdata *out, const git_status_list *status);
+
/** @} */
GIT_END_DECL
#endif
GIT_BEGIN_DECL
/**
- * Available tracing messages. Each tracing level can be enabled
- * independently or pass GIT_TRACE_ALL to enable all levels.
+ * Available tracing levels. When tracing is set to a particular level,
+ * callers will be provided tracing at the given level and all lower levels.
*/
typedef enum {
/** No tracing will be performed. */
- GIT_TRACE_NONE = 0x0000u,
-
- /** All tracing messages will be sent. */
- GIT_TRACE_ALL = 0xFFFFu,
+ GIT_TRACE_NONE = 0,
/** Severe errors that may impact the program's execution */
- GIT_TRACE_FATAL = 0x0001u,
+ GIT_TRACE_FATAL = 1,
/** Errors that do not impact the program's execution */
- GIT_TRACE_ERROR = 0x0002u,
- GIT_TRACE_ERROR_AND_BELOW = 0x0003u,
+ GIT_TRACE_ERROR = 2,
/** Warnings that suggest abnormal data */
- GIT_TRACE_WARN = 0x0004u,
- GIT_TRACE_WARN_AND_BELOW = 0x0007u,
+ GIT_TRACE_WARN = 3,
/** Informational messages about program execution */
- GIT_TRACE_INFO = 0x0008u,
- GIT_TRACE_INFO_AND_BELOW = 0x000Fu,
+ GIT_TRACE_INFO = 4,
/** Detailed data that allows for debugging */
- GIT_TRACE_DEBUG = 0x0010u,
+ GIT_TRACE_DEBUG = 5,
/** Exceptionally detailed debugging data */
- GIT_TRACE_TRACE = 0x0020u,
-
- /** Performance tracking related traces */
- GIT_TRACE_PERF = 0x0040u,
+ GIT_TRACE_TRACE = 6
} git_trace_level_t;
/**
* An instance for a tracing function
*/
-typedef void (*git_trace_callback)(
- git_trace_level_t level, /* just one bit will be sent */
- void *cb_payload,
- void *msg_payload,
- const char *msg);
+typedef void (*git_trace_callback)(git_trace_level_t level, const char *msg);
/**
* Sets the system tracing configuration to the specified level with the
* specified callback. When system events occur at a level equal to, or
* lower than, the given level they will be reported to the given callback.
*
- * @param level Bitmask of all enabled trace levels
- * @param cb Function to call with trace messages
- * @param cb_payload Payload to pass when callback is invoked
+ * @param level Level to set tracing to
+ * @param cb Function to call with trace data
* @return 0 or an error code
*/
-GIT_EXTERN(int) git_trace_set(
- git_trace_level_t level,
- git_trace_callback cb,
- void *cb_payload);
+GIT_EXTERN(int) git_trace_set(git_trace_level_t level, git_trace_callback cb);
/** @} */
GIT_END_DECL
#include "index.h"
#include "odb.h"
#include "submodule.h"
-#include "trace.h"
#define DIFF_FLAG_IS_SET(DIFF,FLAG) (((DIFF)->opts.flags & (FLAG)) != 0)
#define DIFF_FLAG_ISNT_SET(DIFF,FLAG) (((DIFF)->opts.flags & (FLAG)) == 0)
if (!entry.mode) {
struct stat st;
- git_trace(GIT_TRACE_PERF, NULL, "stat");
+ diff->perf.stat_calls++;
+
if (p_stat(full_path.ptr, &st) < 0) {
error = git_path_set_error(errno, entry.path, "stat");
git_buf_free(&full_path);
if (S_ISGITLINK(entry.mode)) {
git_submodule *sm;
- git_trace(GIT_TRACE_PERF, NULL, "submodule_lookup");
if (!git_submodule_lookup(&sm, diff->repo, entry.path)) {
const git_oid *sm_oid = git_submodule_wd_id(sm);
if (sm_oid)
giterr_clear();
}
} else if (S_ISLNK(entry.mode)) {
- git_trace(GIT_TRACE_PERF, NULL, "oid_calculation");
error = git_odb__hashlink(out, full_path.ptr);
+ diff->perf.oid_calculations++;
} else if (!git__is_sizet(entry.file_size)) {
giterr_set(GITERR_OS, "File size overflow (for 32-bits) on '%s'",
entry.path);
if (fd < 0)
error = fd;
else {
- git_trace(GIT_TRACE_PERF, NULL, "oid_calculation");
error = git_odb__hashfd_filtered(
out, fd, (size_t)entry.file_size, GIT_OBJ_BLOB, fl);
p_close(fd);
+ diff->perf.oid_calculations++;
}
git_filter_list_free(fl);
ign == GIT_SUBMODULE_IGNORE_ALL)
return 0;
- git_trace(GIT_TRACE_PERF, NULL, "submodule_lookup");
-
if ((error = git_submodule_lookup(
&sub, diff->repo, info->nitem->path)) < 0) {
delta_type = GIT_DELTA_ADDED;
else if (nitem->mode == GIT_FILEMODE_COMMIT) {
- git_trace(GIT_TRACE_PERF, NULL, "submodule_lookup");
-
/* ignore things that are not actual submodules */
if (git_submodule_lookup(NULL, info->repo, nitem->path) != 0) {
giterr_clear();
error = 0;
}
+ diff->perf.stat_calls += old_iter->stat_calls + new_iter->stat_calls;
+
cleanup:
if (!error)
*diff_ptr = diff;
return (diff->opts.flags & GIT_DIFF_IGNORE_CASE) != 0;
}
+static int diff_options_bad_version(int version, const char *thing)
+{
+ giterr_set(GITERR_INVALID, "Invalid version %d for %s", version, thing);
+ return -1;
+}
+
+int git_diff_get_perfdata(git_diff_perfdata *out, const git_diff *diff)
+{
+ if (!out || out->version != GIT_DIFF_PERFDATA_VERSION)
+ return diff_options_bad_version(
+ out ? out->version : 0, "git_diff_perfdata");
+ out->stat_calls = diff->perf.stat_calls;
+ out->oid_calculations = diff->perf.oid_calculations;
+ return 0;
+}
+
int git_diff__paired_foreach(
git_diff *head2idx,
git_diff *idx2wd,
return error;
}
-int git_diff_init_options(git_diff_options* opts, int version)
+int git_diff_init_options(git_diff_options* opts, unsigned int version)
{
- if (version != GIT_DIFF_OPTIONS_VERSION) {
- giterr_set(GITERR_INVALID, "Invalid version %d for git_diff_options", version);
- return -1;
- } else {
- git_diff_options o = GIT_DIFF_OPTIONS_INIT;
- memcpy(opts, &o, sizeof(o));
- return 0;
- }
+ git_diff_options o = GIT_DIFF_OPTIONS_INIT;
+ if (version != o.version)
+ return diff_options_bad_version(version, "git_diff_options");
+ memcpy(opts, &o, sizeof(o));
+ return 0;
}
-int git_diff_find_init_options(git_diff_find_options* opts, int version)
+int git_diff_find_init_options(git_diff_find_options* opts, unsigned int version)
{
- if (version != GIT_DIFF_FIND_OPTIONS_VERSION) {
- giterr_set(GITERR_INVALID, "Invalid version %d for git_diff_find_options", version);
- return -1;
- } else {
- git_diff_find_options o = GIT_DIFF_FIND_OPTIONS_INIT;
- memcpy(opts, &o, sizeof(o));
- return 0;
- }
+ git_diff_find_options o = GIT_DIFF_FIND_OPTIONS_INIT;
+ if (version != o.version)
+ return diff_options_bad_version(version, "git_diff_find_options");
+ memcpy(opts, &o, sizeof(o));
+ return 0;
}
-int git_diff_format_email_init_options(git_diff_format_email_options* opts, int version)
+int git_diff_format_email_init_options(git_diff_format_email_options* opts, unsigned int version)
{
- if (version != GIT_DIFF_FORMAT_EMAIL_OPTIONS_VERSION) {
- giterr_set(GITERR_INVALID, "Invalid version %d for git_diff_format_email_options", version);
- return -1;
- } else {
- git_diff_format_email_options o = GIT_DIFF_FORMAT_EMAIL_OPTIONS_INIT;
- memcpy(opts, &o, sizeof(o));
- return 0;
- }
+ git_diff_format_email_options o = GIT_DIFF_FORMAT_EMAIL_OPTIONS_INIT;
+ if (version != o.version)
+ return diff_options_bad_version(version, "git_diff_format_email_options");
+ memcpy(opts, &o, sizeof(o));
+ return 0;
}
#define INCLUDE_diff_h__
#include "git2/diff.h"
+#include "git2/sys/diff.h"
#include "git2/oid.h"
#include <stdio.h>
git_iterator_type_t old_src;
git_iterator_type_t new_src;
uint32_t diffcaps;
+ git_diff_perfdata perf;
int (*strcomp)(const char *, const char *);
int (*strncomp)(const char *, const char *, size_t);
#include "ignore.h"
#include "buffer.h"
#include "submodule.h"
-#include "trace.h"
#include <ctype.h>
#define ITERATOR_SET_CB(P,NAME_LC) do { \
fs_iterator__free_frame(ff);
return GIT_ENOTFOUND;
}
-
- git_trace(GIT_TRACE_PERF, &ff->entries.length, "stat");
+ fi->base.stat_calls += ff->entries.length;
fs_iterator__seek_frame_start(fi, ff);
if (!S_ISDIR(entry->st.st_mode) || !strcmp(GIT_DIR, entry->path))
continue;
- git_trace(GIT_TRACE_PERF, entry->path, "submodule_lookup");
if (git_submodule__is_submodule(fi->base.repo, entry->path)) {
entry->st.st_mode = GIT_FILEMODE_COMMIT;
entry->path_len--;
char *start;
char *end;
int (*prefixcomp)(const char *str, const char *prefix);
+ size_t stat_calls;
unsigned int flags;
};
return git_ignore_path_is_ignored(ignored, repo, path);
}
-int git_status_init_options(git_status_options* opts, int version)
+int git_status_init_options(git_status_options* opts, unsigned int version)
{
- if (version != GIT_STATUS_OPTIONS_VERSION) {
+ git_status_options o = GIT_STATUS_OPTIONS_INIT;
+ if (version != o.version) {
giterr_set(GITERR_INVALID, "Invalid version %d for git_status_options", version);
return -1;
- } else {
- git_status_options o = GIT_STATUS_OPTIONS_INIT;
- memcpy(opts, &o, sizeof(o));
- return 0;
}
+ memcpy(opts, &o, sizeof(o));
+ return 0;
+}
+
+int git_status_list_get_perfdata(
+ git_diff_perfdata *out, const git_status_list *status)
+{
+ if (!out || out->version != GIT_DIFF_PERFDATA_VERSION) {
+ giterr_set(GITERR_INVALID, "Invalid version %d for git_diff_perfdata",
+ out ? out->version : 0);
+ return -1;
+ }
+
+ out->stat_calls = 0;
+ out->oid_calculations = 0;
+
+ if (status->head2idx) {
+ out->stat_calls += status->head2idx->perf.stat_calls;
+ out->oid_calculations += status->head2idx->perf.oid_calculations;
+ }
+ if (status->idx2wd) {
+ out->stat_calls += status->idx2wd->perf.stat_calls;
+ out->oid_calculations += status->idx2wd->perf.oid_calculations;
+ }
+
+ return 0;
}
+
#endif
-int git_trace_set(
- git_trace_level_t level, git_trace_callback cb, void *cb_payload)
+int git_trace_set(git_trace_level_t level, git_trace_callback callback)
{
#ifdef GIT_TRACE
- assert(level == 0 || cb != NULL);
+ assert(level == 0 || callback != NULL);
git_trace__data.level = level;
- git_trace__data.callback = cb;
- git_trace__data.callback_payload = cb_payload;
+ git_trace__data.callback = callback;
GIT_MEMORY_BARRIER;
return 0;
#else
GIT_UNUSED(level);
- GIT_UNUSED(cb);
- GIT_UNUSED(cb_payload);
+ GIT_UNUSED(callback);
- giterr_set(
- GITERR_INVALID, "This version of libgit2 was not built with tracing.");
+ giterr_set(GITERR_INVALID,
+ "This version of libgit2 was not built with tracing.");
return -1;
#endif
}
struct git_trace_data {
git_trace_level_t level;
git_trace_callback callback;
- void *callback_payload;
};
extern struct git_trace_data git_trace__data;
GIT_INLINE(void) git_trace__write_fmt(
git_trace_level_t level,
- void *message_payload,
- const char *fmt,
- ...)
+ const char *fmt, ...)
{
git_trace_callback callback = git_trace__data.callback;
git_buf message = GIT_BUF_INIT;
git_buf_vprintf(&message, fmt, ap);
va_end(ap);
- callback(
- level, git_trace__data.callback_payload, message_payload,
- git_buf_cstr(&message));
+ callback(level, git_buf_cstr(&message));
git_buf_free(&message);
}
#define git_trace_level() (git_trace__data.level)
-#define git_trace(l, p, ...) do { \
- if ((git_trace__data.level & (l)) != 0 && git_trace__data.callback) { \
- git_trace__write_fmt((l), (p), __VA_ARGS__); \
- } } while (0)
+#define git_trace(l, ...) { \
+ if (git_trace__data.level >= l && \
+ git_trace__data.callback != NULL) { \
+ git_trace__write_fmt(l, __VA_ARGS__); \
+ } \
+ }
#else
git_diff_print(diff, GIT_DIFF_FORMAT_RAW,
git_diff_print_callback__to_file_handle, fp ? fp : stderr));
}
-
-void diff_perf_track_stats(
- git_trace_level_t level,
- void *cb_payload,
- void *msg_payload,
- const char *msg)
-{
- diff_perf *data = cb_payload;
-
- if (!(level & GIT_TRACE_PERF))
- return;
-
- if (!strcmp("stat", msg))
- data->stat_calls += msg_payload ? *((size_t *)msg_payload) : 1;
- else if (!strcmp("submodule_lookup", msg))
- data->submodule_lookups++;
- else if (!strcmp("oid_calculation", msg))
- data->oid_calcs++;
-}
extern void diff_print(FILE *fp, git_diff *diff);
extern void diff_print_raw(FILE *fp, git_diff *diff);
-
-#include "git2/trace.h"
-
-typedef struct {
- size_t stat_calls;
- size_t oid_calcs;
- size_t submodule_lookups;
-} diff_perf;
-
-extern void diff_perf_track_stats(
- git_trace_level_t level,
- void *cb_payload,
- void *msg_payload,
- const char *msg);
#include "clar_libgit2.h"
#include "diff_helpers.h"
#include "repository.h"
+#include "git2/sys/diff.h"
static git_repository *g_repo = NULL;
-#ifdef GIT_TRACE
-static diff_perf g_diff_perf;
-#endif
-
-void test_diff_workdir__initialize(void)
-{
-#ifdef GIT_TRACE
- memset(&g_diff_perf, 0, sizeof(g_diff_perf));
- cl_git_pass(git_trace_set(
- GIT_TRACE_PERF, diff_perf_track_stats, &g_diff_perf));
-#endif
-}
-
void test_diff_workdir__cleanup(void)
{
cl_git_sandbox_cleanup();
-#ifdef GIT_TRACE
- cl_git_pass(git_trace_set(GIT_TRACE_NONE, NULL, NULL));
-#endif
}
void test_diff_workdir__to_index(void)
cl_assert_equal_i(5, exp.line_ctxt);
cl_assert_equal_i(4, exp.line_adds);
cl_assert_equal_i(5, exp.line_dels);
+ }
-#ifdef GIT_TRACE
+ {
+ git_diff_perfdata perf = GIT_DIFF_PERFDATA_INIT;
+ cl_git_pass(git_diff_get_perfdata(&perf, diff));
cl_assert_equal_sz(
- 13 /* in root */ + 3 /* in subdir */, g_diff_perf.stat_calls);
- cl_assert_equal_sz(5, g_diff_perf.oid_calcs);
- cl_assert_equal_sz(1, g_diff_perf.submodule_lookups);
-#endif
+ 13 /* in root */ + 3 /* in subdir */, perf.stat_calls);
+ cl_assert_equal_sz(5, perf.oid_calculations);
}
git_diff_free(diff);
{
diff_expects exp;
-#ifdef GIT_TRACE
- memset(&g_diff_perf, 0, sizeof(g_diff_perf));
-#endif
-
cl_git_pass(git_diff_index_to_workdir(out, g_repo, NULL, opts));
memset(&exp, 0, sizeof(exp));
{
git_diff_options opts = GIT_DIFF_OPTIONS_INIT;
git_diff *diff = NULL;
+ git_diff_perfdata perf = GIT_DIFF_PERFDATA_INIT;
g_repo = cl_git_sandbox_init("status");
opts.flags |= GIT_DIFF_INCLUDE_IGNORED | GIT_DIFF_INCLUDE_UNTRACKED;
basic_diff_status(&diff, &opts);
-#ifdef GIT_TRACE
- cl_assert_equal_sz(13 + 3, g_diff_perf.stat_calls);
- cl_assert_equal_sz(5, g_diff_perf.oid_calcs);
- cl_assert_equal_sz(1, g_diff_perf.submodule_lookups);
-#endif
+
+ cl_git_pass(git_diff_get_perfdata(&perf, diff));
+ cl_assert_equal_sz(13 + 3, perf.stat_calls);
+ cl_assert_equal_sz(5, perf.oid_calculations);
git_diff_free(diff);
opts.flags |= GIT_DIFF_UPDATE_INDEX;
basic_diff_status(&diff, &opts);
-#ifdef GIT_TRACE
- cl_assert_equal_sz(13 + 3, g_diff_perf.stat_calls);
- cl_assert_equal_sz(5, g_diff_perf.oid_calcs);
- cl_assert_equal_sz(1, g_diff_perf.submodule_lookups);
-#endif
+
+ cl_git_pass(git_diff_get_perfdata(&perf, diff));
+ cl_assert_equal_sz(13 + 3, perf.stat_calls);
+ cl_assert_equal_sz(5, perf.oid_calculations);
git_diff_free(diff);
/* now if we do it again, we should see fewer OID calculations */
basic_diff_status(&diff, &opts);
-#ifdef GIT_TRACE
- cl_assert_equal_sz(13 + 3, g_diff_perf.stat_calls);
- cl_assert_equal_sz(0, g_diff_perf.oid_calcs); /* Yay */
- cl_assert_equal_sz(1, g_diff_perf.submodule_lookups);
-#endif
+
+ cl_git_pass(git_diff_get_perfdata(&perf, diff));
+ cl_assert_equal_sz(13 + 3, perf.stat_calls);
+ cl_assert_equal_sz(0, perf.oid_calculations);
git_diff_free(diff);
}
#include "util.h"
#include "path.h"
#include "../diff/diff_helpers.h"
-
-#ifdef GIT_TRACE
-static diff_perf g_diff_perf;
-#endif
-
-void test_status_worktree__initialize(void)
-{
-#ifdef GIT_TRACE
- memset(&g_diff_perf, 0, sizeof(g_diff_perf));
- cl_git_pass(git_trace_set(
- GIT_TRACE_PERF, diff_perf_track_stats, &g_diff_perf));
-#endif
-}
+#include "git2/sys/diff.h"
/**
* Cleanup
void test_status_worktree__cleanup(void)
{
cl_git_sandbox_cleanup();
-#ifdef GIT_TRACE
- cl_git_pass(git_trace_set(GIT_TRACE_NONE, NULL, NULL));
-#endif
}
/**
* while reducing the amount of work that needs to be done
*/
+static void check_status0(git_status_list *status)
+{
+ size_t i, max_i = git_status_list_entrycount(status);
+ cl_assert_equal_sz(entry_count0, max_i);
+ for (i = 0; i < max_i; ++i) {
+ const git_status_entry *entry = git_status_byindex(status, i);
+ cl_assert_equal_i(entry_statuses0[i], entry->status);
+ }
+}
+
void test_status_worktree__update_stat_cache_0(void)
{
git_repository *repo = cl_git_sandbox_init("status");
+ git_status_options opts = GIT_STATUS_OPTIONS_INIT;
+ git_status_list *status;
+ git_diff_perfdata perf = GIT_DIFF_PERFDATA_INIT;
- assert_show(entry_count0, entry_paths0, entry_statuses0,
- repo, GIT_STATUS_SHOW_INDEX_AND_WORKDIR, 0);
+ opts.flags = GIT_STATUS_OPT_DEFAULTS;
-#ifdef GIT_TRACE
- cl_assert_equal_sz(13 + 3, g_diff_perf.stat_calls);
- cl_assert_equal_sz(5, g_diff_perf.oid_calcs);
- cl_assert_equal_sz(1, g_diff_perf.submodule_lookups);
+ cl_git_pass(git_status_list_new(&status, repo, &opts));
+ check_status0(status);
+ cl_git_pass(git_status_list_get_perfdata(&perf, status));
+ cl_assert_equal_sz(13 + 3, perf.stat_calls);
+ cl_assert_equal_sz(5, perf.oid_calculations);
- memset(&g_diff_perf, 0, sizeof(g_diff_perf));
-#endif
+ git_status_list_free(status);
- assert_show(entry_count0, entry_paths0, entry_statuses0,
- repo, GIT_STATUS_SHOW_INDEX_AND_WORKDIR, GIT_STATUS_OPT_UPDATE_INDEX);
+ opts.flags |= GIT_STATUS_OPT_UPDATE_INDEX;
+
+ cl_git_pass(git_status_list_new(&status, repo, &opts));
+ check_status0(status);
+ cl_git_pass(git_status_list_get_perfdata(&perf, status));
+ cl_assert_equal_sz(13 + 3, perf.stat_calls);
+ cl_assert_equal_sz(5, perf.oid_calculations);
-#ifdef GIT_TRACE
- cl_assert_equal_sz(13 + 3, g_diff_perf.stat_calls);
- cl_assert_equal_sz(5, g_diff_perf.oid_calcs);
- cl_assert_equal_sz(1, g_diff_perf.submodule_lookups);
+ git_status_list_free(status);
- memset(&g_diff_perf, 0, sizeof(g_diff_perf));
-#endif
+ opts.flags &= ~GIT_STATUS_OPT_UPDATE_INDEX;
- assert_show(entry_count0, entry_paths0, entry_statuses0,
- repo, GIT_STATUS_SHOW_INDEX_AND_WORKDIR, 0);
+ cl_git_pass(git_status_list_new(&status, repo, &opts));
+ check_status0(status);
+ cl_git_pass(git_status_list_get_perfdata(&perf, status));
+ cl_assert_equal_sz(13 + 3, perf.stat_calls);
+ cl_assert_equal_sz(0, perf.oid_calculations);
-#ifdef GIT_TRACE
- cl_assert_equal_sz(13 + 3, g_diff_perf.stat_calls);
- cl_assert_equal_sz(0, g_diff_perf.oid_calcs);
- cl_assert_equal_sz(1, g_diff_perf.submodule_lookups);
-#endif
+ git_status_list_free(status);
}
static int written = 0;
-static void trace_callback(
- git_trace_level_t level,
- void *cb_payload,
- void *msg_payload,
- const char *msg)
+static void trace_callback(git_trace_level_t level, const char *message)
{
- GIT_UNUSED(level); GIT_UNUSED(msg_payload);
+ GIT_UNUSED(level);
- cl_assert(strcmp(msg, "Hello world!") == 0);
+ cl_assert(strcmp(message, "Hello world!") == 0);
- if (cb_payload)
- *((int *)cb_payload) = 1;
+ written = 1;
}
void test_trace_trace__initialize(void)
{
- git_trace_set(GIT_TRACE_INFO_AND_BELOW, trace_callback, &written);
+ git_trace_set(GIT_TRACE_INFO, trace_callback);
written = 0;
}
void test_trace_trace__cleanup(void)
{
- git_trace_set(GIT_TRACE_NONE, NULL, NULL);
+ git_trace_set(GIT_TRACE_NONE, NULL);
}
void test_trace_trace__sets(void)
{
#ifdef GIT_TRACE
- cl_assert(git_trace_level() == GIT_TRACE_INFO_AND_BELOW);
+ cl_assert(git_trace_level() == GIT_TRACE_INFO);
#endif
}
void test_trace_trace__can_reset(void)
{
#ifdef GIT_TRACE
- cl_assert(git_trace_level() == GIT_TRACE_INFO_AND_BELOW);
- cl_git_pass(git_trace_set(GIT_TRACE_ERROR, trace_callback, &written));
+ cl_assert(git_trace_level() == GIT_TRACE_INFO);
+ cl_git_pass(git_trace_set(GIT_TRACE_ERROR, trace_callback));
cl_assert(written == 0);
- git_trace(GIT_TRACE_INFO, NULL, "Hello %s!", "world");
+ git_trace(GIT_TRACE_INFO, "Hello %s!", "world");
cl_assert(written == 0);
- git_trace(GIT_TRACE_ERROR, NULL, "Hello %s!", "world");
+ git_trace(GIT_TRACE_ERROR, "Hello %s!", "world");
cl_assert(written == 1);
#endif
}
void test_trace_trace__can_unset(void)
{
#ifdef GIT_TRACE
- cl_assert(git_trace_level() == GIT_TRACE_INFO_AND_BELOW);
- cl_git_pass(git_trace_set(GIT_TRACE_NONE, NULL, NULL));
+ cl_assert(git_trace_level() == GIT_TRACE_INFO);
+ cl_git_pass(git_trace_set(GIT_TRACE_NONE, NULL));
cl_assert(git_trace_level() == GIT_TRACE_NONE);
cl_assert(written == 0);
- git_trace(GIT_TRACE_FATAL, NULL, "Hello %s!", "world");
+ git_trace(GIT_TRACE_FATAL, "Hello %s!", "world");
cl_assert(written == 0);
#endif
}
{
#ifdef GIT_TRACE
cl_assert(written == 0);
- git_trace(GIT_TRACE_DEBUG, NULL, "Hello %s!", "world");
+ git_trace(GIT_TRACE_DEBUG, "Hello %s!", "world");
cl_assert(written == 0);
#endif
}
{
#ifdef GIT_TRACE
cl_assert(written == 0);
- git_trace(GIT_TRACE_INFO, NULL, "Hello %s!", "world");
+ git_trace(GIT_TRACE_INFO, "Hello %s!", "world");
cl_assert(written == 1);
#endif
}
{
#ifdef GIT_TRACE
cl_assert(written == 0);
- git_trace(GIT_TRACE_ERROR, NULL, "Hello %s!", "world");
+ git_trace(GIT_TRACE_ERROR, "Hello %s!", "world");
cl_assert(written == 1);
#endif
}
projects / libgit2.git / commitdiff