Merge branch 'development' into blame

Conflicts:
	include/git2.h

19 files changed, 518 insertions, 260 deletions

diff --git a/tests-clar/clar_libgit2.c b/tests-clar/clar_libgit2.c
index 555af38db..6063bf91c 100644
--- a/tests-clar/clar_libgit2.c
+++ b/tests-clar/clar_libgit2.c
@@ -440,7 +440,7 @@ void clar__assert_equal_file(
 	int ignore_cr,
 	const char *path,
 	const char *file,
-	size_t line)
+	int line)
 {
 	char buf[4000];
 	ssize_t bytes, total_bytes = 0;
diff --git a/tests-clar/clar_libgit2.h b/tests-clar/clar_libgit2.h
index 9d4d63e6c..b9ef5627e 100644
--- a/tests-clar/clar_libgit2.h
+++ b/tests-clar/clar_libgit2.h
@@ -44,7 +44,7 @@ GIT_INLINE(void) clar__assert_in_range(
 }
 
 #define cl_assert_equal_sz(sz1,sz2) do { \
-	size_t __sz1 = (sz1), __sz2 = (sz2); \
+	size_t __sz1 = (size_t)(sz1), __sz2 = (size_t)(sz2); \
 	clar__assert_equal(__FILE__,__LINE__,#sz1 " != " #sz2, 1, "%"PRIuZ, __sz1, __sz2); \
 } while (0)
 
@@ -52,10 +52,10 @@ GIT_INLINE(void) clar__assert_in_range(
 	clar__assert_in_range((L),(V),(H),__FILE__,__LINE__,"Range check: " #V " in [" #L "," #H "]", 1)
 
 #define cl_assert_equal_file(DATA,SIZE,PATH) \
-	clar__assert_equal_file(DATA,SIZE,0,PATH,__FILE__,__LINE__)
+	clar__assert_equal_file(DATA,SIZE,0,PATH,__FILE__,(int)__LINE__)
 
 #define cl_assert_equal_file_ignore_cr(DATA,SIZE,PATH) \
-	clar__assert_equal_file(DATA,SIZE,1,PATH,__FILE__,__LINE__)
+	clar__assert_equal_file(DATA,SIZE,1,PATH,__FILE__,(int)__LINE__)
 
 void clar__assert_equal_file(
 	const char *expected_data,
@@ -63,7 +63,7 @@ void clar__assert_equal_file(
 	int ignore_cr,
 	const char *path,
 	const char *file,
-	size_t line);
+	int line);
 
 /*
  * Some utility macros for building long strings
diff --git a/tests-clar/clone/empty.c b/tests-clar/clone/empty.c
index d9dc24fde..6d19244cc 100644
--- a/tests-clar/clone/empty.c
+++ b/tests-clar/clone/empty.c
@@ -10,12 +10,14 @@ static git_repository *g_repo_cloned;
 void test_clone_empty__initialize(void)
 {
 	git_repository *sandbox = cl_git_sandbox_init("empty_bare.git");
+	git_remote_callbacks dummy_callbacks = GIT_REMOTE_CALLBACKS_INIT;
 	cl_git_remove_placeholders(git_repository_path(sandbox), "dummy-marker.txt");
 
 	g_repo = NULL;
 
 	memset(&g_options, 0, sizeof(git_clone_options));
 	g_options.version = GIT_CLONE_OPTIONS_VERSION;
+	g_options.remote_callbacks = dummy_callbacks;
 }
 
 void test_clone_empty__cleanup(void)
diff --git a/tests-clar/clone/nonetwork.c b/tests-clar/clone/nonetwork.c
index 5b9faa645..4bcb5be1e 100644
--- a/tests-clar/clone/nonetwork.c
+++ b/tests-clar/clone/nonetwork.c
@@ -15,6 +15,7 @@ static git_remote* g_remote;
 void test_clone_nonetwork__initialize(void)
 {
 	git_checkout_opts dummy_opts = GIT_CHECKOUT_OPTS_INIT;
+	git_remote_callbacks dummy_callbacks = GIT_REMOTE_CALLBACKS_INIT;
 
 	g_repo = NULL;
 
@@ -22,6 +23,7 @@ void test_clone_nonetwork__initialize(void)
 	g_options.version = GIT_CLONE_OPTIONS_VERSION;
 	g_options.checkout_opts = dummy_opts;
 	g_options.checkout_opts.checkout_strategy = GIT_CHECKOUT_SAFE;
+	g_options.remote_callbacks = dummy_callbacks;
 }
 
 void test_clone_nonetwork__cleanup(void)
@@ -124,84 +126,17 @@ void test_clone_nonetwork__fail_with_already_existing_but_non_empty_directory(vo
 
 void test_clone_nonetwork__custom_origin_name(void)
 {
-	g_options.remote_name = "my_origin";
-	cl_git_pass(git_clone(&g_repo, cl_git_fixture_url("testrepo.git"), "./foo", &g_options));
+       g_options.remote_name = "my_origin";
+       cl_git_pass(git_clone(&g_repo, cl_git_fixture_url("testrepo.git"), "./foo", &g_options));
 
-	cl_git_pass(git_remote_load(&g_remote, g_repo, "my_origin"));
+       cl_git_pass(git_remote_load(&g_remote, g_repo, "my_origin"));
 }
 
-void test_clone_nonetwork__custom_push_url(void)
+void test_clone_nonetwork__defaults(void)
 {
-	const char *url = "http://example.com";
-
-	g_options.pushurl = url;
-	cl_git_pass(git_clone(&g_repo, cl_git_fixture_url("testrepo.git"), "./foo", &g_options));
-
-	cl_git_pass(git_remote_load(&g_remote, g_repo, "origin"));
-	cl_assert_equal_s(url, git_remote_pushurl(g_remote));
-}
-
-void test_clone_nonetwork__custom_fetch_spec(void)
-{
-	const git_refspec *actual_fs;
-	const char *spec = "+refs/heads/master:refs/heads/foo";
-
-	g_options.fetch_spec = spec;
-	cl_git_pass(git_clone(&g_repo, cl_git_fixture_url("testrepo.git"), "./foo", &g_options));
-
-	cl_git_pass(git_remote_load(&g_remote, g_repo, "origin"));
-	actual_fs = git_remote_get_refspec(g_remote, 0);
-	cl_assert_equal_s("refs/heads/master", git_refspec_src(actual_fs));
-	cl_assert_equal_s("refs/heads/foo", git_refspec_dst(actual_fs));
-
-	cl_git_pass(git_reference_lookup(&g_ref, g_repo, "refs/heads/foo"));
-}
-
-void test_clone_nonetwork__custom_push_spec(void)
-{
-	const git_refspec *actual_fs;
-	const char *spec = "+refs/heads/master:refs/heads/foo";
-
-	g_options.push_spec = spec;
-	cl_git_pass(git_clone(&g_repo, cl_git_fixture_url("testrepo.git"), "./foo", &g_options));
-
+	cl_git_pass(git_clone(&g_repo, cl_git_fixture_url("testrepo.git"), "./foo", NULL));
+	cl_assert(g_repo);
 	cl_git_pass(git_remote_load(&g_remote, g_repo, "origin"));
-	actual_fs = git_remote_get_refspec(g_remote, git_remote_refspec_count(g_remote) - 1);
-	cl_assert_equal_s("refs/heads/master", git_refspec_src(actual_fs));
-	cl_assert_equal_s("refs/heads/foo", git_refspec_dst(actual_fs));
-}
-
-void test_clone_nonetwork__custom_autotag(void)
-{
-	git_remote *origin;
-	git_strarray tags = {0};
-
-	g_options.remote_autotag = GIT_REMOTE_DOWNLOAD_TAGS_NONE;
-	cl_git_pass(git_clone(&g_repo, cl_git_fixture_url("testrepo.git"), "./foo", &g_options));
-
-	cl_git_pass(git_tag_list(&tags, g_repo));
-	cl_assert_equal_sz(0, tags.count);
-
-	cl_git_pass(git_remote_load(&origin, g_repo, "origin"));
-	cl_assert_equal_i(GIT_REMOTE_DOWNLOAD_TAGS_NONE, origin->download_tags);
-
-	git_strarray_free(&tags);
-	git_remote_free(origin);
-}
-
-void test_clone_nonetwork__custom_autotag_tags_all(void)
-{
-	git_strarray tags = {0};
-	git_remote *origin;
-
-	g_options.remote_autotag = GIT_REMOTE_DOWNLOAD_TAGS_ALL;
-	cl_git_pass(git_clone(&g_repo, cl_git_fixture_url("testrepo.git"), "./foo", &g_options));
-
-	cl_git_pass(git_remote_load(&origin, g_repo, "origin"));
-	cl_assert_equal_i(GIT_REMOTE_DOWNLOAD_TAGS_ALL, origin->download_tags);
-
-	git_strarray_free(&tags);
-	git_remote_free(origin);
 }
 
 void test_clone_nonetwork__cope_with_already_existing_directory(void)
diff --git a/tests-clar/commit/parse.c b/tests-clar/commit/parse.c
index 415860a6e..41e162440 100644
--- a/tests-clar/commit/parse.c
+++ b/tests-clar/commit/parse.c
@@ -7,77 +7,77 @@
 static git_repository *g_repo;
 void test_commit_parse__initialize(void)
 {
-   g_repo = cl_git_sandbox_init("testrepo");
+	g_repo = cl_git_sandbox_init("testrepo");
 }
 void test_commit_parse__cleanup(void)
 {
-   cl_git_sandbox_cleanup();
+	cl_git_sandbox_cleanup();
 }
 
 
 // Header parsing
 typedef struct {
-   const char *line;
-   const char *header;
+	const char *line;
+	const char *header;
 } parse_test_case;
 
 static parse_test_case passing_header_cases[] = {
-   { "parent 05452d6349abcd67aa396dfb28660d765d8b2a36\n", "parent " },
-   { "tree 05452d6349abcd67aa396dfb28660d765d8b2a36\n", "tree " },
-   { "random_heading 05452d6349abcd67aa396dfb28660d765d8b2a36\n", "random_heading " },
-   { "stuck_heading05452d6349abcd67aa396dfb28660d765d8b2a36\n", "stuck_heading" },
-   { "tree 5F4BEFFC0759261D015AA63A3A85613FF2F235DE\n", "tree " },
-   { "tree 1A669B8AB81B5EB7D9DB69562D34952A38A9B504\n", "tree " },
-   { "tree 5B20DCC6110FCC75D31C6CEDEBD7F43ECA65B503\n", "tree " },
-   { "tree 173E7BF00EA5C33447E99E6C1255954A13026BE4\n", "tree " },
-   { NULL, NULL }
+	{ "parent 05452d6349abcd67aa396dfb28660d765d8b2a36\n", "parent " },
+	{ "tree 05452d6349abcd67aa396dfb28660d765d8b2a36\n", "tree " },
+	{ "random_heading 05452d6349abcd67aa396dfb28660d765d8b2a36\n", "random_heading " },
+	{ "stuck_heading05452d6349abcd67aa396dfb28660d765d8b2a36\n", "stuck_heading" },
+	{ "tree 5F4BEFFC0759261D015AA63A3A85613FF2F235DE\n", "tree " },
+	{ "tree 1A669B8AB81B5EB7D9DB69562D34952A38A9B504\n", "tree " },
+	{ "tree 5B20DCC6110FCC75D31C6CEDEBD7F43ECA65B503\n", "tree " },
+	{ "tree 173E7BF00EA5C33447E99E6C1255954A13026BE4\n", "tree " },
+	{ NULL, NULL }
 };
 
 static parse_test_case failing_header_cases[] = {
-   { "parent 05452d6349abcd67aa396dfb28660d765d8b2a36", "parent " },
-   { "05452d6349abcd67aa396dfb28660d765d8b2a36\n", "tree " },
-   { "parent05452d6349abcd67aa396dfb28660d765d8b2a6a\n", "parent " },
-   { "parent 05452d6349abcd67aa396dfb280d765d8b2a6\n", "parent " },
-   { "tree  05452d6349abcd67aa396dfb28660d765d8b2a36\n", "tree " },
-   { "parent 0545xd6349abcd67aa396dfb28660d765d8b2a36\n", "parent " },
-   { "parent 0545xd6349abcd67aa396dfb28660d765d8b2a36FF\n", "parent " },
-   { "", "tree " },
-   { "", "" },
-   { NULL, NULL }
+	{ "parent 05452d6349abcd67aa396dfb28660d765d8b2a36", "parent " },
+	{ "05452d6349abcd67aa396dfb28660d765d8b2a36\n", "tree " },
+	{ "parent05452d6349abcd67aa396dfb28660d765d8b2a6a\n", "parent " },
+	{ "parent 05452d6349abcd67aa396dfb280d765d8b2a6\n", "parent " },
+	{ "tree  05452d6349abcd67aa396dfb28660d765d8b2a36\n", "tree " },
+	{ "parent 0545xd6349abcd67aa396dfb28660d765d8b2a36\n", "parent " },
+	{ "parent 0545xd6349abcd67aa396dfb28660d765d8b2a36FF\n", "parent " },
+	{ "", "tree " },
+	{ "", "" },
+	{ NULL, NULL }
 };
 
 void test_commit_parse__header(void)
 {
-   git_oid oid;
+	git_oid oid;
 
-   parse_test_case *testcase;
-   for (testcase = passing_header_cases; testcase->line != NULL; testcase++)
-   {
-      const char *line = testcase->line;
-      const char *line_end = line + strlen(line);
+	parse_test_case *testcase;
+	for (testcase = passing_header_cases; testcase->line != NULL; testcase++)
+	{
+		const char *line = testcase->line;
+		const char *line_end = line + strlen(line);
 
-      cl_git_pass(git_oid__parse(&oid, &line, line_end, testcase->header));
-      cl_assert(line == line_end);
-   }
+		cl_git_pass(git_oid__parse(&oid, &line, line_end, testcase->header));
+		cl_assert(line == line_end);
+	}
 
-   for (testcase = failing_header_cases; testcase->line != NULL; testcase++)
-   {
-      const char *line = testcase->line;
-      const char *line_end = line + strlen(line);
+	for (testcase = failing_header_cases; testcase->line != NULL; testcase++)
+	{
+		const char *line = testcase->line;
+		const char *line_end = line + strlen(line);
 
-      cl_git_fail(git_oid__parse(&oid, &line, line_end, testcase->header));
-   }
+		cl_git_fail(git_oid__parse(&oid, &line, line_end, testcase->header));
+	}
 }
 
 
 // Signature parsing
 typedef struct {
-   const char *string;
-   const char *header;
-   const char *name;
-   const char *email;
-   git_time_t time;
-   int offset;
+	const char *string;
+	const char *header;
+	const char *name;
+	const char *email;
+	git_time_t time;
+	int offset;
 } passing_signature_test_case;
 
 passing_signature_test_case passing_signature_cases[] = {
@@ -122,12 +122,12 @@ passing_signature_test_case passing_signature_cases[] = {
 	{"author Vicent Marti <tanoku@gmail.com> 4294967296 \n", "author ", "Vicent Marti", "tanoku@gmail.com", 4294967296, 0},
 	{"author Vicent Marti <tanoku@gmail.com> 8589934592 \n", "author ", "Vicent Marti", "tanoku@gmail.com", 8589934592, 0},
 
-   {NULL,NULL,NULL,NULL,0,0}
+	{NULL,NULL,NULL,NULL,0,0}
 };
 
 typedef struct {
-   const char *string;
-   const char *header;
+	const char *string;
+	const char *header;
 } failing_signature_test_case;
 
 failing_signature_test_case failing_signature_cases[] = {
@@ -143,31 +143,31 @@ failing_signature_test_case failing_signature_cases[] = {
 
 void test_commit_parse__signature(void)
 {
-   passing_signature_test_case *passcase;
-   failing_signature_test_case *failcase;
-
-   for (passcase = passing_signature_cases; passcase->string != NULL; passcase++)
-   {
-      const char *str = passcase->string;
-      size_t len = strlen(passcase->string);
-      struct git_signature person = {0};
-
-      cl_git_pass(git_signature__parse(&person, &str, str + len, passcase->header, '\n'));
-      cl_assert_equal_s(passcase->name, person.name);
-      cl_assert_equal_s(passcase->email, person.email);
-      cl_assert_equal_i((int)passcase->time, (int)person.when.time);
-      cl_assert_equal_i(passcase->offset, person.when.offset);
-      git__free(person.name); git__free(person.email);
-   }
-
-   for (failcase = failing_signature_cases; failcase->string != NULL; failcase++)
-   {
-      const char *str = failcase->string;
-      size_t len = strlen(failcase->string);
-      git_signature person = {0};
-      cl_git_fail(git_signature__parse(&person, &str, str + len, failcase->header, '\n'));
-      git__free(person.name); git__free(person.email);
-   }
+	passing_signature_test_case *passcase;
+	failing_signature_test_case *failcase;
+
+	for (passcase = passing_signature_cases; passcase->string != NULL; passcase++)
+	{
+		const char *str = passcase->string;
+		size_t len = strlen(passcase->string);
+		struct git_signature person = {0};
+
+		cl_git_pass(git_signature__parse(&person, &str, str + len, passcase->header, '\n'));
+		cl_assert_equal_s(passcase->name, person.name);
+		cl_assert_equal_s(passcase->email, person.email);
+		cl_assert_equal_i((int)passcase->time, (int)person.when.time);
+		cl_assert_equal_i(passcase->offset, person.when.offset);
+		git__free(person.name); git__free(person.email);
+	}
+
+	for (failcase = failing_signature_cases; failcase->string != NULL; failcase++)
+	{
+		const char *str = failcase->string;
+		size_t len = strlen(failcase->string);
+		git_signature person = {0};
+		cl_git_fail(git_signature__parse(&person, &str, str + len, failcase->header, '\n'));
+		git__free(person.name); git__free(person.email);
+	}
 }
 
 
@@ -312,17 +312,17 @@ void test_commit_parse__entire_commit(void)
 
 // query the details on a parsed commit
 void test_commit_parse__details0(void) {
-   static const char *commit_ids[] = {
-      "a4a7dce85cf63874e984719f4fdd239f5145052f", /* 0 */
-      "9fd738e8f7967c078dceed8190330fc8648ee56a", /* 1 */
-      "4a202b346bb0fb0db7eff3cffeb3c70babbd2045", /* 2 */
-      "c47800c7266a2be04c571c04d5a6614691ea99bd", /* 3 */
-      "8496071c1b46c854b31185ea97743be6a8774479", /* 4 */
-      "5b5b025afb0b4c913b4c338a42934a3863bf3644", /* 5 */
-      "a65fedf39aefe402d3bb6e24df4d4f5fe4547750", /* 6 */
-   };
+	static const char *commit_ids[] = {
+		"a4a7dce85cf63874e984719f4fdd239f5145052f", /* 0 */
+		"9fd738e8f7967c078dceed8190330fc8648ee56a", /* 1 */
+		"4a202b346bb0fb0db7eff3cffeb3c70babbd2045", /* 2 */
+		"c47800c7266a2be04c571c04d5a6614691ea99bd", /* 3 */
+		"8496071c1b46c854b31185ea97743be6a8774479", /* 4 */
+		"5b5b025afb0b4c913b4c338a42934a3863bf3644", /* 5 */
+		"a65fedf39aefe402d3bb6e24df4d4f5fe4547750", /* 6 */
+	};
 	const size_t commit_count = sizeof(commit_ids) / sizeof(const char *);
-   unsigned int i;
+	unsigned int i;
 
 	for (i = 0; i < commit_count; ++i) {
 		git_oid id;
@@ -349,7 +349,6 @@ void test_commit_parse__details0(void) {
 		cl_assert_equal_s("Scott Chacon", committer->name);
 		cl_assert_equal_s("schacon@gmail.com", committer->email);
 		cl_assert(message != NULL);
-		cl_assert(strchr(message, '\n') != NULL);
 		cl_assert(commit_time > 0);
 		cl_assert(parents <= 2);
 		for (p = 0;p < parents;p++) {
@@ -382,11 +381,33 @@ committer Vicent Marti <tanoku@gmail.com> 1273848544 +0200\n\
 \n\
 This commit has a few LF at the start of the commit message";
 	const char *message =
+"This commit has a few LF at the start of the commit message";
+	const char *raw_message =
 "\n\
 \n\
 This commit has a few LF at the start of the commit message";
+	cl_git_pass(parse_commit(&commit, buffer));
+	cl_assert_equal_s(message, git_commit_message(commit));
+	cl_assert_equal_s(raw_message, git_commit_message_raw(commit));
+	git_commit__free(commit);
+}
+
+void test_commit_parse__only_lf(void)
+{
+	git_commit *commit;
+	const char *buffer =
+"tree 1810dff58d8a660512d4832e740f692884338ccd\n\
+parent e90810b8df3e80c413d903f631643c716887138d\n\
+author Vicent Marti <tanoku@gmail.com> 1273848544 +0200\n\
+committer Vicent Marti <tanoku@gmail.com> 1273848544 +0200\n\
+\n\
+\n\
+\n";
+	const char *message = "";
+	const char *raw_message = "\n\n";
 
 	cl_git_pass(parse_commit(&commit, buffer));
 	cl_assert_equal_s(message, git_commit_message(commit));
+	cl_assert_equal_s(raw_message, git_commit_message_raw(commit));
 	git_commit__free(commit);
 }
diff --git a/tests-clar/config/read.c b/tests-clar/config/read.c
index 722a15a71..abc088d59 100644
--- a/tests-clar/config/read.c
+++ b/tests-clar/config/read.c
@@ -164,6 +164,13 @@ void test_config_read__empty_files(void)
 	git_config_free(cfg);
 }
 
+void test_config_read__symbol_headers(void)
+{
+	git_config *cfg;
+	cl_git_pass(git_config_open_ondisk(&cfg, cl_fixture("config/config20")));
+	git_config_free(cfg);
+}
+
 void test_config_read__header_in_last_line(void)
 {
 	git_config *cfg;
@@ -524,6 +531,28 @@ void test_config_read__corrupt_header(void)
 	git_config_free(cfg);
 }
 
+void test_config_read__corrupt_header2(void)
+{
+	git_config *cfg;
+
+	cl_set_cleanup(&clean_test_config, NULL);
+	cl_git_mkfile("./testconfig", "[unclosed \"bracket\"\n    lib = git2\n");
+	cl_git_fail(git_config_open_ondisk(&cfg, "./testconfig"));
+
+	git_config_free(cfg);
+}
+
+void test_config_read__corrupt_header3(void)
+{
+	git_config *cfg;
+
+	cl_set_cleanup(&clean_test_config, NULL);
+	cl_git_mkfile("./testconfig", "[unclosed \"slash\\\"]\n    lib = git2\n");
+	cl_git_fail(git_config_open_ondisk(&cfg, "./testconfig"));
+
+	git_config_free(cfg);
+}
+
 void test_config_read__override_variable(void)
 {
 	git_config *cfg;
diff --git a/tests-clar/network/fetchlocal.c b/tests-clar/network/fetchlocal.c
index 09335b3df..28c7115bf 100644
--- a/tests-clar/network/fetchlocal.c
+++ b/tests-clar/network/fetchlocal.c
@@ -25,13 +25,18 @@ void test_network_fetchlocal__complete(void)
 	git_strarray refnames = {0};
 
 	const char *url = cl_git_fixture_url("testrepo.git");
+	git_remote_callbacks callbacks = GIT_REMOTE_CALLBACKS_INIT;
+
+	callbacks.transfer_progress = transfer_cb;
+	callbacks.payload = &callcount;
 
 	cl_set_cleanup(&cleanup_local_repo, "foo");
 	cl_git_pass(git_repository_init(&repo, "foo", true));
 
 	cl_git_pass(git_remote_create(&origin, repo, GIT_REMOTE_ORIGIN, url));
+	git_remote_set_callbacks(origin, &callbacks);
 	cl_git_pass(git_remote_connect(origin, GIT_DIRECTION_FETCH));
-	cl_git_pass(git_remote_download(origin, transfer_cb, &callcount));
+	cl_git_pass(git_remote_download(origin));
 	cl_git_pass(git_remote_update_tips(origin));
 
 	cl_git_pass(git_reference_list(&refnames, repo));
@@ -56,6 +61,10 @@ void test_network_fetchlocal__partial(void)
 	int callcount = 0;
 	git_strarray refnames = {0};
 	const char *url;
+	git_remote_callbacks callbacks = GIT_REMOTE_CALLBACKS_INIT;
+
+	callbacks.transfer_progress = transfer_cb;
+	callbacks.payload = &callcount;
 
 	cl_set_cleanup(&cleanup_sandbox, NULL);
 	cl_git_pass(git_reference_list(&refnames, repo));
@@ -63,8 +72,9 @@ void test_network_fetchlocal__partial(void)
 
 	url = cl_git_fixture_url("testrepo.git");
 	cl_git_pass(git_remote_create(&origin, repo, GIT_REMOTE_ORIGIN, url));
+	git_remote_set_callbacks(origin, &callbacks);
 	cl_git_pass(git_remote_connect(origin, GIT_DIRECTION_FETCH));
-	cl_git_pass(git_remote_download(origin, transfer_cb, &callcount));
+	cl_git_pass(git_remote_download(origin));
 	cl_git_pass(git_remote_update_tips(origin));
 
 	git_strarray_free(&refnames);
diff --git a/tests-clar/network/remote/local.c b/tests-clar/network/remote/local.c
index c8edd37f5..6d658a2e4 100644
--- a/tests-clar/network/remote/local.c
+++ b/tests-clar/network/remote/local.c
@@ -123,7 +123,7 @@ void test_network_remote_local__shorthand_fetch_refspec0(void)
 	cl_git_pass(git_remote_add_fetch(remote, refspec));
 	cl_git_pass(git_remote_add_fetch(remote, refspec2));
 
-	cl_git_pass(git_remote_download(remote, NULL, NULL));
+	cl_git_pass(git_remote_download(remote));
 	cl_git_pass(git_remote_update_tips(remote));
 
 	cl_git_pass(git_reference_lookup(&ref, repo, "refs/remotes/sloppy/master"));
@@ -145,7 +145,7 @@ void test_network_remote_local__shorthand_fetch_refspec1(void)
 	cl_git_pass(git_remote_add_fetch(remote, refspec));
 	cl_git_pass(git_remote_add_fetch(remote, refspec2));
 
-	cl_git_pass(git_remote_download(remote, NULL, NULL));
+	cl_git_pass(git_remote_download(remote));
 	cl_git_pass(git_remote_update_tips(remote));
 
 	cl_git_fail(git_reference_lookup(&ref, repo, "refs/remotes/master"));
@@ -160,7 +160,7 @@ void test_network_remote_local__tagopt(void)
 	connect_to_local_repository(cl_fixture("testrepo.git"));
 	git_remote_set_autotag(remote, GIT_REMOTE_DOWNLOAD_TAGS_ALL);
 
-	cl_git_pass(git_remote_download(remote, NULL, NULL));
+	cl_git_pass(git_remote_download(remote));
 	cl_git_pass(git_remote_update_tips(remote));
 
 
@@ -179,7 +179,7 @@ void test_network_remote_local__push_to_bare_remote(void)
 	/* Get some commits */
 	connect_to_local_repository(cl_fixture("testrepo.git"));
 	cl_git_pass(git_remote_add_fetch(remote, "master:master"));
-	cl_git_pass(git_remote_download(remote, NULL, NULL));
+	cl_git_pass(git_remote_download(remote));
 	cl_git_pass(git_remote_update_tips(remote));
 	git_remote_disconnect(remote);
 
@@ -215,7 +215,7 @@ void test_network_remote_local__push_to_non_bare_remote(void)
 	/* Get some commits */
 	connect_to_local_repository(cl_fixture("testrepo.git"));
 	cl_git_pass(git_remote_add_fetch(remote, "master:master"));
-	cl_git_pass(git_remote_download(remote, NULL, NULL));
+	cl_git_pass(git_remote_download(remote));
 	cl_git_pass(git_remote_update_tips(remote));
 	git_remote_disconnect(remote);
 
diff --git a/tests-clar/network/urlparse.c b/tests-clar/network/urlparse.c
index 173e57d0f..274d7e900 100644
--- a/tests-clar/network/urlparse.c
+++ b/tests-clar/network/urlparse.c
@@ -2,10 +2,12 @@
 #include "netops.h"
 
 char *host, *port, *user, *pass;
+gitno_connection_data conndata;
 
 void test_network_urlparse__initialize(void)
 {
 	host = port = user = pass = NULL;
+	memset(&conndata, 0, sizeof(conndata));
 }
 
 void test_network_urlparse__cleanup(void)
@@ -15,6 +17,8 @@ void test_network_urlparse__cleanup(void)
 	FREE_AND_NULL(port);
 	FREE_AND_NULL(user);
 	FREE_AND_NULL(pass);
+
+	gitno_connection_data_free_ptrs(&conndata);
 }
 
 void test_network_urlparse__trivial(void)
@@ -80,3 +84,80 @@ void test_network_urlparse__user_pass_port(void)
 	cl_assert_equal_s(user, "user");
 	cl_assert_equal_s(pass, "pass");
 }
+
+void test_network_urlparse__connection_data_http(void)
+{
+	cl_git_pass(gitno_connection_data_from_url(&conndata,
+				"http://example.com/foo/bar/baz", "bar/baz"));
+	cl_assert_equal_s(conndata.host, "example.com");
+	cl_assert_equal_s(conndata.port, "80");
+	cl_assert_equal_s(conndata.path, "/foo/");
+	cl_assert_equal_p(conndata.user, NULL);
+	cl_assert_equal_p(conndata.pass, NULL);
+	cl_assert_equal_i(conndata.use_ssl, false);
+}
+
+void test_network_urlparse__connection_data_ssl(void)
+{
+	cl_git_pass(gitno_connection_data_from_url(&conndata,
+				"https://example.com/foo/bar/baz", "bar/baz"));
+	cl_assert_equal_s(conndata.host, "example.com");
+	cl_assert_equal_s(conndata.port, "443");
+	cl_assert_equal_s(conndata.path, "/foo/");
+	cl_assert_equal_p(conndata.user, NULL);
+	cl_assert_equal_p(conndata.pass, NULL);
+	cl_assert_equal_i(conndata.use_ssl, true);
+}
+
+void test_network_urlparse__connection_data_cross_host_redirect(void)
+{
+	conndata.host = git__strdup("bar.com");
+	cl_git_fail_with(gitno_connection_data_from_url(&conndata,
+				"https://foo.com/bar/baz", NULL),
+			-1);
+}
+
+void test_network_urlparse__connection_data_http_downgrade(void)
+{
+	conndata.use_ssl = true;
+	cl_git_fail_with(gitno_connection_data_from_url(&conndata,
+				"http://foo.com/bar/baz", NULL),
+			-1);
+}
+
+void test_network_urlparse__connection_data_relative_redirect(void)
+{
+	cl_git_pass(gitno_connection_data_from_url(&conndata,
+				"http://foo.com/bar/baz/biff", NULL));
+	cl_git_pass(gitno_connection_data_from_url(&conndata,
+				"/zap/baz/biff?bam", NULL));
+	cl_assert_equal_s(conndata.host, "foo.com");
+	cl_assert_equal_s(conndata.port, "80");
+	cl_assert_equal_s(conndata.path, "/zap/baz/biff?bam");
+	cl_assert_equal_p(conndata.user, NULL);
+	cl_assert_equal_p(conndata.pass, NULL);
+	cl_assert_equal_i(conndata.use_ssl, false);
+}
+
+void test_network_urlparse__connection_data_relative_redirect_ssl(void)
+{
+	cl_git_pass(gitno_connection_data_from_url(&conndata,
+				"https://foo.com/bar/baz/biff", NULL));
+	cl_git_pass(gitno_connection_data_from_url(&conndata,
+				"/zap/baz/biff?bam", NULL));
+	cl_assert_equal_s(conndata.host, "foo.com");
+	cl_assert_equal_s(conndata.port, "443");
+	cl_assert_equal_s(conndata.path, "/zap/baz/biff?bam");
+	cl_assert_equal_p(conndata.user, NULL);
+	cl_assert_equal_p(conndata.pass, NULL);
+	cl_assert_equal_i(conndata.use_ssl, true);
+}
+
+/* Run this under valgrind */
+void test_network_urlparse__connection_data_cleanup(void)
+{
+	cl_git_pass(gitno_connection_data_from_url(&conndata,
+				"http://foo.com/bar/baz/biff", "baz/biff"));
+	cl_git_pass(gitno_connection_data_from_url(&conndata,
+				"https://foo.com/bar/baz/biff", "baz/biff"));
+}
diff --git a/tests-clar/online/clone.c b/tests-clar/online/clone.c
index dc5aa4150..4a6ade52d 100644
--- a/tests-clar/online/clone.c
+++ b/tests-clar/online/clone.c
@@ -18,6 +18,7 @@ static git_clone_options g_options;
 void test_online_clone__initialize(void)
 {
 	git_checkout_opts dummy_opts = GIT_CHECKOUT_OPTS_INIT;
+	git_remote_callbacks dummy_callbacks = GIT_REMOTE_CALLBACKS_INIT;
 
 	g_repo = NULL;
 
@@ -25,6 +26,7 @@ void test_online_clone__initialize(void)
 	g_options.version = GIT_CLONE_OPTIONS_VERSION;
 	g_options.checkout_opts = dummy_opts;
 	g_options.checkout_opts.checkout_strategy = GIT_CHECKOUT_SAFE;
+	g_options.remote_callbacks = dummy_callbacks;
 }
 
 void test_online_clone__cleanup(void)
@@ -103,8 +105,8 @@ void test_online_clone__can_checkout_a_cloned_repo(void)
 	g_options.checkout_opts.checkout_strategy = GIT_CHECKOUT_SAFE_CREATE;
 	g_options.checkout_opts.progress_cb = &checkout_progress;
 	g_options.checkout_opts.progress_payload = &checkout_progress_cb_was_called;
-	g_options.fetch_progress_cb = &fetch_progress;
-	g_options.fetch_progress_payload = &fetch_progress_cb_was_called;
+	g_options.remote_callbacks.transfer_progress = &fetch_progress;
+	g_options.remote_callbacks.payload = &fetch_progress_cb_was_called;
 
 	cl_git_pass(git_clone(&g_repo, LIVE_REPO_URL, "./foo", &g_options));
 
@@ -122,6 +124,45 @@ void test_online_clone__can_checkout_a_cloned_repo(void)
 	git_buf_free(&path);
 }
 
+void test_online_clone__clone_into(void)
+{
+	git_buf path = GIT_BUF_INIT;
+	git_remote *remote;
+	git_reference *head;
+	git_checkout_opts checkout_opts = GIT_CHECKOUT_OPTS_INIT;
+	git_remote_callbacks callbacks = GIT_REMOTE_CALLBACKS_INIT;
+
+	bool checkout_progress_cb_was_called = false,
+		  fetch_progress_cb_was_called = false;
+
+	checkout_opts.checkout_strategy = GIT_CHECKOUT_SAFE_CREATE;
+	checkout_opts.progress_cb = &checkout_progress;
+	checkout_opts.progress_payload = &checkout_progress_cb_was_called;
+
+	cl_git_pass(git_repository_init(&g_repo, "./foo", false));
+	cl_git_pass(git_remote_create(&remote, g_repo, "origin", LIVE_REPO_URL));
+
+	callbacks.transfer_progress = &fetch_progress;
+	callbacks.payload = &fetch_progress_cb_was_called;
+	git_remote_set_callbacks(remote, &callbacks);
+
+	cl_git_pass(git_clone_into(g_repo, remote, &checkout_opts, NULL));
+
+	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)));
+
+	cl_git_pass(git_reference_lookup(&head, g_repo, "HEAD"));
+	cl_assert_equal_i(GIT_REF_SYMBOLIC, git_reference_type(head));
+	cl_assert_equal_s("refs/heads/master", git_reference_symbolic_target(head));
+
+	cl_assert_equal_i(true, checkout_progress_cb_was_called);
+	cl_assert_equal_i(true, fetch_progress_cb_was_called);
+
+	git_remote_free(remote);
+	git_reference_free(head);
+	git_buf_free(&path);
+}
+
 static int update_tips(const char *refname, const git_oid *a, const git_oid *b, void *payload)
 {
 	int *callcount = (int*)payload;
@@ -132,12 +173,10 @@ static int update_tips(const char *refname, const git_oid *a, const git_oid *b,
 
 void test_online_clone__custom_remote_callbacks(void)
 {
-	git_remote_callbacks remote_callbacks = GIT_REMOTE_CALLBACKS_INIT;
 	int callcount = 0;
 
-	g_options.remote_callbacks = &remote_callbacks;
-	remote_callbacks.update_tips = update_tips;
-	remote_callbacks.payload = &callcount;
+	g_options.remote_callbacks.update_tips = update_tips;
+	g_options.remote_callbacks.payload = &callcount;
 
 	cl_git_pass(git_clone(&g_repo, LIVE_REPO_URL, "./foo", &g_options));
 	cl_assert(callcount > 0);
@@ -154,8 +193,8 @@ void test_online_clone__credentials(void)
 
 	if (!remote_url) return;
 
-	g_options.cred_acquire_cb = git_cred_userpass;
-	g_options.cred_acquire_payload = &user_pass;
+	g_options.remote_callbacks.credentials = git_cred_userpass;
+	g_options.remote_callbacks.payload = &user_pass;
 
 	cl_git_pass(git_clone(&g_repo, remote_url, "./foo", &g_options));
 	git_repository_free(g_repo); g_repo = NULL;
@@ -168,8 +207,8 @@ void test_online_clone__bitbucket_style(void)
 		"libgit2", "libgit2"
 	};
 
-	g_options.cred_acquire_cb = git_cred_userpass;
-	g_options.cred_acquire_payload = &user_pass;
+	g_options.remote_callbacks.credentials = git_cred_userpass;
+	g_options.remote_callbacks.payload = &user_pass;
 
 	cl_git_pass(git_clone(&g_repo, BB_REPO_URL, "./foo", &g_options));
 	git_repository_free(g_repo); g_repo = NULL;
@@ -199,6 +238,13 @@ static int cancel_at_half(const git_transfer_progress *stats, void *payload)
 
 void test_online_clone__can_cancel(void)
 {
-	g_options.fetch_progress_cb = cancel_at_half;
+	g_options.remote_callbacks.transfer_progress = cancel_at_half;
+
 	cl_git_fail_with(git_clone(&g_repo, LIVE_REPO_URL, "./foo", &g_options), GIT_EUSER);
 }
+
+
+
+
+
+
diff --git a/tests-clar/online/fetch.c b/tests-clar/online/fetch.c
index f76c6cff9..df1b2e288 100644
--- a/tests-clar/online/fetch.c
+++ b/tests-clar/online/fetch.c
@@ -38,14 +38,16 @@ static void do_fetch(const char *url, git_remote_autotag_option_t flag, int n)
 	git_remote_callbacks callbacks = GIT_REMOTE_CALLBACKS_INIT;
 	size_t bytes_received = 0;
 
+	callbacks.transfer_progress = progress;
 	callbacks.update_tips = update_tips;
+	callbacks.payload = &bytes_received;
 	counter = 0;
 
 	cl_git_pass(git_remote_create(&remote, _repo, "test", url));
 	git_remote_set_callbacks(remote, &callbacks);
 	git_remote_set_autotag(remote, flag);
 	cl_git_pass(git_remote_connect(remote, GIT_DIRECTION_FETCH));
-	cl_git_pass(git_remote_download(remote, progress, &bytes_received));
+	cl_git_pass(git_remote_download(remote));
 	cl_git_pass(git_remote_update_tips(remote));
 	git_remote_disconnect(remote);
 	cl_assert_equal_i(counter, n);
@@ -93,6 +95,7 @@ void test_online_fetch__doesnt_retrieve_a_pack_when_the_repository_is_up_to_date
 	git_repository *_repository;
 	bool invoked = false;
 	git_remote *remote;
+	git_remote_callbacks callbacks = GIT_REMOTE_CALLBACKS_INIT;
 	git_clone_options opts = GIT_CLONE_OPTIONS_INIT;
 	opts.bare = true;
 
@@ -107,7 +110,10 @@ void test_online_fetch__doesnt_retrieve_a_pack_when_the_repository_is_up_to_date
 
 	cl_assert_equal_i(false, invoked);
 
-	cl_git_pass(git_remote_download(remote, &transferProgressCallback, &invoked));
+	callbacks.transfer_progress = &transferProgressCallback;
+	callbacks.payload = &invoked;
+	git_remote_set_callbacks(remote, &callbacks);
+	cl_git_pass(git_remote_download(remote));
 
 	cl_assert_equal_i(false, invoked);
 
@@ -131,11 +137,17 @@ void test_online_fetch__can_cancel(void)
 {
 	git_remote *remote;
 	size_t bytes_received = 0;
+	git_remote_callbacks callbacks = GIT_REMOTE_CALLBACKS_INIT;
 
 	cl_git_pass(git_remote_create(&remote, _repo, "test",
 				"http://github.com/libgit2/TestGitRepository.git"));
+
+	callbacks.transfer_progress = cancel_at_half;
+	callbacks.payload = &bytes_received;
+	git_remote_set_callbacks(remote, &callbacks);
+
 	cl_git_pass(git_remote_connect(remote, GIT_DIRECTION_FETCH));
-	cl_git_fail_with(git_remote_download(remote, cancel_at_half, &bytes_received), GIT_EUSER);
+	cl_git_fail_with(git_remote_download(remote), GIT_EUSER);
 	git_remote_disconnect(remote);
 	git_remote_free(remote);
 }
diff --git a/tests-clar/online/fetchhead.c b/tests-clar/online/fetchhead.c
index 58717eef8..57b183f88 100644
--- a/tests-clar/online/fetchhead.c
+++ b/tests-clar/online/fetchhead.c
@@ -12,10 +12,12 @@ static git_clone_options g_options;
 
 void test_online_fetchhead__initialize(void)
 {
+	git_remote_callbacks dummy_callbacks = GIT_REMOTE_CALLBACKS_INIT;
 	g_repo = NULL;
 
 	memset(&g_options, 0, sizeof(git_clone_options));
 	g_options.version = GIT_CLONE_OPTIONS_VERSION;
+	g_options.remote_callbacks = dummy_callbacks;
 }
 
 void test_online_fetchhead__cleanup(void)
@@ -48,7 +50,7 @@ static void fetchhead_test_fetch(const char *fetchspec, const char *expected_fet
 	}
 
 	cl_git_pass(git_remote_connect(remote, GIT_DIRECTION_FETCH));
-	cl_git_pass(git_remote_download(remote, NULL, NULL));
+	cl_git_pass(git_remote_download(remote));
 	cl_git_pass(git_remote_update_tips(remote));
 	git_remote_disconnect(remote);
 	git_remote_free(remote);
diff --git a/tests-clar/online/push.c b/tests-clar/online/push.c
index 4c0a28c1c..05cef56e7 100644
--- a/tests-clar/online/push.c
+++ b/tests-clar/online/push.c
@@ -17,6 +17,8 @@ static char *_remote_url;
 static char *_remote_user;
 static char *_remote_pass;
 
+static int cred_acquire_cb(git_cred **,	const char *, const char *, unsigned int, void *);
+
 static git_remote *_remote;
 static bool _cred_acquire_called;
 static record_callbacks_data _record_cbs_data = {{ 0 }};
@@ -294,7 +296,6 @@ void test_online_push__initialize(void)
 	if (_remote_url) {
 		cl_git_pass(git_remote_create(&_remote, _repo, "test", _remote_url));
 
-		git_remote_set_cred_acquire_cb(_remote, cred_acquire_cb, &_cred_acquire_called);
 		record_callbacks_data_clear(&_record_cbs_data);
 		git_remote_set_callbacks(_remote, &_record_cbs);
 
@@ -326,7 +327,7 @@ void test_online_push__initialize(void)
 
 		/* Now that we've deleted everything, fetch from the remote */
 		cl_git_pass(git_remote_connect(_remote, GIT_DIRECTION_FETCH));
-		cl_git_pass(git_remote_download(_remote, NULL, NULL));
+		cl_git_pass(git_remote_download(_remote));
 		cl_git_pass(git_remote_update_tips(_remote));
 		git_remote_disconnect(_remote);
 	} else
@@ -348,6 +349,18 @@ void test_online_push__cleanup(void)
 	cl_git_sandbox_cleanup();
 }
 
+static void push_pack_progress_cb(int stage, unsigned int current, unsigned int total, void* payload)
+{
+	int *was_called = (int *) payload;
+	*was_called = 1;
+}
+
+static void push_transfer_progress_cb(unsigned int current, unsigned int total, size_t bytes, void* payload)
+{
+	int *was_called = (int *) payload;
+	*was_called = 1;
+}
+
 /**
  * Calls push and relists refs on remote to verify success.
  *
@@ -356,15 +369,17 @@ void test_online_push__cleanup(void)
  * @param expected_refs expected remote refs after push
  * @param expected_refs_len length of expected_refs
  * @param expected_ret expected return value from git_push_finish()
+ * @param check_progress_cb Check that the push progress callbacks are called
  */
 static void do_push(const char *refspecs[], size_t refspecs_len,
 	push_status expected_statuses[], size_t expected_statuses_len,
-	expected_ref expected_refs[], size_t expected_refs_len, int expected_ret)
+	expected_ref expected_refs[], size_t expected_refs_len, int expected_ret, int check_progress_cb)
 {
 	git_push *push;
 	git_push_options opts = GIT_PUSH_OPTIONS_INIT;
 	size_t i;
 	int ret;
+	int pack_progress_called = 0, transfer_progress_called = 0;
 
 	if (_remote) {
 		/* Auto-detect the number of threads to use */
@@ -375,6 +390,9 @@ static void do_push(const char *refspecs[], size_t refspecs_len,
 		cl_git_pass(git_push_new(&push, _remote));
 		cl_git_pass(git_push_set_options(push, &opts));
 
+		if (check_progress_cb)
+			cl_git_pass(git_push_set_callbacks(push, push_pack_progress_cb, &pack_progress_called, push_transfer_progress_cb, &transfer_progress_called));
+
 		for (i = 0; i < refspecs_len; i++)
 			cl_git_pass(git_push_add_refspec(push, refspecs[i]));
 
@@ -387,6 +405,11 @@ static void do_push(const char *refspecs[], size_t refspecs_len,
 			cl_assert_equal_i(1, git_push_unpack_ok(push));
 		}
 
+		if (check_progress_cb) {
+			cl_assert_equal_i(1, pack_progress_called);
+			cl_assert_equal_i(1, transfer_progress_called);
+		}
+
 		do_verify_push_status(push, expected_statuses, expected_statuses_len);
 
 		cl_assert_equal_i(expected_ret, ret);
@@ -405,7 +428,7 @@ static void do_push(const char *refspecs[], size_t refspecs_len,
 /* Call push_finish() without ever calling git_push_add_refspec() */
 void test_online_push__noop(void)
 {
-	do_push(NULL, 0, NULL, 0, NULL, 0, 0);
+	do_push(NULL, 0, NULL, 0, NULL, 0, 0, 0);
 }
 
 void test_online_push__b1(void)
@@ -415,7 +438,7 @@ void test_online_push__b1(void)
 	expected_ref exp_refs[] = { { "refs/heads/b1", &_oid_b1 } };
 	do_push(specs, ARRAY_SIZE(specs),
 		exp_stats, ARRAY_SIZE(exp_stats),
-		exp_refs, ARRAY_SIZE(exp_refs), 0);
+		exp_refs, ARRAY_SIZE(exp_refs), 0, 1);
 }
 
 void test_online_push__b2(void)
@@ -425,7 +448,7 @@ void test_online_push__b2(void)
 	expected_ref exp_refs[] = { { "refs/heads/b2", &_oid_b2 } };
 	do_push(specs, ARRAY_SIZE(specs),
 		exp_stats, ARRAY_SIZE(exp_stats),
-		exp_refs, ARRAY_SIZE(exp_refs), 0);
+		exp_refs, ARRAY_SIZE(exp_refs), 0, 1);
 }
 
 void test_online_push__b3(void)
