thodg/libgit2/tests/index/version.c

• Show log

  Commit

• Hash : 8fe33538
  Author :
  Date : 2017-05-19T12:45:48
  

  tests: index::version: verify we write compressed index entries
  
  While we do have a test which checks whether a written index of version
  4 has the correct version set, we do not check whether this actually
  enables path compression for index entries. This commit adds a new test
  by adding a number of index entries with equal path prefixes to the
  index and subsequently flushing that to disk. With suffix compression
  enabled by index version 4, only the last few bytes of these paths will
  actually have to be written to the index, saving a lot of disk space.
  For the test, differences are about an order of magnitude, allowing us
  to easily verify without taking a deeper look at actual on-disk
  contents.
  

Download

• tests/index/version.c

• #include "clar_libgit2.h"
  #include "index.h"
  
  static git_repository *g_repo = NULL;
  
  void test_index_version__cleanup(void)
  {
          cl_git_sandbox_cleanup();
          g_repo = NULL;
  }
  
  void test_index_version__can_read_v4(void)
  {
  	const char *paths[] = {
  	    "file.tx", "file.txt", "file.txz", "foo", "zzz",
  	};
  	git_index *index;
  	size_t i;
  
  	g_repo = cl_git_sandbox_init("indexv4");
  
  	cl_git_pass(git_repository_index(&index, g_repo));
  	cl_assert_equal_sz(git_index_entrycount(index), 5);
  
  	for (i = 0; i < ARRAY_SIZE(paths); i++) {
  		const git_index_entry *entry =
  		    git_index_get_bypath(index, paths[i], GIT_INDEX_STAGE_NORMAL);
  
  		cl_assert(entry != NULL);
  	}
  
  	git_index_free(index);
  }
  
  void test_index_version__can_write_v4(void)
  {
  	const char *paths[] = {
  	    "foo",
  	    "foox",
  	    "foobar",
  	    "foobal",
  	    "x",
  	    "xz",
  	    "xyzzyx"
  	};
  	git_index_entry entry;
  	git_index *index;
  	size_t i;
  
  	g_repo = cl_git_sandbox_init("empty_standard_repo");
  	cl_git_pass(git_repository_index(&index, g_repo));
  	cl_git_pass(git_index_set_version(index, 4));
  
  	for (i = 0; i < ARRAY_SIZE(paths); i++) {
  		memset(&entry, 0, sizeof(entry));
  		entry.path = paths[i];
  		entry.mode = GIT_FILEMODE_BLOB;
  		cl_git_pass(git_index_add_frombuffer(index, &entry, paths[i],
  						     strlen(paths[i]) + 1));
  	}
  	cl_assert_equal_sz(git_index_entrycount(index), ARRAY_SIZE(paths));
  
  	cl_git_pass(git_index_write(index));
  	git_index_free(index);
  
  	cl_git_pass(git_repository_index(&index, g_repo));
  	cl_assert(git_index_version(index) == 4);
  
  	for (i = 0; i < ARRAY_SIZE(paths); i++) {
  		const git_index_entry *e;
  
  		cl_assert(e = git_index_get_bypath(index, paths[i], 0));
  		cl_assert_equal_s(paths[i], e->path);
  	}
  
  	git_index_free(index);
  }
  
  void test_index_version__v4_uses_path_compression(void)
  {
  	git_index_entry entry;
  	git_index *index;
  	char path[250], buf[1];
  	struct stat st;
  	char i, j;
  
  	memset(path, 'a', sizeof(path));
  	memset(buf, 'a', sizeof(buf));
  
  	memset(&entry, 0, sizeof(entry));
  	entry.path = path;
  	entry.mode = GIT_FILEMODE_BLOB;
  
  	g_repo = cl_git_sandbox_init("indexv4");
  	cl_git_pass(git_repository_index(&index, g_repo));
  
  	/* write 676 paths of 250 bytes length */
  	for (i = 'a'; i <= 'z'; i++) {
  		for (j = 'a'; j < 'z'; j++) {
  			path[ARRAY_SIZE(path) - 3] = i;
  			path[ARRAY_SIZE(path) - 2] = j;
  			path[ARRAY_SIZE(path) - 1] = '\0';
  			cl_git_pass(git_index_add_frombuffer(index, &entry, buf, sizeof(buf)));
  		}
  	}
  
  	cl_git_pass(git_index_write(index));
  	cl_git_pass(p_stat(git_index_path(index), &st));
  
  	/*
  	 * Without path compression, the written paths would at
  	 * least take
  	 *
  	 *    (entries * pathlen) = len
  	 *    (676 * 250) = 169000
  	 *
  	 *  bytes. As index v4 uses suffix-compression and our
  	 *  written paths only differ in the last two entries,
  	 *  this number will be much smaller, e.g.
  	 *
  	 *    (1 * pathlen) + (675 * 2) = len
  	 *    676 + 1350 = 2026
  	 *
  	 *    bytes.
  	 *
  	 *    Note that the above calculations do not include
  	 *    additional metadata of the index, e.g. OIDs or
  	 *    index extensions. Including those we get an index
  	 *    of approx. 200kB without compression and 40kB with
  	 *    compression. As this is a lot smaller than without
  	 *    compression, we can verify that path compression is
  	 *    used.
  	 */
  	cl_assert_(st.st_size < 75000, "path compression not enabled");
  
  	git_index_free(index);
  }
  

Download