ADD_CUSTOM_COMMAND(
OUTPUT ${CLAR_PATH}/clar_main.c ${CLAR_PATH}/clar.h
- COMMAND ${PYTHON_EXECUTABLE} clar -vtap .
+ COMMAND ${PYTHON_EXECUTABLE} clar .
DEPENDS ${CLAR_PATH}/clar ${SRC_TEST}
WORKING_DIRECTORY ${CLAR_PATH}
)
size_t num_attr,
const char **names);
+typedef int (*git_attr_foreach_cb)(const char *name, const char *value, void *payload);
+
/**
* Loop over all the git attributes for a path.
*
git_repository *repo,
uint32_t flags,
const char *path,
- int (*callback)(const char *name, const char *value, void *payload),
+ git_attr_foreach_cb callback,
void *payload);
/**
git_object_free((git_object *) blob);
}
+/**
+ * Get the id of a blob.
+ *
+ * @param blob a previously loaded blob.
+ * @return SHA1 hash for this blob.
+ */
+GIT_INLINE(const git_oid *) git_blob_id(const git_blob *blob)
+{
+ return git_object_id((const git_object *)blob);
+}
+
/**
* Get a read-only buffer with the raw content of a blob.
* @param blob pointer to the blob
* @return size on bytes
*/
-GIT_EXTERN(size_t) git_blob_rawsize(git_blob *blob);
+GIT_EXTERN(git_off_t) git_blob_rawsize(git_blob *blob);
/**
* Read a file from the working folder of a repository
* and write it to the Object Database as a loose blob
*
- * @param oid return the id of the written blob
+ * @param id return the id of the written blob
* @param repo repository where the blob will be written.
* this repository cannot be bare
- * @param path file from which the blob will be created,
+ * @param relative_path file from which the blob will be created,
* relative to the repository's working dir
* @return 0 or an error code
*/
-GIT_EXTERN(int) git_blob_create_fromfile(git_oid *oid, git_repository *repo, const char *path);
+GIT_EXTERN(int) git_blob_create_fromworkdir(git_oid *id, git_repository *repo, const char *relative_path);
/**
* Read a file from the filesystem and write its content
* to the Object Database as a loose blob
*
- * @param oid return the id of the written blob
+ * @param id return the id of the written blob
* @param repo repository where the blob will be written.
* this repository can be bare or not
* @param path file from which the blob will be created
* @return 0 or an error code
*/
-GIT_EXTERN(int) git_blob_create_fromdisk(git_oid *oid, git_repository *repo, const char *path);
+GIT_EXTERN(int) git_blob_create_fromdisk(git_oid *id, git_repository *repo, const char *path);
+
+
+typedef int (*git_blob_chunk_cb)(char *content, size_t max_length, void *payload);
/**
* Write a loose blob to the Object Database from a
* - When an error occurs, the callback should return -1.
*
*
- * @param oid Return the id of the written blob
+ * @param id Return the id of the written blob
*
* @param repo repository where the blob will be written.
* This repository can be bare or not.
* @return GIT_SUCCESS or an error code
*/
GIT_EXTERN(int) git_blob_create_fromchunks(
- git_oid *oid,
+ git_oid *id,
git_repository *repo,
const char *hintpath,
- int (*source_cb)(char *content, size_t max_length, void *payload),
+ git_blob_chunk_cb callback,
void *payload);
/**
*
* The returned reference must be freed by the user.
*
- * @param branch_out Pointer where to store the underlying reference.
+ * @param out Pointer where to store the underlying reference.
*
* @param branch_name Name for the branch; this name is
* validated for consistency. It should also not conflict with
* pointing to the provided target commit.
*/
GIT_EXTERN(int) git_branch_create(
- git_reference **branch_out,
+ git_reference **out,
git_repository *repo,
const char *branch_name,
- const git_object *target,
+ const git_commit *target,
int force);
/**
*
* The generated reference must be freed by the user.
*
- * @param branch_out pointer to the looked-up branch reference
+ * @param out pointer to the looked-up branch reference
*
* @param repo the repository to look up the branch
*
* exists, otherwise an error code.
*/
GIT_EXTERN(int) git_branch_lookup(
- git_reference **branch_out,
+ git_reference **out,
git_repository *repo,
const char *branch_name,
git_branch_t branch_type);
* Return the reference supporting the remote tracking branch,
* given a local branch reference.
*
- * @param tracking_out Pointer where to store the retrieved
+ * @param out Pointer where to store the retrieved
* reference.
*
* @param branch Current underlying reference of the branch.
* reference exists, otherwise an error code.
*/
GIT_EXTERN(int) git_branch_tracking(
- git_reference **tracking_out,
+ git_reference **out,
git_reference *branch);
/**
* Checkout options structure
*
* Use zeros to indicate default settings.
+ * This needs to be initialized with the `GIT_CHECKOUT_OPTS_INIT` macro:
+ *
+ * git_checkout_opts opts = GIT_CHECKOUT_OPTS_INIT;
*/
typedef struct git_checkout_opts {
+ unsigned int version;
unsigned int checkout_strategy; /** default will be a dry run */
int disable_filters; /** don't apply filters like CRLF conversion */
git_strarray paths;
} git_checkout_opts;
+#define GIT_CHECKOUT_OPTS_INIT {1, 0}
+
/**
* Updates files in the index and the working tree to match the content of the
* commit pointed at by HEAD.
*/
GIT_EXTERN(int) git_checkout_tree(
git_repository *repo,
- git_object *treeish,
+ const git_object *treeish,
git_checkout_opts *opts);
/** @} */
git_repository **out,
const char *origin_url,
const char *workdir_path,
+ git_checkout_opts *checkout_opts,
git_transfer_progress_callback fetch_progress_cb,
- void *fetch_progress_payload,
- git_checkout_opts *checkout_opts);
+ void *fetch_progress_payload);
/**
* Create a bare clone of a remote repository.
* @param commit a previously loaded commit.
* @return object identity for the commit.
*/
-GIT_EXTERN(const git_oid *) git_commit_id(git_commit *commit);
+GIT_INLINE(const git_oid *) git_commit_id(const git_commit *commit)
+{
+ return git_object_id((const git_object *)commit);
+}
/**
* Get the encoding for the message of a commit,
* @param commit a previously loaded commit.
* @return NULL, or the encoding
*/
-GIT_EXTERN(const char *) git_commit_message_encoding(git_commit *commit);
+GIT_EXTERN(const char *) git_commit_message_encoding(const git_commit *commit);
/**
* Get the full message of a commit.
* @param commit a previously loaded commit.
* @return the message of a commit
*/
-GIT_EXTERN(const char *) git_commit_message(git_commit *commit);
+GIT_EXTERN(const char *) git_commit_message(const git_commit *commit);
/**
* Get the commit time (i.e. committer time) of a commit.
* @param commit a previously loaded commit.
* @return the time of a commit
*/
-GIT_EXTERN(git_time_t) git_commit_time(git_commit *commit);
+GIT_EXTERN(git_time_t) git_commit_time(const git_commit *commit);
/**
* Get the commit timezone offset (i.e. committer's preferred timezone) of a commit.
* @param commit a previously loaded commit.
* @return positive or negative timezone offset, in minutes from UTC
*/
-GIT_EXTERN(int) git_commit_time_offset(git_commit *commit);
+GIT_EXTERN(int) git_commit_time_offset(const git_commit *commit);
/**
* Get the committer of a commit.
* @param commit a previously loaded commit.
* @return the committer of a commit
*/
-GIT_EXTERN(const git_signature *) git_commit_committer(git_commit *commit);
+GIT_EXTERN(const git_signature *) git_commit_committer(const git_commit *commit);
/**
* Get the author of a commit.
* @param commit a previously loaded commit.
* @return the author of a commit
*/
-GIT_EXTERN(const git_signature *) git_commit_author(git_commit *commit);
+GIT_EXTERN(const git_signature *) git_commit_author(const git_commit *commit);
/**
* Get the tree pointed to by a commit.
* @param commit a previously loaded commit.
* @return 0 or an error code
*/
-GIT_EXTERN(int) git_commit_tree(git_tree **tree_out, git_commit *commit);
+GIT_EXTERN(int) git_commit_tree(git_tree **tree_out, const git_commit *commit);
/**
* Get the id of the tree pointed to by a commit. This differs from
* @param commit a previously loaded commit.
* @return the id of tree pointed to by commit.
*/
-GIT_EXTERN(const git_oid *) git_commit_tree_oid(git_commit *commit);
+GIT_EXTERN(const git_oid *) git_commit_tree_id(const git_commit *commit);
/**
* Get the number of parents of this commit
* @param commit a previously loaded commit.
* @return integer of count of parents
*/
-GIT_EXTERN(unsigned int) git_commit_parentcount(git_commit *commit);
+GIT_EXTERN(unsigned int) git_commit_parentcount(const git_commit *commit);
/**
* Get the specified parent of the commit.
*
- * @param parent Pointer where to store the parent commit
+ * @param out Pointer where to store the parent commit
* @param commit a previously loaded commit.
* @param n the position of the parent (from 0 to `parentcount`)
* @return 0 or an error code
*/
-GIT_EXTERN(int) git_commit_parent(git_commit **parent, git_commit *commit, unsigned int n);
+GIT_EXTERN(int) git_commit_parent(git_commit **out, git_commit *commit, unsigned int n);
/**
* Get the oid of a specified parent for a commit. This is different from
* @param n the position of the parent (from 0 to `parentcount`)
* @return the id of the parent, NULL on error.
*/
-GIT_EXTERN(const git_oid *) git_commit_parent_oid(git_commit *commit, unsigned int n);
+GIT_EXTERN(const git_oid *) git_commit_parent_id(git_commit *commit, unsigned int n);
/**
* Get the commit object that is the <n>th generation ancestor
* The message will not be cleaned up. This can be achieved
* through `git_message_prettify()`.
*
- * @param oid Pointer where to store the OID of the
+ * @param id Pointer where to store the OID of the
* newly created commit
*
* @param repo Repository where to store the commit
* the given reference will be updated to point to it
*/
GIT_EXTERN(int) git_commit_create(
- git_oid *oid,
+ git_oid *id,
git_repository *repo,
const char *update_ref,
const git_signature *author,
* @see git_commit_create
*/
GIT_EXTERN(int) git_commit_create_v(
- git_oid *oid,
+ git_oid *id,
git_repository *repo,
const char *update_ref,
const git_signature *author,
* - max_size: maximum blob size to diff, above this treated as binary
*/
typedef struct {
+ unsigned int version; /**< version for the struct */
uint32_t flags; /**< defaults to GIT_DIFF_NORMAL */
uint16_t context_lines; /**< defaults to 3 */
uint16_t interhunk_lines; /**< defaults to 0 */
/**
* When iterating over a diff, callback that will be made per file.
*/
-typedef int (*git_diff_file_fn)(
+typedef int (*git_diff_file_cb)(
void *cb_data,
const git_diff_delta *delta,
float progress);
/**
* When iterating over a diff, callback that will be made per hunk.
*/
-typedef int (*git_diff_hunk_fn)(
+typedef int (*git_diff_hunk_cb)(
void *cb_data,
const git_diff_delta *delta,
const git_diff_range *range,
* Line origin constants.
*
* These values describe where a line came from and will be passed to
- * the git_diff_data_fn when iterating over a diff. There are some
+ * the git_diff_data_cb when iterating over a diff. There are some
* special origin constants at the end that are used for the text
* output callbacks to demarcate lines that are actually part of
* the file or hunk headers.
*/
typedef enum {
- /* These values will be sent to `git_diff_data_fn` along with the line */
+ /* These values will be sent to `git_diff_data_cb` along with the line */
GIT_DIFF_LINE_CONTEXT = ' ',
GIT_DIFF_LINE_ADDITION = '+',
GIT_DIFF_LINE_DELETION = '-',
GIT_DIFF_LINE_ADD_EOFNL = '\n', /**< Removed line w/o LF & added one with */
GIT_DIFF_LINE_DEL_EOFNL = '\0', /**< LF was removed at end of file */
- /* The following values will only be sent to a `git_diff_data_fn` when
+ /* The following values will only be sent to a `git_diff_data_cb` when
* the content of a diff is being formatted (eg. through
* git_diff_print_patch() or git_diff_print_compact(), for instance).
*/
* of text. This uses some extra GIT_DIFF_LINE_... constants for output
* of lines of file and hunk headers.
*/
-typedef int (*git_diff_data_fn)(
+typedef int (*git_diff_data_cb)(
void *cb_data,
const git_diff_delta *delta,
const git_diff_range *range,
GIT_EXTERN(int) git_diff_foreach(
git_diff_list *diff,
void *cb_data,
- git_diff_file_fn file_cb,
- git_diff_hunk_fn hunk_cb,
- git_diff_data_fn line_cb);
+ git_diff_file_cb file_cb,
+ git_diff_hunk_cb hunk_cb,
+ git_diff_data_cb line_cb);
/**
* Iterate over a diff generating text output like "git diff --name-status".
GIT_EXTERN(int) git_diff_print_compact(
git_diff_list *diff,
void *cb_data,
- git_diff_data_fn print_cb);
+ git_diff_data_cb print_cb);
/**
* Look up the single character abbreviation for a delta status code.
GIT_EXTERN(int) git_diff_print_patch(
git_diff_list *diff,
void *cb_data,
- git_diff_data_fn print_cb);
+ git_diff_data_cb print_cb);
/**
* Query how many diff records are there in a diff list.
GIT_EXTERN(int) git_diff_patch_print(
git_diff_patch *patch,
void *cb_data,
- git_diff_data_fn print_cb);
+ git_diff_data_cb print_cb);
/**
* Get the content of a patch as a single diff text.
git_blob *new_blob,
const git_diff_options *options,
void *cb_data,
- git_diff_file_fn file_cb,
- git_diff_hunk_fn hunk_cb,
- git_diff_data_fn line_cb);
+ git_diff_file_cb file_cb,
+ git_diff_hunk_cb hunk_cb,
+ git_diff_data_cb line_cb);
GIT_END_DECL
*/
GIT_EXTERN(int) git_object_peel(
git_object **peeled,
- git_object *object,
+ const git_object *object,
git_otype target_type);
/** @} */
return blob->odb_object->raw.data;
}
-size_t git_blob_rawsize(git_blob *blob)
+git_off_t git_blob_rawsize(git_blob *blob)
{
assert(blob);
- return blob->odb_object->raw.len;
+ return (git_off_t)blob->odb_object->raw.len;
}
int git_blob__getbuf(git_buf *buffer, git_blob *blob)
return error;
}
-int git_blob_create_fromfile(git_oid *oid, git_repository *repo, const char *path)
+int git_blob_create_fromworkdir(git_oid *oid, git_repository *repo, const char *path)
{
git_buf full_path = GIT_BUF_INIT;
const char *workdir;
return error;
}
-static int create_error_invalid(const char *msg)
-{
- giterr_set(GITERR_INVALID, "Cannot create branch - %s", msg);
- return -1;
-}
-
static int not_a_local_branch(git_reference *ref)
{
giterr_set(GITERR_INVALID, "Reference '%s' is not a local branch.", git_reference_name(ref));
git_reference **ref_out,
git_repository *repository,
const char *branch_name,
- const git_object *target,
+ const git_commit *commit,
int force)
{
- git_object *commit = NULL;
git_reference *branch = NULL;
git_buf canonical_branch_name = GIT_BUF_INIT;
int error = -1;
- assert(branch_name && target && ref_out);
- assert(git_object_owner(target) == repository);
-
- if (git_object_peel(&commit, (git_object *)target, GIT_OBJ_COMMIT) < 0)
- return create_error_invalid("The given target does not resolve to a commit");
+ assert(branch_name && commit && ref_out);
+ assert(git_object_owner((const git_object *)commit) == repository);
if (git_buf_joinpath(&canonical_branch_name, GIT_REFS_HEADS_DIR, branch_name) < 0)
goto cleanup;
error = git_reference_create(&branch, repository,
- git_buf_cstr(&canonical_branch_name), git_object_id(commit), force);
+ git_buf_cstr(&canonical_branch_name), git_commit_id(commit), force);
if (!error)
*ref_out = branch;
cleanup:
- git_object_free(commit);
git_buf_free(&canonical_branch_name);
return error;
}
int git_checkout_tree(
git_repository *repo,
- git_object *treeish,
+ const git_object *treeish,
git_checkout_opts *opts)
{
int error = 0;
const git_oid *target,
const char *name)
{
- git_object *head_obj = NULL;
+ git_commit *head_obj = NULL;
git_reference *branch_ref;
int error;
/* Find the target commit */
- if ((error = git_object_lookup(&head_obj, repo, target, GIT_OBJ_ANY)) < 0)
+ if ((error = git_commit_lookup(&head_obj, repo, target)) < 0)
return error;
/* Create the new branch */
error = git_branch_create(&branch_ref, repo, name, head_obj, 0);
- git_object_free(head_obj);
+ git_commit_free(head_obj);
if (!error)
*branch = branch_ref;
git_repository **out,
const char *origin_url,
const char *workdir_path,
+ git_checkout_opts *checkout_opts,
git_transfer_progress_callback fetch_progress_cb,
- void *fetch_progress_payload,
- git_checkout_opts *checkout_opts)
+ void *fetch_progress_payload)
{
assert(out && origin_url && workdir_path);
{
unsigned int i;
- for (i = 0; i < commit->parent_oids.length; ++i) {
- git_oid *parent = git_vector_get(&commit->parent_oids, i);
+ for (i = 0; i < commit->parent_ids.length; ++i) {
+ git_oid *parent = git_vector_get(&commit->parent_ids, i);
git__free(parent);
}
- git_vector_clear(&commit->parent_oids);
+ git_vector_clear(&commit->parent_ids);
}
void git_commit__free(git_commit *commit)
{
clear_parents(commit);
- git_vector_free(&commit->parent_oids);
+ git_vector_free(&commit->parent_ids);
git_signature_free(commit->author);
git_signature_free(commit->committer);
git__free(commit);
}
-const git_oid *git_commit_id(git_commit *c)
-{
- return git_object_id((git_object *)c);
-}
-
int git_commit_create_v(
git_oid *oid,
git_repository *repo,
const char *buffer = data;
const char *buffer_end = (const char *)data + len;
- git_oid parent_oid;
+ git_oid parent_id;
- git_vector_init(&commit->parent_oids, 4, NULL);
+ git_vector_init(&commit->parent_ids, 4, NULL);
- if (git_oid__parse(&commit->tree_oid, &buffer, buffer_end, "tree ") < 0)
+ if (git_oid__parse(&commit->tree_id, &buffer, buffer_end, "tree ") < 0)
goto bad_buffer;
/*
* TODO: commit grafts!
*/
- while (git_oid__parse(&parent_oid, &buffer, buffer_end, "parent ") == 0) {
- git_oid *new_oid;
+ while (git_oid__parse(&parent_id, &buffer, buffer_end, "parent ") == 0) {
+ git_oid *new_id;
- new_oid = git__malloc(sizeof(git_oid));
- GITERR_CHECK_ALLOC(new_oid);
+ new_id = git__malloc(sizeof(git_oid));
+ GITERR_CHECK_ALLOC(new_id);
- git_oid_cpy(new_oid, &parent_oid);
+ git_oid_cpy(new_id, &parent_id);
- if (git_vector_insert(&commit->parent_oids, new_oid) < 0)
+ if (git_vector_insert(&commit->parent_ids, new_id) < 0)
return -1;
}
}
#define GIT_COMMIT_GETTER(_rvalue, _name, _return) \
- _rvalue git_commit_##_name(git_commit *commit) \
+ _rvalue git_commit_##_name(const git_commit *commit) \
{\
assert(commit); \
return _return; \
GIT_COMMIT_GETTER(const char *, message_encoding, commit->message_encoding)
GIT_COMMIT_GETTER(git_time_t, time, commit->committer->when.time)
GIT_COMMIT_GETTER(int, time_offset, commit->committer->when.offset)
-GIT_COMMIT_GETTER(unsigned int, parentcount, (unsigned int)commit->parent_oids.length)
-GIT_COMMIT_GETTER(const git_oid *, tree_oid, &commit->tree_oid);
+GIT_COMMIT_GETTER(unsigned int, parentcount, (unsigned int)commit->parent_ids.length)
+GIT_COMMIT_GETTER(const git_oid *, tree_id, &commit->tree_id);
-int git_commit_tree(git_tree **tree_out, git_commit *commit)
+int git_commit_tree(git_tree **tree_out, const git_commit *commit)
{
assert(commit);
- return git_tree_lookup(tree_out, commit->object.repo, &commit->tree_oid);
+ return git_tree_lookup(tree_out, commit->object.repo, &commit->tree_id);
}
-const git_oid *git_commit_parent_oid(git_commit *commit, unsigned int n)
+const git_oid *git_commit_parent_id(git_commit *commit, unsigned int n)
{
assert(commit);
- return git_vector_get(&commit->parent_oids, n);
+ return git_vector_get(&commit->parent_ids, n);
}
int git_commit_parent(git_commit **parent, git_commit *commit, unsigned int n)
{
- const git_oid *parent_oid;
+ const git_oid *parent_id;
assert(commit);
- parent_oid = git_commit_parent_oid(commit, n);
- if (parent_oid == NULL) {
+ parent_id = git_commit_parent_id(commit, n);
+ if (parent_id == NULL) {
giterr_set(GITERR_INVALID, "Parent %u does not exist", n);
return GIT_ENOTFOUND;
}
- return git_commit_lookup(parent, commit->object.repo, parent_oid);
+ return git_commit_lookup(parent, commit->object.repo, parent_id);
}
int git_commit_nth_gen_ancestor(
struct git_commit {
git_object object;
- git_vector parent_oids;
- git_oid tree_oid;
+ git_vector parent_ids;
+ git_oid tree_id;
git_signature *author;
git_signature *committer;
git_repository *repo,
const git_diff_options *opts,
void *data,
- git_diff_file_fn file_cb,
- git_diff_hunk_fn hunk_cb,
- git_diff_data_fn data_cb)
+ git_diff_file_cb file_cb,
+ git_diff_hunk_cb hunk_cb,
+ git_diff_data_cb data_cb)
{
memset(ctxt, 0, sizeof(diff_context));
int git_diff_foreach(
git_diff_list *diff,
void *cb_data,
- git_diff_file_fn file_cb,
- git_diff_hunk_fn hunk_cb,
- git_diff_data_fn data_cb)
+ git_diff_file_cb file_cb,
+ git_diff_hunk_cb hunk_cb,
+ git_diff_data_cb data_cb)
{
int error = 0;
diff_context ctxt;
typedef struct {
git_diff_list *diff;
- git_diff_data_fn print_cb;
+ git_diff_data_cb print_cb;
void *cb_data;
git_buf *buf;
} diff_print_info;
int git_diff_print_compact(
git_diff_list *diff,
void *cb_data,
- git_diff_data_fn print_cb)
+ git_diff_data_cb print_cb)
{
int error;
git_buf buf = GIT_BUF_INIT;
int git_diff_print_patch(
git_diff_list *diff,
void *cb_data,
- git_diff_data_fn print_cb)
+ git_diff_data_cb print_cb)
{
int error;
git_buf buf = GIT_BUF_INIT;
git_blob *new_blob,
const git_diff_options *options,
void *cb_data,
- git_diff_file_fn file_cb,
- git_diff_hunk_fn hunk_cb,
- git_diff_data_fn data_cb)
+ git_diff_file_cb file_cb,
+ git_diff_hunk_cb hunk_cb,
+ git_diff_data_cb data_cb)
{
int error;
git_repository *repo;
int git_diff_patch_print(
git_diff_patch *patch,
void *cb_data,
- git_diff_data_fn print_cb)
+ git_diff_data_cb print_cb)
{
int error;
git_buf temp = GIT_BUF_INIT;
git_repository *repo;
git_diff_list *diff;
const git_diff_options *opts;
- git_diff_file_fn file_cb;
- git_diff_hunk_fn hunk_cb;
- git_diff_data_fn data_cb;
+ git_diff_file_cb file_cb;
+ git_diff_hunk_cb hunk_cb;
+ git_diff_data_cb data_cb;
void *cb_data;
int cb_error;
git_diff_range cb_range;
*/
/* write the blob to disk and get the oid */
- if ((error = git_blob_create_fromfile(&oid, INDEX_OWNER(index), rel_path)) < 0)
+ if ((error = git_blob_create_fromworkdir(&oid, INDEX_OWNER(index), rel_path)) < 0)
return error;
entry = git__calloc(1, sizeof(git_index_entry));
int git_object_peel(
git_object **peeled,
- git_object *object,
+ const git_object *object,
git_otype target_type)
{
git_object *source, *deref = NULL;
assert(object && peeled);
if (git_object_type(object) == target_type)
- return git_object__dup(peeled, object);
+ return git_object__dup(peeled, (git_object *)object);
- source = object;
+ source = (git_object *)object;
while (!dereference_object(&deref, source)) {
if (git_odb_exists(odb, &oid)) continue;
if (!git_object_lookup((git_object**)&commit, t->repo, &oid, GIT_OBJ_COMMIT)) {
- const git_oid *tree_oid = git_commit_tree_oid(commit);
+ const git_oid *tree_oid = git_commit_tree_id(commit);
git_commit_free(commit);
/* Add the commit and its tree */
void test_clone_network__can_checkout_a_cloned_repo(void)
{
- git_checkout_opts opts = {0};
+ git_checkout_opts opts = GIT_CHECKOUT_OPTS_INIT;
git_buf path = GIT_BUF_INIT;
git_reference *head;
bool checkout_progress_cb_was_called = false,
cl_set_cleanup(&cleanup_repository, "./default-checkout");
- cl_git_pass(git_clone(&g_repo, LIVE_REPO_URL, "./default-checkout",
- &fetch_progress, &fetch_progress_cb_was_called, &opts));
+ cl_git_pass(git_clone(&g_repo, LIVE_REPO_URL, "./default-checkout", &opts,
+ &fetch_progress, &fetch_progress_cb_was_called));
cl_git_pass(git_buf_joinpath(&path, git_repository_workdir(g_repo), "master.txt"));
cl_assert_equal_i(true, git_path_isfile(git_buf_cstr(&path)));
/* diff on tests/resources/attr/root_test1 */
cl_git_pass(git_diff_blobs(
- a, b, &opts, &expected, diff_file_fn, diff_hunk_fn, diff_line_fn));
+ a, b, &opts, &expected, diff_file_cb, diff_hunk_cb, diff_line_cb));
cl_assert_equal_i(1, expected.files);
cl_assert_equal_i(1, expected.file_status[GIT_DELTA_MODIFIED]);
/* diff on tests/resources/attr/root_test2 */
memset(&expected, 0, sizeof(expected));
cl_git_pass(git_diff_blobs(
- b, c, &opts, &expected, diff_file_fn, diff_hunk_fn, diff_line_fn));
+ b, c, &opts, &expected, diff_file_cb, diff_hunk_cb, diff_line_cb));
cl_assert_equal_i(1, expected.files);
cl_assert_equal_i(1, expected.file_status[GIT_DELTA_MODIFIED]);
/* diff on tests/resources/attr/root_test3 */
memset(&expected, 0, sizeof(expected));
cl_git_pass(git_diff_blobs(
- a, c, &opts, &expected, diff_file_fn, diff_hunk_fn, diff_line_fn));
+ a, c, &opts, &expected, diff_file_cb, diff_hunk_cb, diff_line_cb));
cl_assert_equal_i(1, expected.files);
cl_assert_equal_i(1, expected.file_status[GIT_DELTA_MODIFIED]);
memset(&expected, 0, sizeof(expected));
cl_git_pass(git_diff_blobs(
- c, d, &opts, &expected, diff_file_fn, diff_hunk_fn, diff_line_fn));
+ c, d, &opts, &expected, diff_file_cb, diff_hunk_cb, diff_line_cb));
cl_assert_equal_i(1, expected.files);
cl_assert_equal_i(1, expected.file_status[GIT_DELTA_MODIFIED]);
git_blob *e = NULL;
cl_git_pass(git_diff_blobs(
- d, e, &opts, &expected, diff_file_fn, diff_hunk_fn, diff_line_fn));
+ d, e, &opts, &expected, diff_file_cb, diff_hunk_cb, diff_line_cb));
cl_assert_equal_i(1, expected.files);
cl_assert_equal_i(1, expected.file_status[GIT_DELTA_DELETED]);
memset(&expected, 0, sizeof(expected));
cl_git_pass(git_diff_blobs(
- d, e, &opts, &expected, diff_file_fn, diff_hunk_fn, diff_line_fn));
+ d, e, &opts, &expected, diff_file_cb, diff_hunk_cb, diff_line_cb));
cl_assert_equal_i(1, expected.files);
cl_assert_equal_i(1, expected.file_status[GIT_DELTA_ADDED]);
memset(&expected, 0, sizeof(expected));
cl_git_pass(git_diff_blobs(
- alien, NULL, &opts, &expected, diff_file_fn, diff_hunk_fn, diff_line_fn));
+ alien, NULL, &opts, &expected, diff_file_cb, diff_hunk_cb, diff_line_cb));
cl_assert_equal_i(1, expected.files);
cl_assert_equal_i(1, expected.files_binary);
memset(&expected, 0, sizeof(expected));
cl_git_pass(git_diff_blobs(
- NULL, alien, &opts, &expected, diff_file_fn, diff_hunk_fn, diff_line_fn));
+ NULL, alien, &opts, &expected, diff_file_cb, diff_hunk_cb, diff_line_cb));
cl_assert_equal_i(1, expected.files);
cl_assert_equal_i(1, expected.files_binary);
void test_diff_blob__can_compare_identical_blobs(void)
{
cl_git_pass(git_diff_blobs(
- d, d, &opts, &expected, diff_file_fn, diff_hunk_fn, diff_line_fn));
+ d, d, &opts, &expected, diff_file_cb, diff_hunk_cb, diff_line_cb));
cl_assert_equal_i(0, expected.files_binary);
assert_identical_blobs_comparison(&expected);
memset(&expected, 0, sizeof(expected));
cl_git_pass(git_diff_blobs(
- NULL, NULL, &opts, &expected, diff_file_fn, diff_hunk_fn, diff_line_fn));
+ NULL, NULL, &opts, &expected, diff_file_cb, diff_hunk_cb, diff_line_cb));
cl_assert_equal_i(0, expected.files_binary);
assert_identical_blobs_comparison(&expected);
memset(&expected, 0, sizeof(expected));
cl_git_pass(git_diff_blobs(
- alien, alien, &opts, &expected, diff_file_fn, diff_hunk_fn, diff_line_fn));
+ alien, alien, &opts, &expected, diff_file_cb, diff_hunk_cb, diff_line_cb));
cl_assert(expected.files_binary > 0);
assert_identical_blobs_comparison(&expected);
cl_git_pass(git_blob_lookup_prefix(&heart, g_repo, &h_oid, 4));
cl_git_pass(git_diff_blobs(
- alien, heart, &opts, &expected, diff_file_fn, diff_hunk_fn, diff_line_fn));
+ alien, heart, &opts, &expected, diff_file_cb, diff_hunk_cb, diff_line_cb));
assert_binary_blobs_comparison(&expected);
memset(&expected, 0, sizeof(expected));
cl_git_pass(git_diff_blobs(
- heart, alien, &opts, &expected, diff_file_fn, diff_hunk_fn, diff_line_fn));
+ heart, alien, &opts, &expected, diff_file_cb, diff_hunk_cb, diff_line_cb));
assert_binary_blobs_comparison(&expected);
void test_diff_blob__can_compare_a_binary_blob_and_a_text_blob(void)
{
cl_git_pass(git_diff_blobs(
- alien, d, &opts, &expected, diff_file_fn, diff_hunk_fn, diff_line_fn));
+ alien, d, &opts, &expected, diff_file_cb, diff_hunk_cb, diff_line_cb));
assert_binary_blobs_comparison(&expected);
memset(&expected, 0, sizeof(expected));
cl_git_pass(git_diff_blobs(
- d, alien, &opts, &expected, diff_file_fn, diff_hunk_fn, diff_line_fn));
+ d, alien, &opts, &expected, diff_file_cb, diff_hunk_cb, diff_line_cb));
assert_binary_blobs_comparison(&expected);
}
/* Test with default inter-hunk-context (not set) => default is 0 */
cl_git_pass(git_diff_blobs(
- old_d, d, &opts, &expected, diff_file_fn, diff_hunk_fn, diff_line_fn));
+ old_d, d, &opts, &expected, diff_file_cb, diff_hunk_cb, diff_line_cb));
cl_assert_equal_i(2, expected.hunks);
opts.interhunk_lines = 0;
memset(&expected, 0, sizeof(expected));
cl_git_pass(git_diff_blobs(
- old_d, d, &opts, &expected, diff_file_fn, diff_hunk_fn, diff_line_fn));
+ old_d, d, &opts, &expected, diff_file_cb, diff_hunk_cb, diff_line_cb));
cl_assert_equal_i(2, expected.hunks);
opts.interhunk_lines = 1;
memset(&expected, 0, sizeof(expected));
cl_git_pass(git_diff_blobs(
- old_d, d, &opts, &expected, diff_file_fn, diff_hunk_fn, diff_line_fn));
+ old_d, d, &opts, &expected, diff_file_cb, diff_hunk_cb, diff_line_cb));
cl_assert_equal_i(1, expected.hunks);
return tree;
}
-int diff_file_fn(
+int diff_file_cb(
void *cb_data,
const git_diff_delta *delta,
float progress)
return 0;
}
-int diff_hunk_fn(
+int diff_hunk_cb(
void *cb_data,
const git_diff_delta *delta,
const git_diff_range *range,
return 0;
}
-int diff_line_fn(
+int diff_line_cb(
void *cb_data,
const git_diff_delta *delta,
const git_diff_range *range,
int diff_foreach_via_iterator(
git_diff_list *diff,
void *data,
- git_diff_file_fn file_cb,
- git_diff_hunk_fn hunk_cb,
- git_diff_data_fn line_cb)
+ git_diff_file_cb file_cb,
+ git_diff_hunk_cb hunk_cb,
+ git_diff_data_cb line_cb)
{
size_t d, num_d = git_diff_num_deltas(diff);
int line_dels;
} diff_expects;
-extern int diff_file_fn(
+extern int diff_file_cb(
void *cb_data,
const git_diff_delta *delta,
float progress);
-extern int diff_hunk_fn(
+extern int diff_hunk_cb(
void *cb_data,
const git_diff_delta *delta,
const git_diff_range *range,
const char *header,
size_t header_len);
-extern int diff_line_fn(
+extern int diff_line_cb(
void *cb_data,
const git_diff_delta *delta,
const git_diff_range *range,
extern int diff_foreach_via_iterator(
git_diff_list *diff,
void *data,
- git_diff_file_fn file_cb,
- git_diff_hunk_fn hunk_cb,
- git_diff_data_fn line_cb);
+ git_diff_file_cb file_cb,
+ git_diff_hunk_cb hunk_cb,
+ git_diff_data_cb line_cb);
extern void diff_print(FILE *fp, git_diff_list *diff);
cl_git_pass(git_diff_index_to_tree(&diff, g_repo, a, NULL, &opts));
cl_git_pass(git_diff_foreach(
- diff, &exp, diff_file_fn, diff_hunk_fn, diff_line_fn));
+ diff, &exp, diff_file_cb, diff_hunk_cb, diff_line_cb));
/* to generate these values:
* - cd to tests/resources/status,
cl_git_pass(git_diff_index_to_tree(&diff, g_repo, b, NULL, &opts));
cl_git_pass(git_diff_foreach(
- diff, &exp, diff_file_fn, diff_hunk_fn, diff_line_fn));
+ diff, &exp, diff_file_cb, diff_hunk_cb, diff_line_cb));
/* to generate these values:
* - cd to tests/resources/status,
*/
memset(&exp, 0, sizeof(exp));
cl_git_pass(git_diff_foreach(
- diff, &exp, diff_file_fn, diff_hunk_fn, diff_line_fn));
+ diff, &exp, diff_file_cb, diff_hunk_cb, diff_line_cb));
cl_assert_equal_i(4, exp.files);
cl_assert_equal_i(1, exp.file_status[GIT_DELTA_UNMODIFIED]);
memset(&exp, 0, sizeof(exp));
cl_git_pass(git_diff_foreach(
- diff, &exp, diff_file_fn, diff_hunk_fn, diff_line_fn));
+ diff, &exp, diff_file_cb, diff_hunk_cb, diff_line_cb));
cl_assert_equal_i(3, exp.files);
cl_assert_equal_i(1, exp.file_status[GIT_DELTA_UNMODIFIED]);
memset(&exp, 0, sizeof(exp));
cl_git_pass(git_diff_foreach(
- diff, &exp, diff_file_fn, diff_hunk_fn, diff_line_fn));
+ diff, &exp, diff_file_cb, diff_hunk_cb, diff_line_cb));
cl_assert_equal_i(3, exp.files);
cl_assert_equal_i(1, exp.file_status[GIT_DELTA_UNMODIFIED]);
cl_git_pass(git_diff_tree_to_tree(&diff, g_repo, a, b, &opts));
cl_git_pass(git_diff_foreach(
- diff, &exp, diff_file_fn, diff_hunk_fn, diff_line_fn));
+ diff, &exp, diff_file_cb, diff_hunk_cb, diff_line_cb));
cl_assert_equal_i(5, exp.files);
cl_assert_equal_i(2, exp.file_status[GIT_DELTA_ADDED]);
cl_git_pass(git_diff_tree_to_tree(&diff, g_repo, c, b, &opts));
cl_git_pass(git_diff_foreach(
- diff, &exp, diff_file_fn, diff_hunk_fn, diff_line_fn));
+ diff, &exp, diff_file_cb, diff_hunk_cb, diff_line_cb));
cl_assert_equal_i(2, exp.files);
cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);
int test_ab_or_cd[] = { 0, 0, 0, 0, 1, 1, 1, 1, 1 };
git_diff_options test_options[] = {
/* a vs b tests */
- { GIT_DIFF_NORMAL, 1, 1, NULL, NULL, {0} },
- { GIT_DIFF_NORMAL, 3, 1, NULL, NULL, {0} },
- { GIT_DIFF_REVERSE, 2, 1, NULL, NULL, {0} },
- { GIT_DIFF_FORCE_TEXT, 2, 1, NULL, NULL, {0} },
+ { 1, GIT_DIFF_NORMAL, 1, 1, NULL, NULL, {0} },
+ { 1, GIT_DIFF_NORMAL, 3, 1, NULL, NULL, {0} },
+ { 1, GIT_DIFF_REVERSE, 2, 1, NULL, NULL, {0} },
+ { 1, GIT_DIFF_FORCE_TEXT, 2, 1, NULL, NULL, {0} },
/* c vs d tests */
- { GIT_DIFF_NORMAL, 3, 1, NULL, NULL, {0} },
- { GIT_DIFF_IGNORE_WHITESPACE, 3, 1, NULL, NULL, {0} },
- { GIT_DIFF_IGNORE_WHITESPACE_CHANGE, 3, 1, NULL, NULL, {0} },
- { GIT_DIFF_IGNORE_WHITESPACE_EOL, 3, 1, NULL, NULL, {0} },
- { GIT_DIFF_IGNORE_WHITESPACE | GIT_DIFF_REVERSE, 1, 1, NULL, NULL, {0} },
+ { 1, GIT_DIFF_NORMAL, 3, 1, NULL, NULL, {0} },
+ { 1, GIT_DIFF_IGNORE_WHITESPACE, 3, 1, NULL, NULL, {0} },
+ { 1, GIT_DIFF_IGNORE_WHITESPACE_CHANGE, 3, 1, NULL, NULL, {0} },
+ { 1, GIT_DIFF_IGNORE_WHITESPACE_EOL, 3, 1, NULL, NULL, {0} },
+ { 1, GIT_DIFF_IGNORE_WHITESPACE | GIT_DIFF_REVERSE, 1, 1, NULL, NULL, {0} },
};
+
/* to generate these values:
* - cd to tests/resources/attr,
* - mv .gitted .git
* - mv .git .gitted
*/
#define EXPECT_STATUS_ADM(ADDS,DELS,MODS) { 0, ADDS, DELS, MODS, 0, 0, 0, 0, 0 }
+
diff_expects test_expects[] = {
/* a vs b tests */
{ 5, 0, EXPECT_STATUS_ADM(3, 0, 2), 4, 0, 0, 51, 2, 46, 3 },
cl_git_pass(git_diff_tree_to_tree(&diff, g_repo, c, d, &opts));
cl_git_pass(git_diff_foreach(
- diff, &actual, diff_file_fn, diff_hunk_fn, diff_line_fn));
+ diff, &actual, diff_file_cb, diff_hunk_cb, diff_line_cb));
expected = &test_expects[i];
cl_assert_equal_i(actual.files, expected->files);
cl_git_pass(git_diff_tree_to_tree(&diff, g_repo, a, b, &opts));
cl_git_pass(git_diff_foreach(
- diff, &exp, diff_file_fn, diff_hunk_fn, diff_line_fn));
+ diff, &exp, diff_file_cb, diff_hunk_cb, diff_line_cb));
cl_assert_equal_i(3, exp.files);
cl_assert_equal_i(2, exp.file_status[GIT_DELTA_ADDED]);
memset(&exp, 0, sizeof(exp));
cl_git_pass(git_diff_foreach(
- diff1, &exp, diff_file_fn, diff_hunk_fn, diff_line_fn));
+ diff1, &exp, diff_file_cb, diff_hunk_cb, diff_line_cb));
cl_assert_equal_i(6, exp.files);
cl_assert_equal_i(2, exp.file_status[GIT_DELTA_ADDED]);
if (use_iterator)
cl_git_pass(diff_foreach_via_iterator(
- diff, &exp, diff_file_fn, diff_hunk_fn, diff_line_fn));
+ diff, &exp, diff_file_cb, diff_hunk_cb, diff_line_cb));
else
cl_git_pass(git_diff_foreach(
- diff, &exp, diff_file_fn, diff_hunk_fn, diff_line_fn));
+ diff, &exp, diff_file_cb, diff_hunk_cb, diff_line_cb));
/* to generate these values:
* - cd to tests/resources/status,
if (use_iterator)
cl_git_pass(diff_foreach_via_iterator(
- diff, &exp, diff_file_fn, diff_hunk_fn, diff_line_fn));
+ diff, &exp, diff_file_cb, diff_hunk_cb, diff_line_cb));
else
cl_git_pass(git_diff_foreach(
- diff, &exp, diff_file_fn, diff_hunk_fn, diff_line_fn));
+ diff, &exp, diff_file_cb, diff_hunk_cb, diff_line_cb));
cl_assert_equal_i(14, exp.files);
cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);
if (use_iterator)
cl_git_pass(diff_foreach_via_iterator(
- diff, &exp, diff_file_fn, diff_hunk_fn, diff_line_fn));
+ diff, &exp, diff_file_cb, diff_hunk_cb, diff_line_cb));
else
cl_git_pass(git_diff_foreach(
- diff, &exp, diff_file_fn, diff_hunk_fn, diff_line_fn));
+ diff, &exp, diff_file_cb, diff_hunk_cb, diff_line_cb));
cl_assert_equal_i(15, exp.files);
cl_assert_equal_i(2, exp.file_status[GIT_DELTA_ADDED]);
if (use_iterator)
cl_git_pass(diff_foreach_via_iterator(
- diff, &exp, diff_file_fn, diff_hunk_fn, diff_line_fn));
+ diff, &exp, diff_file_cb, diff_hunk_cb, diff_line_cb));
else
cl_git_pass(git_diff_foreach(
- diff, &exp, diff_file_fn, diff_hunk_fn, diff_line_fn));
+ diff, &exp, diff_file_cb, diff_hunk_cb, diff_line_cb));
cl_assert_equal_i(16, exp.files);
cl_assert_equal_i(5, exp.file_status[GIT_DELTA_ADDED]);
if (use_iterator)
cl_git_pass(diff_foreach_via_iterator(
- diff, &exp, diff_file_fn, NULL, NULL));
+ diff, &exp, diff_file_cb, NULL, NULL));
else
- cl_git_pass(git_diff_foreach(diff, &exp, diff_file_fn, NULL, NULL));
+ cl_git_pass(git_diff_foreach(diff, &exp, diff_file_cb, NULL, NULL));
cl_assert_equal_i(13, exp.files);
cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);
if (use_iterator)
cl_git_pass(diff_foreach_via_iterator(
- diff, &exp, diff_file_fn, NULL, NULL));
+ diff, &exp, diff_file_cb, NULL, NULL));
else
- cl_git_pass(git_diff_foreach(diff, &exp, diff_file_fn, NULL, NULL));
+ cl_git_pass(git_diff_foreach(diff, &exp, diff_file_cb, NULL, NULL));
cl_assert_equal_i(1, exp.files);
cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);
if (use_iterator)
cl_git_pass(diff_foreach_via_iterator(
- diff, &exp, diff_file_fn, NULL, NULL));
+ diff, &exp, diff_file_cb, NULL, NULL));
else
- cl_git_pass(git_diff_foreach(diff, &exp, diff_file_fn, NULL, NULL));
+ cl_git_pass(git_diff_foreach(diff, &exp, diff_file_cb, NULL, NULL));
cl_assert_equal_i(3, exp.files);
cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);
if (use_iterator)
cl_git_pass(diff_foreach_via_iterator(
- diff, &exp, diff_file_fn, NULL, NULL));
+ diff, &exp, diff_file_cb, NULL, NULL));
else
- cl_git_pass(git_diff_foreach(diff, &exp, diff_file_fn, NULL, NULL));
+ cl_git_pass(git_diff_foreach(diff, &exp, diff_file_cb, NULL, NULL));
cl_assert_equal_i(2, exp.files);
cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);
if (use_iterator)
cl_git_pass(diff_foreach_via_iterator(
- diff, &exp, diff_file_fn, diff_hunk_fn, diff_line_fn));
+ diff, &exp, diff_file_cb, diff_hunk_cb, diff_line_cb));
else
cl_git_pass(git_diff_foreach(
- diff, &exp, diff_file_fn, diff_hunk_fn, diff_line_fn));
+ diff, &exp, diff_file_cb, diff_hunk_cb, diff_line_cb));
cl_assert_equal_i(0, exp.files);
cl_assert_equal_i(0, exp.file_status[GIT_DELTA_MODIFIED]);
if (use_iterator)
cl_git_pass(diff_foreach_via_iterator(
- diff, &exp, diff_file_fn, diff_hunk_fn, diff_line_fn));
+ diff, &exp, diff_file_cb, diff_hunk_cb, diff_line_cb));
else
cl_git_pass(git_diff_foreach(
- diff, &exp, diff_file_fn, diff_hunk_fn, diff_line_fn));
+ diff, &exp, diff_file_cb, diff_hunk_cb, diff_line_cb));
cl_assert_equal_i(1, exp.files);
cl_assert_equal_i(1, exp.file_status[GIT_DELTA_MODIFIED]);
memset(&exp, 0, sizeof(exp));
cl_git_pass(git_diff_foreach(
- diff, &exp, diff_file_fn, diff_hunk_fn, diff_line_fn));
+ diff, &exp, diff_file_cb, diff_hunk_cb, diff_line_cb));
cl_assert_equal_i(0, exp.files);
cl_assert_equal_i(0, exp.file_status[GIT_DELTA_MODIFIED]);
memset(&exp, 0, sizeof(exp));
cl_git_pass(git_diff_foreach(
- diff, &exp, diff_file_fn, diff_hunk_fn, diff_line_fn));
+ diff, &exp, diff_file_cb, diff_hunk_cb, diff_line_cb));
cl_assert_equal_i(0, exp.files);
cl_assert_equal_i(0, exp.file_status[GIT_DELTA_MODIFIED]);
if (use_iterator)
cl_git_pass(diff_foreach_via_iterator(
- diff_i2t, &exp, diff_file_fn, diff_hunk_fn, diff_line_fn));
+ diff_i2t, &exp, diff_file_cb, diff_hunk_cb, diff_line_cb));
else
cl_git_pass(git_diff_foreach(
- diff_i2t, &exp, diff_file_fn, diff_hunk_fn, diff_line_fn));
+ diff_i2t, &exp, diff_file_cb, diff_hunk_cb, diff_line_cb));
cl_assert_equal_i(1, exp.files);
cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);
if (use_iterator)
cl_git_pass(diff_foreach_via_iterator(
- diff_w2i, &exp, diff_file_fn, diff_hunk_fn, diff_line_fn));
+ diff_w2i, &exp, diff_file_cb, diff_hunk_cb, diff_line_cb));
else
cl_git_pass(git_diff_foreach(
- diff_w2i, &exp, diff_file_fn, diff_hunk_fn, diff_line_fn));
+ diff_w2i, &exp, diff_file_cb, diff_hunk_cb, diff_line_cb));
cl_assert_equal_i(1, exp.files);
cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);
if (use_iterator)
cl_git_pass(diff_foreach_via_iterator(
- diff_i2t, &exp, diff_file_fn, diff_hunk_fn, diff_line_fn));
+ diff_i2t, &exp, diff_file_cb, diff_hunk_cb, diff_line_cb));
else
cl_git_pass(git_diff_foreach(
- diff_i2t, &exp, diff_file_fn, diff_hunk_fn, diff_line_fn));
+ diff_i2t, &exp, diff_file_cb, diff_hunk_cb, diff_line_cb));
cl_assert_equal_i(1, exp.files);
cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);
if (use_iterator)
cl_git_pass(diff_foreach_via_iterator(
- diff, &exp, diff_file_fn, diff_hunk_fn, diff_line_fn));
+ diff, &exp, diff_file_cb, diff_hunk_cb, diff_line_cb));
else
cl_git_pass(git_diff_foreach(
- diff, &exp, diff_file_fn, diff_hunk_fn, diff_line_fn));
+ diff, &exp, diff_file_cb, diff_hunk_cb, diff_line_cb));
cl_assert_equal_i(0, exp.files);
cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);
if (use_iterator)
cl_git_pass(diff_foreach_via_iterator(
- diff, &exp, diff_file_fn, diff_hunk_fn, diff_line_fn));
+ diff, &exp, diff_file_cb, diff_hunk_cb, diff_line_cb));
else
cl_git_pass(git_diff_foreach(
- diff, &exp, diff_file_fn, diff_hunk_fn, diff_line_fn));
+ diff, &exp, diff_file_cb, diff_hunk_cb, diff_line_cb));
cl_assert_equal_i(1, exp.files);
cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);
if (use_iterator)
cl_git_pass(diff_foreach_via_iterator(
- diff, &exp, diff_file_fn, diff_hunk_fn, diff_line_fn));
+ diff, &exp, diff_file_cb, diff_hunk_cb, diff_line_cb));
else
cl_git_pass(git_diff_foreach(
- diff, &exp, diff_file_fn, diff_hunk_fn, diff_line_fn));
+ diff, &exp, diff_file_cb, diff_hunk_cb, diff_line_cb));
cl_assert_equal_i(1, exp.files);
cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);
memset(&exp, 0, sizeof(exp));
cl_git_pass(git_diff_foreach(
- diff, &exp, diff_file_fn, diff_hunk_fn, diff_line_fn));
+ diff, &exp, diff_file_cb, diff_hunk_cb, diff_line_cb));
/* the following differs from "git diff 873585" by one "untracked" file
* because the diff list includes the "not_submodule/" directory which
"foo\nbar\rboth\r\nreversed\n\ragain\nproblems\r",
"123\n\000\001\002\003\004abc\255\254\253\r\n"
};
-static int g_len[NUM_TEST_OBJECTS] = { -1, -1, -1, -1, -1, 17 };
+static git_off_t g_len[NUM_TEST_OBJECTS] = { -1, -1, -1, -1, -1, 17 };
static git_text_stats g_stats[NUM_TEST_OBJECTS] = {
{ 0, 0, 0, 0, 0, 0 },
{ 0, 0, 2, 0, 6, 0 },
for (i = 0; i < NUM_TEST_OBJECTS; i++) {
cl_git_pass(git_blob_lookup(&blob, g_repo, &g_oids[i]));
- cl_assert((size_t)g_len[i] == git_blob_rawsize(blob));
+ cl_assert(g_len[i] == git_blob_rawsize(blob));
cl_assert(memcmp(git_blob_rawcontent(blob), g_raw[i], g_len[i]) == 0);
git_blob_free(blob);
}
{
repo = cl_git_sandbox_init(WORKDIR);
- assert_blob_creation(WORKDIR "/test.txt", "test.txt", &git_blob_create_fromfile);
+ assert_blob_creation(WORKDIR "/test.txt", "test.txt", &git_blob_create_fromworkdir);
}
void test_object_blob_write__can_create_a_blob_in_a_standard_repo_from_a_absolute_filepath_pointing_outside_of_the_working_directory(void)
git_object *obj;
cl_git_pass(git_object_lookup(&obj, _repo, o, GIT_OBJ_COMMIT));
cl_git_pass(git_packbuilder_insert_tree(_packbuilder,
- git_commit_tree_oid((git_commit *)obj)));
+ git_commit_tree_id((git_commit *)obj)));
git_object_free(obj);
}
}
#include "refs.h"
static git_repository *repo;
-static git_object *target;
+static git_commit *target;
static git_reference *branch;
void test_refs_branches_create__initialize(void)
cl_fixture_cleanup("testrepo.git");
}
-static void retrieve_target_from_oid(git_object **object_out, git_repository *repo, const char *sha)
+static void retrieve_target_from_oid(git_commit **out, git_repository *repo, const char *sha)
{
git_oid oid;
cl_git_pass(git_oid_fromstr(&oid, sha));
- cl_git_pass(git_object_lookup(object_out, repo, &oid, GIT_OBJ_ANY));
+ cl_git_pass(git_commit_lookup(out, repo, &oid));
}
-static void retrieve_known_commit(git_object **object, git_repository *repo)
+static void retrieve_known_commit(git_commit **commit, git_repository *repo)
{
- retrieve_target_from_oid(object, repo, "e90810b8df3e80c413d903f631643c716887138d");
+ retrieve_target_from_oid(commit, repo, "e90810b8df3e80c413d903f631643c716887138d");
}
#define NEW_BRANCH_NAME "new-branch-on-the-block"
retrieve_known_commit(&target, repo);
cl_git_pass(git_branch_create(&branch, repo, NEW_BRANCH_NAME, target, 0));
- cl_git_pass(git_oid_cmp(git_reference_target(branch), git_object_id(target)));
+ cl_git_pass(git_oid_cmp(git_reference_target(branch), git_commit_id(target)));
}
void test_refs_branches_create__can_not_create_a_branch_if_its_name_collide_with_an_existing_one(void)
retrieve_known_commit(&target, repo);
cl_git_pass(git_branch_create(&branch, repo, "br2", target, 1));
- cl_git_pass(git_oid_cmp(git_reference_target(branch), git_object_id(target)));
+ cl_git_pass(git_oid_cmp(git_reference_target(branch), git_commit_id(target)));
cl_assert_equal_s("refs/heads/br2", git_reference_name(branch));
}
-
-void test_refs_branches_create__creating_a_branch_targeting_a_tag_dereferences_it_to_its_commit(void)
-{
- /* b25fa35 is a tag, pointing to another tag which points to a commit */
- retrieve_target_from_oid(&target, repo, "b25fa35b38051e4ae45d4222e795f9df2e43f1d1");
-
- cl_git_pass(git_branch_create(&branch, repo, NEW_BRANCH_NAME, target, 0));
- cl_git_pass(git_oid_streq(git_reference_target(branch), "e90810b8df3e80c413d903f631643c716887138d"));
-}
-
-void test_refs_branches_create__can_not_create_a_branch_pointing_to_a_non_commit_object(void)
-{
- /* 53fc32d is the tree of commit e90810b */
- retrieve_target_from_oid(&target, repo, "53fc32d17276939fc79ed05badaef2db09990016");
-
- cl_git_fail(git_branch_create(&branch, repo, NEW_BRANCH_NAME, target, 0));
- git_object_free(target);
-
- /* 521d87c is an annotated tag pointing to a blob */
- retrieve_target_from_oid(&target, repo, "521d87c1ec3aef9824daf6d96cc0ae3710766d91");
-
- cl_git_fail(git_branch_create(&branch, repo, NEW_BRANCH_NAME, target, 0));
-}
projects / libgit2.git / commitdiff