@@ -435,7 +458,7 @@ void test_online_push__b3(void)
 	expected_ref exp_refs[] = { { "refs/heads/b3", &_oid_b3 } };
 	do_push(specs, ARRAY_SIZE(specs),
 		exp_stats, ARRAY_SIZE(exp_stats),
-		exp_refs, ARRAY_SIZE(exp_refs), 0);
+		exp_refs, ARRAY_SIZE(exp_refs), 0, 1);
 }
 
 void test_online_push__b4(void)
@@ -445,7 +468,7 @@ void test_online_push__b4(void)
 	expected_ref exp_refs[] = { { "refs/heads/b4", &_oid_b4 } };
 	do_push(specs, ARRAY_SIZE(specs),
 		exp_stats, ARRAY_SIZE(exp_stats),
-		exp_refs, ARRAY_SIZE(exp_refs), 0);
+		exp_refs, ARRAY_SIZE(exp_refs), 0, 1);
 }
 
 void test_online_push__b5(void)
@@ -455,7 +478,7 @@ void test_online_push__b5(void)
 	expected_ref exp_refs[] = { { "refs/heads/b5", &_oid_b5 } };
 	do_push(specs, ARRAY_SIZE(specs),
 		exp_stats, ARRAY_SIZE(exp_stats),
-		exp_refs, ARRAY_SIZE(exp_refs), 0);
+		exp_refs, ARRAY_SIZE(exp_refs), 0, 1);
 }
 
 void test_online_push__multi(void)
