proxmox-mirrors/libgit2
1
0
Fork 0
mirror of https://git.proxmox.com/git/libgit2 synced 2025-05-06 19:37:29 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge branch 'timezone'

Browse Source
This commit is contained in:
Vicent Marti 2010-12-18 02:35:45 +02:00
commit b5ced41e85
18 changed files with 345 additions and 192 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

61
src/commit.c
View File

@ -26,11 +26,12 @@
#include "git2/common.h"
#include "git2/object.h"
#include "git2/repository.h"
#include "git2/signature.h"
#include "common.h"
#include "commit.h"
#include "revwalk.h"
#include "person.h"
#include "signature.h"
#define COMMIT_BASIC_PARSE 0x0
#define COMMIT_FULL_PARSE 0x1
@ -50,8 +51,8 @@ void git_commit__free(git_commit *commit)
{
clear_parents(commit);
git_person__free(commit->author);
git_person__free(commit->committer);
git_signature_free(commit->author);
git_signature_free(commit->committer);
free(commit->message);
free(commit->message_short);
@ -82,12 +83,12 @@ int git_commit__writeback(git_commit *commit, git_odb_source *src)
if (commit->author == NULL)
return GIT_EMISSINGOBJDATA;
git_person__write(src, "author", commit->author);
git_signature__write(src, "author", commit->author);
if (commit->committer == NULL)
return GIT_EMISSINGOBJDATA;
git_person__write(src, "committer", commit->committer);
git_signature__write(src, "committer", commit->committer);
if (commit->message != NULL)
git__source_printf(src, "\n%s", commit->message);
@ -137,10 +138,10 @@ int commit_parse_buffer(git_commit *commit, void *data, size_t len, unsigned int
if (parse_flags & COMMIT_FULL_PARSE) {
if (commit->author)
git_person__free(commit->author);
git_signature_free(commit->author);
commit->author = git__malloc(sizeof(git_person));
if ((error = git_person__parse(commit->author, &buffer, buffer_end, "author ")) < GIT_SUCCESS)
commit->author = git__malloc(sizeof(git_signature));
if ((error = git_signature__parse(commit->author, &buffer, buffer_end, "author ")) < GIT_SUCCESS)
return error;
} else {
@ -152,14 +153,12 @@ int commit_parse_buffer(git_commit *commit, void *data, size_t len, unsigned int
/* Always parse the committer; we need the commit time */
if (commit->committer)
git_person__free(commit->committer);
git_signature_free(commit->committer);
commit->committer = git__malloc(sizeof(git_person));
if ((error = git_person__parse(commit->committer, &buffer, buffer_end, "committer ")) < GIT_SUCCESS)
commit->committer = git__malloc(sizeof(git_signature));
if ((error = git_signature__parse(commit->committer, &buffer, buffer_end, "committer ")) < GIT_SUCCESS)
return error;
commit->commit_time = commit->committer->time;
/* parse commit message */
while (buffer <= buffer_end && *buffer == '\n')
buffer++;
@ -231,22 +230,21 @@ int git_commit__parse_full(git_commit *commit)
git_commit__parse_full(commit);
GIT_COMMIT_GETTER(git_tree *, tree)
GIT_COMMIT_GETTER(git_person *, author)
GIT_COMMIT_GETTER(git_person *, committer)
GIT_COMMIT_GETTER(git_signature *, author)
GIT_COMMIT_GETTER(git_signature *, committer)
GIT_COMMIT_GETTER(char *, message)
GIT_COMMIT_GETTER(char *, message_short)
time_t git_commit_time(git_commit *commit)
{
assert(commit);
assert(commit && commit->committer);
return commit->committer->when.time;
}
if (commit->commit_time)
return commit->commit_time;
if (!commit->object.in_memory)
git_commit__parse_full(commit);
return commit->commit_time;
int git_commit_time_offset(git_commit *commit)
{
assert(commit && commit->committer);
return commit->committer->when.offset;
}
unsigned int git_commit_parentcount(git_commit *commit)
@ -269,25 +267,24 @@ void git_commit_set_tree(git_commit *commit, git_tree *tree)
commit->tree = tree;
}
void git_commit_set_author(git_commit *commit, const char *name, const char *email, time_t time)
void git_commit_set_author(git_commit *commit, const git_signature *author_sig)
{
assert(commit && name && email);
assert(commit && author_sig);
commit->object.modified = 1;
CHECK_FULL_PARSE();
git_person__free(commit->author);
commit->author = git_person__new(name, email, time);
git_signature_free(commit->author);
commit->author = git_signature_dup(author_sig);
}
void git_commit_set_committer(git_commit *commit, const char *name, const char *email, time_t time)
void git_commit_set_committer(git_commit *commit, const git_signature *committer_sig)
{
assert(commit && name && email);
assert(commit && committer_sig);
commit->object.modified = 1;
CHECK_FULL_PARSE();
git_person__free(commit->committer);
commit->committer = git_person__new(name, email, time);
commit->commit_time = time;
git_signature_free(commit->committer);
commit->committer = git_signature_dup(committer_sig);
}
void git_commit_set_message(git_commit *commit, const char *message)

5
src/commit.h
View File

@ -11,12 +11,11 @@
struct git_commit {
git_object object;
time_t commit_time;
git_vector parents;
git_tree *tree;
git_person *author;
git_person *committer;
git_signature *author;
git_signature *committer;
char *message;
char *message_short;

1
src/git2.h
View File

@ -33,6 +33,7 @@
#include "git2/types.h"
#include "git2/oid.h"
#include "git2/signature.h"
#include "git2/odb.h"
#include "git2/repository.h"

23
src/git2/commit.h
View File

@ -92,19 +92,26 @@ GIT_EXTERN(const char *) git_commit_message(git_commit *commit);
*/
GIT_EXTERN(time_t) git_commit_time(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_timezone_offset(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_person *) git_commit_committer(git_commit *commit);
GIT_EXTERN(const git_signature *) git_commit_committer(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_person *) git_commit_author(git_commit *commit);
GIT_EXTERN(const git_signature *) git_commit_author(git_commit *commit);
/**
* Get the tree pointed to by a commit.
@ -147,20 +154,16 @@ GIT_EXTERN(void) git_commit_set_message(git_commit *commit, const char *message)
/**
* Set the committer of a commit
* @param commit the commit object
* @param name name of the new committer
* @param email email of the new committer
* @param time time when the committer committed the commit
* @param author_sig signature of the committer
*/
GIT_EXTERN(void) git_commit_set_committer(git_commit *commit, const char *name, const char *email, time_t time);
GIT_EXTERN(void) git_commit_set_committer(git_commit *commit, const git_signature *committer_sig);
/**
* Set the author of a commit
* @param commit the commit object
* @param name name of the new author
* @param email email of the new author
* @param time time when the author created the commit
* @param author_sig signature of the author
*/
GIT_EXTERN(void) git_commit_set_author(git_commit *commit, const char *name, const char *email, time_t time);
GIT_EXTERN(void) git_commit_set_author(git_commit *commit, const git_signature *author_sig);
/**
* Set the tree which is pointed to by a commit

9
src/git2/common.h
View File

@ -134,16 +134,7 @@
/** The index file is not backed up by an existing repository */
#define GIT_EBAREINDEX (GIT_ERROR -14)
GIT_BEGIN_DECL
/** Parsed representation of a person */
typedef struct git_person git_person;
const char *git_person_name(git_person *person);
const char *git_person_email(git_person *person);
time_t git_person_time(git_person *person);
/** @} */
GIT_END_DECL
#endif

70
src/git2/signature.h Normal file
View File

@ -0,0 +1,70 @@
/*
* This file is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License, version 2,
* as published by the Free Software Foundation.
*
* In addition to the permissions in the GNU General Public License,
* the authors give you unlimited permission to link the compiled
* version of this file into combinations with other programs,
* and to distribute those combinations without any restriction
* coming from the use of this file. (The General Public License
* restrictions do apply in other respects; for example, they cover
* modification of the file, and distribution when not linked into
* a combined executable.)
*
* This file is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; see the file COPYING. If not, write to
* the Free Software Foundation, 51 Franklin Street, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
#ifndef INCLUDE_git_signature_h__
#define INCLUDE_git_signature_h__
#include "common.h"
#include "types.h"
/**
* @file git2/signature.h
* @brief Git signature creation
* @defgroup git_signature Git signature creation
* @ingroup Git
* @{
*/
GIT_BEGIN_DECL
/**
* Create a new action signature. The signature must be freed
* manually or using git_signature_free
*
* @name name of the person
* @email email of the person
* @time time when the action happened
* @offset timezone offset in minutes for the time
* @return the new sig, NULl on out of memory
*/
GIT_EXTERN(git_signature *) git_signature_new(const char *name, const char *email, time_t time, int offset);
/**
* Create a copy of an existing signature.
*
* All internal strings are also duplicated.
* @sig signature to duplicated
* @return a copy of sig, NULL on out of memory
*/
GIT_EXTERN(git_signature *) git_signature_dup(const git_signature *sig);
/**
* Free an existing signature
*
* @sig signature to free
*/
GIT_EXTERN(void) git_signature_free(git_signature *sig);
/** @} */
GIT_END_DECL
#endif

8
src/git2/tag.h
View File

@ -96,7 +96,7 @@ GIT_EXTERN(const char *) git_tag_name(git_tag *t);
* @param tag a previously loaded tag.
* @return reference to the tag's author
*/
GIT_EXTERN(const git_person *) git_tag_tagger(git_tag *t);
GIT_EXTERN(const git_signature *) git_tag_tagger(git_tag *t);
/**
* Get the message of a tag
@ -122,11 +122,9 @@ GIT_EXTERN(void) git_tag_set_name(git_tag *tag, const char *name);
/**
* Set the tagger of a tag
* @param tag The tag to modify
* @param name the name of the new tagger
* @param email the email of the new tagger
* @param time the time when the tag was created
* @param tagger_sig signature of the tagging action
*/
GIT_EXTERN(void) git_tag_set_tagger(git_tag *tag, const char *name, const char *email, time_t time);
GIT_EXTERN(void) git_tag_set_tagger(git_tag *tag, const git_signature *tagger_sig);
/**
* Set the message of a tag

13
src/git2/types.h
View File

@ -82,6 +82,19 @@ typedef struct git_tree git_tree;
/** Memory representation of an index file. */
typedef struct git_index git_index;
/** Time in a signature */
typedef struct git_time {
time_t time; /** time in seconds from epoch */
int offset; /** timezone offset, in minutes */
} git_time;
/** An action signature (e.g. for committers, taggers, etc) */
typedef struct git_signature {
char *name; /** full name of the author */
char *email; /** email of the author */
git_time when; /** time when the action happened */
} git_signature;
/** @} */
GIT_END_DECL

20
src/person.h
View File

@ -1,20 +0,0 @@
#ifndef INCLUDE_person_h__
#define INCLUDE_person_h__
#include "git2/common.h"
#include "repository.h"
#include <time.h>
/** Parsed representation of a person */
struct git_person {
char *name; /**< Full name */
char *email; /**< Email address */
time_t time; /**< Time when this person committed the change */
};
void git_person__free(git_person *person);
git_person *git_person__new(const char *name, const char *email, time_t time);
int git_person__parse(git_person *person, char **buffer_out, const char *buffer_end, const char *header);
int git_person__write(git_odb_source *src, const char *header, const git_person *person);
#endif

4
src/revwalk.c
View File

@ -400,8 +400,8 @@ void git_revwalk_list_timesort(git_revwalk_list *list)
e = q, q = q->next, q_size--;
else if (q_size == 0 || q == NULL ||
p->walk_commit->commit_object->commit_time >=
q->walk_commit->commit_object->commit_time)
p->walk_commit->commit_object->committer->when.time >=
q->walk_commit->commit_object->committer->when.time)
e = p, p = p->next, p_size--;
else

121
src/person.c → src/signature.c
View File

@ -24,30 +24,37 @@
*/
#include "common.h"
#include "person.h"
#include "signature.h"
#include "repository.h"
#include "git2/common.h"
void git_person__free(git_person *person)
void git_signature_free(git_signature *sig)
{
if (person == NULL)
if (sig == NULL)
return;
free(person->name);
free(person->email);
free(person);
free(sig->name);
free(sig->email);
free(sig);
}
git_person *git_person__new(const char *name, const char *email, time_t time)
git_signature *git_signature_new(const char *name, const char *email, time_t time, int offset)
{
git_person *p;
git_signature *p = NULL;
if ((p = git__malloc(sizeof(git_person))) == NULL)
if ((p = git__malloc(sizeof(git_signature))) == NULL)
goto cleanup;
p->name = git__strdup(name);
if (p->name == NULL)
goto cleanup;
p->email = git__strdup(email);
p->time = time;
if (p->email == NULL)
goto cleanup;
p->when.time = time;
p->when.offset = offset;
if (p->name == NULL || p->email == NULL)
goto cleanup;
@ -55,26 +62,60 @@ git_person *git_person__new(const char *name, const char *email, time_t time)
return p;
cleanup:
git_person__free(p);
git_signature_free(p);
return NULL;
}
const char *git_person_name(git_person *person)
git_signature *git_signature_dup(const git_signature *sig)
{
return person->name;
return git_signature_new(sig->name, sig->email, sig->when.time, sig->when.offset);
}
const char *git_person_email(git_person *person)
static int parse_timezone_offset(const char *buffer, int *offset_out)
{
return person->email;
int offset, dec_offset;
int mins, hours;
const char* offset_start;
char* offset_end;
offset_start = buffer + 1;
if (*offset_start == '\n') {
*offset_out = 0;
return GIT_SUCCESS;
}
if (offset_start[0] != '-' && offset_start[0] != '+')
return GIT_EOBJCORRUPTED;
dec_offset = strtol(offset_start + 1, &offset_end, 10);
if (offset_end - offset_start != 5)
return GIT_EOBJCORRUPTED;
hours = dec_offset / 100;
mins = dec_offset % 100;
if (hours > 14) // see http://www.worldtimezone.com/faq.html
return GIT_EOBJCORRUPTED;
if (mins > 59)
return GIT_EOBJCORRUPTED;
offset = (hours * 60) + mins;
if (offset_start[0] == '-')
offset *= -1;
*offset_out = offset;
return GIT_SUCCESS;
}
time_t git_person_time(git_person *person)
{
return person->time;
}
int git_person__parse(git_person *person, char **buffer_out,
int git_signature__parse(git_signature *sig, char **buffer_out,
const char *buffer_end, const char *header)
{
const size_t header_len = strlen(header);
@ -82,8 +123,9 @@ int git_person__parse(git_person *person, char **buffer_out,
int name_length, email_length;
char *buffer = *buffer_out;
char *line_end, *name_end, *email_end;
int offset = 0;
memset(person, 0x0, sizeof(git_person));
memset(sig, 0x0, sizeof(git_signature));
line_end = memchr(buffer, '\n', buffer_end - buffer);
if (!line_end)
@ -102,9 +144,9 @@ int git_person__parse(git_person *person, char **buffer_out,
return GIT_EOBJCORRUPTED;
name_length = name_end - buffer - 1;
person->name = git__malloc(name_length + 1);
memcpy(person->name, buffer, name_length);
person->name[name_length] = 0;
sig->name = git__malloc(name_length + 1);
memcpy(sig->name, buffer, name_length);
sig->name[name_length] = 0;
buffer = name_end + 1;
if (buffer >= line_end)
@ -115,26 +157,43 @@ int git_person__parse(git_person *person, char **buffer_out,
return GIT_EOBJCORRUPTED;
email_length = email_end - buffer;
person->email = git__malloc(email_length + 1);
memcpy(person->email, buffer, email_length);
person->email[email_length] = 0;
sig->email = git__malloc(email_length + 1);
memcpy(sig->email, buffer, email_length);
sig->email[email_length] = 0;
buffer = email_end + 1;
if (buffer >= line_end)
return GIT_EOBJCORRUPTED;
person->time = strtol(buffer, &buffer, 10);
sig->when.time = strtol(buffer, &buffer, 10);
if (person->time == 0)
if (sig->when.time == 0)
return GIT_EOBJCORRUPTED;
if (parse_timezone_offset(buffer, &offset) < GIT_SUCCESS)
return GIT_EOBJCORRUPTED;
sig->when.offset = offset;
*buffer_out = (line_end + 1);
return GIT_SUCCESS;
}
int git_person__write(git_odb_source *src, const char *header, const git_person *person)
int git_signature__write(git_odb_source *src, const char *header, const git_signature *sig)
{
return git__source_printf(src, "%s %s <%s> %u\n", header, person->name, person->email, person->time);
char sign;
int offset, hours, mins;
offset = sig->when.offset;
sign = (sig->when.offset < 0) ? '-' : '+';
if (offset < 0)
offset = -offset;
hours = offset / 60;
mins = offset % 60;
return git__source_printf(src, "%s %s <%s> %u %c%02d%02d\n", header, sig->name, sig->email, sig->when.time, sign, hours, mins);
}

12
src/signature.h Normal file
View File

@ -0,0 +1,12 @@
#ifndef INCLUDE_signature_h__
#define INCLUDE_signature_h__
#include "git2/common.h"
#include "git2/signature.h"
#include "repository.h"
#include <time.h>
int git_signature__parse(git_signature *sig, char **buffer_out, const char *buffer_end, const char *header);
int git_signature__write(git_odb_source *src, const char *header, const git_signature *sig);
#endif

23
src/tag.c
View File

@ -26,14 +26,15 @@
#include "common.h"
#include "commit.h"
#include "tag.h"
#include "person.h"
#include "signature.h"
#include "revwalk.h"
#include "git2/object.h"
#include "git2/repository.h"
#include "git2/signature.h"
void git_tag__free(git_tag *tag)
{
git_person__free(tag->tagger);
git_signature_free(tag->tagger);
free(tag->message);
free(tag->tag_name);
free(tag);
@ -92,18 +93,18 @@ void git_tag_set_name(git_tag *tag, const char *name)
tag->tag_name = git__strdup(name);
}
const git_person *git_tag_tagger(git_tag *t)
const git_signature *git_tag_tagger(git_tag *t)
{
return t->tagger;
}
void git_tag_set_tagger(git_tag *tag, const char *name, const char *email, time_t time)
void git_tag_set_tagger(git_tag *tag, const git_signature *tagger_sig)
{
assert(tag && name && email);
assert(tag && tagger_sig);
tag->object.modified = 1;
git_person__free(tag->tagger);
tag->tagger = git_person__new(name, email, time);
git_signature_free(tag->tagger);
tag->tagger = git_signature_dup(tagger_sig);
}
const char *git_tag_message(git_tag *t)
@ -190,11 +191,11 @@ static int parse_tag_buffer(git_tag *tag, char *buffer, const char *buffer_end)
buffer = search + 1;
if (tag->tagger != NULL)
git_person__free(tag->tagger);
git_signature_free(tag->tagger);
tag->tagger = git__malloc(sizeof(git_person));
tag->tagger = git__malloc(sizeof(git_signature));
if ((error = git_person__parse(tag->tagger, &buffer, buffer_end, "tagger ")) != 0)
if ((error = git_signature__parse(tag->tagger, &buffer, buffer_end, "tagger ")) != 0)
return error;
text_len = buffer_end - ++buffer;
@ -217,7 +218,7 @@ int git_tag__writeback(git_tag *tag, git_odb_source *src)
git__write_oid(src, "object", git_object_id(tag->target));
git__source_printf(src, "type %s\n", git_object_type2string(tag->type));
git__source_printf(src, "tag %s\n", tag->tag_name);
git_person__write(src, "tagger", tag->tagger);
git_signature__write(src, "tagger", tag->tagger);
if (tag->message != NULL)
git__source_printf(src, "\n%s", tag->message);

2
src/tag.h
View File

@ -10,7 +10,7 @@ struct git_tag {
git_object *target;
git_otype type;
char *tag_name;
git_person *tagger;
git_signature *tagger;
char *message;
};

104
tests/t0401-parse.c
View File

@ -1,7 +1,7 @@
#include "test_lib.h"
#include "test_helpers.h"
#include "commit.h"
#include "person.h"
#include "signature.h"
#include <git2/odb.h>
#include <git2/commit.h>
#include <git2/revwalk.h>
@ -129,96 +129,134 @@ BEGIN_TEST(parse_oid_test)
END_TEST
BEGIN_TEST(parse_person_test)
BEGIN_TEST(parse_sig_test)
#define TEST_PERSON_PASS(_string, _header, _name, _email, _time) { \
#define TEST_SIGNATURE_PASS(_string, _header, _name, _email, _time, _offset) { \
char *ptr = _string; \
size_t len = strlen(_string);\
git_person person = {NULL, NULL, 0}; \
must_pass(git_person__parse(&person, &ptr, ptr + len, _header));\
git_signature person = {NULL, NULL, {0, 0}}; \
must_pass(git_signature__parse(&person, &ptr, ptr + len, _header));\
must_be_true(strcmp(_name, person.name) == 0);\
must_be_true(strcmp(_email, person.email) == 0);\
must_be_true(_time == person.time);\
must_be_true(_time == person.when.time);\
must_be_true(_offset == person.when.offset);\
free(person.name); free(person.email);\
}
#define TEST_PERSON_FAIL(_string, _header) { \
#define TEST_SIGNATURE_FAIL(_string, _header) { \
char *ptr = _string; \
size_t len = strlen(_string);\
git_person person = {NULL, NULL, 0}; \
must_fail(git_person__parse(&person, &ptr, ptr + len, _header));\
git_signature person = {NULL, NULL, {0, 0}}; \
must_fail(git_signature__parse(&person, &ptr, ptr + len, _header));\
free(person.name); free(person.email);\
}
TEST_PERSON_PASS(
"author Vicent Marti <tanoku@gmail.com> 12345 \n",
"author ",
"Vicent Marti",
"tanoku@gmail.com",
12345);
TEST_SIGNATURE_PASS(
"author Vicent Marti <tanoku@gmail.com> 12345 \n",
"author ",
"Vicent Marti",
"tanoku@gmail.com",
12345,
0);
TEST_PERSON_PASS(
TEST_SIGNATURE_PASS(
"author Vicent Marti <> 12345 \n",
"author ",
"Vicent Marti",
"",
12345);
12345,
0);
TEST_PERSON_PASS(
"author Vicent Marti <tanoku@gmail.com> 231301 +2020\n",
TEST_SIGNATURE_PASS(
"author Vicent Marti <tanoku@gmail.com> 231301 +1020\n",
"author ",
"Vicent Marti",
"tanoku@gmail.com",
231301);
231301,
620);
TEST_PERSON_PASS(
TEST_SIGNATURE_PASS(
"author Vicent Marti with an outrageously long name \
which will probably overflow the buffer <tanoku@gmail.com> 12345 \n",
"author ",
"Vicent Marti with an outrageously long name \
which will probably overflow the buffer",
"tanoku@gmail.com",
12345);
12345,
0);
TEST_PERSON_PASS(
TEST_SIGNATURE_PASS(
"author Vicent Marti <tanokuwithaveryveryverylongemail\
whichwillprobablyvoverflowtheemailbuffer@gmail.com> 12345 \n",
"author ",
"Vicent Marti",
"tanokuwithaveryveryverylongemail\
whichwillprobablyvoverflowtheemailbuffer@gmail.com",
12345);
12345,
0);
TEST_PERSON_FAIL(
TEST_SIGNATURE_PASS(
"committer Vicent Marti <tanoku@gmail.com> 123456 +0000 \n",
"committer ",
"Vicent Marti",
"tanoku@gmail.com",
123456,
0);
TEST_SIGNATURE_PASS(
"committer Vicent Marti <tanoku@gmail.com> 123456 +0100 \n",
"committer ",
"Vicent Marti",
"tanoku@gmail.com",
123456,
60);
TEST_SIGNATURE_PASS(
"committer Vicent Marti <tanoku@gmail.com> 123456 -0100 \n",
"committer ",
"Vicent Marti",
"tanoku@gmail.com",
123456,
-60);
TEST_SIGNATURE_FAIL(
"committer Vicent Marti <tanoku@gmail.com> 123456 -1500 \n",
"committer ");
TEST_SIGNATURE_FAIL(
"committer Vicent Marti <tanoku@gmail.com> 123456 +0163 \n",
"committer ");
TEST_SIGNATURE_FAIL(
"author Vicent Marti <tanoku@gmail.com> 12345 \n",
"author ");
TEST_PERSON_FAIL(
TEST_SIGNATURE_FAIL(
"author Vicent Marti <tanoku@gmail.com> 12345 \n",
"committer ");
TEST_PERSON_FAIL(
TEST_SIGNATURE_FAIL(
"author Vicent Marti 12345 \n",
"author ");
TEST_PERSON_FAIL(
TEST_SIGNATURE_FAIL(
"author Vicent Marti <broken@email 12345 \n",
"author ");
TEST_PERSON_FAIL(
TEST_SIGNATURE_FAIL(
"author Vicent Marti <tanoku@gmail.com> notime \n",
"author ");
TEST_PERSON_FAIL(
TEST_SIGNATURE_FAIL(
"author Vicent Marti <tanoku@gmail.com>\n",
"author ");
TEST_PERSON_FAIL(
TEST_SIGNATURE_FAIL(
"author ",
"author ");
#undef TEST_PERSON_PASS
#undef TEST_PERSON_FAIL
#undef TEST_SIGNATURE_PASS
#undef TEST_SIGNATURE_FAIL
END_TEST

4
tests/t0402-details.c
View File

@ -1,7 +1,7 @@
#include "test_lib.h"
#include "test_helpers.h"
#include "commit.h"
#include "person.h"
#include "signature.h"
#include <git2/odb.h>
#include <git2/commit.h>
@ -28,7 +28,7 @@ BEGIN_TEST(query_details_test)
git_oid id;
git_commit *commit;
const git_person *author, *committer;
const git_signature *author, *committer;
const char *message, *message_short;
time_t commit_time;
unsigned int parents, p;

47
tests/t0403-write.c
View File

@ -1,11 +1,12 @@
#include "test_lib.h"
#include "test_helpers.h"
#include "commit.h"
#include "person.h"
#include "signature.h"
#include <git2/odb.h>
#include <git2/commit.h>
#include <git2/revwalk.h>
#include <git2/signature.h>
static const char *commit_ids[] = {
"a4a7dce85cf63874e984719f4fdd239f5145052f", /* 0 */
@ -27,7 +28,7 @@ BEGIN_TEST(writenew_test)
git_commit *commit, *parent;
git_tree *tree;
git_oid id;
const git_person *author, *committer;
const git_signature *author, *committer;
/* char hex_oid[41]; */
must_pass(git_repository_open(&repo, REPOSITORY_FOLDER));
@ -42,23 +43,33 @@ BEGIN_TEST(writenew_test)
git_commit_add_parent(commit, parent);
/* Set other attributes */
git_commit_set_committer(commit, COMMITTER_NAME, COMMITTER_EMAIL, 123456789);
git_commit_set_author(commit, COMMITTER_NAME, COMMITTER_EMAIL, 987654321);
committer = git_signature_new(COMMITTER_NAME, COMMITTER_EMAIL, 123456789, 60);
must_be_true(committer != NULL);
author = git_signature_new(COMMITTER_NAME, COMMITTER_EMAIL, 987654321, 90);
must_be_true(author != NULL);
git_commit_set_committer(commit, committer);
git_commit_set_author(commit, author);
git_commit_set_message(commit, COMMIT_MESSAGE);
git_signature_free((git_signature *)committer);
git_signature_free((git_signature *)author);
/* Check attributes were set correctly */
author = git_commit_author(commit);
must_be_true(author != NULL);
must_be_true(strcmp(author->name, COMMITTER_NAME) == 0);
must_be_true(strcmp(author->email, COMMITTER_EMAIL) == 0);
must_be_true(author->time == 987654321);
must_be_true(author->when.time == 987654321);
must_be_true(author->when.offset == 90);
committer = git_commit_committer(commit);
must_be_true(committer != NULL);
must_be_true(strcmp(committer->name, COMMITTER_NAME) == 0);
must_be_true(strcmp(committer->email, COMMITTER_EMAIL) == 0);
must_be_true(committer->time == 123456789);
must_be_true(git_commit_time(commit) == 123456789);
must_be_true(committer->when.time == 123456789);
must_be_true(committer->when.offset == 60);
must_be_true(strcmp(git_commit_message(commit), COMMIT_MESSAGE) == 0);
@ -74,18 +85,8 @@ BEGIN_TEST(writenew_test)
/* Write to disk */
must_pass(git_object_write((git_object *)commit));
/* Show new SHA1 */
/*
git_oid_fmt(hex_oid, git_commit_id(commit));
hex_oid[40] = 0;
printf("Written new commit, SHA1: %s\n", hex_oid);
*/
must_pass(remove_loose_object(REPOSITORY_FOLDER, (git_object *)commit));
//git_person_free(&author);
//git_person_free(&committer);
git_repository_free(repo);
END_TEST
@ -104,12 +105,6 @@ BEGIN_TEST(writeback_test)
message = git_commit_message(commit);
/*
git_oid_fmt(hex_oid, git_commit_id(commit));
hex_oid[40] = 0;
printf("Old SHA1: %s\n", hex_oid);
*/
git_commit_set_message(commit, "This is a new test message. Cool!\n");
git_oid_mkstr(&id, commit_ids[4]);
@ -119,12 +114,6 @@ BEGIN_TEST(writeback_test)
must_pass(git_object_write((git_object *)commit));
/*
git_oid_fmt(hex_oid, git_commit_id(commit));
hex_oid[40] = 0;
printf("New SHA1: %s\n", hex_oid);
*/
must_pass(remove_loose_object(REPOSITORY_FOLDER, (git_object *)commit));
git_repository_free(repo);

10
tests/t0502-list.c
View File

@ -4,6 +4,7 @@
#include "revwalk.h"
#include <git2/odb.h>
#include <git2/commit.h>
#include <git2/signature.h>
BEGIN_TEST(list_timesort_test)
@ -15,12 +16,13 @@ BEGIN_TEST(list_timesort_test)
#define TEST_SORTED() \
previous_time = INT_MAX;\
for (n = list.head; n != NULL; n = n->next) {\
must_be_true(n->walk_commit->commit_object->commit_time <= previous_time);\
previous_time = n->walk_commit->commit_object->commit_time;\
must_be_true(n->walk_commit->commit_object->committer->when.time <= previous_time);\
previous_time = n->walk_commit->commit_object->committer->when.time;\
}
#define CLEAR_LIST() \
for (n = list.head; n != NULL; n = n->next) {\
git_signature_free(n->walk_commit->commit_object->committer);\
free(n->walk_commit->commit_object);\
free(n->walk_commit);\
}\
@ -37,7 +39,7 @@ BEGIN_TEST(list_timesort_test)
git_commit *c = git__malloc(sizeof(git_commit));
git_revwalk_commit *rc = git__malloc(sizeof(git_revwalk_commit));
c->commit_time = (time_t)rand();
c->committer = git_signature_new("", "", (time_t)rand(), 0);
rc->commit_object = c;
git_revwalk_list_push_back(&list, rc);
@ -53,7 +55,7 @@ BEGIN_TEST(list_timesort_test)
git_commit *c = git__malloc(sizeof(git_commit));
git_revwalk_commit *rc = git__malloc(sizeof(git_revwalk_commit));
c->commit_time = 0;
c->committer = git_signature_new("", "", 0, 0);
rc->commit_object = c;
git_revwalk_list_push_back(&list, rc);