thodg/libgit2/tests/object/raw/hash.c

• Show log

  Commit

• Hash : f0e693b1
  Author :
  Date : 2021-09-07T17:53:49
  

  str: introduce `git_str` for internal, `git_buf` is external
  
  libgit2 has two distinct requirements that were previously solved by
  `git_buf`.  We require:
  
  1. A general purpose string class that provides a number of utility APIs
     for manipulating data (eg, concatenating, truncating, etc).
  2. A structure that we can use to return strings to callers that they
     can take ownership of.
  
  By using a single class (`git_buf`) for both of these purposes, we have
  confused the API to the point that refactorings are difficult and
  reasoning about correctness is also difficult.
  
  Move the utility class `git_buf` to be called `git_str`: this represents
  its general purpose, as an internal string buffer class.  The name also
  is an homage to Junio Hamano ("gitstr").
  
  The public API remains `git_buf`, and has a much smaller footprint.  It
  is generally only used as an "out" param with strict requirements that
  follow the documentation.  (Exceptions exist for some legacy APIs to
  avoid breaking callers unnecessarily.)
  
  Utility functions exist to convert a user-specified `git_buf` to a
  `git_str` so that we can call internal functions, then converting it
  back again.
  

Download

• tests/object/raw/hash.c

• 
  #include "clar_libgit2.h"
  
  #include "odb.h"
  #include "hash.h"
  
  #include "data.h"
  
  static void hash_object_pass(git_oid *oid, git_rawobj *obj)
  {
  	cl_git_pass(git_odb_hash(oid, obj->data, obj->len, obj->type));
  }
  static void hash_object_fail(git_oid *oid, git_rawobj *obj)
  {
  	cl_git_fail(git_odb_hash(oid, obj->data, obj->len, obj->type));
  }
  
  static char *hello_id = "22596363b3de40b06f981fb85d82312e8c0ed511";
  static char *hello_text = "hello world\n";
  
  static char *bye_id = "ce08fe4884650f067bd5703b6a59a8b3b3c99a09";
  static char *bye_text = "bye world\n";
  
  void test_object_raw_hash__hash_by_blocks(void)
  {
  	git_hash_ctx ctx;
  	git_oid id1, id2;
  
  	cl_git_pass(git_hash_ctx_init(&ctx, GIT_HASH_ALGORITHM_SHA1));
  
  	/* should already be init'd */
  	cl_git_pass(git_hash_update(&ctx, hello_text, strlen(hello_text)));
  	cl_git_pass(git_hash_final(id2.id, &ctx));
  	cl_git_pass(git_oid_fromstr(&id1, hello_id));
  	cl_assert(git_oid_cmp(&id1, &id2) == 0);
  
  	/* reinit should permit reuse */
  	cl_git_pass(git_hash_init(&ctx));
  	cl_git_pass(git_hash_update(&ctx, bye_text, strlen(bye_text)));
  	cl_git_pass(git_hash_final(id2.id, &ctx));
  	cl_git_pass(git_oid_fromstr(&id1, bye_id));
  	cl_assert(git_oid_cmp(&id1, &id2) == 0);
  
  	git_hash_ctx_cleanup(&ctx);
  }
  
  void test_object_raw_hash__hash_buffer_in_single_call(void)
  {
  	git_oid id1, id2;
  
  	cl_git_pass(git_oid_fromstr(&id1, hello_id));
  	git_hash_buf(id2.id, hello_text, strlen(hello_text), GIT_HASH_ALGORITHM_SHA1);
  	cl_assert(git_oid_cmp(&id1, &id2) == 0);
  }
  
  void test_object_raw_hash__hash_vector(void)
  {
  	git_oid id1, id2;
  	git_str_vec vec[2];
  
  	cl_git_pass(git_oid_fromstr(&id1, hello_id));
  
  	vec[0].data = hello_text;
  	vec[0].len  = 4;
  	vec[1].data = hello_text+4;
  	vec[1].len  = strlen(hello_text)-4;
  
  	git_hash_vec(id2.id, vec, 2, GIT_HASH_ALGORITHM_SHA1);
  
  	cl_assert(git_oid_cmp(&id1, &id2) == 0);
  }
  
  void test_object_raw_hash__hash_junk_data(void)
  {
  	git_oid id, id_zero;
  
  	cl_git_pass(git_oid_fromstr(&id_zero, zero_id));
  
  	/* invalid types: */
  	junk_obj.data = some_data;
  	hash_object_fail(&id, &junk_obj);
  
  	junk_obj.type = 0; /* EXT1 */
  	hash_object_fail(&id, &junk_obj);
  
  	junk_obj.type = 5; /* EXT2 */
  	hash_object_fail(&id, &junk_obj);
  
  	junk_obj.type = GIT_OBJECT_OFS_DELTA;
  	hash_object_fail(&id, &junk_obj);
  
  	junk_obj.type = GIT_OBJECT_REF_DELTA;
  	hash_object_fail(&id, &junk_obj);
  
  	junk_obj.type = 42;
  	hash_object_fail(&id, &junk_obj);
  
  	/* data can be NULL only if len is zero: */
  	junk_obj.type = GIT_OBJECT_BLOB;
  	junk_obj.data = NULL;
  	hash_object_pass(&id, &junk_obj);
  	cl_assert(git_oid_cmp(&id, &id_zero) == 0);
  
  	junk_obj.len = 1;
  	hash_object_fail(&id, &junk_obj);
  }
  
  void test_object_raw_hash__hash_commit_object(void)
  {
  	git_oid id1, id2;
  
  	cl_git_pass(git_oid_fromstr(&id1, commit_id));
  	hash_object_pass(&id2, &commit_obj);
  	cl_assert(git_oid_cmp(&id1, &id2) == 0);
  }
  
  void test_object_raw_hash__hash_tree_object(void)
  {
  	git_oid id1, id2;
  
  	cl_git_pass(git_oid_fromstr(&id1, tree_id));
  	hash_object_pass(&id2, &tree_obj);
  	cl_assert(git_oid_cmp(&id1, &id2) == 0);
  }
  
  void test_object_raw_hash__hash_tag_object(void)
  {
  	git_oid id1, id2;
  
  	cl_git_pass(git_oid_fromstr(&id1, tag_id));
  	hash_object_pass(&id2, &tag_obj);
  	cl_assert(git_oid_cmp(&id1, &id2) == 0);
  }
  
  void test_object_raw_hash__hash_zero_length_object(void)
  {
  	git_oid id1, id2;
  
  	cl_git_pass(git_oid_fromstr(&id1, zero_id));
  	hash_object_pass(&id2, &zero_obj);
  	cl_assert(git_oid_cmp(&id1, &id2) == 0);
  }
  
  void test_object_raw_hash__hash_one_byte_object(void)
  {
  	git_oid id1, id2;
  
  	cl_git_pass(git_oid_fromstr(&id1, one_id));
  	hash_object_pass(&id2, &one_obj);
  	cl_assert(git_oid_cmp(&id1, &id2) == 0);
  }
  
  void test_object_raw_hash__hash_two_byte_object(void)
  {
  	git_oid id1, id2;
  
  	cl_git_pass(git_oid_fromstr(&id1, two_id));
  	hash_object_pass(&id2, &two_obj);
  	cl_assert(git_oid_cmp(&id1, &id2) == 0);
  }
  
  void test_object_raw_hash__hash_multi_byte_object(void)
  {
  	git_oid id1, id2;
  
  	cl_git_pass(git_oid_fromstr(&id1, some_id));
  	hash_object_pass(&id2, &some_obj);
  	cl_assert(git_oid_cmp(&id1, &id2) == 0);
  }
  

Download