@@ -483,7 +506,7 @@ void test_online_push__multi(void)
 	};
 	do_push(specs, ARRAY_SIZE(specs),
 		exp_stats, ARRAY_SIZE(exp_stats),
-		exp_refs, ARRAY_SIZE(exp_refs), 0);
+		exp_refs, ARRAY_SIZE(exp_refs), 0, 1);
 }
 
 void test_online_push__implicit_tgt(void)
@@ -501,10 +524,10 @@ void test_online_push__implicit_tgt(void)
 
 	do_push(specs1, ARRAY_SIZE(specs1),
 		exp_stats1, ARRAY_SIZE(exp_stats1),
-		exp_refs1, ARRAY_SIZE(exp_refs1), 0);
+		exp_refs1, ARRAY_SIZE(exp_refs1), 0, 1);
 	do_push(specs2, ARRAY_SIZE(specs2),
 		exp_stats2, ARRAY_SIZE(exp_stats2),
-		exp_refs2, ARRAY_SIZE(exp_refs2), 0);
+		exp_refs2, ARRAY_SIZE(exp_refs2), 0, 0);
 }
 
 void test_online_push__fast_fwd(void)
@@ -526,19 +549,19 @@ void test_online_push__fast_fwd(void)
 
 	do_push(specs_init, ARRAY_SIZE(specs_init),
 		exp_stats_init, ARRAY_SIZE(exp_stats_init),
-		exp_refs_init, ARRAY_SIZE(exp_refs_init), 0);
+		exp_refs_init, ARRAY_SIZE(exp_refs_init), 0, 1);
 
 	do_push(specs_ff, ARRAY_SIZE(specs_ff),
 		exp_stats_ff, ARRAY_SIZE(exp_stats_ff),
-		exp_refs_ff, ARRAY_SIZE(exp_refs_ff), 0);
+		exp_refs_ff, ARRAY_SIZE(exp_refs_ff), 0, 0);
 
 	do_push(specs_reset, ARRAY_SIZE(specs_reset),
 		exp_stats_init, ARRAY_SIZE(exp_stats_init),
-		exp_refs_init, ARRAY_SIZE(exp_refs_init), 0);
+		exp_refs_init, ARRAY_SIZE(exp_refs_init), 0, 0);
 
 	do_push(specs_ff_force, ARRAY_SIZE(specs_ff_force),
 		exp_stats_ff, ARRAY_SIZE(exp_stats_ff),
-		exp_refs_ff, ARRAY_SIZE(exp_refs_ff), 0);
+		exp_refs_ff, ARRAY_SIZE(exp_refs_ff), 0, 0);
 }
 
 void test_online_push__tag_commit(void)
