void test_filter_blob__ident(void) { git_oid id; git_blob *blob; git_buf buf = { 0 }; cl_git_mkfile("crlf/test.ident", "Some text\n$Id$\nGoes there\n"); cl_git_pass(git_blob_create_fromworkdir(&id, g_repo, "test.ident")); cl_git_pass(git_blob_lookup(&blob, g_repo, &id)); cl_assert_equal_s( "Some text\n$Id$\nGoes there\n", git_blob_rawcontent(blob)); git_blob_free(blob); cl_git_mkfile("crlf/test.ident", "Some text\n$Id: Any old just you want$\nGoes there\n"); cl_git_pass(git_blob_create_fromworkdir(&id, g_repo, "test.ident")); cl_git_pass(git_blob_lookup(&blob, g_repo, &id)); cl_assert_equal_s( "Some text\n$Id$\nGoes there\n", git_blob_rawcontent(blob)); cl_git_pass(git_blob_filtered_content(&buf, blob, "filter.bin", 1)); cl_assert_equal_s( "Some text\n$Id$\nGoes there\n", buf.ptr); cl_git_pass(git_blob_filtered_content(&buf, blob, "filter.identcrlf", 1)); cl_assert_equal_s( "Some text\r\n$Id: 3164f585d548ac68027d22b104f2d8100b2b6845$\r\nGoes there\r\n", buf.ptr); cl_git_pass(git_blob_filtered_content(&buf, blob, "filter.identlf", 1)); cl_assert_equal_s( "Some text\n$Id: 3164f585d548ac68027d22b104f2d8100b2b6845$\nGoes there\n", buf.ptr); git_buf_free(&buf); git_blob_free(blob); }
void test_diff_blob__patch_with_freed_blobs(void) { git_oid a_oid, b_oid; git_blob *a, *b; git_patch *p; git_buf buf = GIT_BUF_INIT; /* tests/resources/attr/root_test1 */ cl_git_pass(git_oid_fromstrn(&a_oid, "45141a79", 8)); cl_git_pass(git_blob_lookup_prefix(&a, g_repo, &a_oid, 4)); /* tests/resources/attr/root_test2 */ cl_git_pass(git_oid_fromstrn(&b_oid, "4d713dc4", 8)); cl_git_pass(git_blob_lookup_prefix(&b, g_repo, &b_oid, 4)); cl_git_pass(git_patch_from_blobs(&p, a, NULL, b, NULL, NULL)); git_blob_free(a); git_blob_free(b); cl_git_pass(git_patch_to_buf(&buf, p)); cl_assert_equal_s(buf.ptr, BLOB_DIFF); git_patch_free(p); git_buf_free(&buf); }
void test_filter_custom__order_dependency(void) { git_index *index; git_blob *blob; git_buf buf = { 0 }; /* so if ident and reverse are used together, an interesting thing * happens - a reversed "$Id$" string is no longer going to trigger * ident correctly. When checking out, the filters should be applied * in order CLRF, then ident, then reverse, so ident expansion should * work correctly. On check in, the content should be reversed, then * ident, then CRLF filtered. Let's make sure that works... */ cl_git_mkfile( "empty_standard_repo/.gitattributes", "hero.*.rev-ident text ident prereverse eol=lf\n"); cl_git_mkfile( "empty_standard_repo/hero.1.rev-ident", "This is a test\n$Id$\nHave fun!\n"); cl_git_mkfile( "empty_standard_repo/hero.2.rev-ident", "Another test\n$dI$\nCrazy!\n"); cl_git_pass(git_repository_index(&index, g_repo)); cl_git_pass(git_index_add_bypath(index, "hero.1.rev-ident")); cl_git_pass(git_index_add_bypath(index, "hero.2.rev-ident")); cl_repo_commit_from_index(NULL, g_repo, NULL, 0, "Filter chains\n"); git_index_free(index); cl_git_pass(git_blob_lookup(&blob, g_repo, & git_index_get_bypath(index, "hero.1.rev-ident", 0)->oid)); cl_assert_equal_s( "\n!nuf evaH\n$dI$\ntset a si sihT", git_blob_rawcontent(blob)); cl_git_pass(git_blob_filtered_content(&buf, blob, "hero.1.rev-ident", 0)); /* no expansion because id was reversed at checkin and now at ident * time, reverse is not applied yet */ cl_assert_equal_s( "This is a test\n$Id$\nHave fun!\n", buf.ptr); git_blob_free(blob); cl_git_pass(git_blob_lookup(&blob, g_repo, & git_index_get_bypath(index, "hero.2.rev-ident", 0)->oid)); cl_assert_equal_s( "\n!yzarC\n$Id$\ntset rehtonA", git_blob_rawcontent(blob)); cl_git_pass(git_blob_filtered_content(&buf, blob, "hero.2.rev-ident", 0)); /* expansion because reverse was applied at checkin and at ident time, * reverse is not applied yet */ cl_assert_equal_s( "Another test\n$59001fe193103b1016b27027c0c827d036fd0ac8 :dI$\nCrazy!\n", buf.ptr); cl_assert_equal_i(0, git_oid_strcmp( git_blob_id(blob), "8ca0df630d728c0c72072b6101b301391ef10095")); git_blob_free(blob); git_buf_free(&buf); }
void test_diff_blob__can_compare_text_blobs(void) { git_blob *a, *b, *c; git_oid a_oid, b_oid, c_oid; /* tests/resources/attr/root_test1 */ cl_git_pass(git_oid_fromstrn(&a_oid, "45141a79", 8)); cl_git_pass(git_blob_lookup_prefix(&a, g_repo, &a_oid, 4)); /* tests/resources/attr/root_test2 */ cl_git_pass(git_oid_fromstrn(&b_oid, "4d713dc4", 8)); cl_git_pass(git_blob_lookup_prefix(&b, g_repo, &b_oid, 4)); /* tests/resources/attr/root_test3 */ cl_git_pass(git_oid_fromstrn(&c_oid, "c96bbb2c2557a832", 16)); cl_git_pass(git_blob_lookup_prefix(&c, g_repo, &c_oid, 16)); /* Doing the equivalent of a `git diff -U1` on these files */ /* diff on tests/resources/attr/root_test1 */ memset(&expected, 0, sizeof(expected)); cl_git_pass(git_diff_blobs( a, NULL, b, NULL, &opts, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expected)); assert_one_modified(1, 6, 1, 5, 0, &expected); /* same diff but use direct buffers */ memset(&expected, 0, sizeof(expected)); cl_git_pass(git_diff_buffers( git_blob_rawcontent(a), (size_t)git_blob_rawsize(a), NULL, git_blob_rawcontent(b), (size_t)git_blob_rawsize(b), NULL, &opts, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expected)); assert_one_modified(1, 6, 1, 5, 0, &expected); /* diff on tests/resources/attr/root_test2 */ memset(&expected, 0, sizeof(expected)); cl_git_pass(git_diff_blobs( b, NULL, c, NULL, &opts, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expected)); assert_one_modified(1, 15, 3, 9, 3, &expected); /* diff on tests/resources/attr/root_test3 */ memset(&expected, 0, sizeof(expected)); cl_git_pass(git_diff_blobs( a, NULL, c, NULL, &opts, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expected)); assert_one_modified(1, 13, 0, 12, 1, &expected); memset(&expected, 0, sizeof(expected)); cl_git_pass(git_diff_blobs( c, NULL, d, NULL, &opts, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expected)); assert_one_modified(2, 14, 4, 6, 4, &expected); git_blob_free(a); git_blob_free(b); git_blob_free(c); }
void test_diff_blob__cleanup(void) { git_blob_free(d); d = NULL; git_blob_free(alien); alien = NULL; cl_git_sandbox_cleanup(); }
void test_diff_binary__blob_to_blob(void) { git_index *index; git_diff_options opts = GIT_DIFF_OPTIONS_INIT; git_blob *old_blob, *new_blob; git_oid old_id, new_id; struct diff_data diff_data = {0}; opts.flags = GIT_DIFF_SHOW_BINARY | GIT_DIFF_FORCE_BINARY; opts.id_abbrev = GIT_OID_HEXSZ; repo = cl_git_sandbox_init("renames"); cl_git_pass(git_repository_index__weakptr(&index, repo)); cl_git_append2file("renames/untimely.txt", "Oh that crazy Kipling!\r\n"); cl_git_pass(git_index_add_bypath(index, "untimely.txt")); cl_git_pass(git_index_write(index)); git_oid_fromstr(&old_id, "9a69d960ae94b060f56c2a8702545e2bb1abb935"); git_oid_fromstr(&new_id, "1111d4f11f4b35bf6759e0fb714fe09731ef0840"); cl_git_pass(git_blob_lookup(&old_blob, repo, &old_id)); cl_git_pass(git_blob_lookup(&new_blob, repo, &new_id)); cl_git_pass(git_diff_blobs(old_blob, "untimely.txt", new_blob, "untimely.txt", &opts, file_cb, binary_cb, hunk_cb, line_cb, &diff_data)); cl_assert_equal_s("untimely.txt", diff_data.old_path); cl_assert_equal_oid(&old_id, &diff_data.old_id); cl_assert_equal_i(GIT_DIFF_BINARY_DELTA, diff_data.old_binary_type); cl_assert_equal_i(7, diff_data.old_binary_inflatedlen); cl_assert_equal_s("c%18D`@*{63ljhg(E~C7", diff_data.old_binary_base85.ptr); cl_assert_equal_s("untimely.txt", diff_data.new_path); cl_assert_equal_oid(&new_id, &diff_data.new_id); cl_assert_equal_i(GIT_DIFF_BINARY_DELTA, diff_data.new_binary_type); cl_assert_equal_i(32, diff_data.new_binary_inflatedlen); cl_assert_equal_s("c%1vf+QYWt3zLL@hC)e3Vu?a>QDRl4f_G*?PG(-ZA}<#J$+QbW", diff_data.new_binary_base85.ptr); git_blob_free(old_blob); git_blob_free(new_blob); git__free(diff_data.old_path); git__free(diff_data.new_path); git_buf_dispose(&diff_data.old_binary_base85); git_buf_dispose(&diff_data.new_binary_base85); }
static int checkout_blob( struct checkout_diff_data *data, const git_diff_file *file) { git_blob *blob; int error; git_buf_truncate(data->path, data->workdir_len); if (git_buf_joinpath(data->path, git_buf_cstr(data->path), file->path) < 0) return -1; if ((error = git_blob_lookup(&blob, data->owner, &file->oid)) < 0) return error; if (S_ISLNK(file->mode)) error = blob_content_to_link( blob, git_buf_cstr(data->path), data->can_symlink); else error = blob_content_to_file( blob, git_buf_cstr(data->path), file->mode, data->checkout_opts); git_blob_free(blob); return error; }
void git_diff_file_content__unload(git_diff_file_content *fc) { if ((fc->flags & GIT_DIFF_FLAG__LOADED) == 0) return; if (fc->flags & GIT_DIFF_FLAG__FREE_DATA) { git__free(fc->map.data); fc->map.data = ""; fc->map.len = 0; fc->flags &= ~GIT_DIFF_FLAG__FREE_DATA; } else if (fc->flags & GIT_DIFF_FLAG__UNMAP_DATA) { git_futils_mmap_free(&fc->map); fc->map.data = ""; fc->map.len = 0; fc->flags &= ~GIT_DIFF_FLAG__UNMAP_DATA; } if (fc->flags & GIT_DIFF_FLAG__FREE_BLOB) { git_blob_free((git_blob *)fc->blob); fc->blob = NULL; fc->flags &= ~GIT_DIFF_FLAG__FREE_BLOB; } fc->flags &= ~GIT_DIFF_FLAG__LOADED; }
void test_diff_blob__can_compare_two_binary_blobs(void) { git_blob *heart; git_oid h_oid; /* heart.png */ cl_git_pass(git_oid_fromstrn(&h_oid, "de863bff", 8)); cl_git_pass(git_blob_lookup_prefix(&heart, g_repo, &h_oid, 8)); cl_git_pass(git_diff_blobs( alien, NULL, heart, NULL, &opts, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expected)); assert_binary_blobs_comparison(&expected); memset(&expected, 0, sizeof(expected)); cl_git_pass(git_diff_blobs( heart, NULL, alien, NULL, &opts, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &expected)); assert_binary_blobs_comparison(&expected); git_blob_free(heart); }
static int index_reader_read( git_buf *out, git_oid *out_id, git_filemode_t *out_filemode, git_reader *_reader, const char *filename) { index_reader *reader = (index_reader *)_reader; const git_index_entry *entry; git_blob *blob; int error; if ((entry = git_index_get_bypath(reader->index, filename, 0)) == NULL) return GIT_ENOTFOUND; if ((error = git_blob_lookup(&blob, reader->repo, &entry->id)) < 0) goto done; if (out_id) git_oid_cpy(out_id, &entry->id); if (out_filemode) *out_filemode = entry->mode; error = git_blob__getbuf(out, blob); done: git_blob_free(blob); return error; }
int CRepositoryBrowser::ReadTreeRecursive(git_repository &repo, git_tree * tree, CShadowFilesTree * treeroot) { size_t count = git_tree_entrycount(tree); for (size_t i = 0; i < count; ++i) { const git_tree_entry *entry = git_tree_entry_byindex(tree, i); if (entry == NULL) continue; const int mode = git_tree_entry_filemode(entry); CString base = CUnicodeUtils::GetUnicode(git_tree_entry_name(entry), CP_UTF8); const git_oid *oid = git_tree_entry_id(entry); CShadowFilesTree * pNextTree = &treeroot->m_ShadowTree[base]; pNextTree->m_sName = base; pNextTree->m_pParent = treeroot; pNextTree->m_hash = CGitHash((char *)oid->id); if (mode == GIT_FILEMODE_COMMIT) pNextTree->m_bSubmodule = true; else if (mode & S_IFDIR) { pNextTree->m_bFolder = true; TVINSERTSTRUCT tvinsert = {0}; tvinsert.hParent = treeroot->m_hTree; tvinsert.hInsertAfter = TVI_SORT; tvinsert.itemex.mask = TVIF_DI_SETITEM | TVIF_PARAM | TVIF_TEXT | TVIF_IMAGE | TVIF_SELECTEDIMAGE | TVIF_STATE; tvinsert.itemex.pszText = base.GetBuffer(base.GetLength()); tvinsert.itemex.lParam = (LPARAM)pNextTree; tvinsert.itemex.iImage = m_nIconFolder; tvinsert.itemex.iSelectedImage = m_nOpenIconFolder; pNextTree->m_hTree = m_RepoTree.InsertItem(&tvinsert); base.ReleaseBuffer(); git_object *object = nullptr; git_tree_entry_to_object(&object, &repo, entry); if (object == nullptr) continue; ReadTreeRecursive(repo, (git_tree*)object, pNextTree); git_object_free(object); } else { git_blob * blob = nullptr; git_blob_lookup(&blob, &repo, oid); if (blob == NULL) continue; pNextTree->m_iSize = git_blob_rawsize(blob); git_blob_free(blob); } } return 0; }
void test_notes_notes__1(void) { git_oid oid, note_oid; static git_note *note; static git_blob *blob; cl_git_pass(git_oid_fromstr(&oid, "8496071c1b46c854b31185ea97743be6a8774479")); cl_git_pass(git_note_create(¬e_oid, _repo, _sig, _sig, "refs/notes/some/namespace", &oid, "hello world\n")); cl_git_pass(git_note_create(¬e_oid, _repo, _sig, _sig, NULL, &oid, "hello world\n")); cl_git_pass(git_note_read(¬e, _repo, NULL, &oid)); cl_assert_equal_s(git_note_message(note), "hello world\n"); cl_assert(!git_oid_cmp(git_note_oid(note), ¬e_oid)); cl_git_pass(git_blob_lookup(&blob, _repo, ¬e_oid)); cl_assert_equal_s(git_note_message(note), git_blob_rawcontent(blob)); cl_git_fail(git_note_create(¬e_oid, _repo, _sig, _sig, NULL, &oid, "hello world\n")); cl_git_fail(git_note_create(¬e_oid, _repo, _sig, _sig, "refs/notes/some/namespace", &oid, "hello world\n")); cl_git_pass(git_note_remove(_repo, NULL, _sig, _sig, &oid)); cl_git_pass(git_note_remove(_repo, "refs/notes/some/namespace", _sig, _sig, &oid)); cl_git_fail(git_note_remove(_repo, NULL, _sig, _sig, ¬e_oid)); cl_git_fail(git_note_remove(_repo, "refs/notes/some/namespace", _sig, _sig, &oid)); git_note_free(note); git_blob_free(blob); }
static int parse_picture_entry(git_repository *repo, const git_tree_entry *entry, const char *name) { git_blob *blob; struct picture *pic; int hh, mm, ss, offset; char sign; /* * The format of the picture name files is just the offset * within the dive in form [[+-]hh:mm:ss, possibly followed * by a hash to make the filename unique (which we can just * ignore). */ if (sscanf(name, "%c%d:%d:%d", &sign, &hh, &mm, &ss) != 4) return report_error("Unknown file name %s", name); offset = ss + 60*(mm + 60*hh); if (sign == '-') offset = -offset; blob = git_tree_entry_blob(repo, entry); if (!blob) return report_error("Unable to read trip file"); pic = alloc_picture(); pic->offset.seconds = offset; dive_add_picture(active_dive, pic); for_each_line(blob, picture_parser, pic); git_blob_free(blob); return 0; }
static int tree_reader_read( git_buf *out, git_oid *out_id, git_filemode_t *out_filemode, git_reader *_reader, const char *filename) { tree_reader *reader = (tree_reader *)_reader; git_tree_entry *tree_entry = NULL; git_blob *blob = NULL; int error; if ((error = git_tree_entry_bypath(&tree_entry, reader->tree, filename)) < 0 || (error = git_blob_lookup(&blob, git_tree_owner(reader->tree), git_tree_entry_id(tree_entry))) < 0 || (error = git_buf_set(out, git_blob_rawcontent(blob), git_blob_rawsize(blob))) < 0) goto done; if (out_id) git_oid_cpy(out_id, git_tree_entry_id(tree_entry)); if (out_filemode) *out_filemode = git_tree_entry_filemode(tree_entry); done: git_blob_free(blob); git_tree_entry_free(tree_entry); return error; }
static int note_lookup(git_note **out, git_repository *repo, git_tree *tree, const char *target) { int error, fanout = 0; git_oid oid; git_blob *blob = NULL; git_note *note = NULL; git_tree *subtree = NULL; if ((error = find_subtree_r(&subtree, tree, repo, target, &fanout)) < 0) goto cleanup; if ((error = find_blob(&oid, subtree, target + fanout)) < 0) goto cleanup; if ((error = git_blob_lookup(&blob, repo, &oid)) < 0) goto cleanup; if ((error = note_new(¬e, &oid, blob)) < 0) goto cleanup; *out = note; cleanup: git_tree_free(subtree); git_blob_free(blob); return error; }
void test_filter_blob__all_crlf(void) { git_blob *blob; git_buf buf = { 0 }; cl_git_pass(git_revparse_single( (git_object **)&blob, g_repo, "a9a2e891")); /* all-crlf */ cl_assert_equal_s(ALL_CRLF_TEXT_RAW, git_blob_rawcontent(blob)); cl_git_pass(git_blob_filtered_content(&buf, blob, "file.bin", 1)); cl_assert_equal_s(ALL_CRLF_TEXT_RAW, buf.ptr); cl_git_pass(git_blob_filtered_content(&buf, blob, "file.crlf", 1)); /* in this case, raw content has crlf in it already */ cl_assert_equal_s(ALL_CRLF_TEXT_AS_CRLF, buf.ptr); cl_git_pass(git_blob_filtered_content(&buf, blob, "file.lf", 1)); /* we never convert CRLF -> LF on platforms that have LF */ cl_assert_equal_s(ALL_CRLF_TEXT_AS_CRLF, buf.ptr); git_buf_free(&buf); git_blob_free(blob); }
void test_filter_blob__sanitizes(void) { git_blob *blob; git_buf buf; cl_git_pass(git_revparse_single( (git_object **)&blob, g_repo, "e69de29")); /* zero-byte */ cl_assert_equal_i(0, git_blob_rawsize(blob)); cl_assert_equal_s("", git_blob_rawcontent(blob)); memset(&buf, 0, sizeof(git_buf)); cl_git_pass(git_blob_filtered_content(&buf, blob, "file.bin", 1)); cl_assert_equal_sz(0, buf.size); cl_assert_equal_s("", buf.ptr); git_buf_free(&buf); memset(&buf, 0, sizeof(git_buf)); cl_git_pass(git_blob_filtered_content(&buf, blob, "file.crlf", 1)); cl_assert_equal_sz(0, buf.size); cl_assert_equal_s("", buf.ptr); git_buf_free(&buf); memset(&buf, 0, sizeof(git_buf)); cl_git_pass(git_blob_filtered_content(&buf, blob, "file.lf", 1)); cl_assert_equal_sz(0, buf.size); cl_assert_equal_s("", buf.ptr); git_buf_free(&buf); git_blob_free(blob); }
static int parse_trip_entry(git_repository *repo, const git_tree_entry *entry) { git_blob *blob = git_tree_entry_blob(repo, entry); if (!blob) return report_error("Unable to read trip file"); for_each_line(blob, trip_parser, active_trip); git_blob_free(blob); return 0; }
void test_diff_blob__can_compare_text_blobs_with_patch(void) { git_blob *a, *b, *c; git_oid a_oid, b_oid, c_oid; git_patch *p; /* tests/resources/attr/root_test1 */ cl_git_pass(git_oid_fromstrn(&a_oid, "45141a79", 8)); cl_git_pass(git_blob_lookup_prefix(&a, g_repo, &a_oid, 8)); /* tests/resources/attr/root_test2 */ cl_git_pass(git_oid_fromstrn(&b_oid, "4d713dc4", 8)); cl_git_pass(git_blob_lookup_prefix(&b, g_repo, &b_oid, 8)); /* tests/resources/attr/root_test3 */ cl_git_pass(git_oid_fromstrn(&c_oid, "c96bbb2c2557a832", 16)); cl_git_pass(git_blob_lookup_prefix(&c, g_repo, &c_oid, 16)); /* Doing the equivalent of a `git diff -U1` on these files */ /* diff on tests/resources/attr/root_test1 */ cl_git_pass(git_patch_from_blobs(&p, a, NULL, b, NULL, &opts)); assert_patch_matches_blobs(p, a, b, 1, 6, 0, 1, 5, 0); git_patch_free(p); /* diff on tests/resources/attr/root_test2 */ cl_git_pass(git_patch_from_blobs(&p, b, NULL, c, NULL, &opts)); assert_patch_matches_blobs(p, b, c, 1, 15, 0, 3, 9, 3); git_patch_free(p); /* diff on tests/resources/attr/root_test3 */ cl_git_pass(git_patch_from_blobs(&p, a, NULL, c, NULL, &opts)); assert_patch_matches_blobs(p, a, c, 1, 13, 0, 0, 12, 1); git_patch_free(p); /* one more */ cl_git_pass(git_patch_from_blobs(&p, c, NULL, d, NULL, &opts)); assert_patch_matches_blobs(p, c, d, 2, 5, 9, 4, 6, 4); git_patch_free(p); git_blob_free(a); git_blob_free(b); git_blob_free(c); }
void test_index_tests__add_frombuffer(void) { git_index *index; git_repository *repo; git_index_entry entry; const git_index_entry *returned_entry; git_oid id1; git_blob *blob; const char *content = "hey there\n"; cl_set_cleanup(&cleanup_myrepo, NULL); /* Intialize a new repository */ cl_git_pass(git_repository_init(&repo, "./myrepo", 0)); /* Ensure we're the only guy in the room */ cl_git_pass(git_repository_index(&index, repo)); cl_assert(git_index_entrycount(index) == 0); /* Store the expected hash of the file/blob * This has been generated by executing the following * $ echo "hey there" | git hash-object --stdin */ cl_git_pass(git_oid_fromstr(&id1, "a8233120f6ad708f843d861ce2b7228ec4e3dec6")); /* Add the new file to the index */ memset(&entry, 0x0, sizeof(git_index_entry)); entry.mode = GIT_FILEMODE_BLOB; entry.path = "test.txt"; cl_git_pass(git_index_add_frombuffer(index, &entry, content, strlen(content))); /* Wow... it worked! */ cl_assert(git_index_entrycount(index) == 1); returned_entry = git_index_get_byindex(index, 0); /* And the built-in hashing mechanism worked as expected */ cl_assert_equal_oid(&id1, &returned_entry->id); /* And mode is the one asked */ cl_assert_equal_i(GIT_FILEMODE_BLOB, returned_entry->mode); /* Test access by path instead of index */ cl_assert((returned_entry = git_index_get_bypath(index, "test.txt", 0)) != NULL); cl_assert_equal_oid(&id1, &returned_entry->id); /* Test the blob is in the repository */ cl_git_pass(git_blob_lookup(&blob, repo, &id1)); cl_assert_equal_s( content, git_blob_rawcontent(blob)); git_blob_free(blob); git_index_free(index); git_repository_free(repo); }
static void origin_decref(git_blame__origin *o) { if (o && --o->refcnt <= 0) { if (o->previous) origin_decref(o->previous); git_blob_free(o->blob); git_commit_free(o->commit); git__free(o); } }
static int parse_settings_entry(git_repository *repo, const git_tree_entry *entry) { git_blob *blob = git_tree_entry_blob(repo, entry); if (!blob) return report_error("Unable to read settings file"); set_save_userid_local(false); for_each_line(blob, settings_parser, NULL); git_blob_free(blob); return 0; }
static void assert_note_equal(git_note *note, char *message, git_oid *note_oid) { git_blob *blob; cl_assert_equal_s(git_note_message(note), message); cl_assert_equal_oid(git_note_id(note), note_oid); cl_git_pass(git_blob_lookup(&blob, _repo, note_oid)); cl_assert_equal_s(git_note_message(note), (const char *)git_blob_rawcontent(blob)); git_blob_free(blob); }
static int parse_site_entry(git_repository *repo, const git_tree_entry *entry, const char *suffix) { if (*suffix == '\0') return report_error("Dive site without uuid"); uint32_t uuid = strtoul(suffix, NULL, 16); struct dive_site *ds = alloc_or_get_dive_site(uuid); git_blob *blob = git_tree_entry_blob(repo, entry); if (!blob) return report_error("Unable to read dive site file"); for_each_line(blob, site_parser, ds); git_blob_free(blob); return 0; }
/* * We should *really* try to delay the dive computer data parsing * until necessary, in order to reduce load-time. The parsing is * cheap, but the loading of the git blob into memory can be pretty * costly. */ static int parse_divecomputer_entry(git_repository *repo, const git_tree_entry *entry, const char *suffix) { git_blob *blob = git_tree_entry_blob(repo, entry); if (!blob) return report_error("Unable to read divecomputer file"); active_dc = create_new_dc(active_dive); for_each_line(blob, divecomputer_parser, active_dc); git_blob_free(blob); active_dc = NULL; return 0; }
static int parse_dive_entry(git_repository *repo, const git_tree_entry *entry, const char *suffix) { struct dive *dive = active_dive; git_blob *blob = git_tree_entry_blob(repo, entry); if (!blob) return report_error("Unable to read dive file"); if (*suffix) dive->number = atoi(suffix+1); cylinder_index = weightsystem_index = 0; for_each_line(blob, dive_parser, active_dive); git_blob_free(blob); return 0; }
static int parse_picture_file(git_repository *repo, const git_tree_entry *entry, const char *name) { /* remember the picture data so we can handle it when all dive data has been loaded * the name of the git file is PIC-<hash> */ git_blob *blob = git_tree_entry_blob(repo, entry); const void *rawdata = git_blob_rawcontent(blob); int len = git_blob_rawsize(blob); struct picture_entry_list *new_pel = malloc(sizeof(struct picture_entry_list)); new_pel->next = pel; pel = new_pel; pel->data = malloc(len); memcpy(pel->data, rawdata, len); pel->len = len; pel->hash = strdup(name + 4); git_blob_free(blob); return 0; }
void test_object_blob_filter__unfiltered(void) { int i; git_blob *blob; for (i = 0; i < CRLF_NUM_TEST_OBJECTS; i++) { size_t raw_len = (size_t)g_crlf_raw_len[i]; cl_git_pass(git_blob_lookup(&blob, g_repo, &g_crlf_oids[i])); cl_assert_equal_sz(raw_len, (size_t)git_blob_rawsize(blob)); cl_assert_equal_i( 0, memcmp(g_crlf_raw[i], git_blob_rawcontent(blob), raw_len)); git_blob_free(blob); } }
void test_object_blob_filter__stats(void) { int i; git_blob *blob; git_buf buf = GIT_BUF_INIT; git_buf_text_stats stats; for (i = 0; i < CRLF_NUM_TEST_OBJECTS; i++) { cl_git_pass(git_blob_lookup(&blob, g_repo, &g_crlf_oids[i])); cl_git_pass(git_blob__getbuf(&buf, blob)); git_buf_text_gather_stats(&stats, &buf, false); cl_assert_equal_i( 0, memcmp(&g_crlf_filtered_stats[i], &stats, sizeof(stats))); git_blob_free(blob); } git_buf_free(&buf); }
void test_object_blob_filter__to_odb(void) { git_filter_list *fl = NULL; git_config *cfg; int i; git_blob *blob; git_buf out = GIT_BUF_INIT, zeroed; cl_git_pass(git_repository_config(&cfg, g_repo)); cl_assert(cfg); git_attr_cache_flush(g_repo); cl_git_append2file("empty_standard_repo/.gitattributes", "*.txt text\n"); cl_git_pass(git_filter_list_load( &fl, g_repo, NULL, "filename.txt", GIT_FILTER_TO_ODB, 0)); cl_assert(fl != NULL); for (i = 0; i < CRLF_NUM_TEST_OBJECTS; i++) { cl_git_pass(git_blob_lookup(&blob, g_repo, &g_crlf_oids[i])); /* try once with allocated blob */ cl_git_pass(git_filter_list_apply_to_blob(&out, fl, blob)); cl_assert_equal_sz(g_crlf_filtered[i].size, out.size); cl_assert_equal_i( 0, memcmp(out.ptr, g_crlf_filtered[i].ptr, out.size)); /* try again with zeroed blob */ memset(&zeroed, 0, sizeof(zeroed)); cl_git_pass(git_filter_list_apply_to_blob(&zeroed, fl, blob)); cl_assert_equal_sz(g_crlf_filtered[i].size, zeroed.size); cl_assert_equal_i( 0, memcmp(zeroed.ptr, g_crlf_filtered[i].ptr, zeroed.size)); git_buf_free(&zeroed); git_blob_free(blob); } git_filter_list_free(fl); git_buf_free(&out); git_config_free(cfg); }