]>
Commit | Line | Data |
---|---|---|
d4b5a4e2 VM |
1 | /* |
2 | * This file is free software; you can redistribute it and/or modify | |
3 | * it under the terms of the GNU General Public License, version 2, | |
4 | * as published by the Free Software Foundation. | |
5 | * | |
6 | * In addition to the permissions in the GNU General Public License, | |
7 | * the authors give you unlimited permission to link the compiled | |
8 | * version of this file into combinations with other programs, | |
9 | * and to distribute those combinations without any restriction | |
10 | * coming from the use of this file. (The General Public License | |
11 | * restrictions do apply in other respects; for example, they cover | |
12 | * modification of the file, and distribution when not linked into | |
13 | * a combined executable.) | |
14 | * | |
15 | * This file is distributed in the hope that it will be useful, but | |
16 | * WITHOUT ANY WARRANTY; without even the implied warranty of | |
17 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
18 | * General Public License for more details. | |
19 | * | |
20 | * You should have received a copy of the GNU General Public License | |
21 | * along with this program; see the file COPYING. If not, write to | |
22 | * the Free Software Foundation, 51 Franklin Street, Fifth Floor, | |
23 | * Boston, MA 02110-1301, USA. | |
24 | */ | |
25 | #include "test_lib.h" | |
26 | #include "test_helpers.h" | |
27 | ||
28 | #include "odb.h" | |
29 | #include "git2/odb_backend.h" | |
705a90ec | 30 | #include "repository.h" |
d4b5a4e2 VM |
31 | |
32 | typedef struct { | |
33 | git_odb_backend base; | |
34 | int position; | |
35 | } fake_backend; | |
36 | ||
37 | git_odb_backend *new_backend(int position) | |
38 | { | |
39 | fake_backend *b; | |
40 | ||
41 | b = git__malloc(sizeof(fake_backend)); | |
42 | if (b == NULL) | |
43 | return NULL; | |
44 | ||
45 | memset(b, 0x0, sizeof(fake_backend)); | |
46 | b->position = position; | |
47 | return (git_odb_backend *)b; | |
48 | } | |
49 | ||
50 | int test_backend_sorting(git_odb *odb) | |
51 | { | |
52 | unsigned int i; | |
53 | ||
54 | for (i = 0; i < odb->backends.length; ++i) { | |
55 | fake_backend *internal = *((fake_backend **)git_vector_get(&odb->backends, i)); | |
56 | ||
57 | if (internal == NULL) | |
58 | return GIT_ERROR; | |
59 | ||
60 | if (internal->position != (int)i) | |
61 | return GIT_ERROR; | |
62 | } | |
63 | ||
64 | return GIT_SUCCESS; | |
65 | } | |
66 | ||
3dccfed1 | 67 | BEGIN_TEST(odb0, "assure that ODB backends are properly sorted") |
d4b5a4e2 VM |
68 | git_odb *odb; |
69 | must_pass(git_odb_new(&odb)); | |
70 | must_pass(git_odb_add_backend(odb, new_backend(0), 5)); | |
71 | must_pass(git_odb_add_backend(odb, new_backend(2), 3)); | |
72 | must_pass(git_odb_add_backend(odb, new_backend(1), 4)); | |
73 | must_pass(git_odb_add_backend(odb, new_backend(3), 1)); | |
74 | must_pass(test_backend_sorting(odb)); | |
75 | git_odb_close(odb); | |
76 | END_TEST | |
77 | ||
3dccfed1 | 78 | BEGIN_TEST(odb1, "assure that alternate backends are properly sorted") |
d4b5a4e2 VM |
79 | git_odb *odb; |
80 | must_pass(git_odb_new(&odb)); | |
81 | must_pass(git_odb_add_backend(odb, new_backend(0), 5)); | |
82 | must_pass(git_odb_add_backend(odb, new_backend(2), 3)); | |
83 | must_pass(git_odb_add_backend(odb, new_backend(1), 4)); | |
84 | must_pass(git_odb_add_backend(odb, new_backend(3), 1)); | |
85 | must_pass(git_odb_add_alternate(odb, new_backend(4), 5)); | |
86 | must_pass(git_odb_add_alternate(odb, new_backend(6), 3)); | |
87 | must_pass(git_odb_add_alternate(odb, new_backend(5), 4)); | |
88 | must_pass(git_odb_add_alternate(odb, new_backend(7), 1)); | |
89 | must_pass(test_backend_sorting(odb)); | |
90 | git_odb_close(odb); | |
91 | END_TEST | |
92 | ||
705a90ec | 93 | |
94 | #define STANDARD_REPOSITORY 0 | |
95 | #define BARE_REPOSITORY 1 | |
96 | ||
3dccfed1 VM |
97 | static int ensure_repository_init( |
98 | const char *working_directory, | |
99 | int repository_kind, | |
100 | const char *expected_path_index, | |
101 | const char *expected_path_repository, | |
102 | const char *expected_working_directory) | |
705a90ec | 103 | { |
104 | char path_odb[GIT_PATH_MAX]; | |
105 | git_repository *repo; | |
106 | ||
3dccfed1 VM |
107 | if (gitfo_isdir(working_directory) == GIT_SUCCESS) |
108 | return GIT_ERROR; | |
705a90ec | 109 | |
110 | git__joinpath(path_odb, expected_path_repository, GIT_OBJECTS_DIR); | |
111 | ||
3dccfed1 VM |
112 | if (git_repository_init(&repo, working_directory, repository_kind) < GIT_SUCCESS) |
113 | return GIT_ERROR; | |
114 | ||
115 | if (repo->path_workdir != NULL || expected_working_directory != NULL) { | |
c90292ce | 116 | if (git__suffixcmp(repo->path_workdir, expected_working_directory) != 0) |
45314a7e | 117 | goto cleanup; |
3dccfed1 VM |
118 | } |
119 | ||
c90292ce | 120 | if (git__suffixcmp(repo->path_odb, path_odb) != 0) |
45314a7e | 121 | goto cleanup; |
3dccfed1 | 122 | |
c90292ce | 123 | if (git__suffixcmp(repo->path_repository, expected_path_repository) != 0) |
45314a7e | 124 | goto cleanup; |
3dccfed1 VM |
125 | |
126 | if (repo->path_index != NULL || expected_path_index != NULL) { | |
c90292ce | 127 | if (git__suffixcmp(repo->path_index, expected_path_index) != 0) |
45314a7e | 128 | goto cleanup; |
fa9bcd81 | 129 | |
130 | if (git_repository_is_bare(repo) == 1) | |
131 | goto cleanup; | |
132 | } else if (git_repository_is_bare(repo) == 0) | |
133 | goto cleanup; | |
134 | ||
135 | if (git_repository_is_empty(repo) == 0) | |
136 | goto cleanup; | |
705a90ec | 137 | |
138 | git_repository_free(repo); | |
3dccfed1 VM |
139 | rmdir_recurs(working_directory); |
140 | ||
141 | return GIT_SUCCESS; | |
45314a7e TC |
142 | |
143 | cleanup: | |
144 | git_repository_free(repo); | |
145 | rmdir_recurs(working_directory); | |
146 | return GIT_ERROR; | |
705a90ec | 147 | } |
148 | ||
3dccfed1 | 149 | BEGIN_TEST(init0, "initialize a standard repo") |
705a90ec | 150 | char path_index[GIT_PATH_MAX], path_repository[GIT_PATH_MAX]; |
151 | ||
3dccfed1 | 152 | git__joinpath(path_repository, TEMP_REPO_FOLDER, GIT_DIR); |
705a90ec | 153 | git__joinpath(path_index, path_repository, GIT_INDEX_FILE); |
154 | ||
45314a7e TC |
155 | must_pass(ensure_repository_init(TEMP_REPO_FOLDER, STANDARD_REPOSITORY, path_index, path_repository, TEMP_REPO_FOLDER)); |
156 | must_pass(ensure_repository_init(TEMP_REPO_FOLDER_NS, STANDARD_REPOSITORY, path_index, path_repository, TEMP_REPO_FOLDER)); | |
705a90ec | 157 | END_TEST |
158 | ||
3dccfed1 | 159 | BEGIN_TEST(init1, "initialize a bare repo") |
705a90ec | 160 | char path_repository[GIT_PATH_MAX]; |
161 | ||
3dccfed1 | 162 | git__joinpath(path_repository, TEMP_REPO_FOLDER, ""); |
705a90ec | 163 | |
45314a7e TC |
164 | must_pass(ensure_repository_init(TEMP_REPO_FOLDER, BARE_REPOSITORY, NULL, path_repository, NULL)); |
165 | must_pass(ensure_repository_init(TEMP_REPO_FOLDER_NS, BARE_REPOSITORY, NULL, path_repository, NULL)); | |
705a90ec | 166 | END_TEST |
167 | ||
ba1bdf86 | 168 | BEGIN_TEST(init2, "Initialize and open a bare repo with a relative path escaping out of the current working directory") |
677a3c07 | 169 | char path_repository[GIT_PATH_MAX]; |
170 | char current_workdir[GIT_PATH_MAX]; | |
171 | const int mode = 0755; /* or 0777 ? */ | |
172 | git_repository* repo; | |
173 | ||
174 | must_pass(gitfo_getcwd(current_workdir, sizeof(current_workdir))); | |
175 | ||
c90292ce | 176 | git__joinpath(path_repository, TEMP_REPO_FOLDER, "a/b/c/"); |
677a3c07 | 177 | must_pass(gitfo_mkdir_recurs(path_repository, mode)); |
178 | ||
179 | must_pass(chdir(path_repository)); | |
180 | ||
181 | must_pass(git_repository_init(&repo, "../d/e.git", 1)); | |
c90292ce | 182 | must_pass(git__suffixcmp(repo->path_repository, "/a/b/d/e.git/")); |
183 | ||
677a3c07 | 184 | git_repository_free(repo); |
185 | ||
ba1bdf86 | 186 | must_pass(git_repository_open(&repo, "../d/e.git")); |
187 | ||
188 | git_repository_free(repo); | |
189 | ||
190 | must_pass(chdir(current_workdir)); | |
191 | rmdir_recurs(TEMP_REPO_FOLDER); | |
192 | END_TEST | |
193 | ||
2ce44b67 | 194 | #define EMPTY_BARE_REPOSITORY_NAME "empty_bare.git" |
195 | #define EMPTY_BARE_REPOSITORY_FOLDER TEST_RESOURCES "/" EMPTY_BARE_REPOSITORY_NAME "/" | |
196 | ||
197 | BEGIN_TEST(open0, "Open a bare repository that has just been initialized by git") | |
198 | git_repository *repo; | |
199 | ||
200 | must_pass(copydir_recurs(EMPTY_BARE_REPOSITORY_FOLDER, TEMP_REPO_FOLDER)); | |
201 | must_pass(remove_placeholders(TEMP_REPO_FOLDER, "dummy-marker.txt")); | |
202 | ||
203 | must_pass(git_repository_open(&repo, TEMP_REPO_FOLDER)); | |
4a34b3a9 | 204 | must_be_true(git_repository_path(repo) != NULL); |
205 | must_be_true(git_repository_workdir(repo) == NULL); | |
2ce44b67 | 206 | |
207 | git_repository_free(repo); | |
208 | must_pass(rmdir_recurs(TEMP_REPO_FOLDER)); | |
209 | END_TEST | |
210 | ||
a8375f53 | 211 | #define SOURCE_EMPTY_REPOSITORY_NAME "empty_standard_repo/.gitted" |
212 | #define EMPTY_REPOSITORY_NAME "empty_standard_repo/.git" | |
213 | #define EMPTY_REPOSITORY_FOLDER TEST_RESOURCES "/" SOURCE_EMPTY_REPOSITORY_NAME "/" | |
214 | #define DEST_REPOSITORY_FOLDER TEMP_REPO_FOLDER DOT_GIT "/" | |
215 | ||
216 | BEGIN_TEST(open1, "Open a standard repository that has just been initialized by git") | |
217 | git_repository *repo; | |
218 | ||
219 | must_pass(copydir_recurs(EMPTY_REPOSITORY_FOLDER, DEST_REPOSITORY_FOLDER)); | |
220 | must_pass(remove_placeholders(DEST_REPOSITORY_FOLDER, "dummy-marker.txt")); | |
221 | ||
222 | must_pass(git_repository_open(&repo, DEST_REPOSITORY_FOLDER)); | |
4a34b3a9 | 223 | must_be_true(git_repository_path(repo) != NULL); |
224 | must_be_true(git_repository_workdir(repo) != NULL); | |
a8375f53 | 225 | |
226 | git_repository_free(repo); | |
227 | must_pass(rmdir_recurs(TEMP_REPO_FOLDER)); | |
228 | END_TEST | |
229 | ||
230 | ||
ba1bdf86 | 231 | BEGIN_TEST(open2, "Open a bare repository with a relative path escaping out of the current working directory") |
232 | char new_current_workdir[GIT_PATH_MAX]; | |
233 | char current_workdir[GIT_PATH_MAX]; | |
234 | char path_repository[GIT_PATH_MAX]; | |
235 | ||
236 | const int mode = 0755; /* or 0777 ? */ | |
237 | git_repository* repo; | |
238 | ||
239 | /* Setup the repository to open */ | |
240 | must_pass(gitfo_getcwd(current_workdir, sizeof(current_workdir))); | |
241 | strcpy(path_repository, current_workdir); | |
242 | git__joinpath_n(path_repository, 3, path_repository, TEMP_REPO_FOLDER, "a/d/e.git"); | |
ba1bdf86 | 243 | must_pass(copydir_recurs(REPOSITORY_FOLDER, path_repository)); |
244 | ||
245 | /* Change the current working directory */ | |
246 | git__joinpath(new_current_workdir, TEMP_REPO_FOLDER, "a/b/c/"); | |
247 | must_pass(gitfo_mkdir_recurs(new_current_workdir, mode)); | |
248 | must_pass(chdir(new_current_workdir)); | |
249 | ||
250 | must_pass(git_repository_open(&repo, "../../d/e.git")); | |
251 | ||
252 | git_repository_free(repo); | |
253 | ||
677a3c07 | 254 | must_pass(chdir(current_workdir)); |
c90292ce | 255 | rmdir_recurs(TEMP_REPO_FOLDER); |
677a3c07 | 256 | END_TEST |
d4b5a4e2 | 257 | |
41233c40 VM |
258 | BEGIN_TEST(empty0, "test if a repository is empty or not") |
259 | ||
260 | git_repository *repo_empty, *repo_normal; | |
261 | ||
262 | must_pass(git_repository_open(&repo_normal, REPOSITORY_FOLDER)); | |
263 | must_be_true(git_repository_is_empty(repo_normal) == 0); | |
264 | git_repository_free(repo_normal); | |
265 | ||
266 | must_pass(git_repository_open(&repo_empty, EMPTY_BARE_REPOSITORY_FOLDER)); | |
267 | must_be_true(git_repository_is_empty(repo_empty) == 1); | |
268 | git_repository_free(repo_empty); | |
269 | END_TEST | |
270 | ||
76e9e3b7 RG |
271 | #define DISCOVER_FOLDER TEST_RESOURCES "/discover.git" |
272 | ||
273 | #define SUB_REPOSITORY_FOLDER_NAME "sub_repo" | |
274 | #define SUB_REPOSITORY_FOLDER DISCOVER_FOLDER "/" SUB_REPOSITORY_FOLDER_NAME | |
275 | #define SUB_REPOSITORY_FOLDER_SUB SUB_REPOSITORY_FOLDER "/sub" | |
276 | #define SUB_REPOSITORY_FOLDER_SUB_SUB SUB_REPOSITORY_FOLDER_SUB "/subsub" | |
277 | #define SUB_REPOSITORY_FOLDER_SUB_SUB_SUB SUB_REPOSITORY_FOLDER_SUB_SUB "/subsubsub" | |
278 | ||
279 | #define REPOSITORY_ALTERNATE_FOLDER DISCOVER_FOLDER "/alternate_sub_repo" | |
280 | #define REPOSITORY_ALTERNATE_FOLDER_SUB REPOSITORY_ALTERNATE_FOLDER "/sub" | |
281 | #define REPOSITORY_ALTERNATE_FOLDER_SUB_SUB REPOSITORY_ALTERNATE_FOLDER_SUB "/subsub" | |
282 | #define REPOSITORY_ALTERNATE_FOLDER_SUB_SUB_SUB REPOSITORY_ALTERNATE_FOLDER_SUB_SUB "/subsubsub" | |
283 | ||
284 | #define ALTERNATE_MALFORMED_FOLDER1 DISCOVER_FOLDER "/alternate_malformed_repo1" | |
285 | #define ALTERNATE_MALFORMED_FOLDER2 DISCOVER_FOLDER "/alternate_malformed_repo2" | |
286 | #define ALTERNATE_MALFORMED_FOLDER3 DISCOVER_FOLDER "/alternate_malformed_repo3" | |
287 | #define ALTERNATE_NOT_FOUND_FOLDER DISCOVER_FOLDER "/alternate_not_found_repo" | |
288 | ||
289 | static int ensure_repository_discover(const char *start_path, const char *ceiling_dirs, const char *expected_path) | |
290 | { | |
291 | int error; | |
292 | char found_path[GIT_PATH_MAX]; | |
293 | ||
294 | error = git_repository_discover(found_path, sizeof(found_path), start_path, 0, ceiling_dirs); | |
295 | //across_fs is always 0 as we can't automate the filesystem change tests | |
296 | ||
297 | if (error < GIT_SUCCESS) | |
298 | return error; | |
299 | ||
300 | return strcmp(found_path, expected_path) ? GIT_ERROR : GIT_SUCCESS; | |
301 | } | |
302 | ||
303 | static int write_file(const char *path, const char *content) | |
304 | { | |
305 | int error; | |
306 | git_file file; | |
307 | ||
308 | if (gitfo_exists(path) == GIT_SUCCESS) { | |
309 | error = gitfo_unlink(path); | |
310 | ||
311 | if (error < GIT_SUCCESS) | |
312 | return error; | |
313 | } | |
314 | ||
315 | file = gitfo_creat_force(path, 0644); | |
316 | if (file < GIT_SUCCESS) | |
317 | return file; | |
318 | ||
319 | error = gitfo_write(file, (void*)content, strlen(content) * sizeof(char)); | |
320 | ||
321 | gitfo_close(file); | |
322 | ||
323 | return error; | |
324 | } | |
325 | ||
326 | //no check is performed on ceiling_dirs length, so be sure it's long enough | |
327 | static int append_ceiling_dir(char *ceiling_dirs, const char *path) | |
328 | { | |
329 | int len = strlen(ceiling_dirs); | |
330 | int error; | |
331 | ||
332 | error = gitfo_prettify_dir_path(ceiling_dirs + len + (len ? 1 : 0), GIT_PATH_MAX, path, NULL); | |
333 | if (error < GIT_SUCCESS) | |
334 | return git__rethrow(error, "Failed to append ceiling directory."); | |
335 | ||
336 | if (len) | |
337 | ceiling_dirs[len] = ':'; | |
338 | ||
339 | return GIT_SUCCESS; | |
340 | } | |
341 | ||
342 | BEGIN_TEST(discover0, "test discover") | |
343 | git_repository *repo; | |
344 | char ceiling_dirs[GIT_PATH_MAX * 2] = ""; | |
345 | char repository_path[GIT_PATH_MAX]; | |
346 | char sub_repository_path[GIT_PATH_MAX]; | |
347 | char found_path[GIT_PATH_MAX]; | |
348 | int error; | |
349 | int mode = 0755; | |
350 | ||
351 | rmdir_recurs(DISCOVER_FOLDER); | |
352 | must_pass(append_ceiling_dir(ceiling_dirs,TEST_RESOURCES)); | |
353 | gitfo_mkdir_recurs(DISCOVER_FOLDER, mode); | |
354 | ||
355 | must_fail(error = git_repository_discover(repository_path, sizeof(repository_path), DISCOVER_FOLDER, 0, ceiling_dirs)); | |
356 | must_be_true(error == GIT_ENOTAREPO); | |
357 | ||
358 | must_pass(git_repository_init(&repo, DISCOVER_FOLDER, 1)); | |
359 | must_pass(git_repository_discover(repository_path, sizeof(repository_path), DISCOVER_FOLDER, 0, ceiling_dirs)); | |
360 | ||
361 | must_pass(git_repository_init(&repo, SUB_REPOSITORY_FOLDER, 0)); | |
362 | must_pass(gitfo_mkdir_recurs(SUB_REPOSITORY_FOLDER_SUB_SUB_SUB, mode)); | |
363 | must_pass(git_repository_discover(sub_repository_path, sizeof(sub_repository_path), SUB_REPOSITORY_FOLDER, 0, ceiling_dirs)); | |
364 | ||
365 | must_pass(gitfo_mkdir_recurs(SUB_REPOSITORY_FOLDER_SUB_SUB_SUB, mode)); | |
366 | must_pass(ensure_repository_discover(SUB_REPOSITORY_FOLDER_SUB, ceiling_dirs, sub_repository_path)); | |
367 | must_pass(ensure_repository_discover(SUB_REPOSITORY_FOLDER_SUB_SUB, ceiling_dirs, sub_repository_path)); | |
368 | must_pass(ensure_repository_discover(SUB_REPOSITORY_FOLDER_SUB_SUB_SUB, ceiling_dirs, sub_repository_path)); | |
369 | ||
370 | must_pass(gitfo_mkdir_recurs(REPOSITORY_ALTERNATE_FOLDER_SUB_SUB_SUB, mode)); | |
371 | must_pass(write_file(REPOSITORY_ALTERNATE_FOLDER "/" DOT_GIT, "gitdir: ../" SUB_REPOSITORY_FOLDER_NAME "/" DOT_GIT)); | |
372 | must_pass(write_file(REPOSITORY_ALTERNATE_FOLDER_SUB_SUB "/" DOT_GIT, "gitdir: ../../../" SUB_REPOSITORY_FOLDER_NAME "/" DOT_GIT)); | |
373 | must_pass(write_file(REPOSITORY_ALTERNATE_FOLDER_SUB_SUB_SUB "/" DOT_GIT, "gitdir: ../../../../")); | |
374 | must_pass(ensure_repository_discover(REPOSITORY_ALTERNATE_FOLDER, ceiling_dirs, sub_repository_path)); | |
375 | must_pass(ensure_repository_discover(REPOSITORY_ALTERNATE_FOLDER_SUB, ceiling_dirs, sub_repository_path)); | |
376 | must_pass(ensure_repository_discover(REPOSITORY_ALTERNATE_FOLDER_SUB_SUB, ceiling_dirs, sub_repository_path)); | |
377 | must_pass(ensure_repository_discover(REPOSITORY_ALTERNATE_FOLDER_SUB_SUB_SUB, ceiling_dirs, repository_path)); | |
378 | ||
379 | must_pass(gitfo_mkdir_recurs(ALTERNATE_MALFORMED_FOLDER1, mode)); | |
380 | must_pass(write_file(ALTERNATE_MALFORMED_FOLDER1 "/" DOT_GIT, "Anything but not gitdir:")); | |
381 | must_pass(gitfo_mkdir_recurs(ALTERNATE_MALFORMED_FOLDER2, mode)); | |
382 | must_pass(write_file(ALTERNATE_MALFORMED_FOLDER2 "/" DOT_GIT, "gitdir:")); | |
383 | must_pass(gitfo_mkdir_recurs(ALTERNATE_MALFORMED_FOLDER3, mode)); | |
384 | must_pass(write_file(ALTERNATE_MALFORMED_FOLDER3 "/" DOT_GIT, "gitdir: \n\n\n")); | |
385 | must_pass(gitfo_mkdir_recurs(ALTERNATE_NOT_FOUND_FOLDER, mode)); | |
386 | must_pass(write_file(ALTERNATE_NOT_FOUND_FOLDER "/" DOT_GIT, "gitdir: a_repository_that_surely_does_not_exist")); | |
387 | must_fail(git_repository_discover(found_path, sizeof(found_path), ALTERNATE_MALFORMED_FOLDER1, 0, ceiling_dirs)); | |
388 | must_fail(git_repository_discover(found_path, sizeof(found_path), ALTERNATE_MALFORMED_FOLDER2, 0, ceiling_dirs)); | |
389 | must_fail(git_repository_discover(found_path, sizeof(found_path), ALTERNATE_MALFORMED_FOLDER3, 0, ceiling_dirs)); | |
390 | must_fail(git_repository_discover(found_path, sizeof(found_path), ALTERNATE_NOT_FOUND_FOLDER, 0, ceiling_dirs)); | |
391 | ||
392 | must_pass(append_ceiling_dir(ceiling_dirs, SUB_REPOSITORY_FOLDER)); | |
393 | //this must pass as ceiling_directories cannot predent the current | |
394 | //working directory to be checked | |
395 | must_pass(git_repository_discover(found_path, sizeof(found_path), SUB_REPOSITORY_FOLDER, 0, ceiling_dirs)); | |
396 | must_fail(error = git_repository_discover(found_path, sizeof(found_path), SUB_REPOSITORY_FOLDER_SUB, 0, ceiling_dirs)); | |
397 | must_fail(error = git_repository_discover(found_path, sizeof(found_path), SUB_REPOSITORY_FOLDER_SUB_SUB, 0, ceiling_dirs)); | |
398 | must_fail(error = git_repository_discover(found_path, sizeof(found_path), SUB_REPOSITORY_FOLDER_SUB_SUB_SUB, 0, ceiling_dirs)); | |
399 | ||
400 | //.gitfile redirection should not be affected by ceiling directories | |
401 | must_pass(ensure_repository_discover(REPOSITORY_ALTERNATE_FOLDER, ceiling_dirs, sub_repository_path)); | |
402 | must_pass(ensure_repository_discover(REPOSITORY_ALTERNATE_FOLDER_SUB, ceiling_dirs, sub_repository_path)); | |
403 | must_pass(ensure_repository_discover(REPOSITORY_ALTERNATE_FOLDER_SUB_SUB, ceiling_dirs, sub_repository_path)); | |
404 | must_pass(ensure_repository_discover(REPOSITORY_ALTERNATE_FOLDER_SUB_SUB_SUB, ceiling_dirs, repository_path)); | |
405 | ||
406 | rmdir_recurs(DISCOVER_FOLDER); | |
407 | END_TEST | |
408 | ||
3dccfed1 VM |
409 | BEGIN_SUITE(repository) |
410 | ADD_TEST(odb0); | |
411 | ADD_TEST(odb1); | |
412 | ADD_TEST(init0); | |
413 | ADD_TEST(init1); | |
677a3c07 | 414 | ADD_TEST(init2); |
2ce44b67 | 415 | ADD_TEST(open0); |
a8375f53 | 416 | ADD_TEST(open1); |
ba1bdf86 | 417 | ADD_TEST(open2); |
41233c40 | 418 | ADD_TEST(empty0); |
76e9e3b7 | 419 | ADD_TEST(discover0); |
3dccfed1 | 420 | END_SUITE |
d4b5a4e2 | 421 |