@@ -548,7 +571,7 @@ void test_online_push__tag_commit(void)
 	expected_ref exp_refs[] = { { "refs/tags/tag-commit", &_tag_commit } };
 	do_push(specs, ARRAY_SIZE(specs),
 		exp_stats, ARRAY_SIZE(exp_stats),
-		exp_refs, ARRAY_SIZE(exp_refs), 0);
+		exp_refs, ARRAY_SIZE(exp_refs), 0, 1);
 }
 
 void test_online_push__tag_tree(void)
@@ -558,7 +581,7 @@ void test_online_push__tag_tree(void)
 	expected_ref exp_refs[] = { { "refs/tags/tag-tree", &_tag_tree } };
 	do_push(specs, ARRAY_SIZE(specs),
 		exp_stats, ARRAY_SIZE(exp_stats),
-		exp_refs, ARRAY_SIZE(exp_refs), 0);
+		exp_refs, ARRAY_SIZE(exp_refs), 0, 1);
 }
 
 void test_online_push__tag_blob(void)
@@ -568,7 +591,7 @@ void test_online_push__tag_blob(void)
 	expected_ref exp_refs[] = { { "refs/tags/tag-blob", &_tag_blob } };
 	do_push(specs, ARRAY_SIZE(specs),
 		exp_stats, ARRAY_SIZE(exp_stats),
-		exp_refs, ARRAY_SIZE(exp_refs), 0);
+		exp_refs, ARRAY_SIZE(exp_refs), 0, 1);
 }
 
 void test_online_push__tag_lightweight(void)
@@ -578,7 +601,7 @@ void test_online_push__tag_lightweight(void)
 	expected_ref exp_refs[] = { { "refs/tags/tag-lightweight", &_tag_lightweight } };
 	do_push(specs, ARRAY_SIZE(specs),
 		exp_stats, ARRAY_SIZE(exp_stats),
-		exp_refs, ARRAY_SIZE(exp_refs), 0);
+		exp_refs, ARRAY_SIZE(exp_refs), 0, 1);
 }
 
 void test_online_push__tag_to_tag(void)
@@ -588,7 +611,7 @@ void test_online_push__tag_to_tag(void)
 	expected_ref exp_refs[] = { { "refs/tags/tag-tag", &_tag_tag } };
 	do_push(specs, ARRAY_SIZE(specs),
 		exp_stats, ARRAY_SIZE(exp_stats),
-		exp_refs, ARRAY_SIZE(exp_refs), 0);
+		exp_refs, ARRAY_SIZE(exp_refs), 0, 0);
 }
 
 void test_online_push__force(void)
@@ -605,16 +628,16 @@ void test_online_push__force(void)
 
 	do_push(specs1, ARRAY_SIZE(specs1),
 		exp_stats1, ARRAY_SIZE(exp_stats1),
-		exp_refs1, ARRAY_SIZE(exp_refs1), 0);
+		exp_refs1, ARRAY_SIZE(exp_refs1), 0, 1);
 
 	do_push(specs2, ARRAY_SIZE(specs2),
 		NULL, 0,
-		exp_refs1, ARRAY_SIZE(exp_refs1), GIT_ENONFASTFORWARD);
+		exp_refs1, ARRAY_SIZE(exp_refs1), GIT_ENONFASTFORWARD, 0);
 
 	/* Non-fast-forward update with force should pass. */
 	do_push(specs2_force, ARRAY_SIZE(specs2_force),
 		exp_stats2_force, ARRAY_SIZE(exp_stats2_force),
-		exp_refs2_force, ARRAY_SIZE(exp_refs2_force), 0);
+		exp_refs2_force, ARRAY_SIZE(exp_refs2_force), 0, 1);
 }
 
 void test_online_push__delete(void)
@@ -645,7 +668,7 @@ void test_online_push__delete(void)
 
 	do_push(specs1, ARRAY_SIZE(specs1),
 		exp_stats1, ARRAY_SIZE(exp_stats1),
-		exp_refs1, ARRAY_SIZE(exp_refs1), 0);
+		exp_refs1, ARRAY_SIZE(exp_refs1), 0, 1);
 
 	/* When deleting a non-existent branch, the git client sends zero for both
 	 * the old and new commit id.  This should succeed on the server with the
@@ -655,23 +678,23 @@ void test_online_push__delete(void)
 	 */
 	do_push(specs_del_fake, ARRAY_SIZE(specs_del_fake),
 		exp_stats_fake, 1,
-		exp_refs1, ARRAY_SIZE(exp_refs1), 0);
+		exp_refs1, ARRAY_SIZE(exp_refs1), 0, 0);
 	do_push(specs_del_fake_force, ARRAY_SIZE(specs_del_fake_force),
 		exp_stats_fake, 1,
-		exp_refs1, ARRAY_SIZE(exp_refs1), 0);
+		exp_refs1, ARRAY_SIZE(exp_refs1), 0, 0);
 
 	/* Delete one of the pushed branches. */
 	do_push(specs_delete, ARRAY_SIZE(specs_delete),
 		exp_stats_delete, ARRAY_SIZE(exp_stats_delete),
-		exp_refs_delete, ARRAY_SIZE(exp_refs_delete), 0);
+		exp_refs_delete, ARRAY_SIZE(exp_refs_delete), 0, 0);
 
 	/* Re-push branches and retry delete with force. */
 	do_push(specs1, ARRAY_SIZE(specs1),
 		exp_stats1, ARRAY_SIZE(exp_stats1),
-		exp_refs1, ARRAY_SIZE(exp_refs1), 0);
+		exp_refs1, ARRAY_SIZE(exp_refs1), 0, 0);
 	do_push(specs_delete_force, ARRAY_SIZE(specs_delete_force),
 		exp_stats_delete, ARRAY_SIZE(exp_stats_delete),
-		exp_refs_delete, ARRAY_SIZE(exp_refs_delete), 0);
+		exp_refs_delete, ARRAY_SIZE(exp_refs_delete), 0, 0);
 }
 
 void test_online_push__bad_refspecs(void)
@@ -703,11 +726,11 @@ void test_online_push__expressions(void)
 	/* TODO: Find a more precise way of checking errors than a exit code of -1. */
 	do_push(specs_left_expr, ARRAY_SIZE(specs_left_expr),
 		NULL, 0,
-		NULL, 0, -1);
+		NULL, 0, -1, 0);
 
 	do_push(specs_right_expr, ARRAY_SIZE(specs_right_expr),
 		exp_stats_right_expr, ARRAY_SIZE(exp_stats_right_expr),
-		NULL, 0, 0);
+		NULL, 0, 0, 1);
 }
 
 void test_online_push__notes(void)
@@ -727,7 +750,7 @@ void test_online_push__notes(void)
 
 	do_push(specs, ARRAY_SIZE(specs),
 		exp_stats, ARRAY_SIZE(exp_stats),
-		exp_refs, ARRAY_SIZE(exp_refs), 0);
+		exp_refs, ARRAY_SIZE(exp_refs), 0, 1);
 
 	git_signature_free(signature);
 }
diff --git a/tests-clar/online/push_util.h b/tests-clar/online/push_util.h
index 759122aa6..64f02cf2f 100644
--- a/tests-clar/online/push_util.h
+++ b/tests-clar/online/push_util.h
@@ -12,7 +12,7 @@ extern const git_oid OID_ZERO;
  * @param data pointer to a record_callbacks_data instance
  */
 #define RECORD_CALLBACKS_INIT(data) \
-	{ GIT_REMOTE_CALLBACKS_VERSION, NULL, NULL, record_update_tips_cb, data }
+	{ GIT_REMOTE_CALLBACKS_VERSION, NULL, NULL, cred_acquire_cb, NULL, record_update_tips_cb, data }
 
 typedef struct {
 	char *name;
diff --git a/tests-clar/resources/config/config20 b/tests-clar/resources/config/config20
new file mode 100644
index 000000000..8f0f12c4c
--- /dev/null
+++ b/tests-clar/resources/config/config20
@@ -0,0 +1,11 @@
+[valid "[subsection]"]
+    something = a
+; we don't allow anything after closing "
+[sec "[subsec]/child"]
+    parent = grand
+[sec2 "[subsec2]/child2"]
+    type = dvcs
+[sec3 "escape\"quote"]
+    vcs = git
+[sec4 "escaping\\slash"]
+    lib = git2
diff --git a/tests-clar/stash/save.c b/tests-clar/stash/save.c
index 035b62279..3d92b26bd 100644
--- a/tests-clar/stash/save.c
+++ b/tests-clar/stash/save.c
@@ -113,33 +113,15 @@ $ git status --short
 	cl_assert_equal_i(GIT_STATUS_WT_NEW, status);
 }
 
-static void assert_status(
-	const char *path,
-	int status_flags)
-{
-	unsigned int status;
-	int error;
-
-	error = git_status_file(&status, repo, path);
-
-	if (status_flags < 0) {
-		cl_assert_equal_i(status_flags, error);
-		return;
-	}
-
-	cl_assert_equal_i(0, error);
-	cl_assert_equal_i((unsigned int)status_flags, status);
-}
-
 void test_stash_save__can_keep_index(void)
 {
 	cl_git_pass(git_stash_save(&stash_tip_oid, repo, signature, NULL, GIT_STASH_KEEP_INDEX));
 
-	assert_status("what", GIT_STATUS_INDEX_MODIFIED);
-	assert_status("how", GIT_STATUS_INDEX_MODIFIED);
-	assert_status("who", GIT_STATUS_CURRENT);
-	assert_status("when", GIT_STATUS_WT_NEW);
-	assert_status("just.ignore", GIT_STATUS_IGNORED);
+	assert_status(repo, "what", GIT_STATUS_INDEX_MODIFIED);
+	assert_status(repo, "how", GIT_STATUS_INDEX_MODIFIED);
+	assert_status(repo, "who", GIT_STATUS_CURRENT);
+	assert_status(repo, "when", GIT_STATUS_WT_NEW);
+	assert_status(repo, "just.ignore", GIT_STATUS_IGNORED);
 }
 
 static void assert_commit_message_contains(const char *revision, const char *fragment)
@@ -308,25 +290,25 @@ void test_stash_save__can_stage_normal_then_stage_untracked(void)
 	 * 100644 blob b6ed15e81e2593d7bb6265eb4a991d29dc3e628b    when
 	*/
 
-	assert_status("what", GIT_STATUS_WT_MODIFIED | GIT_STATUS_INDEX_MODIFIED);
-	assert_status("how", GIT_STATUS_INDEX_MODIFIED);
-	assert_status("who", GIT_STATUS_WT_MODIFIED);
-	assert_status("when", GIT_STATUS_WT_NEW);
-	assert_status("just.ignore", GIT_STATUS_IGNORED);
+	assert_status(repo, "what", GIT_STATUS_WT_MODIFIED | GIT_STATUS_INDEX_MODIFIED);
+	assert_status(repo, "how", GIT_STATUS_INDEX_MODIFIED);
+	assert_status(repo, "who", GIT_STATUS_WT_MODIFIED);
+	assert_status(repo, "when", GIT_STATUS_WT_NEW);
+	assert_status(repo, "just.ignore", GIT_STATUS_IGNORED);
 
 	cl_git_pass(git_stash_save(&stash_tip_oid, repo, signature, NULL, GIT_STASH_DEFAULT));
-	assert_status("what", GIT_STATUS_CURRENT);
-	assert_status("how", GIT_STATUS_CURRENT);
-	assert_status("who", GIT_STATUS_CURRENT);
-	assert_status("when", GIT_STATUS_WT_NEW);
-	assert_status("just.ignore", GIT_STATUS_IGNORED);
+	assert_status(repo, "what", GIT_STATUS_CURRENT);
+	assert_status(repo, "how", GIT_STATUS_CURRENT);
+	assert_status(repo, "who", GIT_STATUS_CURRENT);
+	assert_status(repo, "when", GIT_STATUS_WT_NEW);
+	assert_status(repo, "just.ignore", GIT_STATUS_IGNORED);
 
 	cl_git_pass(git_stash_save(&stash_tip_oid, repo, signature, NULL, GIT_STASH_INCLUDE_UNTRACKED));
-	assert_status("what", GIT_STATUS_CURRENT);
-	assert_status("how", GIT_STATUS_CURRENT);
-	assert_status("who", GIT_STATUS_CURRENT);
-	assert_status("when", GIT_ENOTFOUND);
-	assert_status("just.ignore", GIT_STATUS_IGNORED);
+	assert_status(repo, "what", GIT_STATUS_CURRENT);
+	assert_status(repo, "how", GIT_STATUS_CURRENT);
+	assert_status(repo, "who", GIT_STATUS_CURRENT);
+	assert_status(repo, "when", GIT_ENOTFOUND);
+	assert_status(repo, "just.ignore", GIT_STATUS_IGNORED);
 
 
 	assert_blob_oid("stash@{1}^0:what", "bc99dc98b3eba0e9157e94769cd4d49cb49de449");	/* see you later */
@@ -360,11 +342,11 @@ void test_stash_save__including_untracked_without_any_untracked_file_creates_an_
 {
 	cl_git_pass(p_unlink("stash/when"));
 
-	assert_status("what", GIT_STATUS_WT_MODIFIED | GIT_STATUS_INDEX_MODIFIED);
-	assert_status("how", GIT_STATUS_INDEX_MODIFIED);
-	assert_status("who", GIT_STATUS_WT_MODIFIED);
-	assert_status("when", GIT_ENOTFOUND);
-	assert_status("just.ignore", GIT_STATUS_IGNORED);
+	assert_status(repo, "what", GIT_STATUS_WT_MODIFIED | GIT_STATUS_INDEX_MODIFIED);
+	assert_status(repo, "how", GIT_STATUS_INDEX_MODIFIED);
+	assert_status(repo, "who", GIT_STATUS_WT_MODIFIED);
+	assert_status(repo, "when", GIT_ENOTFOUND);
+	assert_status(repo, "just.ignore", GIT_STATUS_IGNORED);
 
 	cl_git_pass(git_stash_save(&stash_tip_oid, repo, signature, NULL, GIT_STASH_INCLUDE_UNTRACKED));
 
diff --git a/tests-clar/stash/stash_helpers.c b/tests-clar/stash/stash_helpers.c
index 06b63f177..8b7d685f8 100644
--- a/tests-clar/stash/stash_helpers.c
+++ b/tests-clar/stash/stash_helpers.c
@@ -35,3 +35,22 @@ void setup_stash(git_repository *repo, git_signature *signature)
 
 	git_index_free(index);
 }
+
+void assert_status(
+	git_repository *repo,
+	const char *path,
+	int status_flags)
+{
+	unsigned int status;
+	int error;
+
+	error = git_status_file(&status, repo, path);
+
+	if (status_flags < 0) {
+		cl_assert_equal_i(status_flags, error);
+		return;
+	}
+
+	cl_assert_equal_i(0, error);
+	cl_assert_equal_i((unsigned int)status_flags, status);
+}
diff --git a/tests-clar/stash/stash_helpers.h b/tests-clar/stash/stash_helpers.h
index 7c3e13de3..66d758fe2 100644
--- a/tests-clar/stash/stash_helpers.h
+++ b/tests-clar/stash/stash_helpers.h
@@ -1,3 +1,8 @@
 void setup_stash(
 	git_repository *repo,
 	git_signature *signature);
+
+void assert_status(
+	git_repository *repo,
+	const char *path,
+	int status_flags);
diff --git a/tests-clar/stash/submodules.c b/tests-clar/stash/submodules.c
new file mode 100644
index 000000000..137c4408c
--- /dev/null
+++ b/tests-clar/stash/submodules.c
@@ -0,0 +1,80 @@
+#include "clar_libgit2.h"
+#include "stash_helpers.h"
+#include "../submodule/submodule_helpers.h"
+
+static git_repository *repo;
+static git_signature *signature;
+static git_oid stash_tip_oid;
+
+static git_submodule *sm;
+
+void test_stash_submodules__initialize(void)
+{
+	cl_git_pass(git_signature_new(&signature, "nulltoken", "emeric.fermas@gmail.com", 1323847743, 60)); /* Wed Dec 14 08:29:03 2011 +0100 */
+
+	repo = setup_fixture_submodules();
+
+	cl_git_pass(git_submodule_lookup(&sm, repo, "testrepo"));
+}
+
+void test_stash_submodules__cleanup(void)
+{
+	git_signature_free(signature);
+	signature = NULL;
+}
+
+void test_stash_submodules__does_not_stash_modified_submodules(void)
+{
+	static git_index *smindex;
+	static git_repository *smrepo;
+
+	assert_status(repo, "modified", GIT_STATUS_WT_MODIFIED);
+
+	/* modify file in submodule */
+	cl_git_rewritefile("submodules/testrepo/README", "heyheyhey");
+	assert_status(repo, "testrepo", GIT_STATUS_WT_MODIFIED);
+
+	/* add file to index in submodule */
+	cl_git_pass(git_submodule_open(&smrepo, sm));
+	cl_git_pass(git_repository_index(&smindex, smrepo));
+	cl_git_pass(git_index_add_bypath(smindex, "README"));
+
+	/* commit changed index of submodule */
+	cl_repo_commit_from_index(NULL, smrepo, NULL, 1372350000, "Modify it");
+	assert_status(repo, "testrepo", GIT_STATUS_WT_MODIFIED);
+
+	cl_git_pass(git_stash_save(&stash_tip_oid, repo, signature, NULL, GIT_STASH_DEFAULT));
+
+	assert_status(repo, "testrepo", GIT_STATUS_WT_MODIFIED);
+	assert_status(repo, "modified", GIT_STATUS_CURRENT);
+
+	git_index_free(smindex);
+	git_repository_free(smrepo);
+}
+
+void test_stash_submodules__stash_is_empty_with_modified_submodules(void)
+{
+	static git_index *smindex;
+	static git_repository *smrepo;
+
+	cl_git_pass(git_stash_save(&stash_tip_oid, repo, signature, NULL, GIT_STASH_DEFAULT));
+	assert_status(repo, "modified", GIT_STATUS_CURRENT);
+
+	/* modify file in submodule */
+	cl_git_rewritefile("submodules/testrepo/README", "heyheyhey");
+	assert_status(repo, "testrepo", GIT_STATUS_WT_MODIFIED);
+
+	/* add file to index in submodule */
+	cl_git_pass(git_submodule_open(&smrepo, sm));
+	cl_git_pass(git_repository_index(&smindex, smrepo));
+	cl_git_pass(git_index_add_bypath(smindex, "README"));
+
+	/* commit changed index of submodule */
+	cl_repo_commit_from_index(NULL, smrepo, NULL, 1372350000, "Modify it");
+	assert_status(repo, "testrepo", GIT_STATUS_WT_MODIFIED);
+
+	cl_git_fail_with(git_stash_save(&stash_tip_oid, repo, signature, NULL, GIT_STASH_DEFAULT), GIT_ENOTFOUND);
+
+	git_index_free(smindex);
+	git_repository_free(smrepo);
+}