diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index 4ca339806..ab974224a 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -122,6 +122,43 @@ jobs: SKIP_SSH_TESTS: true SKIP_NEGOTIATE_TESTS: true + # All builds: reftable + - name: "Linux (Noble, GCC, OpenSSL, libssh2, reftable)" + id: noble-gcc-openssl-reftable + os: ubuntu-latest + container: + name: noble + env: + CC: gcc + CLAR_REF_FORMAT: reftable + CMAKE_GENERATOR: Ninja + CMAKE_OPTIONS: -DUSE_HTTPS=OpenSSL -DREGEX_BACKEND=builtin -DDEPRECATE_HARD=ON -DDEBUG_LEAK_CHECKER=valgrind -DUSE_GSSAPI=ON -DUSE_SSH=libssh2 -DDEBUG_STRICT_ALLOC=ON -DDEBUG_STRICT_OPEN=ON + - name: "macOS (reftable)" + id: macos-reftable + os: macos-14 + setup-script: osx + env: + CC: clang + CLAR_REF_FORMAT: reftable + CMAKE_OPTIONS: -DREGEX_BACKEND=regcomp_l -DDEPRECATE_HARD=ON -DDEBUG_LEAK_CHECKER=leaks -DUSE_GSSAPI=ON + CMAKE_GENERATOR: Ninja + PKG_CONFIG_PATH: /usr/local/opt/openssl/lib/pkgconfig + SKIP_SSH_TESTS: true + SKIP_NEGOTIATE_TESTS: true + - name: "Windows (amd64, Visual Studio, Schannel, reftable)" + id: windows-amd64-vs-reftable + os: windows-2022 + setup-script: win32 + env: + ARCH: amd64 + CLAR_REF_FORMAT: reftable + CMAKE_GENERATOR: Visual Studio 17 2022 + CMAKE_OPTIONS: -A x64 -DDEBUG_LEAK_CHECKER=win32 -DDEPRECATE_HARD=ON -DUSE_HTTPS=Schannel -DUSE_SSH=ON -DCMAKE_PREFIX_PATH=D:\Temp\libssh2 + BUILD_PATH: C:\Windows\system32;C:\Windows;C:\Windows\System32\Wbem;C:\Program Files (x86)\CMake\bin;D:\Temp\libssh2\bin + BUILD_TEMP: D:\Temp + SKIP_SSH_TESTS: true + SKIP_NEGOTIATE_TESTS: true + # All builds: sanitizers - name: "Sanitizer (Memory)" id: sanitizer-memory diff --git a/deps/clar/clar_libgit2.c b/deps/clar/clar_libgit2.c index afea57f25..de3cab5c0 100644 --- a/deps/clar/clar_libgit2.c +++ b/deps/clar/clar_libgit2.c @@ -172,13 +172,42 @@ static git_repository *_cl_repo = NULL; git_repository *cl_git_sandbox_init(const char *sandbox) { - /* Get the name of the sandbox folder which will be created */ - const char *basename = cl_fixture_basename(sandbox); + const char *basename; + char *ref_format; - /* Copy the whole sandbox folder from our fixtures to our test sandbox - * area. After this it can be accessed with `./sandbox` - */ - cl_fixture_sandbox(sandbox); + /* Get the name of the sandbox folder which will be created */ + basename = cl_fixture_basename(sandbox); + + ref_format = cl_getenv("CLAR_REF_FORMAT"); + if (!ref_format || !strcmp(ref_format, "files")) { + /* + * Copy the whole sandbox folder from our fixtures to our + * test sandbox area. After this it can be accessed with + * `./sandbox` + */ + cl_fixture_sandbox(sandbox); + } else if (!strcmp(ref_format, "reftable")) { + struct git_str reftable_sandbox = GIT_STR_INIT; + + cl_git_pass(git_str_joinpath(&reftable_sandbox, "reftable", sandbox)); + if (!git_fs_path_isdir(cl_fixture(reftable_sandbox.ptr))) { + git_str_dispose(&reftable_sandbox); + _cl_sandbox = NULL; + _cl_repo = NULL; + cl_fail("no seed for reftable repository"); + } + + /* + * Copy over the sandbox and rename it so that the basename + * matches the originally requested basename. + */ + cl_fixture_sandbox(reftable_sandbox.ptr); + git_str_dispose(&reftable_sandbox); + } else { + cl_fail("Unexpected ref format"); + } + + git__free(ref_format); _cl_sandbox = sandbox; cl_git_pass(p_chdir(basename)); diff --git a/deps/reftable/CMakeLists.txt b/deps/reftable/CMakeLists.txt new file mode 100644 index 000000000..e096e71e2 --- /dev/null +++ b/deps/reftable/CMakeLists.txt @@ -0,0 +1,29 @@ +add_library(reftable OBJECT ${SRC_REFTABLE}) + +disable_warnings(implicit-fallthrough) + +file(GLOB SRC_REFTABLE "*.c" "*.h") +list(SORT SRC_REFTABLE) + +set_property(TARGET reftable PROPERTY C_STANDARD 99) +target_sources(reftable PRIVATE ${SRC_REFTABLE}) +target_include_directories(reftable PRIVATE + include + "${PROJECT_BINARY_DIR}/src/util" + "${PROJECT_BINARY_DIR}/include" + "${PROJECT_SOURCE_DIR}/src/util" + "${PROJECT_SOURCE_DIR}/include" + ${LIBGIT2_DEPENDENCY_INCLUDES} + ${LIBGIT2_SYSTEM_INCLUDES} +) + +# The reftable library is not warning-free, so we disable turning warnings into +# errors. +if(MSVC) + set_source_files_properties(block.c PROPERTIES COMPILE_FLAGS -WX-) + set_source_files_properties(blocksource.c PROPERTIES COMPILE_FLAGS -WX-) + set_source_files_properties(record.c PROPERTIES COMPILE_FLAGS -WX-) + set_source_files_properties(stack.c PROPERTIES COMPILE_FLAGS -WX-) + set_source_files_properties(table.c PROPERTIES COMPILE_FLAGS -WX-) + set_source_files_properties(writer.c PROPERTIES COMPILE_FLAGS -WX-) +endif() diff --git a/deps/reftable/LICENSE b/deps/reftable/LICENSE new file mode 100644 index 000000000..402e0f935 --- /dev/null +++ b/deps/reftable/LICENSE @@ -0,0 +1,31 @@ +BSD License + +Copyright (c) 2020, Google LLC +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + +* Redistributions of source code must retain the above copyright notice, +this list of conditions and the following disclaimer. + +* Redistributions in binary form must reproduce the above copyright +notice, this list of conditions and the following disclaimer in the +documentation and/or other materials provided with the distribution. + +* Neither the name of Google LLC nor the names of its contributors may +be used to endorse or promote products derived from this software +without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/deps/reftable/basics.c b/deps/reftable/basics.c new file mode 100644 index 000000000..e969927b6 --- /dev/null +++ b/deps/reftable/basics.c @@ -0,0 +1,278 @@ +/* + * Copyright 2020 Google LLC + * + * Use of this source code is governed by a BSD-style + * license that can be found in the LICENSE file or at + * https://developers.google.com/open-source/licenses/bsd + */ + +#define REFTABLE_ALLOW_BANNED_ALLOCATORS +#include "basics.h" +#include "reftable-basics.h" +#include "reftable-error.h" + +static void *(*reftable_malloc_ptr)(size_t sz); +static void *(*reftable_realloc_ptr)(void *, size_t); +static void (*reftable_free_ptr)(void *); + +void *reftable_malloc(size_t sz) +{ + if (!sz) + return NULL; + if (reftable_malloc_ptr) + return (*reftable_malloc_ptr)(sz); + return malloc(sz); +} + +void *reftable_realloc(void *p, size_t sz) +{ + if (!sz) { + reftable_free(p); + return NULL; + } + + if (reftable_realloc_ptr) + return (*reftable_realloc_ptr)(p, sz); + return realloc(p, sz); +} + +void reftable_free(void *p) +{ + if (reftable_free_ptr) + reftable_free_ptr(p); + else + free(p); +} + +void *reftable_calloc(size_t nelem, size_t elsize) +{ + void *p; + + if (nelem && elsize > SIZE_MAX / nelem) + return NULL; + + p = reftable_malloc(nelem * elsize); + if (!p) + return NULL; + + memset(p, 0, nelem * elsize); + return p; +} + +char *reftable_strdup(const char *str) +{ + size_t len = strlen(str); + char *result = reftable_malloc(len + 1); + if (!result) + return NULL; + memcpy(result, str, len + 1); + return result; +} + +void reftable_set_alloc(void *(*malloc)(size_t), + void *(*realloc)(void *, size_t), void (*free)(void *)) +{ + reftable_malloc_ptr = malloc; + reftable_realloc_ptr = realloc; + reftable_free_ptr = free; +} + +void reftable_buf_init(struct reftable_buf *buf) +{ + struct reftable_buf empty = REFTABLE_BUF_INIT; + *buf = empty; +} + +void reftable_buf_release(struct reftable_buf *buf) +{ + reftable_free(buf->buf); + reftable_buf_init(buf); +} + +void reftable_buf_reset(struct reftable_buf *buf) +{ + if (buf->alloc) { + buf->len = 0; + buf->buf[0] = '\0'; + } +} + +int reftable_buf_setlen(struct reftable_buf *buf, size_t len) +{ + if (len > buf->len) + return -1; + if (len == buf->len) + return 0; + buf->buf[len] = '\0'; + buf->len = len; + return 0; +} + +int reftable_buf_cmp(const struct reftable_buf *a, const struct reftable_buf *b) +{ + size_t len = a->len < b->len ? a->len : b->len; + if (len) { + int cmp = memcmp(a->buf, b->buf, len); + if (cmp) + return cmp; + } + return a->len < b->len ? -1 : a->len != b->len; +} + +int reftable_buf_add(struct reftable_buf *buf, const void *data, size_t len) +{ + size_t newlen = buf->len + len; + + if (newlen + 1 > buf->alloc) { + if (REFTABLE_ALLOC_GROW(buf->buf, newlen + 1, buf->alloc)) + return REFTABLE_OUT_OF_MEMORY_ERROR; + } + + memcpy(buf->buf + buf->len, data, len); + buf->buf[newlen] = '\0'; + buf->len = newlen; + + return 0; +} + +int reftable_buf_addstr(struct reftable_buf *buf, const char *s) +{ + return reftable_buf_add(buf, s, strlen(s)); +} + +char *reftable_buf_detach(struct reftable_buf *buf) +{ + char *result = buf->buf; + reftable_buf_init(buf); + return result; +} + +size_t binsearch(size_t sz, int (*f)(size_t k, void *args), void *args) +{ + size_t lo = 0; + size_t hi = sz; + + /* Invariants: + * + * (hi == sz) || f(hi) == true + * (lo == 0 && f(0) == true) || fi(lo) == false + */ + while (hi - lo > 1) { + size_t mid = lo + (hi - lo) / 2; + int ret = f(mid, args); + if (ret < 0) + return sz; + + if (ret > 0) + hi = mid; + else + lo = mid; + } + + if (lo) + return hi; + + return f(0, args) ? 0 : 1; +} + +void free_names(char **a) +{ + char **p; + if (!a) { + return; + } + for (p = a; *p; p++) { + reftable_free(*p); + } + reftable_free(a); +} + +size_t names_length(const char **names) +{ + const char **p = names; + while (*p) + p++; + return p - names; +} + +int parse_names(char *buf, int size, char ***out) +{ + char **names = NULL; + size_t names_cap = 0; + size_t names_len = 0; + char *p = buf; + char *end = buf + size; + int err = 0; + + while (p < end) { + char *next = strchr(p, '\n'); + if (!next) { + err = REFTABLE_FORMAT_ERROR; + goto done; + } else if (next < end) { + *next = '\0'; + } else { + next = end; + } + + if (p < next) { + if (REFTABLE_ALLOC_GROW(names, names_len + 1, + names_cap)) { + err = REFTABLE_OUT_OF_MEMORY_ERROR; + goto done; + } + + names[names_len] = reftable_strdup(p); + if (!names[names_len++]) { + err = REFTABLE_OUT_OF_MEMORY_ERROR; + goto done; + } + } + p = next + 1; + } + + if (REFTABLE_ALLOC_GROW(names, names_len + 1, names_cap)) { + err = REFTABLE_OUT_OF_MEMORY_ERROR; + goto done; + } + names[names_len] = NULL; + + *out = names; + return 0; +done: + for (size_t i = 0; i < names_len; i++) + reftable_free(names[i]); + reftable_free(names); + return err; +} + +int names_equal(const char **a, const char **b) +{ + size_t i = 0; + for (; a[i] && b[i]; i++) + if (strcmp(a[i], b[i])) + return 0; + return a[i] == b[i]; +} + +size_t common_prefix_size(struct reftable_buf *a, struct reftable_buf *b) +{ + size_t p = 0; + for (; p < a->len && p < b->len; p++) + if (a->buf[p] != b->buf[p]) + break; + return p; +} + +uint32_t hash_size(enum reftable_hash id) +{ + if (!id) + return REFTABLE_HASH_SIZE_SHA1; + switch (id) { + case REFTABLE_HASH_SHA1: + return REFTABLE_HASH_SIZE_SHA1; + case REFTABLE_HASH_SHA256: + return REFTABLE_HASH_SIZE_SHA256; + } + abort(); +} diff --git a/deps/reftable/basics.h b/deps/reftable/basics.h new file mode 100644 index 000000000..e4b83b2b0 --- /dev/null +++ b/deps/reftable/basics.h @@ -0,0 +1,291 @@ +/* + * Copyright 2020 Google LLC + * + * Use of this source code is governed by a BSD-style + * license that can be found in the LICENSE file or at + * https://developers.google.com/open-source/licenses/bsd + */ + +#ifndef BASICS_H +#define BASICS_H + +/* + * miscellaneous utilities that are not provided by Git. + */ + +#include "system.h" +#include "reftable-basics.h" + +#ifdef __GNUC__ +#define REFTABLE_UNUSED __attribute__((__unused__)) +#else +#define REFTABLE_UNUSED +#endif + +/* + * Initialize the buffer such that it is ready for use. This is equivalent to + * using REFTABLE_BUF_INIT for stack-allocated variables. + */ +void reftable_buf_init(struct reftable_buf *buf); + +/* + * Release memory associated with the buffer. The buffer is reinitialized such + * that it can be reused for subsequent operations. + */ +void reftable_buf_release(struct reftable_buf *buf); + +/* + * Reset the buffer such that it is effectively empty, without releasing the + * memory that this structure holds on to. This is equivalent to calling + * `reftable_buf_setlen(buf, 0)`. + */ +void reftable_buf_reset(struct reftable_buf *buf); + +/* + * Trim the buffer to a shorter length by updating the `len` member and writing + * a NUL byte to `buf[len]`. Returns 0 on success, -1 when `len` points outside + * of the array. + */ +int reftable_buf_setlen(struct reftable_buf *buf, size_t len); + +/* + * Lexicographically compare the two buffers. Returns 0 when both buffers have + * the same contents, -1 when `a` is lexicographically smaller than `b`, and 1 + * otherwise. + */ +int reftable_buf_cmp(const struct reftable_buf *a, const struct reftable_buf *b); + +/* + * Append `len` bytes from `data` to the buffer. This function works with + * arbitrary byte sequences, including ones that contain embedded NUL + * characters. As such, we use `void *` as input type. Returns 0 on success, + * REFTABLE_OUT_OF_MEMORY_ERROR on allocation failure. + */ +int reftable_buf_add(struct reftable_buf *buf, const void *data, size_t len); + +/* Equivalent to `reftable_buf_add(buf, s, strlen(s))`. */ +int reftable_buf_addstr(struct reftable_buf *buf, const char *s); + +/* + * Detach the buffer from the structure such that the underlying memory is now + * owned by the caller. The buffer is reinitialized such that it can be reused + * for subsequent operations. + */ +char *reftable_buf_detach(struct reftable_buf *buf); + +/* Bigendian en/decoding of integers */ + +static inline void reftable_put_be16(void *out, uint16_t i) +{ + unsigned char *p = out; + p[0] = (uint8_t)((i >> 8) & 0xff); + p[1] = (uint8_t)((i >> 0) & 0xff); +} + +static inline void reftable_put_be24(void *out, uint32_t i) +{ + unsigned char *p = out; + p[0] = (uint8_t)((i >> 16) & 0xff); + p[1] = (uint8_t)((i >> 8) & 0xff); + p[2] = (uint8_t)((i >> 0) & 0xff); +} + +static inline void reftable_put_be32(void *out, uint32_t i) +{ + unsigned char *p = out; + p[0] = (uint8_t)((i >> 24) & 0xff); + p[1] = (uint8_t)((i >> 16) & 0xff); + p[2] = (uint8_t)((i >> 8) & 0xff); + p[3] = (uint8_t)((i >> 0) & 0xff); +} + +static inline void reftable_put_be64(void *out, uint64_t i) +{ + unsigned char *p = out; + p[0] = (uint8_t)((i >> 56) & 0xff); + p[1] = (uint8_t)((i >> 48) & 0xff); + p[2] = (uint8_t)((i >> 40) & 0xff); + p[3] = (uint8_t)((i >> 32) & 0xff); + p[4] = (uint8_t)((i >> 24) & 0xff); + p[5] = (uint8_t)((i >> 16) & 0xff); + p[6] = (uint8_t)((i >> 8) & 0xff); + p[7] = (uint8_t)((i >> 0) & 0xff); +} + +static inline uint16_t reftable_get_be16(const void *in) +{ + const unsigned char *p = in; + return (uint16_t)(p[0]) << 8 | + (uint16_t)(p[1]) << 0; +} + +static inline uint32_t reftable_get_be24(const void *in) +{ + const unsigned char *p = in; + return (uint32_t)(p[0]) << 16 | + (uint32_t)(p[1]) << 8 | + (uint32_t)(p[2]) << 0; +} + +static inline uint32_t reftable_get_be32(const void *in) +{ + const unsigned char *p = in; + return (uint32_t)(p[0]) << 24 | + (uint32_t)(p[1]) << 16 | + (uint32_t)(p[2]) << 8| + (uint32_t)(p[3]) << 0; +} + +static inline uint64_t reftable_get_be64(const void *in) +{ + const unsigned char *p = in; + return (uint64_t)(p[0]) << 56 | + (uint64_t)(p[1]) << 48 | + (uint64_t)(p[2]) << 40 | + (uint64_t)(p[3]) << 32 | + (uint64_t)(p[4]) << 24 | + (uint64_t)(p[5]) << 16 | + (uint64_t)(p[6]) << 8 | + (uint64_t)(p[7]) << 0; +} + +/* + * find smallest index i in [0, sz) at which `f(i) > 0`, assuming that f is + * ascending. Return sz if `f(i) == 0` for all indices. The search is aborted + * and `sz` is returned in case `f(i) < 0`. + * + * Contrary to bsearch(3), this returns something useful if the argument is not + * found. + */ +size_t binsearch(size_t sz, int (*f)(size_t k, void *args), void *args); + +/* + * Frees a NULL terminated array of malloced strings. The array itself is also + * freed. + */ +void free_names(char **a); + +/* + * Parse a newline separated list of names. `size` is the length of the buffer, + * without terminating '\0'. Empty names are discarded. + * + * Returns 0 on success, a reftable error code on error. + */ +int parse_names(char *buf, int size, char ***out); + +/* compares two NULL-terminated arrays of strings. */ +int names_equal(const char **a, const char **b); + +/* returns the array size of a NULL-terminated array of strings. */ +size_t names_length(const char **names); + +/* Allocation routines; they invoke the functions set through + * reftable_set_alloc() */ +void *reftable_malloc(size_t sz); +void *reftable_realloc(void *p, size_t sz); +void reftable_free(void *p); +void *reftable_calloc(size_t nelem, size_t elsize); +char *reftable_strdup(const char *str); + +static inline int reftable_alloc_size(size_t nelem, size_t elsize, size_t *out) +{ + if (nelem && elsize > SIZE_MAX / nelem) + return -1; + *out = nelem * elsize; + return 0; +} + +#define REFTABLE_ALLOC_ARRAY(x, alloc) do { \ + size_t alloc_size; \ + if (reftable_alloc_size(sizeof(*(x)), (alloc), &alloc_size) < 0) { \ + errno = ENOMEM; \ + (x) = NULL; \ + } else { \ + (x) = reftable_malloc(alloc_size); \ + } \ + } while (0) +#define REFTABLE_CALLOC_ARRAY(x, alloc) (x) = reftable_calloc((alloc), sizeof(*(x))) +#define REFTABLE_REALLOC_ARRAY(x, alloc) do { \ + size_t alloc_size; \ + if (reftable_alloc_size(sizeof(*(x)), (alloc), &alloc_size) < 0) { \ + errno = ENOMEM; \ + (x) = NULL; \ + } else { \ + (x) = reftable_realloc((x), alloc_size); \ + } \ + } while (0) + +static inline void *reftable_alloc_grow(void *p, size_t nelem, size_t elsize, + size_t *allocp) +{ + void *new_p; + size_t alloc = *allocp * 2 + 1, alloc_bytes; + if (alloc < nelem) + alloc = nelem; + if (reftable_alloc_size(elsize, alloc, &alloc_bytes) < 0) { + errno = ENOMEM; + return p; + } + new_p = reftable_realloc(p, alloc_bytes); + if (!new_p) + return p; + *allocp = alloc; + return new_p; +} + +#define REFTABLE_ALLOC_GROW(x, nr, alloc) ( \ + (nr) > (alloc) && ( \ + (x) = reftable_alloc_grow((x), (nr), sizeof(*(x)), &(alloc)), \ + (nr) > (alloc) \ + ) \ +) + +#define REFTABLE_ALLOC_GROW_OR_NULL(x, nr, alloc) do { \ + size_t reftable_alloc_grow_or_null_alloc = alloc; \ + if (REFTABLE_ALLOC_GROW((x), (nr), reftable_alloc_grow_or_null_alloc)) { \ + REFTABLE_FREE_AND_NULL(x); \ + alloc = 0; \ + } else { \ + alloc = reftable_alloc_grow_or_null_alloc; \ + } \ +} while (0) + +#define REFTABLE_FREE_AND_NULL(p) do { reftable_free(p); (p) = NULL; } while (0) + +#ifndef REFTABLE_ALLOW_BANNED_ALLOCATORS +# define REFTABLE_BANNED(func) use_reftable_##func##_instead +# undef malloc +# define malloc(sz) REFTABLE_BANNED(malloc) +# undef realloc +# define realloc(ptr, sz) REFTABLE_BANNED(realloc) +# undef free +# define free(ptr) REFTABLE_BANNED(free) +# undef calloc +# define calloc(nelem, elsize) REFTABLE_BANNED(calloc) +# undef strdup +# define strdup(str) REFTABLE_BANNED(strdup) +#endif + +#define REFTABLE_SWAP(a, b) do { \ + void *_swap_a_ptr = &(a); \ + void *_swap_b_ptr = &(b); \ + unsigned char _swap_buffer[sizeof(a) - 2 * sizeof(a) * (sizeof(a) != sizeof(b))]; \ + memcpy(_swap_buffer, _swap_a_ptr, sizeof(a)); \ + memcpy(_swap_a_ptr, _swap_b_ptr, sizeof(a)); \ + memcpy(_swap_b_ptr, _swap_buffer, sizeof(a)); \ +} while (0) + +/* Find the longest shared prefix size of `a` and `b` */ +size_t common_prefix_size(struct reftable_buf *a, struct reftable_buf *b); + +uint32_t hash_size(enum reftable_hash id); + +/* + * Format IDs that identify the hash function used by a reftable. Note that + * these constants end up on disk and thus mustn't change. The format IDs are + * "sha1" and "s256" in big endian, respectively. + */ +#define REFTABLE_FORMAT_ID_SHA1 ((uint32_t) 0x73686131) +#define REFTABLE_FORMAT_ID_SHA256 ((uint32_t) 0x73323536) + +#endif diff --git a/deps/reftable/block.c b/deps/reftable/block.c new file mode 100644 index 000000000..920b3f448 --- /dev/null +++ b/deps/reftable/block.c @@ -0,0 +1,655 @@ +/* + * Copyright 2020 Google LLC + * + * Use of this source code is governed by a BSD-style + * license that can be found in the LICENSE file or at + * https://developers.google.com/open-source/licenses/bsd + */ + +#include "block.h" + +#include "blocksource.h" +#include "constants.h" +#include "iter.h" +#include "record.h" +#include "reftable-error.h" +#include "system.h" + +size_t header_size(int version) +{ + switch (version) { + case 1: + return 24; + case 2: + return 28; + } + abort(); +} + +size_t footer_size(int version) +{ + switch (version) { + case 1: + return 68; + case 2: + return 72; + } + abort(); +} + +static int block_writer_register_restart(struct block_writer *w, int n, + int is_restart, struct reftable_buf *key) +{ + uint32_t rlen; + int err; + + rlen = w->restart_len; + if (rlen >= MAX_RESTARTS) + is_restart = 0; + + if (is_restart) + rlen++; + if (2 + 3 * rlen + n > w->block_size - w->next) + return REFTABLE_ENTRY_TOO_BIG_ERROR; + if (is_restart) { + REFTABLE_ALLOC_GROW_OR_NULL(w->restarts, w->restart_len + 1, + w->restart_cap); + if (!w->restarts) + return REFTABLE_OUT_OF_MEMORY_ERROR; + w->restarts[w->restart_len++] = w->next; + } + + w->next += n; + + reftable_buf_reset(&w->last_key); + err = reftable_buf_add(&w->last_key, key->buf, key->len); + if (err < 0) + return err; + + w->entries++; + return 0; +} + +int block_writer_init(struct block_writer *bw, uint8_t typ, uint8_t *block, + uint32_t block_size, uint32_t header_off, uint32_t hash_size) +{ + bw->block = block; + bw->hash_size = hash_size; + bw->block_size = block_size; + bw->header_off = header_off; + bw->block[header_off] = typ; + bw->next = header_off + 4; + bw->restart_interval = 16; + bw->entries = 0; + bw->restart_len = 0; + bw->last_key.len = 0; + if (!bw->zstream) { + REFTABLE_CALLOC_ARRAY(bw->zstream, 1); + if (!bw->zstream) + return REFTABLE_OUT_OF_MEMORY_ERROR; + deflateInit(bw->zstream, 9); + } + + return 0; +} + +uint8_t block_writer_type(struct block_writer *bw) +{ + return bw->block[bw->header_off]; +} + +/* + * Adds the reftable_record to the block. Returns 0 on success and + * appropriate error codes on failure. + */ +int block_writer_add(struct block_writer *w, struct reftable_record *rec) +{ + struct reftable_buf empty = REFTABLE_BUF_INIT; + struct reftable_buf last = + w->entries % w->restart_interval == 0 ? empty : w->last_key; + struct string_view out = { + .buf = w->block + w->next, + .len = w->block_size - w->next, + }; + struct string_view start = out; + int is_restart = 0; + int n = 0; + int err; + + err = reftable_record_key(rec, &w->scratch); + if (err < 0) + goto done; + + if (!w->scratch.len) { + err = REFTABLE_API_ERROR; + goto done; + } + + n = reftable_encode_key(&is_restart, out, last, w->scratch, + reftable_record_val_type(rec)); + if (n < 0) { + err = n; + goto done; + } + string_view_consume(&out, n); + + n = reftable_record_encode(rec, out, w->hash_size); + if (n < 0) { + err = n; + goto done; + } + string_view_consume(&out, n); + + err = block_writer_register_restart(w, start.len - out.len, is_restart, + &w->scratch); +done: + return err; +} + +int block_writer_finish(struct block_writer *w) +{ + for (uint32_t i = 0; i < w->restart_len; i++) { + reftable_put_be24(w->block + w->next, w->restarts[i]); + w->next += 3; + } + + reftable_put_be16(w->block + w->next, w->restart_len); + w->next += 2; + reftable_put_be24(w->block + 1 + w->header_off, w->next); + + /* + * Log records are stored zlib-compressed. Note that the compression + * also spans over the restart points we have just written. + */ + if (block_writer_type(w) == REFTABLE_BLOCK_TYPE_LOG) { + int block_header_skip = 4 + w->header_off; + uLongf src_len = w->next - block_header_skip, compressed_len; + int ret; + + ret = deflateReset(w->zstream); + if (ret != Z_OK) + return REFTABLE_ZLIB_ERROR; + + /* + * Precompute the upper bound of how many bytes the compressed + * data may end up with. Combined with `Z_FINISH`, `deflate()` + * is guaranteed to return `Z_STREAM_END`. + */ + compressed_len = deflateBound(w->zstream, src_len); + REFTABLE_ALLOC_GROW_OR_NULL(w->compressed, compressed_len, + w->compressed_cap); + if (!w->compressed) { + ret = REFTABLE_OUT_OF_MEMORY_ERROR; + return ret; + } + + w->zstream->next_out = w->compressed; + w->zstream->avail_out = compressed_len; + w->zstream->next_in = w->block + block_header_skip; + w->zstream->avail_in = src_len; + + /* + * We want to perform all decompression in a single step, which + * is why we can pass Z_FINISH here. As we have precomputed the + * deflated buffer's size via `deflateBound()` this function is + * guaranteed to succeed according to the zlib documentation. + */ + ret = deflate(w->zstream, Z_FINISH); + if (ret != Z_STREAM_END) + return REFTABLE_ZLIB_ERROR; + + /* + * Overwrite the uncompressed data we have already written and + * adjust the `next` pointer to point right after the + * compressed data. + */ + memcpy(w->block + block_header_skip, w->compressed, + w->zstream->total_out); + w->next = w->zstream->total_out + block_header_skip; + } + + return w->next; +} + +static int read_block(struct reftable_block_source *source, + struct reftable_block_data *dest, uint64_t off, + uint32_t sz) +{ + size_t size = block_source_size(source); + block_source_release_data(dest); + if (off >= size) + return 0; + if (off + sz > size) + sz = size - off; + return block_source_read_data(source, dest, off, sz); +} + +int reftable_block_init(struct reftable_block *block, + struct reftable_block_source *source, + uint32_t offset, uint32_t header_size, + uint32_t table_block_size, uint32_t hash_size, + uint8_t want_type) +{ + uint32_t guess_block_size = table_block_size ? + table_block_size : DEFAULT_BLOCK_SIZE; + uint32_t full_block_size = table_block_size; + uint16_t restart_count; + uint32_t restart_off; + uint32_t block_size; + uint8_t block_type; + int err; + + err = read_block(source, &block->block_data, offset, guess_block_size); + if (err < 0) + goto done; + + block_type = block->block_data.data[header_size]; + if (!reftable_is_block_type(block_type)) { + err = REFTABLE_FORMAT_ERROR; + goto done; + } + if (want_type != REFTABLE_BLOCK_TYPE_ANY && block_type != want_type) { + err = 1; + goto done; + } + + block_size = reftable_get_be24(block->block_data.data + header_size + 1); + if (block_size > guess_block_size) { + err = read_block(source, &block->block_data, offset, block_size); + if (err < 0) + goto done; + } + + if (block_type == REFTABLE_BLOCK_TYPE_LOG) { + uint32_t block_header_skip = 4 + header_size; + uLong dst_len = block_size - block_header_skip; + uLong src_len = block->block_data.len - block_header_skip; + + /* Log blocks specify the *uncompressed* size in their header. */ + REFTABLE_ALLOC_GROW_OR_NULL(block->uncompressed_data, block_size, + block->uncompressed_cap); + if (!block->uncompressed_data) { + err = REFTABLE_OUT_OF_MEMORY_ERROR; + goto done; + } + + /* Copy over the block header verbatim. It's not compressed. */ + memcpy(block->uncompressed_data, block->block_data.data, block_header_skip); + + if (!block->zstream) { + REFTABLE_CALLOC_ARRAY(block->zstream, 1); + if (!block->zstream) { + err = REFTABLE_OUT_OF_MEMORY_ERROR; + goto done; + } + + err = inflateInit(block->zstream); + } else { + err = inflateReset(block->zstream); + } + if (err != Z_OK) { + err = REFTABLE_ZLIB_ERROR; + goto done; + } + + block->zstream->next_in = block->block_data.data + block_header_skip; + block->zstream->avail_in = src_len; + block->zstream->next_out = block->uncompressed_data + block_header_skip; + block->zstream->avail_out = dst_len; + + /* + * We know both input as well as output size, and we know that + * the sizes should never be bigger than `uInt_MAX` because + * blocks can at most be 16MB large. We can thus use `Z_FINISH` + * here to instruct zlib to inflate the data in one go, which + * is more efficient than using `Z_NO_FLUSH`. + */ + err = inflate(block->zstream, Z_FINISH); + if (err != Z_STREAM_END) { + err = REFTABLE_ZLIB_ERROR; + goto done; + } + err = 0; + + if (block->zstream->total_out + block_header_skip != block_size) { + err = REFTABLE_FORMAT_ERROR; + goto done; + } + + /* We're done with the input data. */ + block_source_release_data(&block->block_data); + block->block_data.data = block->uncompressed_data; + block->block_data.len = block_size; + full_block_size = src_len + block_header_skip - block->zstream->avail_in; + } else if (full_block_size == 0) { + full_block_size = block_size; + } else if (block_size < full_block_size && block_size < block->block_data.len && + block->block_data.data[block_size] != 0) { + /* If the block is smaller than the full block size, it is + padded (data followed by '\0') or the next block is + unaligned. */ + full_block_size = block_size; + } + + restart_count = reftable_get_be16(block->block_data.data + block_size - 2); + restart_off = block_size - 2 - 3 * restart_count; + + block->block_type = block_type; + block->hash_size = hash_size; + block->restart_off = restart_off; + block->full_block_size = full_block_size; + block->header_off = header_size; + block->restart_count = restart_count; + + err = 0; + +done: + if (err < 0) + reftable_block_release(block); + return err; +} + +void reftable_block_release(struct reftable_block *block) +{ + inflateEnd(block->zstream); + reftable_free(block->zstream); + reftable_free(block->uncompressed_data); + block_source_release_data(&block->block_data); + memset(block, 0, sizeof(*block)); +} + +uint8_t reftable_block_type(const struct reftable_block *b) +{ + return b->block_data.data[b->header_off]; +} + +int reftable_block_first_key(const struct reftable_block *block, struct reftable_buf *key) +{ + int off = block->header_off + 4, n; + struct string_view in = { + .buf = block->block_data.data + off, + .len = block->restart_off - off, + }; + uint8_t extra = 0; + + reftable_buf_reset(key); + + n = reftable_decode_key(key, &extra, in); + if (n < 0) + return n; + if (!key->len) + return REFTABLE_FORMAT_ERROR; + + return 0; +} + +static uint32_t block_restart_offset(const struct reftable_block *b, size_t idx) +{ + return reftable_get_be24(b->block_data.data + b->restart_off + 3 * idx); +} + +void block_iter_init(struct block_iter *it, const struct reftable_block *block) +{ + it->block = block; + block_iter_seek_start(it); +} + +void block_iter_seek_start(struct block_iter *it) +{ + reftable_buf_reset(&it->last_key); + it->next_off = it->block->header_off + 4; +} + +struct restart_needle_less_args { + int error; + struct reftable_buf needle; + const struct reftable_block *block; +}; + +static int restart_needle_less(size_t idx, void *_args) +{ + struct restart_needle_less_args *args = _args; + uint32_t off = block_restart_offset(args->block, idx); + struct string_view in = { + .buf = args->block->block_data.data + off, + .len = args->block->restart_off - off, + }; + uint64_t prefix_len, suffix_len; + uint8_t extra; + int n; + + /* + * Records at restart points are stored without prefix compression, so + * there is no need to fully decode the record key here. This removes + * the need for allocating memory. + */ + n = reftable_decode_keylen(in, &prefix_len, &suffix_len, &extra); + if (n < 0 || prefix_len) { + args->error = 1; + return -1; + } + + string_view_consume(&in, n); + if (suffix_len > in.len) { + args->error = 1; + return -1; + } + + n = memcmp(args->needle.buf, in.buf, + args->needle.len < suffix_len ? args->needle.len : suffix_len); + if (n) + return n < 0; + return args->needle.len < suffix_len; +} + +int block_iter_next(struct block_iter *it, struct reftable_record *rec) +{ + struct string_view in = { + .buf = (unsigned char *) it->block->block_data.data + it->next_off, + .len = it->block->restart_off - it->next_off, + }; + struct string_view start = in; + uint8_t extra = 0; + int n = 0; + + if (it->next_off >= it->block->restart_off) + return 1; + + n = reftable_decode_key(&it->last_key, &extra, in); + if (n < 0) + return -1; + if (!it->last_key.len) + return REFTABLE_FORMAT_ERROR; + + string_view_consume(&in, n); + n = reftable_record_decode(rec, it->last_key, extra, in, it->block->hash_size, + &it->scratch); + if (n < 0) + return -1; + string_view_consume(&in, n); + + it->next_off += start.len - in.len; + return 0; +} + +void block_iter_reset(struct block_iter *it) +{ + reftable_buf_reset(&it->last_key); + it->next_off = 0; + it->block = NULL; +} + +void block_iter_close(struct block_iter *it) +{ + reftable_buf_release(&it->last_key); + reftable_buf_release(&it->scratch); +} + +int block_iter_seek_key(struct block_iter *it, struct reftable_buf *want) +{ + struct restart_needle_less_args args = { + .needle = *want, + .block = it->block, + }; + struct reftable_record rec; + int err = 0; + size_t i; + + /* + * Perform a binary search over the block's restart points, which + * avoids doing a linear scan over the whole block. Like this, we + * identify the section of the block that should contain our key. + * + * Note that we explicitly search for the first restart point _greater_ + * than the sought-after record, not _greater or equal_ to it. In case + * the sought-after record is located directly at the restart point we + * would otherwise start doing the linear search at the preceding + * restart point. While that works alright, we would end up scanning + * too many record. + */ + i = binsearch(it->block->restart_count, &restart_needle_less, &args); + if (args.error) { + err = REFTABLE_FORMAT_ERROR; + goto done; + } + + /* + * Now there are multiple cases: + * + * - `i == 0`: The wanted record is smaller than the record found at + * the first restart point. As the first restart point is the first + * record in the block, our wanted record cannot be located in this + * block at all. We still need to position the iterator so that the + * next call to `block_iter_next()` will yield an end-of-iterator + * signal. + * + * - `i == restart_count`: The wanted record was not found at any of + * the restart points. As there is no restart point at the end of + * the section the record may thus be contained in the last block. + * + * - `i > 0`: The wanted record must be contained in the section + * before the found restart point. We thus do a linear search + * starting from the preceding restart point. + */ + if (i > 0) + it->next_off = block_restart_offset(it->block, i - 1); + else + it->next_off = it->block->header_off + 4; + + err = reftable_record_init(&rec, reftable_block_type(it->block)); + if (err < 0) + goto done; + + /* + * We're looking for the last entry less than the wanted key so that + * the next call to `block_reader_next()` would yield the wanted + * record. We thus don't want to position our iterator at the sought + * after record, but one before. To do so, we have to go one entry too + * far and then back up. + */ + while (1) { + size_t prev_off = it->next_off; + + err = block_iter_next(it, &rec); + if (err < 0) + goto done; + if (err > 0) { + it->next_off = prev_off; + err = 0; + goto done; + } + + err = reftable_record_key(&rec, &it->last_key); + if (err < 0) + goto done; + + /* + * Check whether the current key is greater or equal to the + * sought-after key. In case it is greater we know that the + * record does not exist in the block and can thus abort early. + * In case it is equal to the sought-after key we have found + * the desired record. + * + * Note that we store the next record's key record directly in + * `last_key` without restoring the key of the preceding record + * in case we need to go one record back. This is safe to do as + * `block_iter_next()` would return the ref whose key is equal + * to `last_key` now, and naturally all keys share a prefix + * with themselves. + */ + if (reftable_buf_cmp(&it->last_key, want) >= 0) { + it->next_off = prev_off; + goto done; + } + } + +done: + reftable_record_release(&rec); + return err; +} + +static int block_iter_seek_void(void *it, struct reftable_record *want) +{ + struct reftable_buf buf = REFTABLE_BUF_INIT; + struct block_iter *bi = it; + int err; + + if (bi->block->block_type != want->type) + return REFTABLE_API_ERROR; + + err = reftable_record_key(want, &buf); + if (err < 0) + goto out; + + err = block_iter_seek_key(it, &buf); + if (err < 0) + goto out; + + err = 0; + +out: + reftable_buf_release(&buf); + return err; +} + +static int block_iter_next_void(void *it, struct reftable_record *rec) +{ + return block_iter_next(it, rec); +} + +static void block_iter_close_void(void *it) +{ + block_iter_close(it); +} + +static struct reftable_iterator_vtable block_iter_vtable = { + .seek = &block_iter_seek_void, + .next = &block_iter_next_void, + .close = &block_iter_close_void, +}; + +int reftable_block_init_iterator(const struct reftable_block *b, + struct reftable_iterator *it) +{ + struct block_iter *bi; + + REFTABLE_CALLOC_ARRAY(bi, 1); + block_iter_init(bi, b); + + assert(!it->ops); + it->iter_arg = bi; + it->ops = &block_iter_vtable; + + return 0; +} + +void block_writer_release(struct block_writer *bw) +{ + deflateEnd(bw->zstream); + REFTABLE_FREE_AND_NULL(bw->zstream); + REFTABLE_FREE_AND_NULL(bw->restarts); + REFTABLE_FREE_AND_NULL(bw->compressed); + reftable_buf_release(&bw->scratch); + reftable_buf_release(&bw->last_key); + /* the block is not owned. */ +} diff --git a/deps/reftable/block.h b/deps/reftable/block.h new file mode 100644 index 000000000..d6dfaae33 --- /dev/null +++ b/deps/reftable/block.h @@ -0,0 +1,115 @@ +/* + * Copyright 2020 Google LLC + * + * Use of this source code is governed by a BSD-style + * license that can be found in the LICENSE file or at + * https://developers.google.com/open-source/licenses/bsd + */ + +#ifndef BLOCK_H +#define BLOCK_H + +#include "basics.h" +#include "record.h" +#include "reftable-block.h" +#include "reftable-blocksource.h" + +/* + * Writes reftable blocks. The block_writer is reused across blocks to minimize + * allocation overhead. + */ +struct block_writer { + struct z_stream_s *zstream; + unsigned char *compressed; + size_t compressed_cap; + + uint8_t *block; + uint32_t block_size; + + /* Offset of the global header. Nonzero in the first block only. */ + uint32_t header_off; + + /* How often to restart keys. */ + uint16_t restart_interval; + uint32_t hash_size; + + /* Offset of next uint8_t to write. */ + uint32_t next; + uint32_t *restarts; + uint32_t restart_len; + uint32_t restart_cap; + + struct reftable_buf last_key; + /* Scratch buffer used to avoid allocations. */ + struct reftable_buf scratch; + int entries; +}; + +/* + * initializes the blockwriter to write `typ` entries, using `block` as temporary + * storage. `block` is not owned by the block_writer. */ +int block_writer_init(struct block_writer *bw, uint8_t typ, uint8_t *block, + uint32_t block_size, uint32_t header_off, uint32_t hash_size); + +/* returns the block type (eg. 'r' for ref records. */ +uint8_t block_writer_type(struct block_writer *bw); + +/* Attempts to append the record. Returns 0 on success or error code on failure. */ +int block_writer_add(struct block_writer *w, struct reftable_record *rec); + +/* appends the key restarts, and compress the block if necessary. */ +int block_writer_finish(struct block_writer *w); + +/* clears out internally allocated block_writer members. */ +void block_writer_release(struct block_writer *bw); + +/* Iterator for records contained in a single block. */ +struct block_iter { + /* offset within the block of the next entry to read. */ + uint32_t next_off; + const struct reftable_block *block; + + /* key for last entry we read. */ + struct reftable_buf last_key; + struct reftable_buf scratch; +}; + +#define BLOCK_ITER_INIT { \ + .last_key = REFTABLE_BUF_INIT, \ + .scratch = REFTABLE_BUF_INIT, \ +} + +/* + * Initialize the block iterator with the given block. The iterator will be + * positioned at the first record contained in the block. The block must remain + * valid until the end of the iterator's lifetime. It is valid to re-initialize + * iterators multiple times. + */ +void block_iter_init(struct block_iter *it, const struct reftable_block *block); + +/* Position the initialized iterator at the first record of its block. */ +void block_iter_seek_start(struct block_iter *it); + +/* + * Position the initialized iterator at the desired record key. It is not an + * error in case the record cannot be found. If so, a subsequent call to + * `block_iter_next()` will indicate that the iterator is exhausted. + */ +int block_iter_seek_key(struct block_iter *it, struct reftable_buf *want); + +/* return < 0 for error, 0 for OK, > 0 for EOF. */ +int block_iter_next(struct block_iter *it, struct reftable_record *rec); + +/* Reset the block iterator to pristine state without releasing its memory. */ +void block_iter_reset(struct block_iter *it); + +/* deallocate memory for `it`. The block reader and its block is left intact. */ +void block_iter_close(struct block_iter *it); + +/* size of file header, depending on format version */ +size_t header_size(int version); + +/* size of file footer, depending on format version */ +size_t footer_size(int version); + +#endif diff --git a/deps/reftable/blocksource.c b/deps/reftable/blocksource.c new file mode 100644 index 000000000..7f7441f75 --- /dev/null +++ b/deps/reftable/blocksource.c @@ -0,0 +1,174 @@ +/* + * Copyright 2020 Google LLC + * + * Use of this source code is governed by a BSD-style + * license that can be found in the LICENSE file or at + * https://developers.google.com/open-source/licenses/bsd + */ + +#include "system.h" + +#include "basics.h" +#include "blocksource.h" +#include "reftable-blocksource.h" +#include "reftable-error.h" + +void block_source_release_data(struct reftable_block_data *data) +{ + struct reftable_block_source source = data->source; + if (data && source.ops) + source.ops->release_data(source.arg, data); + data->data = NULL; + data->len = 0; + data->source.ops = NULL; + data->source.arg = NULL; +} + +void block_source_close(struct reftable_block_source *source) +{ + if (!source->ops) { + return; + } + + source->ops->close(source->arg); + source->ops = NULL; +} + +ssize_t block_source_read_data(struct reftable_block_source *source, + struct reftable_block_data *dest, uint64_t off, + uint32_t size) +{ + ssize_t result = source->ops->read_data(source->arg, dest, off, size); + dest->source = *source; + return result; +} + +uint64_t block_source_size(struct reftable_block_source *source) +{ + return source->ops->size(source->arg); +} + +static void reftable_buf_release_data(void *b REFTABLE_UNUSED, struct reftable_block_data *dest) +{ + if (dest->len) + memset(dest->data, 0xff, dest->len); + reftable_free(dest->data); +} + +static void reftable_buf_close(void *b REFTABLE_UNUSED) +{ +} + +static ssize_t reftable_buf_read_data(void *v, struct reftable_block_data *dest, + uint64_t off, uint32_t size) +{ + struct reftable_buf *b = v; + assert(off + size <= b->len); + REFTABLE_CALLOC_ARRAY(dest->data, size); + if (!dest->data) + return -1; + memcpy(dest->data, b->buf + off, size); + dest->len = size; + return size; +} + +static uint64_t reftable_buf_size(void *b) +{ + return ((struct reftable_buf *)b)->len; +} + +static struct reftable_block_source_vtable reftable_buf_vtable = { + .size = &reftable_buf_size, + .read_data = &reftable_buf_read_data, + .release_data = &reftable_buf_release_data, + .close = &reftable_buf_close, +}; + +void block_source_from_buf(struct reftable_block_source *bs, + struct reftable_buf *buf) +{ + assert(!bs->ops); + bs->ops = &reftable_buf_vtable; + bs->arg = buf; +} + +struct file_block_source { + struct reftable_mmap mmap; +}; + +static uint64_t file_size(void *b) +{ + return ((struct file_block_source *)b)->mmap.size; +} + +static void file_release_data(void *b REFTABLE_UNUSED, struct reftable_block_data *dest REFTABLE_UNUSED) +{ +} + +static void file_close(void *v) +{ + struct file_block_source *b = v; + reftable_munmap(&b->mmap); + reftable_free(b); +} + +static ssize_t file_read_data(void *v, struct reftable_block_data *dest, uint64_t off, + uint32_t size) +{ + struct file_block_source *b = v; + assert(off + size <= b->mmap.size); + dest->data = (unsigned char *) b->mmap.data + off; + dest->len = size; + return size; +} + +static struct reftable_block_source_vtable file_vtable = { + .size = &file_size, + .read_data = &file_read_data, + .release_data = &file_release_data, + .close = &file_close, +}; + +int reftable_block_source_from_file(struct reftable_block_source *bs, + const char *name) +{ + struct file_block_source *p = NULL; + struct stat st; + int fd, err; + + fd = open(name, O_RDONLY); + if (fd < 0) { + if (errno == ENOENT) + return REFTABLE_NOT_EXIST_ERROR; + err = -1; + goto out; + } + + if (fstat(fd, &st) < 0) { + err = REFTABLE_IO_ERROR; + goto out; + } + + REFTABLE_CALLOC_ARRAY(p, 1); + if (!p) { + err = REFTABLE_OUT_OF_MEMORY_ERROR; + goto out; + } + + err = reftable_mmap(&p->mmap, fd, st.st_size); + if (err < 0) + goto out; + + assert(!bs->ops); + bs->ops = &file_vtable; + bs->arg = p; + + err = 0; + +out: + if (fd >= 0) + close(fd); + if (err < 0) + reftable_free(p); + return err; +} diff --git a/deps/reftable/blocksource.h b/deps/reftable/blocksource.h new file mode 100644 index 000000000..a110e0595 --- /dev/null +++ b/deps/reftable/blocksource.h @@ -0,0 +1,46 @@ +/* + * Copyright 2020 Google LLC + * + * Use of this source code is governed by a BSD-style + * license that can be found in the LICENSE file or at + * https://developers.google.com/open-source/licenses/bsd + */ + +#ifndef BLOCKSOURCE_H +#define BLOCKSOURCE_H + +#include "system.h" + +struct reftable_block_source; +struct reftable_block_data; +struct reftable_buf; + +/* + * Close the block source and the underlying resource. This is a no-op in case + * the block source is zero-initialized. + */ +void block_source_close(struct reftable_block_source *source); + +/* + * Read a block of length `size` from the source at the given `off`. + */ +ssize_t block_source_read_data(struct reftable_block_source *source, + struct reftable_block_data *dest, uint64_t off, + uint32_t size); + +/* + * Return the total length of the underlying resource. + */ +uint64_t block_source_size(struct reftable_block_source *source); + +/* + * Return a block to its original source, releasing any resources associated + * with it. + */ +void block_source_release_data(struct reftable_block_data *data); + +/* Create an in-memory block source for reading reftables. */ +void block_source_from_buf(struct reftable_block_source *bs, + struct reftable_buf *buf); + +#endif diff --git a/deps/reftable/constants.h b/deps/reftable/constants.h new file mode 100644 index 000000000..e3b1aaa51 --- /dev/null +++ b/deps/reftable/constants.h @@ -0,0 +1,18 @@ +/* + * Copyright 2020 Google LLC + * + * Use of this source code is governed by a BSD-style + * license that can be found in the LICENSE file or at + * https://developers.google.com/open-source/licenses/bsd + */ + +#ifndef CONSTANTS_H +#define CONSTANTS_H + +#include "reftable-constants.h" + +#define MAX_RESTARTS ((1 << 16) - 1) +#define DEFAULT_BLOCK_SIZE 4096 +#define DEFAULT_GEOMETRIC_FACTOR 2 + +#endif diff --git a/deps/reftable/error.c b/deps/reftable/error.c new file mode 100644 index 000000000..c7cab2dbc --- /dev/null +++ b/deps/reftable/error.c @@ -0,0 +1,46 @@ +/* + * Copyright 2020 Google LLC + * + * Use of this source code is governed by a BSD-style + * license that can be found in the LICENSE file or at + * https://developers.google.com/open-source/licenses/bsd + */ + +#include "system.h" +#include "reftable-error.h" + +#include + +const char *reftable_error_str(int err) +{ + static char buf[250]; + switch (err) { + case REFTABLE_IO_ERROR: + return "I/O error"; + case REFTABLE_FORMAT_ERROR: + return "corrupt reftable file"; + case REFTABLE_NOT_EXIST_ERROR: + return "file does not exist"; + case REFTABLE_LOCK_ERROR: + return "data is locked"; + case REFTABLE_API_ERROR: + return "misuse of the reftable API"; + case REFTABLE_ZLIB_ERROR: + return "zlib failure"; + case REFTABLE_EMPTY_TABLE_ERROR: + return "wrote empty table"; + case REFTABLE_REFNAME_ERROR: + return "invalid refname"; + case REFTABLE_ENTRY_TOO_BIG_ERROR: + return "entry too large"; + case REFTABLE_OUTDATED_ERROR: + return "data concurrently modified"; + case REFTABLE_OUT_OF_MEMORY_ERROR: + return "out of memory"; + case -1: + return "general error"; + default: + snprintf(buf, sizeof(buf), "unknown error code %d", err); + return buf; + } +} diff --git a/deps/reftable/fsck.c b/deps/reftable/fsck.c new file mode 100644 index 000000000..8e73fc83f --- /dev/null +++ b/deps/reftable/fsck.c @@ -0,0 +1,100 @@ +#include "basics.h" +#include "reftable-fsck.h" +#include "reftable-table.h" +#include "stack.h" + +static bool table_has_valid_name(const char *name) +{ + const char *ptr = name; + char *endptr; + + /* strtoull doesn't set errno on success */ + errno = 0; + + strtoull(ptr, &endptr, 16); + if (errno) + return false; + ptr = endptr; + + if (*ptr != '-') + return false; + ptr++; + + strtoull(ptr, &endptr, 16); + if (errno) + return false; + ptr = endptr; + + if (*ptr != '-') + return false; + ptr++; + + strtoul(ptr, &endptr, 16); + if (errno) + return false; + ptr = endptr; + + if (strcmp(ptr, ".ref") && strcmp(ptr, ".log")) + return false; + + return true; +} + +typedef int (*table_check_fn)(struct reftable_table *table, + reftable_fsck_report_fn report_fn, + void *cb_data); + +static int table_check_name(struct reftable_table *table, + reftable_fsck_report_fn report_fn, + void *cb_data) +{ + if (!table_has_valid_name(table->name)) { + struct reftable_fsck_info info; + + info.error = REFTABLE_FSCK_ERROR_TABLE_NAME; + info.msg = "invalid reftable table name"; + info.path = table->name; + + return report_fn(&info, cb_data); + } + + return 0; +} + +static int table_checks(struct reftable_table *table, + reftable_fsck_report_fn report_fn, + reftable_fsck_verbose_fn verbose_fn REFTABLE_UNUSED, + void *cb_data) +{ + table_check_fn table_check_fns[] = { + table_check_name, + NULL, + }; + int err = 0; + + for (size_t i = 0; table_check_fns[i]; i++) + err |= table_check_fns[i](table, report_fn, cb_data); + + return err; +} + +int reftable_fsck_check(struct reftable_stack *stack, + reftable_fsck_report_fn report_fn, + reftable_fsck_verbose_fn verbose_fn, + void *cb_data) +{ + struct reftable_buf msg = REFTABLE_BUF_INIT; + int err = 0; + + for (size_t i = 0; i < stack->tables_len; i++) { + reftable_buf_reset(&msg); + reftable_buf_addstr(&msg, "Checking table: "); + reftable_buf_addstr(&msg, stack->tables[i]->name); + verbose_fn(msg.buf, cb_data); + + err |= table_checks(stack->tables[i], report_fn, verbose_fn, cb_data); + } + + reftable_buf_release(&msg); + return err; +} diff --git a/deps/reftable/iter.c b/deps/reftable/iter.c new file mode 100644 index 000000000..2ecc52b33 --- /dev/null +++ b/deps/reftable/iter.c @@ -0,0 +1,302 @@ +/* + * Copyright 2020 Google LLC + * + * Use of this source code is governed by a BSD-style + * license that can be found in the LICENSE file or at + * https://developers.google.com/open-source/licenses/bsd + */ + +#include "iter.h" + +#include "system.h" + +#include "block.h" +#include "blocksource.h" +#include "constants.h" +#include "reftable-error.h" +#include "table.h" + +int iterator_seek(struct reftable_iterator *it, struct reftable_record *want) +{ + return it->ops->seek(it->iter_arg, want); +} + +int iterator_next(struct reftable_iterator *it, struct reftable_record *rec) +{ + return it->ops->next(it->iter_arg, rec); +} + +static int empty_iterator_seek(void *arg REFTABLE_UNUSED, struct reftable_record *want REFTABLE_UNUSED) +{ + return 0; +} + +static int empty_iterator_next(void *arg REFTABLE_UNUSED, struct reftable_record *rec REFTABLE_UNUSED) +{ + return 1; +} + +static void empty_iterator_close(void *arg REFTABLE_UNUSED) +{ +} + +static struct reftable_iterator_vtable empty_vtable = { + .seek = &empty_iterator_seek, + .next = &empty_iterator_next, + .close = &empty_iterator_close, +}; + +void iterator_set_empty(struct reftable_iterator *it) +{ + assert(!it->ops); + it->iter_arg = NULL; + it->ops = &empty_vtable; +} + +static void filtering_ref_iterator_close(void *iter_arg) +{ + struct filtering_ref_iterator *fri = iter_arg; + reftable_buf_release(&fri->oid); + reftable_iterator_destroy(&fri->it); +} + +static int filtering_ref_iterator_seek(void *iter_arg, + struct reftable_record *want) +{ + struct filtering_ref_iterator *fri = iter_arg; + return iterator_seek(&fri->it, want); +} + +static int filtering_ref_iterator_next(void *iter_arg, + struct reftable_record *rec) +{ + struct filtering_ref_iterator *fri = iter_arg; + struct reftable_ref_record *ref = &rec->u.ref; + int err = 0; + while (1) { + err = reftable_iterator_next_ref(&fri->it, ref); + if (err != 0) { + break; + } + + if (ref->value_type == REFTABLE_REF_VAL2 && + (!memcmp(fri->oid.buf, ref->value.val2.target_value, + fri->oid.len) || + !memcmp(fri->oid.buf, ref->value.val2.value, + fri->oid.len))) + return 0; + + if (ref->value_type == REFTABLE_REF_VAL1 && + !memcmp(fri->oid.buf, ref->value.val1, fri->oid.len)) { + return 0; + } + } + + reftable_ref_record_release(ref); + return err; +} + +static struct reftable_iterator_vtable filtering_ref_iterator_vtable = { + .seek = &filtering_ref_iterator_seek, + .next = &filtering_ref_iterator_next, + .close = &filtering_ref_iterator_close, +}; + +void iterator_from_filtering_ref_iterator(struct reftable_iterator *it, + struct filtering_ref_iterator *fri) +{ + assert(!it->ops); + it->iter_arg = fri; + it->ops = &filtering_ref_iterator_vtable; +} + +static void indexed_table_ref_iter_close(void *p) +{ + struct indexed_table_ref_iter *it = p; + block_iter_close(&it->cur); + block_source_release_data(&it->block.block_data); + reftable_free(it->offsets); + reftable_buf_release(&it->oid); +} + +static int indexed_table_ref_iter_next_block(struct indexed_table_ref_iter *it) +{ + uint64_t off; + int err = 0; + if (it->offset_idx == it->offset_len) { + it->is_finished = 1; + return 1; + } + + block_source_release_data(&it->block.block_data); + + off = it->offsets[it->offset_idx++]; + err = table_init_block(it->table, &it->block, off, REFTABLE_BLOCK_TYPE_REF); + if (err < 0) { + return err; + } + if (err > 0) { + /* indexed block does not exist. */ + return REFTABLE_FORMAT_ERROR; + } + block_iter_init(&it->cur, &it->block); + return 0; +} + +static int indexed_table_ref_iter_seek(void *p REFTABLE_UNUSED, + struct reftable_record *want REFTABLE_UNUSED) +{ + return REFTABLE_API_ERROR; +} + +static int indexed_table_ref_iter_next(void *p, struct reftable_record *rec) +{ + struct indexed_table_ref_iter *it = p; + struct reftable_ref_record *ref = &rec->u.ref; + + while (1) { + int err = block_iter_next(&it->cur, rec); + if (err < 0) { + return err; + } + + if (err > 0) { + err = indexed_table_ref_iter_next_block(it); + if (err < 0) { + return err; + } + + if (it->is_finished) { + return 1; + } + continue; + } + /* BUG */ + if (!memcmp(it->oid.buf, ref->value.val2.target_value, + it->oid.len) || + !memcmp(it->oid.buf, ref->value.val2.value, it->oid.len)) { + return 0; + } + } +} + +int indexed_table_ref_iter_new(struct indexed_table_ref_iter **dest, + struct reftable_table *t, uint8_t *oid, + int oid_len, uint64_t *offsets, int offset_len) +{ + struct indexed_table_ref_iter empty = INDEXED_TABLE_REF_ITER_INIT; + struct indexed_table_ref_iter *itr; + int err = 0; + + itr = reftable_calloc(1, sizeof(*itr)); + if (!itr) { + err = REFTABLE_OUT_OF_MEMORY_ERROR; + goto out; + } + + *itr = empty; + itr->table = t; + + err = reftable_buf_add(&itr->oid, oid, oid_len); + if (err < 0) + goto out; + + itr->offsets = offsets; + itr->offset_len = offset_len; + + err = indexed_table_ref_iter_next_block(itr); + if (err < 0) + goto out; + + *dest = itr; + err = 0; + +out: + if (err < 0) { + *dest = NULL; + reftable_free(itr); + } + return err; +} + +static struct reftable_iterator_vtable indexed_table_ref_iter_vtable = { + .seek = &indexed_table_ref_iter_seek, + .next = &indexed_table_ref_iter_next, + .close = &indexed_table_ref_iter_close, +}; + +void iterator_from_indexed_table_ref_iter(struct reftable_iterator *it, + struct indexed_table_ref_iter *itr) +{ + assert(!it->ops); + it->iter_arg = itr; + it->ops = &indexed_table_ref_iter_vtable; +} + +void reftable_iterator_destroy(struct reftable_iterator *it) +{ + if (!it->ops) + return; + it->ops->close(it->iter_arg); + it->ops = NULL; + REFTABLE_FREE_AND_NULL(it->iter_arg); +} + +int reftable_iterator_seek_ref(struct reftable_iterator *it, + const char *name) +{ + struct reftable_record want = { + .type = REFTABLE_BLOCK_TYPE_REF, + .u.ref = { + .refname = (char *)name, + }, + }; + return it->ops->seek(it->iter_arg, &want); +} + +int reftable_iterator_next_ref(struct reftable_iterator *it, + struct reftable_ref_record *ref) +{ + struct reftable_record rec = { + .type = REFTABLE_BLOCK_TYPE_REF, + .u = { + .ref = *ref + }, + }; + int err = iterator_next(it, &rec); + *ref = rec.u.ref; + return err; +} + +int reftable_iterator_seek_log_at(struct reftable_iterator *it, + const char *name, uint64_t update_index) +{ + struct reftable_record want = { + .type = REFTABLE_BLOCK_TYPE_LOG, + .u.log = { + .refname = (char *)name, + .update_index = update_index, + }, + }; + return it->ops->seek(it->iter_arg, &want); +} + +int reftable_iterator_seek_log(struct reftable_iterator *it, + const char *name) +{ + return reftable_iterator_seek_log_at(it, name, ~((uint64_t) 0)); +} + +int reftable_iterator_next_log(struct reftable_iterator *it, + struct reftable_log_record *log) +{ + struct reftable_record rec = { + .type = REFTABLE_BLOCK_TYPE_LOG, + .u = { + .log = *log, + }, + }; + int err = iterator_next(it, &rec); + *log = rec.u.log; + return err; +} diff --git a/deps/reftable/iter.h b/deps/reftable/iter.h new file mode 100644 index 000000000..cc920970a --- /dev/null +++ b/deps/reftable/iter.h @@ -0,0 +1,89 @@ +/* + * Copyright 2020 Google LLC + * + * Use of this source code is governed by a BSD-style + * license that can be found in the LICENSE file or at + * https://developers.google.com/open-source/licenses/bsd + */ + +#ifndef ITER_H +#define ITER_H + +#include "system.h" +#include "block.h" +#include "record.h" + +#include "reftable-iterator.h" + +/* + * The virtual function table for implementing generic reftable iterators. + */ +struct reftable_iterator_vtable { + int (*seek)(void *iter_arg, struct reftable_record *want); + int (*next)(void *iter_arg, struct reftable_record *rec); + void (*close)(void *iter_arg); +}; + +/* + * Position the iterator at the wanted record such that a call to + * `iterator_next()` would return that record, if it exists. + */ +int iterator_seek(struct reftable_iterator *it, struct reftable_record *want); + +/* + * Yield the next record and advance the iterator. Returns <0 on error, 0 when + * a record was yielded, and >0 when the iterator hit an error. + */ +int iterator_next(struct reftable_iterator *it, struct reftable_record *rec); + +/* + * Set up the iterator such that it behaves the same as an iterator with no + * entries. + */ +void iterator_set_empty(struct reftable_iterator *it); + +/* iterator that produces only ref records that point to `oid` */ +struct filtering_ref_iterator { + struct reftable_buf oid; + struct reftable_iterator it; +}; +#define FILTERING_REF_ITERATOR_INIT \ + { \ + .oid = REFTABLE_BUF_INIT \ + } + +void iterator_from_filtering_ref_iterator(struct reftable_iterator *, + struct filtering_ref_iterator *); + +/* iterator that produces only ref records that point to `oid`, + * but using the object index. + */ +struct indexed_table_ref_iter { + struct reftable_table *table; + struct reftable_buf oid; + + /* mutable */ + uint64_t *offsets; + + /* Points to the next offset to read. */ + int offset_idx; + int offset_len; + struct reftable_block block; + struct block_iter cur; + int is_finished; +}; + +#define INDEXED_TABLE_REF_ITER_INIT { \ + .cur = BLOCK_ITER_INIT, \ + .oid = REFTABLE_BUF_INIT, \ +} + +void iterator_from_indexed_table_ref_iter(struct reftable_iterator *it, + struct indexed_table_ref_iter *itr); + +/* Takes ownership of `offsets` */ +int indexed_table_ref_iter_new(struct indexed_table_ref_iter **dest, + struct reftable_table *t, uint8_t *oid, + int oid_len, uint64_t *offsets, int offset_len); + +#endif diff --git a/deps/reftable/merged.c b/deps/reftable/merged.c new file mode 100644 index 000000000..733de0745 --- /dev/null +++ b/deps/reftable/merged.c @@ -0,0 +1,316 @@ +/* + * Copyright 2020 Google LLC + * + * Use of this source code is governed by a BSD-style + * license that can be found in the LICENSE file or at + * https://developers.google.com/open-source/licenses/bsd + */ + +#include "merged.h" + +#include "constants.h" +#include "iter.h" +#include "pq.h" +#include "record.h" +#include "reftable-merged.h" +#include "reftable-error.h" +#include "system.h" +#include "table.h" + +struct merged_subiter { + struct reftable_iterator iter; + struct reftable_record rec; +}; + +struct merged_iter { + struct merged_subiter *subiters; + struct merged_iter_pqueue pq; + size_t subiters_len; + int suppress_deletions; + ssize_t advance_index; +}; + +static void merged_iter_close(void *p) +{ + struct merged_iter *mi = p; + + merged_iter_pqueue_release(&mi->pq); + for (size_t i = 0; i < mi->subiters_len; i++) { + reftable_iterator_destroy(&mi->subiters[i].iter); + reftable_record_release(&mi->subiters[i].rec); + } + reftable_free(mi->subiters); +} + +static int merged_iter_advance_subiter(struct merged_iter *mi, size_t idx) +{ + struct pq_entry e = { + .index = idx, + .rec = &mi->subiters[idx].rec, + }; + int err; + + err = iterator_next(&mi->subiters[idx].iter, &mi->subiters[idx].rec); + if (err) + return err; + + err = merged_iter_pqueue_add(&mi->pq, &e); + if (err) + return err; + + return 0; +} + +static int merged_iter_seek(struct merged_iter *mi, struct reftable_record *want) +{ + int err; + + mi->advance_index = -1; + while (!merged_iter_pqueue_is_empty(mi->pq)) { + err = merged_iter_pqueue_remove(&mi->pq, NULL); + if (err < 0) + return err; + } + + for (size_t i = 0; i < mi->subiters_len; i++) { + err = iterator_seek(&mi->subiters[i].iter, want); + if (err < 0) + return err; + if (err > 0) + continue; + + err = merged_iter_advance_subiter(mi, i); + if (err < 0) + return err; + } + + return 0; +} + +static int merged_iter_next_entry(struct merged_iter *mi, + struct reftable_record *rec) +{ + struct pq_entry entry = { 0 }; + int err = 0, empty; + + empty = merged_iter_pqueue_is_empty(mi->pq); + + if (mi->advance_index >= 0) { + /* + * When there are no pqueue entries then we only have a single + * subiter left. There is no need to use the pqueue in that + * case anymore as we know that the subiter will return entries + * in the correct order already. + * + * While this may sound like a very specific edge case, it may + * happen more frequently than you think. Most repositories + * will end up having a single large base table that contains + * most of the refs. It's thus likely that we exhaust all + * subiters but the one from that base ref. + */ + if (empty) + return iterator_next(&mi->subiters[mi->advance_index].iter, + rec); + + err = merged_iter_advance_subiter(mi, mi->advance_index); + if (err < 0) + return err; + if (!err) + empty = 0; + mi->advance_index = -1; + } + + if (empty) + return 1; + + err = merged_iter_pqueue_remove(&mi->pq, &entry); + if (err < 0) + return err; + + /* + One can also use reftable as datacenter-local storage, where the ref + database is maintained in globally consistent database (eg. + CockroachDB or Spanner). In this scenario, replication delays together + with compaction may cause newer tables to contain older entries. In + such a deployment, the loop below must be changed to collect all + entries for the same key, and return new the newest one. + */ + while (!merged_iter_pqueue_is_empty(mi->pq)) { + struct pq_entry top = merged_iter_pqueue_top(mi->pq); + int cmp; + + err = reftable_record_cmp(top.rec, entry.rec, &cmp); + if (err < 0) + return err; + if (cmp > 0) + break; + + err = merged_iter_pqueue_remove(&mi->pq, NULL); + if (err < 0) + return err; + + err = merged_iter_advance_subiter(mi, top.index); + if (err < 0) + return err; + } + + mi->advance_index = entry.index; + REFTABLE_SWAP(*rec, *entry.rec); + return 0; +} + +static int merged_iter_seek_void(void *it, struct reftable_record *want) +{ + return merged_iter_seek(it, want); +} + +static int merged_iter_next_void(void *p, struct reftable_record *rec) +{ + struct merged_iter *mi = p; + while (1) { + int err = merged_iter_next_entry(mi, rec); + if (err) + return err; + if (mi->suppress_deletions && reftable_record_is_deletion(rec)) + continue; + return 0; + } +} + +static struct reftable_iterator_vtable merged_iter_vtable = { + .seek = merged_iter_seek_void, + .next = &merged_iter_next_void, + .close = &merged_iter_close, +}; + +static void iterator_from_merged_iter(struct reftable_iterator *it, + struct merged_iter *mi) +{ + assert(!it->ops); + it->iter_arg = mi; + it->ops = &merged_iter_vtable; +} + +int reftable_merged_table_new(struct reftable_merged_table **dest, + struct reftable_table **tables, size_t n, + enum reftable_hash hash_id) +{ + struct reftable_merged_table *m = NULL; + uint64_t last_max = 0; + uint64_t first_min = 0; + + for (size_t i = 0; i < n; i++) { + uint64_t min = reftable_table_min_update_index(tables[i]); + uint64_t max = reftable_table_max_update_index(tables[i]); + + if (reftable_table_hash_id(tables[i]) != hash_id) { + return REFTABLE_FORMAT_ERROR; + } + if (i == 0 || min < first_min) { + first_min = min; + } + if (i == 0 || max > last_max) { + last_max = max; + } + } + + REFTABLE_CALLOC_ARRAY(m, 1); + if (!m) + return REFTABLE_OUT_OF_MEMORY_ERROR; + + m->tables = tables; + m->tables_len = n; + m->min = first_min; + m->max = last_max; + m->hash_id = hash_id; + *dest = m; + return 0; +} + +void reftable_merged_table_free(struct reftable_merged_table *mt) +{ + if (!mt) + return; + reftable_free(mt); +} + +uint64_t +reftable_merged_table_max_update_index(struct reftable_merged_table *mt) +{ + return mt->max; +} + +uint64_t +reftable_merged_table_min_update_index(struct reftable_merged_table *mt) +{ + return mt->min; +} + +int merged_table_init_iter(struct reftable_merged_table *mt, + struct reftable_iterator *it, + uint8_t typ) +{ + struct merged_subiter *subiters = NULL; + struct merged_iter *mi = NULL; + int ret; + + if (mt->tables_len) { + REFTABLE_CALLOC_ARRAY(subiters, mt->tables_len); + if (!subiters) { + ret = REFTABLE_OUT_OF_MEMORY_ERROR; + goto out; + } + } + + for (size_t i = 0; i < mt->tables_len; i++) { + ret = reftable_record_init(&subiters[i].rec, typ); + if (ret < 0) + goto out; + + ret = table_init_iter(mt->tables[i], &subiters[i].iter, typ); + if (ret < 0) + goto out; + } + + REFTABLE_CALLOC_ARRAY(mi, 1); + if (!mi) { + ret = REFTABLE_OUT_OF_MEMORY_ERROR; + goto out; + } + mi->advance_index = -1; + mi->suppress_deletions = mt->suppress_deletions; + mi->subiters = subiters; + mi->subiters_len = mt->tables_len; + + iterator_from_merged_iter(it, mi); + ret = 0; + +out: + if (ret < 0) { + for (size_t i = 0; subiters && i < mt->tables_len; i++) { + reftable_iterator_destroy(&subiters[i].iter); + reftable_record_release(&subiters[i].rec); + } + reftable_free(subiters); + reftable_free(mi); + } + + return ret; +} + +int reftable_merged_table_init_ref_iterator(struct reftable_merged_table *mt, + struct reftable_iterator *it) +{ + return merged_table_init_iter(mt, it, REFTABLE_BLOCK_TYPE_REF); +} + +int reftable_merged_table_init_log_iterator(struct reftable_merged_table *mt, + struct reftable_iterator *it) +{ + return merged_table_init_iter(mt, it, REFTABLE_BLOCK_TYPE_LOG); +} + +enum reftable_hash reftable_merged_table_hash_id(struct reftable_merged_table *mt) +{ + return mt->hash_id; +} diff --git a/deps/reftable/merged.h b/deps/reftable/merged.h new file mode 100644 index 000000000..4317e5f5f --- /dev/null +++ b/deps/reftable/merged.h @@ -0,0 +1,34 @@ +/* + * Copyright 2020 Google LLC + * + * Use of this source code is governed by a BSD-style + * license that can be found in the LICENSE file or at + * https://developers.google.com/open-source/licenses/bsd + */ + +#ifndef MERGED_H +#define MERGED_H + +#include "system.h" +#include "reftable-basics.h" + +struct reftable_merged_table { + struct reftable_table **tables; + size_t tables_len; + enum reftable_hash hash_id; + + /* If unset, produce deletions. This is useful for compaction. For the + * full stack, deletions should be produced. */ + int suppress_deletions; + + uint64_t min; + uint64_t max; +}; + +struct reftable_iterator; + +int merged_table_init_iter(struct reftable_merged_table *mt, + struct reftable_iterator *it, + uint8_t typ); + +#endif diff --git a/deps/reftable/pq.c b/deps/reftable/pq.c new file mode 100644 index 000000000..9a79f5c5e --- /dev/null +++ b/deps/reftable/pq.c @@ -0,0 +1,95 @@ +/* + * Copyright 2020 Google LLC + * + * Use of this source code is governed by a BSD-style + * license that can be found in the LICENSE file or at + * https://developers.google.com/open-source/licenses/bsd + */ + +#include "pq.h" + +#include "reftable-error.h" +#include "reftable-record.h" +#include "system.h" +#include "basics.h" + +int pq_less(struct pq_entry *a, struct pq_entry *b) +{ + int cmp, err; + + err = reftable_record_cmp(a->rec, b->rec, &cmp); + if (err < 0) + return err; + + if (cmp == 0) + return a->index > b->index; + return cmp < 0; +} + +int merged_iter_pqueue_remove(struct merged_iter_pqueue *pq, struct pq_entry *out) +{ + size_t i = 0; + struct pq_entry e = pq->heap[0]; + pq->heap[0] = pq->heap[pq->len - 1]; + pq->len--; + + while (i < pq->len) { + size_t min = i; + size_t j = 2 * i + 1; + size_t k = 2 * i + 2; + int cmp; + + if (j < pq->len) { + cmp = pq_less(&pq->heap[j], &pq->heap[i]); + if (cmp < 0) + return -1; + else if (cmp) + min = j; + } + + if (k < pq->len) { + cmp = pq_less(&pq->heap[k], &pq->heap[min]); + if (cmp < 0) + return -1; + else if (cmp) + min = k; + } + + if (min == i) + break; + REFTABLE_SWAP(pq->heap[i], pq->heap[min]); + i = min; + } + + if (out) + *out = e; + + return 0; +} + +int merged_iter_pqueue_add(struct merged_iter_pqueue *pq, const struct pq_entry *e) +{ + size_t i = 0; + + REFTABLE_ALLOC_GROW_OR_NULL(pq->heap, pq->len + 1, pq->cap); + if (!pq->heap) + return REFTABLE_OUT_OF_MEMORY_ERROR; + pq->heap[pq->len++] = *e; + + i = pq->len - 1; + while (i > 0) { + size_t j = (i - 1) / 2; + if (pq_less(&pq->heap[j], &pq->heap[i])) + break; + REFTABLE_SWAP(pq->heap[j], pq->heap[i]); + i = j; + } + + return 0; +} + +void merged_iter_pqueue_release(struct merged_iter_pqueue *pq) +{ + REFTABLE_FREE_AND_NULL(pq->heap); + memset(pq, 0, sizeof(*pq)); +} diff --git a/deps/reftable/pq.h b/deps/reftable/pq.h new file mode 100644 index 000000000..42310670b --- /dev/null +++ b/deps/reftable/pq.h @@ -0,0 +1,40 @@ +/* + * Copyright 2020 Google LLC + * + * Use of this source code is governed by a BSD-style + * license that can be found in the LICENSE file or at + * https://developers.google.com/open-source/licenses/bsd + */ + +#ifndef PQ_H +#define PQ_H + +#include "record.h" + +struct pq_entry { + size_t index; + struct reftable_record *rec; +}; + +struct merged_iter_pqueue { + struct pq_entry *heap; + size_t len; + size_t cap; +}; + +int merged_iter_pqueue_remove(struct merged_iter_pqueue *pq, struct pq_entry *out); +int merged_iter_pqueue_add(struct merged_iter_pqueue *pq, const struct pq_entry *e); +void merged_iter_pqueue_release(struct merged_iter_pqueue *pq); +int pq_less(struct pq_entry *a, struct pq_entry *b); + +static inline struct pq_entry merged_iter_pqueue_top(struct merged_iter_pqueue pq) +{ + return pq.heap[0]; +} + +static inline int merged_iter_pqueue_is_empty(struct merged_iter_pqueue pq) +{ + return pq.len == 0; +} + +#endif diff --git a/deps/reftable/record.c b/deps/reftable/record.c new file mode 100644 index 000000000..fcd387ba5 --- /dev/null +++ b/deps/reftable/record.c @@ -0,0 +1,1322 @@ +/* + * Copyright 2020 Google LLC + * + * Use of this source code is governed by a BSD-style + * license that can be found in the LICENSE file or at + * https://developers.google.com/open-source/licenses/bsd + */ + +/* record.c - methods for different types of records. */ + +#include "record.h" + +#include "system.h" +#include "constants.h" +#include "reftable-error.h" +#include "basics.h" + +static struct reftable_record_vtable * +reftable_record_vtable(struct reftable_record *rec); +static void *reftable_record_data(struct reftable_record *rec); + +int get_var_int(uint64_t *dest, struct string_view *in) +{ + const unsigned char *buf = in->buf; + unsigned char c; + uint64_t val; + + if (!in->len) + return -1; + c = *buf++; + val = c & 0x7f; + + while (c & 0x80) { + /* + * We use a micro-optimization here: whenever we see that the + * 0x80 bit is set, we know that the remainder of the value + * cannot be 0. The zero-values thus doesn't need to be encoded + * at all, which is why we subtract 1 when encoding and add 1 + * when decoding. + * + * This allows us to save a byte in some edge cases. + */ + val += 1; + if (!val || (val & (uint64_t)(~0ULL << (64 - 7)))) + return -1; /* overflow */ + if (buf >= in->buf + in->len) + return -1; + c = *buf++; + val = (val << 7) + (c & 0x7f); + } + + *dest = val; + return buf - in->buf; +} + +int put_var_int(struct string_view *dest, uint64_t value) +{ + unsigned char varint[10]; + unsigned pos = sizeof(varint) - 1; + varint[pos] = value & 0x7f; + while (value >>= 7) + varint[--pos] = 0x80 | (--value & 0x7f); + if (dest->len < sizeof(varint) - pos) + return REFTABLE_ENTRY_TOO_BIG_ERROR; + memcpy(dest->buf, varint + pos, sizeof(varint) - pos); + return sizeof(varint) - pos; +} + +int reftable_is_block_type(uint8_t typ) +{ + switch (typ) { + case REFTABLE_BLOCK_TYPE_REF: + case REFTABLE_BLOCK_TYPE_LOG: + case REFTABLE_BLOCK_TYPE_OBJ: + case REFTABLE_BLOCK_TYPE_INDEX: + return 1; + } + return 0; +} + +const unsigned char *reftable_ref_record_val1(const struct reftable_ref_record *rec) +{ + switch (rec->value_type) { + case REFTABLE_REF_VAL1: + return rec->value.val1; + case REFTABLE_REF_VAL2: + return rec->value.val2.value; + default: + return NULL; + } +} + +const unsigned char *reftable_ref_record_val2(const struct reftable_ref_record *rec) +{ + switch (rec->value_type) { + case REFTABLE_REF_VAL2: + return rec->value.val2.target_value; + default: + return NULL; + } +} + +static int decode_string(struct reftable_buf *dest, struct string_view in) +{ + int start_len = in.len; + uint64_t tsize = 0; + int n, err; + + n = get_var_int(&tsize, &in); + if (n <= 0) + return -1; + string_view_consume(&in, n); + if (in.len < tsize) + return -1; + + reftable_buf_reset(dest); + err = reftable_buf_add(dest, in.buf, tsize); + if (err < 0) + return err; + + string_view_consume(&in, tsize); + + return start_len - in.len; +} + +static int encode_string(const char *str, struct string_view s) +{ + struct string_view start = s; + size_t l = strlen(str); + int n = put_var_int(&s, l); + if (n < 0) + return n; + string_view_consume(&s, n); + if (s.len < l) + return REFTABLE_ENTRY_TOO_BIG_ERROR; + memcpy(s.buf, str, l); + string_view_consume(&s, l); + + return start.len - s.len; +} + +int reftable_encode_key(int *restart, struct string_view dest, + struct reftable_buf prev_key, struct reftable_buf key, + uint8_t extra) +{ + struct string_view start = dest; + size_t prefix_len = common_prefix_size(&prev_key, &key); + uint64_t suffix_len = key.len - prefix_len; + int n = put_var_int(&dest, prefix_len); + if (n < 0) + return n; + string_view_consume(&dest, n); + + *restart = (prefix_len == 0); + + n = put_var_int(&dest, suffix_len << 3 | (uint64_t)extra); + if (n < 0) + return n; + string_view_consume(&dest, n); + + if (dest.len < suffix_len) + return REFTABLE_ENTRY_TOO_BIG_ERROR; + memcpy(dest.buf, key.buf + prefix_len, suffix_len); + string_view_consume(&dest, suffix_len); + + return start.len - dest.len; +} + +int reftable_decode_keylen(struct string_view in, + uint64_t *prefix_len, + uint64_t *suffix_len, + uint8_t *extra) +{ + size_t start_len = in.len; + int n; + + n = get_var_int(prefix_len, &in); + if (n < 0) + return -1; + string_view_consume(&in, n); + + n = get_var_int(suffix_len, &in); + if (n <= 0) + return -1; + string_view_consume(&in, n); + + *extra = (uint8_t)(*suffix_len & 0x7); + *suffix_len >>= 3; + + return start_len - in.len; +} + +int reftable_decode_key(struct reftable_buf *last_key, uint8_t *extra, + struct string_view in) +{ + int start_len = in.len; + uint64_t prefix_len = 0; + uint64_t suffix_len = 0; + int err, n; + + n = reftable_decode_keylen(in, &prefix_len, &suffix_len, extra); + if (n < 0) + return -1; + string_view_consume(&in, n); + + if (in.len < suffix_len || + prefix_len > last_key->len) + return -1; + + err = reftable_buf_setlen(last_key, prefix_len); + if (err < 0) + return err; + + err = reftable_buf_add(last_key, in.buf, suffix_len); + if (err < 0) + return err; + + string_view_consume(&in, suffix_len); + + return start_len - in.len; +} + +static int reftable_ref_record_key(const void *r, struct reftable_buf *dest) +{ + const struct reftable_ref_record *rec = + (const struct reftable_ref_record *)r; + reftable_buf_reset(dest); + return reftable_buf_addstr(dest, rec->refname); +} + +static int reftable_ref_record_copy_from(void *rec, const void *src_rec, + uint32_t hash_size) +{ + struct reftable_ref_record *ref = rec; + const struct reftable_ref_record *src = src_rec; + char *refname = NULL; + size_t refname_cap = 0; + int err; + + REFTABLE_SWAP(refname, ref->refname); + REFTABLE_SWAP(refname_cap, ref->refname_cap); + reftable_ref_record_release(ref); + REFTABLE_SWAP(ref->refname, refname); + REFTABLE_SWAP(ref->refname_cap, refname_cap); + + if (src->refname) { + size_t refname_len = strlen(src->refname); + + REFTABLE_ALLOC_GROW_OR_NULL(ref->refname, refname_len + 1, + ref->refname_cap); + if (!ref->refname) { + err = REFTABLE_OUT_OF_MEMORY_ERROR; + goto out; + } + + memcpy(ref->refname, src->refname, refname_len); + ref->refname[refname_len] = 0; + } + + ref->update_index = src->update_index; + ref->value_type = src->value_type; + switch (src->value_type) { + case REFTABLE_REF_DELETION: + break; + case REFTABLE_REF_VAL1: + memcpy(ref->value.val1, src->value.val1, hash_size); + break; + case REFTABLE_REF_VAL2: + memcpy(ref->value.val2.value, src->value.val2.value, hash_size); + memcpy(ref->value.val2.target_value, + src->value.val2.target_value, hash_size); + break; + case REFTABLE_REF_SYMREF: + ref->value.symref = reftable_strdup(src->value.symref); + if (!ref->value.symref) { + err = REFTABLE_OUT_OF_MEMORY_ERROR; + goto out; + } + break; + } + + err = 0; +out: + return err; +} + +static void reftable_ref_record_release_void(void *rec) +{ + reftable_ref_record_release(rec); +} + +void reftable_ref_record_release(struct reftable_ref_record *ref) +{ + switch (ref->value_type) { + case REFTABLE_REF_SYMREF: + reftable_free(ref->value.symref); + break; + case REFTABLE_REF_VAL2: + break; + case REFTABLE_REF_VAL1: + break; + case REFTABLE_REF_DELETION: + break; + default: + abort(); + } + + reftable_free(ref->refname); + memset(ref, 0, sizeof(struct reftable_ref_record)); +} + +static uint8_t reftable_ref_record_val_type(const void *rec) +{ + const struct reftable_ref_record *r = + (const struct reftable_ref_record *)rec; + return r->value_type; +} + +static int reftable_ref_record_encode(const void *rec, struct string_view s, + uint32_t hash_size) +{ + const struct reftable_ref_record *r = + (const struct reftable_ref_record *)rec; + struct string_view start = s; + int n = put_var_int(&s, r->update_index); + if (n < 0) + return n; + string_view_consume(&s, n); + + switch (r->value_type) { + case REFTABLE_REF_SYMREF: + n = encode_string(r->value.symref, s); + if (n < 0) + return n; + string_view_consume(&s, n); + break; + case REFTABLE_REF_VAL2: + if (s.len < 2 * hash_size) + return REFTABLE_ENTRY_TOO_BIG_ERROR; + memcpy(s.buf, r->value.val2.value, hash_size); + string_view_consume(&s, hash_size); + memcpy(s.buf, r->value.val2.target_value, hash_size); + string_view_consume(&s, hash_size); + break; + case REFTABLE_REF_VAL1: + if (s.len < hash_size) + return REFTABLE_ENTRY_TOO_BIG_ERROR; + memcpy(s.buf, r->value.val1, hash_size); + string_view_consume(&s, hash_size); + break; + case REFTABLE_REF_DELETION: + break; + default: + abort(); + } + + return start.len - s.len; +} + +static int reftable_ref_record_decode(void *rec, struct reftable_buf key, + uint8_t val_type, struct string_view in, + uint32_t hash_size, struct reftable_buf *scratch) +{ + struct reftable_ref_record *r = rec; + struct string_view start = in; + uint64_t update_index = 0; + const char *refname = NULL; + size_t refname_cap = 0; + int n, err; + + n = get_var_int(&update_index, &in); + if (n < 0) + return n; + string_view_consume(&in, n); + + REFTABLE_SWAP(refname, r->refname); + REFTABLE_SWAP(refname_cap, r->refname_cap); + reftable_ref_record_release(r); + REFTABLE_SWAP(r->refname, refname); + REFTABLE_SWAP(r->refname_cap, refname_cap); + + REFTABLE_ALLOC_GROW_OR_NULL(r->refname, key.len + 1, r->refname_cap); + if (!r->refname) { + err = REFTABLE_OUT_OF_MEMORY_ERROR; + goto done; + } + memcpy(r->refname, key.buf, key.len); + r->refname[key.len] = 0; + + r->update_index = update_index; + r->value_type = val_type; + switch (val_type) { + case REFTABLE_REF_VAL1: + if (in.len < hash_size) { + err = REFTABLE_FORMAT_ERROR; + goto done; + } + + memcpy(r->value.val1, in.buf, hash_size); + string_view_consume(&in, hash_size); + break; + + case REFTABLE_REF_VAL2: + if (in.len < 2 * hash_size) { + err = REFTABLE_FORMAT_ERROR; + goto done; + } + + memcpy(r->value.val2.value, in.buf, hash_size); + string_view_consume(&in, hash_size); + + memcpy(r->value.val2.target_value, in.buf, hash_size); + string_view_consume(&in, hash_size); + break; + + case REFTABLE_REF_SYMREF: { + int n = decode_string(scratch, in); + if (n < 0) { + err = REFTABLE_FORMAT_ERROR; + goto done; + } + string_view_consume(&in, n); + r->value.symref = reftable_buf_detach(scratch); + } break; + + case REFTABLE_REF_DELETION: + break; + default: + abort(); + break; + } + + return start.len - in.len; + +done: + return err; +} + +static int reftable_ref_record_is_deletion_void(const void *p) +{ + return reftable_ref_record_is_deletion( + (const struct reftable_ref_record *)p); +} + +static int reftable_ref_record_equal_void(const void *a, + const void *b, uint32_t hash_size) +{ + struct reftable_ref_record *ra = (struct reftable_ref_record *) a; + struct reftable_ref_record *rb = (struct reftable_ref_record *) b; + return reftable_ref_record_equal(ra, rb, hash_size); +} + +static int reftable_ref_record_cmp_void(const void *_a, const void *_b) +{ + const struct reftable_ref_record *a = _a; + const struct reftable_ref_record *b = _b; + return strcmp(a->refname, b->refname); +} + +static struct reftable_record_vtable reftable_ref_record_vtable = { + .key = &reftable_ref_record_key, + .type = REFTABLE_BLOCK_TYPE_REF, + .copy_from = &reftable_ref_record_copy_from, + .val_type = &reftable_ref_record_val_type, + .encode = &reftable_ref_record_encode, + .decode = &reftable_ref_record_decode, + .release = &reftable_ref_record_release_void, + .is_deletion = &reftable_ref_record_is_deletion_void, + .equal = &reftable_ref_record_equal_void, + .cmp = &reftable_ref_record_cmp_void, +}; + +static int reftable_obj_record_key(const void *r, struct reftable_buf *dest) +{ + const struct reftable_obj_record *rec = + (const struct reftable_obj_record *)r; + reftable_buf_reset(dest); + return reftable_buf_add(dest, rec->hash_prefix, rec->hash_prefix_len); +} + +static void reftable_obj_record_release(void *rec) +{ + struct reftable_obj_record *obj = rec; + REFTABLE_FREE_AND_NULL(obj->hash_prefix); + REFTABLE_FREE_AND_NULL(obj->offsets); + memset(obj, 0, sizeof(struct reftable_obj_record)); +} + +static int reftable_obj_record_copy_from(void *rec, const void *src_rec, + uint32_t hash_size REFTABLE_UNUSED) +{ + struct reftable_obj_record *obj = rec; + const struct reftable_obj_record *src = src_rec; + + reftable_obj_record_release(obj); + + REFTABLE_ALLOC_ARRAY(obj->hash_prefix, src->hash_prefix_len); + if (!obj->hash_prefix) + return REFTABLE_OUT_OF_MEMORY_ERROR; + obj->hash_prefix_len = src->hash_prefix_len; + if (src->hash_prefix_len) + memcpy(obj->hash_prefix, src->hash_prefix, obj->hash_prefix_len); + + if (src->offset_len) { + if (sizeof(*src->offsets) > SIZE_MAX / src->offset_len) + return REFTABLE_OUT_OF_MEMORY_ERROR; + + REFTABLE_ALLOC_ARRAY(obj->offsets, src->offset_len); + if (!obj->offsets) + return REFTABLE_OUT_OF_MEMORY_ERROR; + + memcpy(obj->offsets, src->offsets, sizeof(*src->offsets) * src->offset_len); + obj->offset_len = src->offset_len; + } + + return 0; +} + +static uint8_t reftable_obj_record_val_type(const void *rec) +{ + const struct reftable_obj_record *r = rec; + if (r->offset_len > 0 && r->offset_len < 8) + return r->offset_len; + return 0; +} + +static int reftable_obj_record_encode(const void *rec, struct string_view s, + uint32_t hash_size REFTABLE_UNUSED) +{ + const struct reftable_obj_record *r = rec; + struct string_view start = s; + int i = 0; + int n = 0; + uint64_t last = 0; + if (r->offset_len == 0 || r->offset_len >= 8) { + n = put_var_int(&s, r->offset_len); + if (n < 0) + return n; + string_view_consume(&s, n); + } + if (r->offset_len == 0) + return start.len - s.len; + n = put_var_int(&s, r->offsets[0]); + if (n < 0) + return n; + string_view_consume(&s, n); + + last = r->offsets[0]; + for (i = 1; i < r->offset_len; i++) { + int n = put_var_int(&s, r->offsets[i] - last); + if (n < 0) + return n; + string_view_consume(&s, n); + last = r->offsets[i]; + } + return start.len - s.len; +} + +static int reftable_obj_record_decode(void *rec, struct reftable_buf key, + uint8_t val_type, struct string_view in, + uint32_t hash_size REFTABLE_UNUSED, + struct reftable_buf *scratch REFTABLE_UNUSED) +{ + struct string_view start = in; + struct reftable_obj_record *r = rec; + uint64_t count = val_type; + int n = 0; + uint64_t last; + + reftable_obj_record_release(r); + + REFTABLE_ALLOC_ARRAY(r->hash_prefix, key.len); + if (!r->hash_prefix) + return REFTABLE_OUT_OF_MEMORY_ERROR; + memcpy(r->hash_prefix, key.buf, key.len); + r->hash_prefix_len = key.len; + + if (val_type == 0) { + n = get_var_int(&count, &in); + if (n < 0) { + return n; + } + + string_view_consume(&in, n); + } + + r->offsets = NULL; + r->offset_len = 0; + if (count == 0) + return start.len - in.len; + + REFTABLE_ALLOC_ARRAY(r->offsets, count); + if (!r->offsets) + return REFTABLE_OUT_OF_MEMORY_ERROR; + r->offset_len = count; + + n = get_var_int(&r->offsets[0], &in); + if (n < 0) + return n; + string_view_consume(&in, n); + + last = r->offsets[0]; + for (uint64_t j = 1; j < count; j++) { + uint64_t delta = 0; + int n = get_var_int(&delta, &in); + if (n < 0) { + return n; + } + string_view_consume(&in, n); + + last = r->offsets[j] = (delta + last); + } + return start.len - in.len; +} + +static int not_a_deletion(const void *p REFTABLE_UNUSED) +{ + return 0; +} + +static int reftable_obj_record_equal_void(const void *a, const void *b, + uint32_t hash_size REFTABLE_UNUSED) +{ + struct reftable_obj_record *ra = (struct reftable_obj_record *) a; + struct reftable_obj_record *rb = (struct reftable_obj_record *) b; + + if (ra->hash_prefix_len != rb->hash_prefix_len + || ra->offset_len != rb->offset_len) + return 0; + + if (ra->hash_prefix_len && + memcmp(ra->hash_prefix, rb->hash_prefix, ra->hash_prefix_len)) + return 0; + if (ra->offset_len && + memcmp(ra->offsets, rb->offsets, ra->offset_len * sizeof(uint64_t))) + return 0; + + return 1; +} + +static int reftable_obj_record_cmp_void(const void *_a, const void *_b) +{ + const struct reftable_obj_record *a = _a; + const struct reftable_obj_record *b = _b; + int cmp; + + cmp = memcmp(a->hash_prefix, b->hash_prefix, + a->hash_prefix_len > b->hash_prefix_len ? + a->hash_prefix_len : b->hash_prefix_len); + if (cmp) + return cmp; + + /* + * When the prefix is the same then the object record that is longer is + * considered to be bigger. + */ + return a->hash_prefix_len - b->hash_prefix_len; +} + +static struct reftable_record_vtable reftable_obj_record_vtable = { + .key = &reftable_obj_record_key, + .type = REFTABLE_BLOCK_TYPE_OBJ, + .copy_from = &reftable_obj_record_copy_from, + .val_type = &reftable_obj_record_val_type, + .encode = &reftable_obj_record_encode, + .decode = &reftable_obj_record_decode, + .release = &reftable_obj_record_release, + .is_deletion = ¬_a_deletion, + .equal = &reftable_obj_record_equal_void, + .cmp = &reftable_obj_record_cmp_void, +}; + +static int reftable_log_record_key(const void *r, struct reftable_buf *dest) +{ + const struct reftable_log_record *rec = + (const struct reftable_log_record *)r; + int len = strlen(rec->refname), err; + uint8_t i64[8]; + uint64_t ts = 0; + + reftable_buf_reset(dest); + err = reftable_buf_add(dest, (uint8_t *)rec->refname, len + 1); + if (err < 0) + return err; + + ts = (~ts) - rec->update_index; + reftable_put_be64(&i64[0], ts); + + err = reftable_buf_add(dest, i64, sizeof(i64)); + if (err < 0) + return err; + + return 0; +} + +static int reftable_log_record_copy_from(void *rec, const void *src_rec, + uint32_t hash_size) +{ + struct reftable_log_record *dst = rec; + const struct reftable_log_record *src = + (const struct reftable_log_record *)src_rec; + int ret; + + reftable_log_record_release(dst); + *dst = *src; + + if (dst->refname) { + dst->refname = reftable_strdup(dst->refname); + if (!dst->refname) { + ret = REFTABLE_OUT_OF_MEMORY_ERROR; + goto out; + } + } + + switch (dst->value_type) { + case REFTABLE_LOG_DELETION: + break; + case REFTABLE_LOG_UPDATE: + if (dst->value.update.email) + dst->value.update.email = + reftable_strdup(dst->value.update.email); + if (dst->value.update.name) + dst->value.update.name = + reftable_strdup(dst->value.update.name); + if (dst->value.update.message) + dst->value.update.message = + reftable_strdup(dst->value.update.message); + + if (!dst->value.update.email || + !dst->value.update.name || + !dst->value.update.message) { + ret = REFTABLE_OUT_OF_MEMORY_ERROR; + goto out; + } + + memcpy(dst->value.update.new_hash, + src->value.update.new_hash, hash_size); + memcpy(dst->value.update.old_hash, + src->value.update.old_hash, hash_size); + break; + } + + ret = 0; +out: + return ret; +} + +static void reftable_log_record_release_void(void *rec) +{ + struct reftable_log_record *r = rec; + reftable_log_record_release(r); +} + +void reftable_log_record_release(struct reftable_log_record *r) +{ + reftable_free(r->refname); + switch (r->value_type) { + case REFTABLE_LOG_DELETION: + break; + case REFTABLE_LOG_UPDATE: + reftable_free(r->value.update.name); + reftable_free(r->value.update.email); + reftable_free(r->value.update.message); + break; + } + memset(r, 0, sizeof(struct reftable_log_record)); +} + +static uint8_t reftable_log_record_val_type(const void *rec) +{ + const struct reftable_log_record *log = + (const struct reftable_log_record *)rec; + + return reftable_log_record_is_deletion(log) ? 0 : 1; +} + +static int reftable_log_record_encode(const void *rec, struct string_view s, + uint32_t hash_size) +{ + const struct reftable_log_record *r = rec; + struct string_view start = s; + int n = 0; + if (reftable_log_record_is_deletion(r)) + return 0; + + if (s.len < 2 * hash_size) + return REFTABLE_ENTRY_TOO_BIG_ERROR; + + memcpy(s.buf, r->value.update.old_hash, hash_size); + memcpy(s.buf + hash_size, r->value.update.new_hash, hash_size); + string_view_consume(&s, 2 * hash_size); + + n = encode_string(r->value.update.name ? r->value.update.name : "", s); + if (n < 0) + return n; + string_view_consume(&s, n); + + n = encode_string(r->value.update.email ? r->value.update.email : "", + s); + if (n < 0) + return n; + string_view_consume(&s, n); + + n = put_var_int(&s, r->value.update.time); + if (n < 0) + return n; + string_view_consume(&s, n); + + if (s.len < 2) + return REFTABLE_ENTRY_TOO_BIG_ERROR; + + reftable_put_be16(s.buf, r->value.update.tz_offset); + string_view_consume(&s, 2); + + n = encode_string( + r->value.update.message ? r->value.update.message : "", s); + if (n < 0) + return n; + string_view_consume(&s, n); + + return start.len - s.len; +} + +static int reftable_log_record_decode(void *rec, struct reftable_buf key, + uint8_t val_type, struct string_view in, + uint32_t hash_size, struct reftable_buf *scratch) +{ + struct string_view start = in; + struct reftable_log_record *r = rec; + uint64_t max = 0; + uint64_t ts = 0; + int err, n; + + if (key.len <= 9 || key.buf[key.len - 9] != 0) + return REFTABLE_FORMAT_ERROR; + + REFTABLE_ALLOC_GROW_OR_NULL(r->refname, key.len - 8, r->refname_cap); + if (!r->refname) { + err = REFTABLE_OUT_OF_MEMORY_ERROR; + goto done; + } + + memcpy(r->refname, key.buf, key.len - 8); + ts = reftable_get_be64((unsigned char *)key.buf + key.len - 8); + + r->update_index = (~max) - ts; + + if (val_type != r->value_type) { + switch (r->value_type) { + case REFTABLE_LOG_UPDATE: + REFTABLE_FREE_AND_NULL(r->value.update.message); + r->value.update.message_cap = 0; + REFTABLE_FREE_AND_NULL(r->value.update.email); + REFTABLE_FREE_AND_NULL(r->value.update.name); + break; + case REFTABLE_LOG_DELETION: + break; + } + } + + r->value_type = val_type; + if (val_type == REFTABLE_LOG_DELETION) + return 0; + + if (in.len < 2 * hash_size) { + err = REFTABLE_FORMAT_ERROR; + goto done; + } + + memcpy(r->value.update.old_hash, in.buf, hash_size); + memcpy(r->value.update.new_hash, in.buf + hash_size, hash_size); + + string_view_consume(&in, 2 * hash_size); + + n = decode_string(scratch, in); + if (n < 0) { + err = REFTABLE_FORMAT_ERROR; + goto done; + } + string_view_consume(&in, n); + + /* + * In almost all cases we can expect the reflog name to not change for + * reflog entries as they are tied to the local identity, not to the + * target commits. As an optimization for this common case we can thus + * skip copying over the name in case it's accurate already. + */ + if (!r->value.update.name || + strcmp(r->value.update.name, scratch->buf)) { + char *name = reftable_realloc(r->value.update.name, scratch->len + 1); + if (!name) { + err = REFTABLE_OUT_OF_MEMORY_ERROR; + goto done; + } + + r->value.update.name = name; + memcpy(r->value.update.name, scratch->buf, scratch->len); + r->value.update.name[scratch->len] = 0; + } + + n = decode_string(scratch, in); + if (n < 0) { + err = REFTABLE_FORMAT_ERROR; + goto done; + } + string_view_consume(&in, n); + + /* Same as above, but for the reflog email. */ + if (!r->value.update.email || + strcmp(r->value.update.email, scratch->buf)) { + char *email = reftable_realloc(r->value.update.email, scratch->len + 1); + if (!email) { + err = REFTABLE_OUT_OF_MEMORY_ERROR; + goto done; + } + + r->value.update.email = email; + memcpy(r->value.update.email, scratch->buf, scratch->len); + r->value.update.email[scratch->len] = 0; + } + + ts = 0; + n = get_var_int(&ts, &in); + if (n < 0) { + err = REFTABLE_FORMAT_ERROR; + goto done; + } + string_view_consume(&in, n); + r->value.update.time = ts; + if (in.len < 2) { + err = REFTABLE_FORMAT_ERROR; + goto done; + } + + r->value.update.tz_offset = reftable_get_be16(in.buf); + string_view_consume(&in, 2); + + n = decode_string(scratch, in); + if (n < 0) { + err = REFTABLE_FORMAT_ERROR; + goto done; + } + string_view_consume(&in, n); + + REFTABLE_ALLOC_GROW_OR_NULL(r->value.update.message, scratch->len + 1, + r->value.update.message_cap); + if (!r->value.update.message) { + err = REFTABLE_OUT_OF_MEMORY_ERROR; + goto done; + } + + memcpy(r->value.update.message, scratch->buf, scratch->len); + r->value.update.message[scratch->len] = 0; + + return start.len - in.len; + +done: + return err; +} + +static int null_streq(const char *a, const char *b) +{ + const char *empty = ""; + if (!a) + a = empty; + + if (!b) + b = empty; + + return 0 == strcmp(a, b); +} + +static int reftable_log_record_equal_void(const void *a, + const void *b, uint32_t hash_size) +{ + return reftable_log_record_equal((struct reftable_log_record *) a, + (struct reftable_log_record *) b, + hash_size); +} + +static int reftable_log_record_cmp_void(const void *_a, const void *_b) +{ + const struct reftable_log_record *a = _a; + const struct reftable_log_record *b = _b; + int cmp = strcmp(a->refname, b->refname); + if (cmp) + return cmp; + + /* + * Note that the comparison here is reversed. This is because the + * update index is reversed when comparing keys. For reference, see how + * we handle this in reftable_log_record_key()`. + */ + return b->update_index - a->update_index; +} + +int reftable_log_record_equal(const struct reftable_log_record *a, + const struct reftable_log_record *b, uint32_t hash_size) +{ + if (!(null_streq(a->refname, b->refname) && + a->update_index == b->update_index && + a->value_type == b->value_type)) + return 0; + + switch (a->value_type) { + case REFTABLE_LOG_DELETION: + return 1; + case REFTABLE_LOG_UPDATE: + return null_streq(a->value.update.name, b->value.update.name) && + a->value.update.time == b->value.update.time && + a->value.update.tz_offset == b->value.update.tz_offset && + null_streq(a->value.update.email, + b->value.update.email) && + null_streq(a->value.update.message, + b->value.update.message) && + !memcmp(a->value.update.old_hash, + b->value.update.old_hash, hash_size) && + !memcmp(a->value.update.new_hash, + b->value.update.new_hash, hash_size); + } + + abort(); +} + +static int reftable_log_record_is_deletion_void(const void *p) +{ + return reftable_log_record_is_deletion( + (const struct reftable_log_record *)p); +} + +static struct reftable_record_vtable reftable_log_record_vtable = { + .key = &reftable_log_record_key, + .type = REFTABLE_BLOCK_TYPE_LOG, + .copy_from = &reftable_log_record_copy_from, + .val_type = &reftable_log_record_val_type, + .encode = &reftable_log_record_encode, + .decode = &reftable_log_record_decode, + .release = &reftable_log_record_release_void, + .is_deletion = &reftable_log_record_is_deletion_void, + .equal = &reftable_log_record_equal_void, + .cmp = &reftable_log_record_cmp_void, +}; + +static int reftable_index_record_key(const void *r, struct reftable_buf *dest) +{ + const struct reftable_index_record *rec = r; + reftable_buf_reset(dest); + return reftable_buf_add(dest, rec->last_key.buf, rec->last_key.len); +} + +static int reftable_index_record_copy_from(void *rec, const void *src_rec, + uint32_t hash_size REFTABLE_UNUSED) +{ + struct reftable_index_record *dst = rec; + const struct reftable_index_record *src = src_rec; + int err; + + reftable_buf_reset(&dst->last_key); + err = reftable_buf_add(&dst->last_key, src->last_key.buf, src->last_key.len); + if (err < 0) + return err; + dst->offset = src->offset; + + return 0; +} + +static void reftable_index_record_release(void *rec) +{ + struct reftable_index_record *idx = rec; + reftable_buf_release(&idx->last_key); +} + +static uint8_t reftable_index_record_val_type(const void *rec REFTABLE_UNUSED) +{ + return 0; +} + +static int reftable_index_record_encode(const void *rec, struct string_view out, + uint32_t hash_size REFTABLE_UNUSED) +{ + const struct reftable_index_record *r = + (const struct reftable_index_record *)rec; + struct string_view start = out; + + int n = put_var_int(&out, r->offset); + if (n < 0) + return n; + + string_view_consume(&out, n); + + return start.len - out.len; +} + +static int reftable_index_record_decode(void *rec, struct reftable_buf key, + uint8_t val_type REFTABLE_UNUSED, + struct string_view in, + uint32_t hash_size REFTABLE_UNUSED, + struct reftable_buf *scratch REFTABLE_UNUSED) +{ + struct string_view start = in; + struct reftable_index_record *r = rec; + int err, n = 0; + + reftable_buf_reset(&r->last_key); + err = reftable_buf_add(&r->last_key, key.buf, key.len); + if (err < 0) + return err; + + n = get_var_int(&r->offset, &in); + if (n < 0) + return n; + + string_view_consume(&in, n); + return start.len - in.len; +} + +static int reftable_index_record_equal(const void *a, const void *b, + uint32_t hash_size REFTABLE_UNUSED) +{ + struct reftable_index_record *ia = (struct reftable_index_record *) a; + struct reftable_index_record *ib = (struct reftable_index_record *) b; + + return ia->offset == ib->offset && !reftable_buf_cmp(&ia->last_key, &ib->last_key); +} + +static int reftable_index_record_cmp(const void *_a, const void *_b) +{ + const struct reftable_index_record *a = _a; + const struct reftable_index_record *b = _b; + return reftable_buf_cmp(&a->last_key, &b->last_key); +} + +static struct reftable_record_vtable reftable_index_record_vtable = { + .key = &reftable_index_record_key, + .type = REFTABLE_BLOCK_TYPE_INDEX, + .copy_from = &reftable_index_record_copy_from, + .val_type = &reftable_index_record_val_type, + .encode = &reftable_index_record_encode, + .decode = &reftable_index_record_decode, + .release = &reftable_index_record_release, + .is_deletion = ¬_a_deletion, + .equal = &reftable_index_record_equal, + .cmp = &reftable_index_record_cmp, +}; + +int reftable_record_key(struct reftable_record *rec, struct reftable_buf *dest) +{ + return reftable_record_vtable(rec)->key(reftable_record_data(rec), dest); +} + +int reftable_record_encode(struct reftable_record *rec, struct string_view dest, + uint32_t hash_size) +{ + return reftable_record_vtable(rec)->encode(reftable_record_data(rec), + dest, hash_size); +} + +int reftable_record_copy_from(struct reftable_record *rec, + struct reftable_record *src, uint32_t hash_size) +{ + assert(src->type == rec->type); + + return reftable_record_vtable(rec)->copy_from(reftable_record_data(rec), + reftable_record_data(src), + hash_size); +} + +uint8_t reftable_record_val_type(struct reftable_record *rec) +{ + return reftable_record_vtable(rec)->val_type(reftable_record_data(rec)); +} + +int reftable_record_decode(struct reftable_record *rec, struct reftable_buf key, + uint8_t extra, struct string_view src, uint32_t hash_size, + struct reftable_buf *scratch) +{ + return reftable_record_vtable(rec)->decode(reftable_record_data(rec), + key, extra, src, hash_size, + scratch); +} + +void reftable_record_release(struct reftable_record *rec) +{ + reftable_record_vtable(rec)->release(reftable_record_data(rec)); +} + +int reftable_record_is_deletion(struct reftable_record *rec) +{ + return reftable_record_vtable(rec)->is_deletion( + reftable_record_data(rec)); +} + +int reftable_record_cmp(struct reftable_record *a, struct reftable_record *b, + int *cmp) +{ + if (a->type != b->type) + return -1; + *cmp = reftable_record_vtable(a)->cmp(reftable_record_data(a), + reftable_record_data(b)); + return 0; +} + +int reftable_record_equal(struct reftable_record *a, struct reftable_record *b, uint32_t hash_size) +{ + if (a->type != b->type) + return 0; + return reftable_record_vtable(a)->equal( + reftable_record_data(a), reftable_record_data(b), hash_size); +} + +static int hash_equal(const unsigned char *a, const unsigned char *b, uint32_t hash_size) +{ + if (a && b) + return !memcmp(a, b, hash_size); + + return a == b; +} + +int reftable_ref_record_equal(const struct reftable_ref_record *a, + const struct reftable_ref_record *b, uint32_t hash_size) +{ + if (!null_streq(a->refname, b->refname)) + return 0; + + if (a->update_index != b->update_index || + a->value_type != b->value_type) + return 0; + + switch (a->value_type) { + case REFTABLE_REF_SYMREF: + return !strcmp(a->value.symref, b->value.symref); + case REFTABLE_REF_VAL2: + return hash_equal(a->value.val2.value, b->value.val2.value, + hash_size) && + hash_equal(a->value.val2.target_value, + b->value.val2.target_value, hash_size); + case REFTABLE_REF_VAL1: + return hash_equal(a->value.val1, b->value.val1, hash_size); + case REFTABLE_REF_DELETION: + return 1; + default: + abort(); + } +} + +int reftable_ref_record_compare_name(const void *a, const void *b) +{ + return strcmp(((struct reftable_ref_record *)a)->refname, + ((struct reftable_ref_record *)b)->refname); +} + +int reftable_ref_record_is_deletion(const struct reftable_ref_record *ref) +{ + return ref->value_type == REFTABLE_REF_DELETION; +} + +int reftable_log_record_compare_key(const void *a, const void *b) +{ + const struct reftable_log_record *la = a; + const struct reftable_log_record *lb = b; + + int cmp = strcmp(la->refname, lb->refname); + if (cmp) + return cmp; + if (la->update_index > lb->update_index) + return -1; + return (la->update_index < lb->update_index) ? 1 : 0; +} + +int reftable_log_record_is_deletion(const struct reftable_log_record *log) +{ + return (log->value_type == REFTABLE_LOG_DELETION); +} + +static void *reftable_record_data(struct reftable_record *rec) +{ + switch (rec->type) { + case REFTABLE_BLOCK_TYPE_REF: + return &rec->u.ref; + case REFTABLE_BLOCK_TYPE_LOG: + return &rec->u.log; + case REFTABLE_BLOCK_TYPE_INDEX: + return &rec->u.idx; + case REFTABLE_BLOCK_TYPE_OBJ: + return &rec->u.obj; + } + abort(); +} + +static struct reftable_record_vtable * +reftable_record_vtable(struct reftable_record *rec) +{ + switch (rec->type) { + case REFTABLE_BLOCK_TYPE_REF: + return &reftable_ref_record_vtable; + case REFTABLE_BLOCK_TYPE_LOG: + return &reftable_log_record_vtable; + case REFTABLE_BLOCK_TYPE_INDEX: + return &reftable_index_record_vtable; + case REFTABLE_BLOCK_TYPE_OBJ: + return &reftable_obj_record_vtable; + } + abort(); +} + +int reftable_record_init(struct reftable_record *rec, uint8_t typ) +{ + memset(rec, 0, sizeof(*rec)); + rec->type = typ; + + switch (typ) { + case REFTABLE_BLOCK_TYPE_REF: + case REFTABLE_BLOCK_TYPE_LOG: + case REFTABLE_BLOCK_TYPE_OBJ: + return 0; + case REFTABLE_BLOCK_TYPE_INDEX: + reftable_buf_init(&rec->u.idx.last_key); + return 0; + default: + return REFTABLE_API_ERROR; + } +} diff --git a/deps/reftable/record.h b/deps/reftable/record.h new file mode 100644 index 000000000..7953f352a --- /dev/null +++ b/deps/reftable/record.h @@ -0,0 +1,164 @@ +/* + * Copyright 2020 Google LLC + * + * Use of this source code is governed by a BSD-style + * license that can be found in the LICENSE file or at + * https://developers.google.com/open-source/licenses/bsd + */ + +#ifndef RECORD_H +#define RECORD_H + +#include "basics.h" +#include "system.h" + +#include + +#include "reftable-record.h" + +/* + * A substring of existing string data. This structure takes no responsibility + * for the lifetime of the data it points to. + */ +struct string_view { + uint8_t *buf; + size_t len; +}; + +/* Advance `s.buf` by `n`, and decrease length. */ +static inline void string_view_consume(struct string_view *s, int n) +{ + s->buf += n; + s->len -= n; +} + +/* + * Decode and encode a varint. Returns the number of bytes read/written, or a + * negative value in case encoding/decoding the varint has failed. + */ +int get_var_int(uint64_t *dest, struct string_view *in); +int put_var_int(struct string_view *dest, uint64_t val); + +/* Methods for records. */ +struct reftable_record_vtable { + /* encode the key of to a uint8_t reftable_buf. */ + int (*key)(const void *rec, struct reftable_buf *dest); + + /* The record type of ('r' for ref). */ + uint8_t type; + + int (*copy_from)(void *dest, const void *src, uint32_t hash_size); + + /* a value of [0..7], indicating record subvariants (eg. ref vs. symref + * vs ref deletion) */ + uint8_t (*val_type)(const void *rec); + + /* encodes rec into dest, returning how much space was used. */ + int (*encode)(const void *rec, struct string_view dest, uint32_t hash_size); + + /* decode data from `src` into the record. */ + int (*decode)(void *rec, struct reftable_buf key, uint8_t extra, + struct string_view src, uint32_t hash_size, + struct reftable_buf *scratch); + + /* deallocate and null the record. */ + void (*release)(void *rec); + + /* is this a tombstone? */ + int (*is_deletion)(const void *rec); + + /* Are two records equal? This assumes they have the same type. Returns 0 for non-equal. */ + int (*equal)(const void *a, const void *b, uint32_t hash_size); + + /* + * Compare keys of two records with each other. The records must have + * the same type. + */ + int (*cmp)(const void *a, const void *b); +}; + +/* returns true for recognized block types. Block start with the block type. */ +int reftable_is_block_type(uint8_t typ); + +/* Encode `key` into `dest`. Sets `is_restart` to indicate a restart. Returns + * number of bytes written. */ +int reftable_encode_key(int *is_restart, struct string_view dest, + struct reftable_buf prev_key, struct reftable_buf key, + uint8_t extra); + +/* Decode a record's key lengths. */ +int reftable_decode_keylen(struct string_view in, + uint64_t *prefix_len, + uint64_t *suffix_len, + uint8_t *extra); + +/* + * Decode into `last_key` and `extra` from `in`. `last_key` is expected to + * contain the decoded key of the preceding record, if any. + */ +int reftable_decode_key(struct reftable_buf *last_key, uint8_t *extra, + struct string_view in); + +/* reftable_index_record are used internally to speed up lookups. */ +struct reftable_index_record { + uint64_t offset; /* Offset of block */ + struct reftable_buf last_key; /* Last key of the block. */ +}; + +/* reftable_obj_record stores an object ID => ref mapping. */ +struct reftable_obj_record { + uint8_t *hash_prefix; /* leading bytes of the object ID */ + int hash_prefix_len; /* number of leading bytes. Constant + * across a single table. */ + uint64_t *offsets; /* a vector of file offsets. */ + int offset_len; +}; + +/* record is a generic wrapper for different types of records. It is normally + * created on the stack, or embedded within another struct. If the type is + * known, a fresh instance can be initialized explicitly. Otherwise, use + * `reftable_record_init()` to initialize generically (as the index_record is + * not valid as 0-initialized structure) + */ +struct reftable_record { + uint8_t type; + union { + struct reftable_ref_record ref; + struct reftable_log_record log; + struct reftable_obj_record obj; + struct reftable_index_record idx; + } u; +}; + +/* Initialize the reftable record for the given type. */ +int reftable_record_init(struct reftable_record *rec, uint8_t typ); + +/* see struct record_vtable */ +int reftable_record_cmp(struct reftable_record *a, struct reftable_record *b, int *cmp); +int reftable_record_equal(struct reftable_record *a, struct reftable_record *b, uint32_t hash_size); +int reftable_record_key(struct reftable_record *rec, struct reftable_buf *dest); +int reftable_record_copy_from(struct reftable_record *rec, + struct reftable_record *src, uint32_t hash_size); +uint8_t reftable_record_val_type(struct reftable_record *rec); +int reftable_record_encode(struct reftable_record *rec, struct string_view dest, + uint32_t hash_size); +int reftable_record_decode(struct reftable_record *rec, struct reftable_buf key, + uint8_t extra, struct string_view src, + uint32_t hash_size, struct reftable_buf *scratch); +int reftable_record_is_deletion(struct reftable_record *rec); + +static inline uint8_t reftable_record_type(struct reftable_record *rec) +{ + return rec->type; +} + +/* frees and zeroes out the embedded record */ +void reftable_record_release(struct reftable_record *rec); + +/* for qsort. */ +int reftable_ref_record_compare_name(const void *a, const void *b); + +/* for qsort. */ +int reftable_log_record_compare_key(const void *a, const void *b); + +#endif diff --git a/deps/reftable/reftable-basics.h b/deps/reftable/reftable-basics.h new file mode 100644 index 000000000..dc8622682 --- /dev/null +++ b/deps/reftable/reftable-basics.h @@ -0,0 +1,39 @@ +/* + * Copyright 2020 Google LLC + * + * Use of this source code is governed by a BSD-style + * license that can be found in the LICENSE file or at + * https://developers.google.com/open-source/licenses/bsd + */ + +#ifndef REFTABLE_BASICS_H +#define REFTABLE_BASICS_H + +#include "reftable-system.h" + +/* A buffer that contains arbitrary byte slices. */ +struct reftable_buf { + size_t alloc; + size_t len; + char *buf; +}; +#define REFTABLE_BUF_INIT { 0 } + +/* + * Hash functions understood by the reftable library. Note that the values are + * arbitrary and somewhat random such that we can easily detect cases where the + * hash hasn't been properly set up. + */ +enum reftable_hash { + REFTABLE_HASH_SHA1 = 89, + REFTABLE_HASH_SHA256 = 247, +}; +#define REFTABLE_HASH_SIZE_SHA1 20 +#define REFTABLE_HASH_SIZE_SHA256 32 +#define REFTABLE_HASH_SIZE_MAX REFTABLE_HASH_SIZE_SHA256 + +/* Overrides the functions to use for memory management. */ +void reftable_set_alloc(void *(*malloc)(size_t), + void *(*realloc)(void *, size_t), void (*free)(void *)); + +#endif diff --git a/deps/reftable/reftable-block.h b/deps/reftable/reftable-block.h new file mode 100644 index 000000000..94c79b5c5 --- /dev/null +++ b/deps/reftable/reftable-block.h @@ -0,0 +1,74 @@ +/* + * Copyright 2020 Google LLC + * + * Use of this source code is governed by a BSD-style + * license that can be found in the LICENSE file or at + * https://developers.google.com/open-source/licenses/bsd + */ + +#ifndef REFTABLE_BLOCK_H +#define REFTABLE_BLOCK_H + +#include "reftable-system.h" +#include "reftable-basics.h" +#include "reftable-blocksource.h" +#include "reftable-iterator.h" + +struct z_stream_s; + +/* + * A block part of a reftable. Contains records as well as some metadata + * describing them. + */ +struct reftable_block { + /* + * Offset of the block header; nonzero for the first block in a + * reftable. + */ + uint32_t header_off; + + /* The memory block. */ + struct reftable_block_data block_data; + uint32_t hash_size; + + /* Uncompressed data for log entries. */ + struct z_stream_s *zstream; + unsigned char *uncompressed_data; + size_t uncompressed_cap; + + /* + * Restart point data. Restart points are located after the block's + * record data. + */ + uint16_t restart_count; + uint32_t restart_off; + + /* + * Size of the data in the file. For log blocks, this is the compressed + * size. + */ + uint32_t full_block_size; + uint8_t block_type; +}; + +/* Initialize a reftable block from the given block source. */ +int reftable_block_init(struct reftable_block *b, + struct reftable_block_source *source, + uint32_t offset, uint32_t header_size, + uint32_t table_block_size, uint32_t hash_size, + uint8_t want_type); + +/* Release resources allocated by the block. */ +void reftable_block_release(struct reftable_block *b); + +/* Initialize a generic record iterator from the given block. */ +int reftable_block_init_iterator(const struct reftable_block *b, + struct reftable_iterator *it); + +/* Returns the block type (eg. 'r' for refs). */ +uint8_t reftable_block_type(const struct reftable_block *b); + +/* Decodes the first key in the block. */ +int reftable_block_first_key(const struct reftable_block *b, struct reftable_buf *key); + +#endif /* REFTABLE_BLOCK_H */ diff --git a/deps/reftable/reftable-blocksource.h b/deps/reftable/reftable-blocksource.h new file mode 100644 index 000000000..40c1e9464 --- /dev/null +++ b/deps/reftable/reftable-blocksource.h @@ -0,0 +1,53 @@ +/* + * Copyright 2020 Google LLC + * + * Use of this source code is governed by a BSD-style + * license that can be found in the LICENSE file or at + * https://developers.google.com/open-source/licenses/bsd + */ + +#ifndef REFTABLE_BLOCKSOURCE_H +#define REFTABLE_BLOCKSOURCE_H + +#include "reftable-system.h" + +/* + * Generic wrapper for a seekable readable file. + */ +struct reftable_block_source { + struct reftable_block_source_vtable *ops; + void *arg; +}; + +/* a contiguous segment of bytes. It keeps track of its generating block_source + * so it can return itself into the pool. */ +struct reftable_block_data { + uint8_t *data; + size_t len; + struct reftable_block_source source; +}; + +/* block_source_vtable are the operations that make up block_source */ +struct reftable_block_source_vtable { + /* Returns the size of a block source. */ + uint64_t (*size)(void *source); + + /* + * Reads a segment from the block source. It is an error to read beyond + * the end of the block. + */ + ssize_t (*read_data)(void *source, struct reftable_block_data *dest, + uint64_t off, uint32_t size); + + /* Mark the block as read; may release the data. */ + void (*release_data)(void *source, struct reftable_block_data *data); + + /* Release all resources associated with the block source. */ + void (*close)(void *source); +}; + +/* opens a file on the file system as a block_source */ +int reftable_block_source_from_file(struct reftable_block_source *block_src, + const char *name); + +#endif diff --git a/deps/reftable/reftable-constants.h b/deps/reftable/reftable-constants.h new file mode 100644 index 000000000..4ae9ba4ba --- /dev/null +++ b/deps/reftable/reftable-constants.h @@ -0,0 +1,18 @@ +/* + * Copyright 2020 Google LLC + * + * Use of this source code is governed by a BSD-style + * license that can be found in the LICENSE file or at + * https://developers.google.com/open-source/licenses/bsd + */ + +#ifndef REFTABLE_CONSTANTS_H +#define REFTABLE_CONSTANTS_H + +#define REFTABLE_BLOCK_TYPE_LOG 'g' +#define REFTABLE_BLOCK_TYPE_INDEX 'i' +#define REFTABLE_BLOCK_TYPE_REF 'r' +#define REFTABLE_BLOCK_TYPE_OBJ 'o' +#define REFTABLE_BLOCK_TYPE_ANY 0 + +#endif /* REFTABLE_CONSTANTS_H */ diff --git a/deps/reftable/reftable-error.h b/deps/reftable/reftable-error.h new file mode 100644 index 000000000..0535e1478 --- /dev/null +++ b/deps/reftable/reftable-error.h @@ -0,0 +1,72 @@ +/* + * Copyright 2020 Google LLC + * + * Use of this source code is governed by a BSD-style + * license that can be found in the LICENSE file or at + * https://developers.google.com/open-source/licenses/bsd + */ + +#ifndef REFTABLE_ERROR_H +#define REFTABLE_ERROR_H + +#include "reftable-system.h" + +/* + * Errors in reftable calls are signaled with negative integer return values. 0 + * means success. + */ +enum reftable_error { + /* Unexpected file system behavior */ + REFTABLE_IO_ERROR = -2, + + /* Format inconsistency on reading data */ + REFTABLE_FORMAT_ERROR = -3, + + /* File does not exist. Returned from block_source_from_file(), because + * it needs special handling in stack. + */ + REFTABLE_NOT_EXIST_ERROR = -4, + + /* Trying to access locked data. */ + REFTABLE_LOCK_ERROR = -5, + + /* Misuse of the API: + * - on writing a record with NULL refname. + * - on writing a record before setting the writer limits. + * - on writing a reftable_ref_record outside the table limits + * - on writing a ref or log record before the stack's + * next_update_inde*x + * - on writing a log record with multiline message with + * exact_log_message unset + * - on reading a reftable_ref_record from log iterator, or vice versa. + * + * When a call misuses the API, the internal state of the library is + * kept unchanged. + */ + REFTABLE_API_ERROR = -6, + + /* Decompression error */ + REFTABLE_ZLIB_ERROR = -7, + + /* Wrote a table without blocks. */ + REFTABLE_EMPTY_TABLE_ERROR = -8, + + /* Invalid ref name. */ + REFTABLE_REFNAME_ERROR = -10, + + /* Entry does not fit. This can happen when writing outsize reflog + messages. */ + REFTABLE_ENTRY_TOO_BIG_ERROR = -11, + + /* Trying to write out-of-date data. */ + REFTABLE_OUTDATED_ERROR = -12, + + /* An allocation has failed due to an out-of-memory situation. */ + REFTABLE_OUT_OF_MEMORY_ERROR = -13, +}; + +/* convert the numeric error code to a string. The string should not be + * deallocated. */ +const char *reftable_error_str(int err); + +#endif diff --git a/deps/reftable/reftable-fsck.h b/deps/reftable/reftable-fsck.h new file mode 100644 index 000000000..340fc7762 --- /dev/null +++ b/deps/reftable/reftable-fsck.h @@ -0,0 +1,41 @@ +#ifndef REFTABLE_FSCK_H +#define REFTABLE_FSCK_H + +#include "reftable-system.h" +#include "reftable-stack.h" + +enum reftable_fsck_error { + /* Invalid table name */ + REFTABLE_FSCK_ERROR_TABLE_NAME = 0, + /* Used for bounds checking, must be last */ + REFTABLE_FSCK_MAX_VALUE, +}; + +/* Represents an individual error encountered during the FSCK checks. */ +struct reftable_fsck_info { + enum reftable_fsck_error error; + const char *msg; + const char *path; +}; + +typedef int reftable_fsck_report_fn(struct reftable_fsck_info *info, + void *cb_data); +typedef void reftable_fsck_verbose_fn(const char *msg, void *cb_data); + +/* + * Given a reftable stack, perform consistency checks on the stack. + * + * If an issue is encountered, the issue is reported to the callee via the + * provided 'report_fn'. If the issue is non-recoverable the flow will not + * continue. If it is recoverable, the flow will continue and further issues + * will be reported as identified. + * + * The 'verbose_fn' will be invoked to provide verbose information about + * the progress and state of the consistency checks. + */ +int reftable_fsck_check(struct reftable_stack *stack, + reftable_fsck_report_fn report_fn, + reftable_fsck_verbose_fn verbose_fn, + void *cb_data); + +#endif /* REFTABLE_FSCK_H */ diff --git a/deps/reftable/reftable-iterator.h b/deps/reftable/reftable-iterator.h new file mode 100644 index 000000000..a050cc153 --- /dev/null +++ b/deps/reftable/reftable-iterator.h @@ -0,0 +1,61 @@ +/* + * Copyright 2020 Google LLC + * + * Use of this source code is governed by a BSD-style + * license that can be found in the LICENSE file or at + * https://developers.google.com/open-source/licenses/bsd + */ + +#ifndef REFTABLE_ITERATOR_H +#define REFTABLE_ITERATOR_H + +#include "reftable-system.h" +#include "reftable-record.h" + +struct reftable_iterator_vtable; + +/* iterator is the generic interface for walking over data stored in a + * reftable. + */ +struct reftable_iterator { + struct reftable_iterator_vtable *ops; + void *iter_arg; +}; + +/* + * Position the iterator at the ref record with given name such that the next + * call to `next_ref()` would yield the record. + */ +int reftable_iterator_seek_ref(struct reftable_iterator *it, + const char *name); + +/* reads the next reftable_ref_record. Returns < 0 for error, 0 for OK and > 0: + * end of iteration. + */ +int reftable_iterator_next_ref(struct reftable_iterator *it, + struct reftable_ref_record *ref); + +/* + * Position the iterator at the log record with given name and update index + * such that the next call to `next_log()` would yield the record. + */ +int reftable_iterator_seek_log_at(struct reftable_iterator *it, + const char *name, uint64_t update_index); + +/* + * Position the iterator at the newest log record with given name such that the + * next call to `next_log()` would yield the record. + */ +int reftable_iterator_seek_log(struct reftable_iterator *it, + const char *name); + +/* reads the next reftable_log_record. Returns < 0 for error, 0 for OK and > 0: + * end of iteration. + */ +int reftable_iterator_next_log(struct reftable_iterator *it, + struct reftable_log_record *log); + +/* releases resources associated with an iterator. */ +void reftable_iterator_destroy(struct reftable_iterator *it); + +#endif diff --git a/deps/reftable/reftable-merged.h b/deps/reftable/reftable-merged.h new file mode 100644 index 000000000..02a996683 --- /dev/null +++ b/deps/reftable/reftable-merged.h @@ -0,0 +1,62 @@ +/* + * Copyright 2020 Google LLC + * + * Use of this source code is governed by a BSD-style + * license that can be found in the LICENSE file or at + * https://developers.google.com/open-source/licenses/bsd + */ + +#ifndef REFTABLE_MERGED_H +#define REFTABLE_MERGED_H + +#include "reftable-system.h" +#include "reftable-iterator.h" + +/* + * Merged tables + * + * A ref database kept in a sequence of table files. The merged_table presents a + * unified view to reading (seeking, iterating) a sequence of immutable tables. + * + * The merged tables are on purpose kept disconnected from their actual storage + * (eg. files on disk), because it is useful to merge tables aren't files. For + * example, the per-workspace and global ref namespace can be implemented as a + * merged table of two stacks of file-backed reftables. + */ + +/* A merged table is implements seeking/iterating over a stack of tables. */ +struct reftable_merged_table; + +struct reftable_table; + +/* + * reftable_merged_table_new creates a new merged table. The tables must be + * kept alive as long as the merged table is still in use. + */ +int reftable_merged_table_new(struct reftable_merged_table **dest, + struct reftable_table **tables, size_t n, + enum reftable_hash hash_id); + +/* Initialize a merged table iterator for reading refs. */ +int reftable_merged_table_init_ref_iterator(struct reftable_merged_table *mt, + struct reftable_iterator *it); + +/* Initialize a merged table iterator for reading logs. */ +int reftable_merged_table_init_log_iterator(struct reftable_merged_table *mt, + struct reftable_iterator *it); + +/* returns the max update_index covered by this merged table. */ +uint64_t +reftable_merged_table_max_update_index(struct reftable_merged_table *mt); + +/* returns the min update_index covered by this merged table. */ +uint64_t +reftable_merged_table_min_update_index(struct reftable_merged_table *mt); + +/* releases memory for the merged_table */ +void reftable_merged_table_free(struct reftable_merged_table *m); + +/* return the hash ID of the merged table. */ +enum reftable_hash reftable_merged_table_hash_id(struct reftable_merged_table *m); + +#endif diff --git a/deps/reftable/reftable-record.h b/deps/reftable/reftable-record.h new file mode 100644 index 000000000..e18c53823 --- /dev/null +++ b/deps/reftable/reftable-record.h @@ -0,0 +1,110 @@ +/* + * Copyright 2020 Google LLC + * + * Use of this source code is governed by a BSD-style + * license that can be found in the LICENSE file or at + * https://developers.google.com/open-source/licenses/bsd + */ + +#ifndef REFTABLE_RECORD_H +#define REFTABLE_RECORD_H + +#include "reftable-system.h" +#include "reftable-basics.h" + +/* + * Basic data types + * + * Reftables store the state of each ref in struct reftable_ref_record, and they + * store a sequence of reflog updates in struct reftable_log_record. + */ + +/* reftable_ref_record holds a ref database entry target_value */ +struct reftable_ref_record { + char *refname; /* Name of the ref, malloced. */ + size_t refname_cap; + uint64_t update_index; /* Logical timestamp at which this value is + * written */ + + enum { + /* tombstone to hide deletions from earlier tables */ + REFTABLE_REF_DELETION = 0x0, + + /* a simple ref */ + REFTABLE_REF_VAL1 = 0x1, + /* a tag, plus its peeled hash */ + REFTABLE_REF_VAL2 = 0x2, + + /* a symbolic reference */ + REFTABLE_REF_SYMREF = 0x3, +#define REFTABLE_NR_REF_VALUETYPES 4 + } value_type; + union { + unsigned char val1[REFTABLE_HASH_SIZE_MAX]; + struct { + unsigned char value[REFTABLE_HASH_SIZE_MAX]; /* first hash */ + unsigned char target_value[REFTABLE_HASH_SIZE_MAX]; /* second hash */ + } val2; + char *symref; /* referent, malloced 0-terminated string */ + } value; +}; + +/* Returns the first hash, or NULL if `rec` is not of type + * REFTABLE_REF_VAL1 or REFTABLE_REF_VAL2. */ +const unsigned char *reftable_ref_record_val1(const struct reftable_ref_record *rec); + +/* Returns the second hash, or NULL if `rec` is not of type + * REFTABLE_REF_VAL2. */ +const unsigned char *reftable_ref_record_val2(const struct reftable_ref_record *rec); + +/* returns whether 'ref' represents a deletion */ +int reftable_ref_record_is_deletion(const struct reftable_ref_record *ref); + +/* frees and nulls all pointer values inside `ref`. */ +void reftable_ref_record_release(struct reftable_ref_record *ref); + +/* returns whether two reftable_ref_records are the same. Useful for testing. */ +int reftable_ref_record_equal(const struct reftable_ref_record *a, + const struct reftable_ref_record *b, uint32_t hash_size); + +/* reftable_log_record holds a reflog entry */ +struct reftable_log_record { + char *refname; + size_t refname_cap; + uint64_t update_index; /* logical timestamp of a transactional update. + */ + + enum { + /* tombstone to hide deletions from earlier tables */ + REFTABLE_LOG_DELETION = 0x0, + + /* a simple update */ + REFTABLE_LOG_UPDATE = 0x1, +#define REFTABLE_NR_LOG_VALUETYPES 2 + } value_type; + + union { + struct { + unsigned char new_hash[REFTABLE_HASH_SIZE_MAX]; + unsigned char old_hash[REFTABLE_HASH_SIZE_MAX]; + char *name; + char *email; + uint64_t time; + int16_t tz_offset; + char *message; + size_t message_cap; + } update; + } value; +}; + +/* returns whether 'ref' represents the deletion of a log record. */ +int reftable_log_record_is_deletion(const struct reftable_log_record *log); + +/* frees and nulls all pointer values. */ +void reftable_log_record_release(struct reftable_log_record *log); + +/* returns whether two records are equal. Useful for testing. */ +int reftable_log_record_equal(const struct reftable_log_record *a, + const struct reftable_log_record *b, uint32_t hash_size); + +#endif diff --git a/deps/reftable/reftable-stack.h b/deps/reftable/reftable-stack.h new file mode 100644 index 000000000..5f7be573f --- /dev/null +++ b/deps/reftable/reftable-stack.h @@ -0,0 +1,170 @@ +/* + * Copyright 2020 Google LLC + * + * Use of this source code is governed by a BSD-style + * license that can be found in the LICENSE file or at + * https://developers.google.com/open-source/licenses/bsd + */ + +#ifndef REFTABLE_STACK_H +#define REFTABLE_STACK_H + +#include "reftable-system.h" +#include "reftable-writer.h" + +/* + * The stack presents an interface to a mutable sequence of reftables. + + * A stack can be mutated by pushing a table to the top of the stack. + + * The reftable_stack automatically compacts files on disk to ensure good + * amortized performance. + * + * For windows and other platforms that cannot have open files as rename + * destinations, concurrent access from multiple processes needs the rand() + * random seed to be randomized. + */ +struct reftable_stack; + +/* open a new reftable stack. The tables along with the table list will be + * stored in 'dir'. Typically, this should be .git/reftables. + */ +int reftable_new_stack(struct reftable_stack **dest, const char *dir, + const struct reftable_write_options *opts); + +/* returns the update_index at which a next table should be written. */ +uint64_t reftable_stack_next_update_index(struct reftable_stack *st); + +/* holds a transaction to add tables at the top of a stack. */ +struct reftable_addition; + +enum { + /* + * Reload the stack when the stack is out-of-date after locking it. + */ + REFTABLE_STACK_NEW_ADDITION_RELOAD = (1 << 0), +}; + +/* + * returns a new transaction to add reftables to the given stack. As a side + * effect, the ref database is locked. Accepts REFTABLE_STACK_NEW_ADDITION_* + * flags. + */ +int reftable_stack_new_addition(struct reftable_addition **dest, + struct reftable_stack *st, + unsigned int flags); + +/* Adds a reftable to transaction. */ +int reftable_addition_add(struct reftable_addition *add, + int (*write_table)(struct reftable_writer *wr, + void *arg), + void *arg); + +/* Commits the transaction, releasing the lock. After calling this, + * reftable_addition_destroy should still be called. + */ +int reftable_addition_commit(struct reftable_addition *add); + +/* Release all non-committed data from the transaction, and deallocate the + * transaction. Releases the lock if held. */ +void reftable_addition_destroy(struct reftable_addition *add); + +/* + * Add a new table to the stack. The write_table function must call + * reftable_writer_set_limits, add refs and return an error value. + * The flags are passed through to `reftable_stack_new_addition()`. + */ +int reftable_stack_add(struct reftable_stack *st, + int (*write_table)(struct reftable_writer *wr, + void *write_arg), + void *write_arg, unsigned flags); + +struct reftable_iterator; + +/* + * Initialize an iterator for the merged tables contained in the stack that can + * be used to iterate through refs. The iterator is valid until the next reload + * or write. + */ +int reftable_stack_init_ref_iterator(struct reftable_stack *st, + struct reftable_iterator *it); + +/* + * Initialize an iterator for the merged tables contained in the stack that can + * be used to iterate through logs. The iterator is valid until the next reload + * or write. + */ +int reftable_stack_init_log_iterator(struct reftable_stack *st, + struct reftable_iterator *it); + +/* returns the merged_table for seeking. This table is valid until the + * next write or reload, and should not be closed or deleted. + */ +struct reftable_merged_table * +reftable_stack_merged_table(struct reftable_stack *st); + +/* frees all resources associated with the stack. */ +void reftable_stack_destroy(struct reftable_stack *st); + +/* Reloads the stack if necessary. This is very cheap to run if the stack was up + * to date */ +int reftable_stack_reload(struct reftable_stack *st); + +/* Policy for expiring reflog entries. */ +struct reftable_log_expiry_config { + /* Drop entries older than this timestamp */ + uint64_t time; + + /* Drop older entries */ + uint64_t min_update_index; +}; + +/* compacts all reftables into a giant table. Expire reflog entries if config is + * non-NULL */ +int reftable_stack_compact_all(struct reftable_stack *st, + struct reftable_log_expiry_config *config); + +/* + * Check if compaction is required. + * + * When `use_heuristics` is false, check if all tables can be compacted to a + * single table. If true, use heuristics to determine if the tables need to be + * compacted to maintain geometric progression. + */ +int reftable_stack_compaction_required(struct reftable_stack *st, + bool use_heuristics, + bool *required); + +/* heuristically compact unbalanced table stack. */ +int reftable_stack_auto_compact(struct reftable_stack *st); + +/* delete stale .ref tables. */ +int reftable_stack_clean(struct reftable_stack *st); + +/* convenience function to read a single ref. Returns < 0 for error, 0 for + * success, and 1 if ref not found. */ +int reftable_stack_read_ref(struct reftable_stack *st, const char *refname, + struct reftable_ref_record *ref); + +/* convenience function to read a single log. Returns < 0 for error, 0 for + * success, and 1 if ref not found. */ +int reftable_stack_read_log(struct reftable_stack *st, const char *refname, + struct reftable_log_record *log); + +/* statistics on past compactions. */ +struct reftable_compaction_stats { + uint64_t bytes; /* total number of bytes written */ + uint64_t entries_written; /* total number of entries written, including + failures. */ + int attempts; /* how often we tried to compact */ + int failures; /* failures happen on concurrent updates */ +}; + +/* return statistics for compaction up till now. */ +struct reftable_compaction_stats * +reftable_stack_compaction_stats(struct reftable_stack *st); + +/* Return the hash of the stack. */ +enum reftable_hash reftable_stack_hash_id(struct reftable_stack *st); + +#endif diff --git a/deps/reftable/reftable-system.h b/deps/reftable/reftable-system.h new file mode 100644 index 000000000..6e06758c0 --- /dev/null +++ b/deps/reftable/reftable-system.h @@ -0,0 +1,33 @@ +#ifndef REFTABLE_SYSTEM_H +#define REFTABLE_SYSTEM_H + +/* + * This header defines the platform-specific bits required to compile the + * reftable library. It should provide an environment that bridges over the + * gaps between POSIX and your system, as well as the zlib interfaces. This + * header is expected to be changed by the individual project. + */ + +#include "map.h" +#include "posix.h" +#include "util.h" +#include + +/* + * We only need to redefine on Windows as we expect stat(3p) et al to be + * available on Unix platforms. Furthermore, we only need to redefine fstat(3p) + * because we already redefine stat(3p) "win32-compat.h". + */ +#ifdef GIT_WIN32 +# define fstat(fd, st) p_fstat(fd, st) +#endif + +#define fsync(fd) p_fsync(fd) + +#define poll(fds, fds_len, timeout) p_poll(fds, fds_len, timeout) + +#define REFTABLE_ALLOW_BANNED_ALLOCATORS + +#define inline GIT_INLINE_KEYWORD + +#endif diff --git a/deps/reftable/reftable-table.h b/deps/reftable/reftable-table.h new file mode 100644 index 000000000..d7666b53a --- /dev/null +++ b/deps/reftable/reftable-table.h @@ -0,0 +1,116 @@ +/* + * Copyright 2020 Google LLC + * + * Use of this source code is governed by a BSD-style + * license that can be found in the LICENSE file or at + * https://developers.google.com/open-source/licenses/bsd + */ + +#ifndef REFTABLE_TABLE_H +#define REFTABLE_TABLE_H + +#include "reftable-system.h" +#include "reftable-iterator.h" +#include "reftable-block.h" +#include "reftable-blocksource.h" + +/* + * Reading single tables + * + * The follow routines are for reading single files. For an + * application-level interface, skip ahead to struct + * reftable_merged_table and struct reftable_stack. + */ + +/* Metadata for a block type. */ +struct reftable_table_offsets { + int is_present; + uint64_t offset; + uint64_t index_offset; +}; + +/* The table struct is a handle to an open reftable file. */ +struct reftable_table { + /* for convenience, associate a name with the instance. */ + char *name; + struct reftable_block_source source; + + /* Size of the file, excluding the footer. */ + uint64_t size; + + /* The hash function used for ref records. */ + enum reftable_hash hash_id; + + uint32_t block_size; + uint64_t min_update_index; + uint64_t max_update_index; + /* Length of the OID keys in the 'o' section */ + int object_id_len; + int version; + + struct reftable_table_offsets ref_offsets; + struct reftable_table_offsets obj_offsets; + struct reftable_table_offsets log_offsets; + + uint64_t refcount; +}; + +/* reftable_table_new opens a reftable for reading. If successful, + * returns 0 code and sets pp. The name is used for creating a + * stack. Typically, it is the basename of the file. The block source + * `src` is owned by the table, and is closed on calling + * reftable_table_destroy(). On error, the block source `src` is + * closed as well. + */ +int reftable_table_new(struct reftable_table **out, + struct reftable_block_source *src, const char *name); + +/* + * Manage the reference count of the reftable table. A newly initialized + * table starts with a refcount of 1 and will be deleted once the refcount has + * reached 0. + * + * This is required because tables may have longer lifetimes than the stack + * they belong to. The stack may for example be reloaded while the old tables + * are still being accessed by an iterator. + */ +void reftable_table_incref(struct reftable_table *table); +void reftable_table_decref(struct reftable_table *table); + +/* Initialize a reftable iterator for reading refs. */ +int reftable_table_init_ref_iterator(struct reftable_table *t, + struct reftable_iterator *it); + +/* Initialize a reftable iterator for reading logs. */ +int reftable_table_init_log_iterator(struct reftable_table *t, + struct reftable_iterator *it); + +/* returns the hash ID used in this table. */ +enum reftable_hash reftable_table_hash_id(struct reftable_table *t); + +/* return an iterator for the refs pointing to `oid`. */ +int reftable_table_refs_for(struct reftable_table *t, + struct reftable_iterator *it, uint8_t *oid); + +/* return the max_update_index for a table */ +uint64_t reftable_table_max_update_index(struct reftable_table *t); + +/* return the min_update_index for a table */ +uint64_t reftable_table_min_update_index(struct reftable_table *t); + +/* + * An iterator that iterates through the blocks contained in a given table. + */ +struct reftable_table_iterator { + void *iter_arg; +}; + +int reftable_table_iterator_init(struct reftable_table_iterator *it, + struct reftable_table *t); + +void reftable_table_iterator_release(struct reftable_table_iterator *it); + +int reftable_table_iterator_next(struct reftable_table_iterator *it, + const struct reftable_block **out); + +#endif diff --git a/deps/reftable/reftable-writer.h b/deps/reftable/reftable-writer.h new file mode 100644 index 000000000..a66db415c --- /dev/null +++ b/deps/reftable/reftable-writer.h @@ -0,0 +1,181 @@ +/* + * Copyright 2020 Google LLC + * + * Use of this source code is governed by a BSD-style + * license that can be found in the LICENSE file or at + * https://developers.google.com/open-source/licenses/bsd + */ + +#ifndef REFTABLE_WRITER_H +#define REFTABLE_WRITER_H + +#include "reftable-system.h" +#include "reftable-record.h" + +/* Writing single reftables */ + +/* reftable_write_options sets options for writing a single reftable. */ +struct reftable_write_options { + /* boolean: do not pad out blocks to block size. */ + unsigned unpadded : 1; + + /* the blocksize. Should be less than 2^24. */ + uint32_t block_size; + + /* boolean: do not generate a SHA1 => ref index. */ + unsigned skip_index_objects : 1; + + /* how often to write complete keys in each block. */ + uint16_t restart_interval; + + /* 4-byte identifier ("sha1", "s256") of the hash. + * Defaults to SHA1 if unset + */ + enum reftable_hash hash_id; + + /* Default mode for creating files. If unset, use 0666 (+umask) */ + unsigned int default_permissions; + + /* boolean: copy log messages exactly. If unset, check that the message + * is a single line, and add '\n' if missing. + */ + unsigned exact_log_message : 1; + + /* boolean: Prevent auto-compaction of tables. */ + unsigned disable_auto_compact : 1; + + /* + * Geometric sequence factor used by auto-compaction to decide which + * tables to compact. Defaults to 2 if unset. + */ + uint8_t auto_compaction_factor; + + /* + * The number of milliseconds to wait when trying to lock "tables.list". + * Note that this does not apply to locking individual tables, as these + * should only ever be locked when already holding the "tables.list" + * lock. + * + * Passing 0 will fail immediately when the file is locked, passing a + * negative value will cause us to block indefinitely. + */ + long lock_timeout_ms; + + /* + * Callback function to execute whenever the stack is being reloaded. + * This can be used e.g. to discard cached information that relies on + * the old stack's data. The payload data will be passed as argument to + * the callback. + */ + void (*on_reload)(void *payload); + void *on_reload_payload; +}; + +/* reftable_block_stats holds statistics for a single block type */ +struct reftable_block_stats { + /* total number of entries written */ + int entries; + /* total number of key restarts */ + uint32_t restarts; + /* total number of blocks */ + int blocks; + /* total number of index blocks */ + int index_blocks; + /* depth of the index */ + int max_index_level; + + /* offset of the first block for this type */ + uint64_t offset; + /* offset of the top level index block for this type, or 0 if not + * present */ + uint64_t index_offset; +}; + +/* stats holds overall statistics for a single reftable */ +struct reftable_stats { + /* total number of blocks written. */ + int blocks; + /* stats for ref data */ + struct reftable_block_stats ref_stats; + /* stats for the SHA1 to ref map. */ + struct reftable_block_stats obj_stats; + /* stats for index blocks */ + struct reftable_block_stats idx_stats; + /* stats for log blocks */ + struct reftable_block_stats log_stats; + + /* disambiguation length of shortened object IDs. */ + int object_id_len; +}; + +struct reftable_writer; + +/* Create a new writer. */ +int reftable_writer_new(struct reftable_writer **out, + ssize_t (*writer_func)(void *, const void *, size_t), + int (*flush_func)(void *), + void *writer_arg, const struct reftable_write_options *opts); + +/* + * Set the range of update indices for the records we will add. When writing a + * table into a stack, the min should be at least + * reftable_stack_next_update_index(), or REFTABLE_API_ERROR is returned. + * + * For transactional updates to a stack, typically min==max, and the + * update_index can be obtained by inspeciting the stack. When converting an + * existing ref database into a single reftable, this would be a range of + * update-index timestamps. + * + * The function should be called before adding any records to the writer. If not + * it will fail with REFTABLE_API_ERROR. + */ +int reftable_writer_set_limits(struct reftable_writer *w, uint64_t min, + uint64_t max); + +/* + Add a reftable_ref_record. The record should have names that come after + already added records. + + The update_index must be within the limits set by + reftable_writer_set_limits(), or REFTABLE_API_ERROR is returned. It is an + REFTABLE_API_ERROR error to write a ref record after a log record. +*/ +int reftable_writer_add_ref(struct reftable_writer *w, + struct reftable_ref_record *ref); + +/* + Convenience function to add multiple reftable_ref_records; the function sorts + the records before adding them, reordering the records array passed in. +*/ +int reftable_writer_add_refs(struct reftable_writer *w, + struct reftable_ref_record *refs, size_t n); + +/* + adds reftable_log_records. Log records are keyed by (refname, decreasing + update_index). The key for the record added must come after the already added + log records. +*/ +int reftable_writer_add_log(struct reftable_writer *w, + struct reftable_log_record *log); + +/* + Convenience function to add multiple reftable_log_records; the function sorts + the records before adding them, reordering records array passed in. +*/ +int reftable_writer_add_logs(struct reftable_writer *w, + struct reftable_log_record *logs, size_t n); + +/* reftable_writer_close finalizes the reftable. The writer is retained so + * statistics can be inspected. */ +int reftable_writer_close(struct reftable_writer *w); + +/* writer_stats returns the statistics on the reftable being written. + + This struct becomes invalid when the writer is freed. + */ +const struct reftable_stats *reftable_writer_stats(struct reftable_writer *w); + +/* reftable_writer_free deallocates memory for the writer */ +void reftable_writer_free(struct reftable_writer *w); + +#endif diff --git a/deps/reftable/stack.c b/deps/reftable/stack.c new file mode 100644 index 000000000..1fba96ddb --- /dev/null +++ b/deps/reftable/stack.c @@ -0,0 +1,1830 @@ +/* + * Copyright 2020 Google LLC + * + * Use of this source code is governed by a BSD-style + * license that can be found in the LICENSE file or at + * https://developers.google.com/open-source/licenses/bsd + */ + +#include "stack.h" + +#include "system.h" +#include "constants.h" +#include "merged.h" +#include "reftable-error.h" +#include "reftable-record.h" +#include "reftable-merged.h" +#include "table.h" +#include "writer.h" + +static int stack_filename(struct reftable_buf *dest, struct reftable_stack *st, + const char *name) +{ + int err; + reftable_buf_reset(dest); + if ((err = reftable_buf_addstr(dest, st->reftable_dir)) < 0 || + (err = reftable_buf_addstr(dest, "/")) < 0 || + (err = reftable_buf_addstr(dest, name)) < 0) + return err; + return 0; +} + +static ssize_t reftable_write_data(int fd, const void *data, size_t size) +{ + size_t total_written = 0; + const char *p = data; + + while (total_written < size) { + ssize_t bytes_written = write(fd, p, size - total_written); + if (bytes_written < 0 && (errno == EAGAIN || errno == EINTR)) + continue; + if (bytes_written < 0) + return REFTABLE_IO_ERROR; + + total_written += bytes_written; + p += bytes_written; + } + + return total_written; +} + +struct fd_writer { + const struct reftable_write_options *opts; + int fd; +}; + +static ssize_t fd_writer_write(void *arg, const void *data, size_t sz) +{ + struct fd_writer *writer = arg; + return reftable_write_data(writer->fd, data, sz); +} + +static int fd_writer_flush(void *arg) +{ + struct fd_writer *writer = arg; + return fsync(writer->fd); +} + +static int fd_read_lines(int fd, char ***namesp) +{ + char *buf = NULL; + int err = 0; + off_t size; + + size = lseek(fd, 0, SEEK_END); + if (size < 0) { + err = REFTABLE_IO_ERROR; + goto done; + } + + err = lseek(fd, 0, SEEK_SET); + if (err < 0) { + err = REFTABLE_IO_ERROR; + goto done; + } + + REFTABLE_ALLOC_ARRAY(buf, size + 1); + if (!buf) { + err = REFTABLE_OUT_OF_MEMORY_ERROR; + goto done; + } + + for (off_t total_read = 0; total_read < size; ) { + ssize_t bytes_read = read(fd, buf + total_read, size - total_read); + if (bytes_read < 0 && (errno == EAGAIN || errno == EINTR)) + continue; + if (bytes_read < 0 || !bytes_read) { + err = REFTABLE_IO_ERROR; + goto done; + } + + total_read += bytes_read; + } + buf[size] = 0; + + err = parse_names(buf, size, namesp); +done: + reftable_free(buf); + return err; +} + +int read_lines(const char *filename, char ***namesp) +{ + int fd = open(filename, O_RDONLY); + int err = 0; + if (fd < 0) { + if (errno == ENOENT) { + REFTABLE_CALLOC_ARRAY(*namesp, 1); + if (!*namesp) + return REFTABLE_OUT_OF_MEMORY_ERROR; + return 0; + } + + return REFTABLE_IO_ERROR; + } + err = fd_read_lines(fd, namesp); + close(fd); + return err; +} + +int reftable_stack_init_ref_iterator(struct reftable_stack *st, + struct reftable_iterator *it) +{ + return merged_table_init_iter(reftable_stack_merged_table(st), + it, REFTABLE_BLOCK_TYPE_REF); +} + +int reftable_stack_init_log_iterator(struct reftable_stack *st, + struct reftable_iterator *it) +{ + return merged_table_init_iter(reftable_stack_merged_table(st), + it, REFTABLE_BLOCK_TYPE_LOG); +} + +struct reftable_merged_table * +reftable_stack_merged_table(struct reftable_stack *st) +{ + return st->merged; +} + +static int has_name(char **names, const char *name) +{ + while (*names) { + if (!strcmp(*names, name)) + return 1; + names++; + } + return 0; +} + +/* Close and free the stack */ +void reftable_stack_destroy(struct reftable_stack *st) +{ + char **names = NULL; + int err = 0; + + if (!st) + return; + + if (st->merged) { + reftable_merged_table_free(st->merged); + st->merged = NULL; + } + + err = read_lines(st->list_file, &names); + if (err < 0) { + REFTABLE_FREE_AND_NULL(names); + } + + if (st->tables) { + struct reftable_buf filename = REFTABLE_BUF_INIT; + + for (size_t i = 0; i < st->tables_len; i++) { + const char *name = reftable_table_name(st->tables[i]); + int try_unlinking = 1; + + reftable_buf_reset(&filename); + if (names && !has_name(names, name)) { + if (stack_filename(&filename, st, name) < 0) + try_unlinking = 0; + } + reftable_table_decref(st->tables[i]); + + if (try_unlinking && filename.len) { + /* On Windows, can only unlink after closing. */ + unlink(filename.buf); + } + } + + reftable_buf_release(&filename); + st->tables_len = 0; + REFTABLE_FREE_AND_NULL(st->tables); + } + + if (st->list_fd >= 0) { + close(st->list_fd); + st->list_fd = -1; + } + + REFTABLE_FREE_AND_NULL(st->list_file); + REFTABLE_FREE_AND_NULL(st->reftable_dir); + reftable_free(st); + free_names(names); +} + +static struct reftable_table **stack_copy_tables(struct reftable_stack *st, + size_t cur_len) +{ + struct reftable_table **cur = reftable_calloc(cur_len, sizeof(*cur)); + if (!cur) + return NULL; + for (size_t i = 0; i < cur_len; i++) + cur[i] = st->tables[i]; + return cur; +} + +static int reftable_stack_reload_once(struct reftable_stack *st, + const char **names, + int reuse_open) +{ + size_t cur_len = !st->merged ? 0 : st->merged->tables_len; + struct reftable_table **cur = NULL; + struct reftable_table **reused = NULL; + struct reftable_table **new_tables = NULL; + size_t reused_len = 0, reused_alloc = 0, names_len; + size_t new_tables_len = 0; + struct reftable_merged_table *new_merged = NULL; + struct reftable_buf table_path = REFTABLE_BUF_INIT; + int err = 0; + size_t i; + + if (cur_len) { + cur = stack_copy_tables(st, cur_len); + if (!cur) { + err = REFTABLE_OUT_OF_MEMORY_ERROR; + goto done; + } + } + + names_len = names_length(names); + + if (names_len) { + new_tables = reftable_calloc(names_len, sizeof(*new_tables)); + if (!new_tables) { + err = REFTABLE_OUT_OF_MEMORY_ERROR; + goto done; + } + } + + while (*names) { + struct reftable_table *table = NULL; + const char *name = *names++; + + /* this is linear; we assume compaction keeps the number of + tables under control so this is not quadratic. */ + for (i = 0; reuse_open && i < cur_len; i++) { + if (cur[i] && 0 == strcmp(cur[i]->name, name)) { + table = cur[i]; + cur[i] = NULL; + + /* + * When reloading the stack fails, we end up + * releasing all new tables. This also + * includes the reused tables, even though + * they are still in used by the old stack. We + * thus need to keep them alive here, which we + * do by bumping their refcount. + */ + REFTABLE_ALLOC_GROW_OR_NULL(reused, + reused_len + 1, + reused_alloc); + if (!reused) { + err = REFTABLE_OUT_OF_MEMORY_ERROR; + goto done; + } + reused[reused_len++] = table; + reftable_table_incref(table); + break; + } + } + + if (!table) { + struct reftable_block_source src = { NULL }; + + err = stack_filename(&table_path, st, name); + if (err < 0) + goto done; + + err = reftable_block_source_from_file(&src, + table_path.buf); + if (err < 0) + goto done; + + err = reftable_table_new(&table, &src, name); + if (err < 0) + goto done; + } + + new_tables[new_tables_len] = table; + new_tables_len++; + } + + /* success! */ + err = reftable_merged_table_new(&new_merged, new_tables, + new_tables_len, st->opts.hash_id); + if (err < 0) + goto done; + + /* + * Close the old, non-reused tables and proactively try to unlink + * them. This is done for systems like Windows, where the underlying + * file of such an open table wouldn't have been possible to be + * unlinked by the compacting process. + */ + for (i = 0; i < cur_len; i++) { + if (cur[i]) { + const char *name = reftable_table_name(cur[i]); + + err = stack_filename(&table_path, st, name); + if (err < 0) + goto done; + + reftable_table_decref(cur[i]); + unlink(table_path.buf); + } + } + + /* Update the stack to point to the new tables. */ + if (st->merged) + reftable_merged_table_free(st->merged); + new_merged->suppress_deletions = 1; + st->merged = new_merged; + + if (st->tables) + reftable_free(st->tables); + st->tables = new_tables; + st->tables_len = new_tables_len; + new_tables = NULL; + new_tables_len = 0; + + /* + * Decrement the refcount of reused tables again. This only needs to + * happen on the successful case, because on the unsuccessful one we + * decrement their refcount via `new_tables`. + */ + for (i = 0; i < reused_len; i++) + reftable_table_decref(reused[i]); + +done: + for (i = 0; i < new_tables_len; i++) + reftable_table_decref(new_tables[i]); + reftable_free(new_tables); + reftable_free(reused); + reftable_free(cur); + reftable_buf_release(&table_path); + return err; +} + +static int reftable_stack_reload_maybe_reuse(struct reftable_stack *st, + int reuse_open) +{ + char **names = NULL, **names_after = NULL; + uint64_t deadline; + int64_t delay = 0; + int tries = 0, err; + int fd = -1; + + deadline = reftable_time_ms() + 3000; + + while (1) { + uint64_t now = reftable_time_ms(); + + /* + * Only look at deadlines after the first few times. This + * simplifies debugging in GDB. + */ + tries++; + if (tries > 3 && now >= deadline) + goto out; + + fd = open(st->list_file, O_RDONLY); + if (fd < 0) { + if (errno != ENOENT) { + err = REFTABLE_IO_ERROR; + goto out; + } + + REFTABLE_CALLOC_ARRAY(names, 1); + if (!names) { + err = REFTABLE_OUT_OF_MEMORY_ERROR; + goto out; + } + } else { + err = fd_read_lines(fd, &names); + if (err < 0) + goto out; + } + + err = reftable_stack_reload_once(st, (const char **) names, reuse_open); + if (!err) + break; + if (err != REFTABLE_NOT_EXIST_ERROR) + goto out; + + /* + * REFTABLE_NOT_EXIST_ERROR can be caused by a concurrent + * writer. Check if there was one by checking if the name list + * changed. + */ + err = read_lines(st->list_file, &names_after); + if (err < 0) + goto out; + if (names_equal((const char **) names_after, + (const char **) names)) { + err = REFTABLE_NOT_EXIST_ERROR; + goto out; + } + + free_names(names); + names = NULL; + free_names(names_after); + names_after = NULL; + close(fd); + fd = -1; + + delay = delay + (delay * reftable_rand()) / UINT32_MAX + 1; + poll(NULL, 0, delay); + } + +out: + /* + * Invalidate the stat cache. It is sufficient to only close the file + * descriptor and keep the cached stat info because we never use the + * latter when the former is negative. + */ + if (st->list_fd >= 0) { + close(st->list_fd); + st->list_fd = -1; + } + + /* + * Cache stat information in case it provides a useful signal to us. + * According to POSIX, "The st_ino and st_dev fields taken together + * uniquely identify the file within the system." That being said, + * Windows is not POSIX compliant and we do not have these fields + * available. So the information we have there is insufficient to + * determine whether two file descriptors point to the same file. + * + * While we could fall back to using other signals like the file's + * mtime, those are not sufficient to avoid races. We thus refrain from + * using the stat cache on such systems and fall back to the secondary + * caching mechanism, which is to check whether contents of the file + * have changed. + * + * On other systems which are POSIX compliant we must keep the file + * descriptor open. This is to avoid a race condition where two + * processes access the reftable stack at the same point in time: + * + * 1. A reads the reftable stack and caches its stat info. + * + * 2. B updates the stack, appending a new table to "tables.list". + * This will both use a new inode and result in a different file + * size, thus invalidating A's cache in theory. + * + * 3. B decides to auto-compact the stack and merges two tables. The + * file size now matches what A has cached again. Furthermore, the + * filesystem may decide to recycle the inode number of the file + * we have replaced in (2) because it is not in use anymore. + * + * 4. A reloads the reftable stack. Neither the inode number nor the + * file size changed. If the timestamps did not change either then + * we think the cached copy of our stack is up-to-date. + * + * By keeping the file descriptor open the inode number cannot be + * recycled, mitigating the race. + */ + if (!err && fd >= 0 && !fstat(fd, &st->list_st) && + st->list_st.st_dev && st->list_st.st_ino) { + st->list_fd = fd; + fd = -1; + } + + if (fd >= 0) + close(fd); + free_names(names); + free_names(names_after); + + if (st->opts.on_reload) + st->opts.on_reload(st->opts.on_reload_payload); + + return err; +} + +int reftable_new_stack(struct reftable_stack **dest, const char *dir, + const struct reftable_write_options *_opts) +{ + struct reftable_buf list_file_name = REFTABLE_BUF_INIT; + struct reftable_write_options opts = { 0 }; + struct reftable_stack *p; + int err; + + p = reftable_calloc(1, sizeof(*p)); + if (!p) { + err = REFTABLE_OUT_OF_MEMORY_ERROR; + goto out; + } + + if (_opts) + opts = *_opts; + if (opts.hash_id == 0) + opts.hash_id = REFTABLE_HASH_SHA1; + + *dest = NULL; + + reftable_buf_reset(&list_file_name); + if ((err = reftable_buf_addstr(&list_file_name, dir)) < 0 || + (err = reftable_buf_addstr(&list_file_name, "/tables.list")) < 0) + goto out; + + p->list_file = reftable_buf_detach(&list_file_name); + p->list_fd = -1; + p->opts = opts; + p->reftable_dir = reftable_strdup(dir); + if (!p->reftable_dir) { + err = REFTABLE_OUT_OF_MEMORY_ERROR; + goto out; + } + + err = reftable_stack_reload_maybe_reuse(p, 1); + if (err < 0) + goto out; + + *dest = p; + err = 0; + +out: + if (err < 0) + reftable_stack_destroy(p); + return err; +} + +/* + * Check whether the given stack is up-to-date with what we have in memory. + * Returns 0 if so, 1 if the stack is out-of-date or a negative error code + * otherwise. + */ +static int stack_uptodate(struct reftable_stack *st) +{ + char **names = NULL; + int err; + + /* + * When we have cached stat information available then we use it to + * verify whether the file has been rewritten. + * + * Note that we explicitly do not want to use `stat_validity_check()` + * and friends here because they may end up not comparing the `st_dev` + * and `st_ino` fields. These functions thus cannot guarantee that we + * indeed still have the same file. + */ + if (st->list_fd >= 0) { + struct stat list_st; + + if (stat(st->list_file, &list_st) < 0) { + /* + * It's fine for "tables.list" to not exist. In that + * case, we have to refresh when the loaded stack has + * any tables. + */ + if (errno == ENOENT) + return !!st->tables_len; + return REFTABLE_IO_ERROR; + } + + /* + * When "tables.list" refers to the same file we can assume + * that it didn't change. This is because we always use + * rename(3P) to update the file and never write to it + * directly. + */ + if (st->list_st.st_dev == list_st.st_dev && + st->list_st.st_ino == list_st.st_ino) + return 0; + } + + err = read_lines(st->list_file, &names); + if (err < 0) + return err; + + for (size_t i = 0; i < st->tables_len; i++) { + if (!names[i]) { + err = 1; + goto done; + } + + if (strcmp(st->tables[i]->name, names[i])) { + err = 1; + goto done; + } + } + + if (names[st->merged->tables_len]) { + err = 1; + goto done; + } + +done: + free_names(names); + return err; +} + +int reftable_stack_reload(struct reftable_stack *st) +{ + int err = stack_uptodate(st); + if (err > 0) + return reftable_stack_reload_maybe_reuse(st, 1); + return err; +} + +struct reftable_addition { + struct reftable_flock tables_list_lock; + struct reftable_stack *stack; + + char **new_tables; + size_t new_tables_len, new_tables_cap; + uint64_t next_update_index; +}; + +static void reftable_addition_close(struct reftable_addition *add) +{ + struct reftable_buf nm = REFTABLE_BUF_INIT; + size_t i; + + for (i = 0; i < add->new_tables_len; i++) { + if (!stack_filename(&nm, add->stack, add->new_tables[i])) + unlink(nm.buf); + reftable_free(add->new_tables[i]); + add->new_tables[i] = NULL; + } + reftable_free(add->new_tables); + add->new_tables = NULL; + add->new_tables_len = 0; + add->new_tables_cap = 0; + + flock_release(&add->tables_list_lock); + reftable_buf_release(&nm); +} + +static int reftable_stack_init_addition(struct reftable_addition *add, + struct reftable_stack *st, + unsigned int flags) +{ + struct reftable_buf lock_file_name = REFTABLE_BUF_INIT; + int err; + + memset(add, 0, sizeof(*add)); + add->stack = st; + + err = flock_acquire(&add->tables_list_lock, st->list_file, + st->opts.lock_timeout_ms); + if (err < 0) + goto done; + + if (st->opts.default_permissions) { + if (chmod(add->tables_list_lock.path, + st->opts.default_permissions) < 0) { + err = REFTABLE_IO_ERROR; + goto done; + } + } + + err = stack_uptodate(st); + if (err < 0) + goto done; + if (err > 0 && flags & REFTABLE_STACK_NEW_ADDITION_RELOAD) { + err = reftable_stack_reload_maybe_reuse(add->stack, 1); + if (err) + goto done; + } + if (err > 0) { + err = REFTABLE_OUTDATED_ERROR; + goto done; + } + + add->next_update_index = reftable_stack_next_update_index(st); +done: + if (err) + reftable_addition_close(add); + reftable_buf_release(&lock_file_name); + return err; +} + +static int stack_try_add(struct reftable_stack *st, + int (*write_table)(struct reftable_writer *wr, + void *arg), + void *arg, unsigned flags) +{ + struct reftable_addition add; + int err; + + err = reftable_stack_init_addition(&add, st, flags); + if (err < 0) + goto done; + + err = reftable_addition_add(&add, write_table, arg); + if (err < 0) + goto done; + + err = reftable_addition_commit(&add); +done: + reftable_addition_close(&add); + return err; +} + +int reftable_stack_add(struct reftable_stack *st, + int (*write)(struct reftable_writer *wr, void *arg), + void *arg, unsigned flags) +{ + int err = stack_try_add(st, write, arg, flags); + if (err < 0) { + if (err == REFTABLE_OUTDATED_ERROR) { + /* Ignore error return, we want to propagate + REFTABLE_OUTDATED_ERROR. + */ + reftable_stack_reload(st); + } + return err; + } + + return 0; +} + +static int format_name(struct reftable_buf *dest, uint64_t min, uint64_t max) +{ + char buf[100]; + uint32_t rnd = reftable_rand(); + snprintf(buf, sizeof(buf), "0x%012" PRIx64 "-0x%012" PRIx64 "-%08x", + min, max, rnd); + reftable_buf_reset(dest); + return reftable_buf_addstr(dest, buf); +} + +void reftable_addition_destroy(struct reftable_addition *add) +{ + if (!add) { + return; + } + reftable_addition_close(add); + reftable_free(add); +} + +int reftable_addition_commit(struct reftable_addition *add) +{ + struct reftable_buf table_list = REFTABLE_BUF_INIT; + int err = 0; + size_t i; + + if (add->new_tables_len == 0) + goto done; + + for (i = 0; i < add->stack->merged->tables_len; i++) { + if ((err = reftable_buf_addstr(&table_list, add->stack->tables[i]->name)) < 0 || + (err = reftable_buf_addstr(&table_list, "\n")) < 0) + goto done; + } + for (i = 0; i < add->new_tables_len; i++) { + if ((err = reftable_buf_addstr(&table_list, add->new_tables[i])) < 0 || + (err = reftable_buf_addstr(&table_list, "\n")) < 0) + goto done; + } + + err = reftable_write_data(add->tables_list_lock.fd, + table_list.buf, table_list.len); + reftable_buf_release(&table_list); + if (err < 0) { + err = REFTABLE_IO_ERROR; + goto done; + } + + err = fsync(add->tables_list_lock.fd); + if (err < 0) { + err = REFTABLE_IO_ERROR; + goto done; + } + + err = flock_commit(&add->tables_list_lock); + if (err < 0) { + err = REFTABLE_IO_ERROR; + goto done; + } + + /* success, no more state to clean up. */ + for (i = 0; i < add->new_tables_len; i++) + reftable_free(add->new_tables[i]); + reftable_free(add->new_tables); + add->new_tables = NULL; + add->new_tables_len = 0; + add->new_tables_cap = 0; + + err = reftable_stack_reload_maybe_reuse(add->stack, 1); + if (err) + goto done; + + if (!add->stack->opts.disable_auto_compact) { + /* + * Auto-compact the stack to keep the number of tables in + * control. It is possible that a concurrent writer is already + * trying to compact parts of the stack, which would lead to a + * `REFTABLE_LOCK_ERROR` because parts of the stack are locked + * already. Similarly, the stack may have been rewritten by a + * concurrent writer, which causes `REFTABLE_OUTDATED_ERROR`. + * Both of these errors are benign, so we simply ignore them. + */ + err = reftable_stack_auto_compact(add->stack); + if (err < 0 && err != REFTABLE_LOCK_ERROR && + err != REFTABLE_OUTDATED_ERROR) + goto done; + err = 0; + } + +done: + reftable_addition_close(add); + return err; +} + +int reftable_stack_new_addition(struct reftable_addition **dest, + struct reftable_stack *st, + unsigned int flags) +{ + int err; + + REFTABLE_CALLOC_ARRAY(*dest, 1); + if (!*dest) + return REFTABLE_OUT_OF_MEMORY_ERROR; + + err = reftable_stack_init_addition(*dest, st, flags); + if (err) { + reftable_free(*dest); + *dest = NULL; + } + + return err; +} + +int reftable_addition_add(struct reftable_addition *add, + int (*write_table)(struct reftable_writer *wr, + void *arg), + void *arg) +{ + struct reftable_buf temp_tab_file_name = REFTABLE_BUF_INIT; + struct reftable_buf tab_file_name = REFTABLE_BUF_INIT; + struct reftable_buf next_name = REFTABLE_BUF_INIT; + struct reftable_writer *wr = NULL; + struct reftable_tmpfile tab_file = REFTABLE_TMPFILE_INIT; + struct fd_writer writer = { + .opts = &add->stack->opts, + }; + int err = 0; + + reftable_buf_reset(&next_name); + + err = format_name(&next_name, add->next_update_index, add->next_update_index); + if (err < 0) + goto done; + + err = stack_filename(&temp_tab_file_name, add->stack, next_name.buf); + if (err < 0) + goto done; + + err = reftable_buf_addstr(&temp_tab_file_name, ".temp.XXXXXX"); + if (err < 0) + goto done; + + err = tmpfile_from_pattern(&tab_file, temp_tab_file_name.buf); + if (err < 0) + goto done; + if (add->stack->opts.default_permissions) { + if (chmod(tab_file.path, + add->stack->opts.default_permissions)) { + err = REFTABLE_IO_ERROR; + goto done; + } + } + + writer.fd = tab_file.fd; + err = reftable_writer_new(&wr, fd_writer_write, fd_writer_flush, + &writer, &add->stack->opts); + if (err < 0) + goto done; + + err = write_table(wr, arg); + if (err < 0) + goto done; + + err = reftable_writer_close(wr); + if (err == REFTABLE_EMPTY_TABLE_ERROR) { + err = 0; + goto done; + } + if (err < 0) + goto done; + + err = tmpfile_close(&tab_file); + if (err < 0) + goto done; + + if (wr->min_update_index < add->next_update_index) { + err = REFTABLE_API_ERROR; + goto done; + } + + err = format_name(&next_name, wr->min_update_index, wr->max_update_index); + if (err < 0) + goto done; + + err = reftable_buf_addstr(&next_name, ".ref"); + if (err < 0) + goto done; + + err = stack_filename(&tab_file_name, add->stack, next_name.buf); + if (err < 0) + goto done; + + /* + On windows, this relies on rand() picking a unique destination name. + Maybe we should do retry loop as well? + */ + err = tmpfile_rename(&tab_file, tab_file_name.buf); + if (err < 0) + goto done; + + REFTABLE_ALLOC_GROW_OR_NULL(add->new_tables, add->new_tables_len + 1, + add->new_tables_cap); + if (!add->new_tables) { + err = REFTABLE_OUT_OF_MEMORY_ERROR; + goto done; + } + add->new_tables[add->new_tables_len++] = reftable_buf_detach(&next_name); + +done: + tmpfile_delete(&tab_file); + reftable_buf_release(&temp_tab_file_name); + reftable_buf_release(&tab_file_name); + reftable_buf_release(&next_name); + reftable_writer_free(wr); + return err; +} + +uint64_t reftable_stack_next_update_index(struct reftable_stack *st) +{ + int sz = st->merged->tables_len; + if (sz > 0) + return reftable_table_max_update_index(st->tables[sz - 1]) + + 1; + return 1; +} + +static int stack_write_compact(struct reftable_stack *st, + struct reftable_writer *wr, + size_t first, size_t last, + struct reftable_log_expiry_config *config) +{ + struct reftable_merged_table *mt = NULL; + struct reftable_iterator it = { NULL }; + struct reftable_ref_record ref = { NULL }; + struct reftable_log_record log = { NULL }; + size_t subtabs_len = last - first + 1; + uint64_t entries = 0; + int err = 0; + + for (size_t i = first; i <= last; i++) + st->stats.bytes += st->tables[i]->size; + err = reftable_writer_set_limits(wr, st->tables[first]->min_update_index, + st->tables[last]->max_update_index); + if (err < 0) + goto done; + + err = reftable_merged_table_new(&mt, st->tables + first, subtabs_len, + st->opts.hash_id); + if (err < 0) + goto done; + + err = merged_table_init_iter(mt, &it, REFTABLE_BLOCK_TYPE_REF); + if (err < 0) + goto done; + + err = reftable_iterator_seek_ref(&it, ""); + if (err < 0) + goto done; + + while (1) { + err = reftable_iterator_next_ref(&it, &ref); + if (err > 0) { + err = 0; + break; + } + if (err < 0) + goto done; + + if (first == 0 && reftable_ref_record_is_deletion(&ref)) { + continue; + } + + err = reftable_writer_add_ref(wr, &ref); + if (err < 0) + goto done; + entries++; + } + reftable_iterator_destroy(&it); + + err = merged_table_init_iter(mt, &it, REFTABLE_BLOCK_TYPE_LOG); + if (err < 0) + goto done; + + err = reftable_iterator_seek_log(&it, ""); + if (err < 0) + goto done; + + while (1) { + err = reftable_iterator_next_log(&it, &log); + if (err > 0) { + err = 0; + break; + } + if (err < 0) + goto done; + if (first == 0 && reftable_log_record_is_deletion(&log)) { + continue; + } + + if (config && config->min_update_index > 0 && + log.update_index < config->min_update_index) { + continue; + } + + if (config && config->time > 0 && + log.value.update.time < config->time) { + continue; + } + + err = reftable_writer_add_log(wr, &log); + if (err < 0) + goto done; + entries++; + } + +done: + reftable_iterator_destroy(&it); + if (mt) + reftable_merged_table_free(mt); + reftable_ref_record_release(&ref); + reftable_log_record_release(&log); + st->stats.entries_written += entries; + return err; +} + +static int stack_compact_locked(struct reftable_stack *st, + size_t first, size_t last, + struct reftable_log_expiry_config *config, + struct reftable_tmpfile *tab_file_out) +{ + struct reftable_buf next_name = REFTABLE_BUF_INIT; + struct reftable_buf tab_file_path = REFTABLE_BUF_INIT; + struct reftable_writer *wr = NULL; + struct fd_writer writer= { + .opts = &st->opts, + }; + struct reftable_tmpfile tab_file = REFTABLE_TMPFILE_INIT; + int err = 0; + + err = format_name(&next_name, reftable_table_min_update_index(st->tables[first]), + reftable_table_max_update_index(st->tables[last])); + if (err < 0) + goto done; + + err = stack_filename(&tab_file_path, st, next_name.buf); + if (err < 0) + goto done; + + err = reftable_buf_addstr(&tab_file_path, ".temp.XXXXXX"); + if (err < 0) + goto done; + + err = tmpfile_from_pattern(&tab_file, tab_file_path.buf); + if (err < 0) + goto done; + + if (st->opts.default_permissions && + chmod(tab_file.path, st->opts.default_permissions) < 0) { + err = REFTABLE_IO_ERROR; + goto done; + } + + writer.fd = tab_file.fd; + err = reftable_writer_new(&wr, fd_writer_write, fd_writer_flush, + &writer, &st->opts); + if (err < 0) + goto done; + + err = stack_write_compact(st, wr, first, last, config); + if (err < 0) + goto done; + + err = reftable_writer_close(wr); + if (err < 0) + goto done; + + err = tmpfile_close(&tab_file); + if (err < 0) + goto done; + + *tab_file_out = tab_file; + tab_file = REFTABLE_TMPFILE_INIT; + +done: + tmpfile_delete(&tab_file); + reftable_writer_free(wr); + reftable_buf_release(&next_name); + reftable_buf_release(&tab_file_path); + return err; +} + +enum stack_compact_range_flags { + /* + * Perform a best-effort compaction. That is, even if we cannot lock + * all tables in the specified range, we will try to compact the + * remaining slice. + */ + STACK_COMPACT_RANGE_BEST_EFFORT = (1 << 0), +}; + +/* + * Compact all tables in the range `[first, last)` into a single new table. + * + * This function returns `0` on success or a code `< 0` on failure. When the + * stack or any of the tables in the specified range are already locked then + * this function returns `REFTABLE_LOCK_ERROR`. This is a benign error that + * callers can either ignore, or they may choose to retry compaction after some + * amount of time. + */ +static int stack_compact_range(struct reftable_stack *st, + size_t first, size_t last, + struct reftable_log_expiry_config *expiry, + unsigned int flags) +{ + struct reftable_buf tables_list_buf = REFTABLE_BUF_INIT; + struct reftable_buf new_table_name = REFTABLE_BUF_INIT; + struct reftable_buf new_table_path = REFTABLE_BUF_INIT; + struct reftable_buf table_name = REFTABLE_BUF_INIT; + struct reftable_flock tables_list_lock = REFTABLE_FLOCK_INIT; + struct reftable_flock *table_locks = NULL; + struct reftable_tmpfile new_table = REFTABLE_TMPFILE_INIT; + int is_empty_table = 0, err = 0; + size_t first_to_replace, last_to_replace; + size_t i, nlocks = 0; + char **names = NULL; + + if (first > last || (!expiry && first == last)) { + err = 0; + goto done; + } + + st->stats.attempts++; + + /* + * Hold the lock so that we can read "tables.list" and lock all tables + * which are part of the user-specified range. + */ + err = flock_acquire(&tables_list_lock, st->list_file, st->opts.lock_timeout_ms); + if (err < 0) + goto done; + + /* + * Check whether the stack is up-to-date. We unfortunately cannot + * handle the situation gracefully in case it's _not_ up-to-date + * because the range of tables that the user has requested us to + * compact may have been changed. So instead we abort. + * + * We could in theory improve the situation by having the caller not + * pass in a range, but instead the list of tables to compact. If so, + * we could check that relevant tables still exist. But for now it's + * good enough to just abort. + */ + err = stack_uptodate(st); + if (err < 0) + goto done; + if (err > 0) { + err = REFTABLE_OUTDATED_ERROR; + goto done; + } + + /* + * Lock all tables in the user-provided range. This is the slice of our + * stack which we'll compact. + * + * Note that we lock tables in reverse order from last to first. The + * intent behind this is to allow a newer process to perform best + * effort compaction of tables that it has added in the case where an + * older process is still busy compacting tables which are preexisting + * from the point of view of the newer process. + */ + REFTABLE_ALLOC_ARRAY(table_locks, last - first + 1); + if (!table_locks) { + err = REFTABLE_OUT_OF_MEMORY_ERROR; + goto done; + } + for (i = 0; i < last - first + 1; i++) + table_locks[i] = REFTABLE_FLOCK_INIT; + + for (i = last + 1; i > first; i--) { + err = stack_filename(&table_name, st, reftable_table_name(st->tables[i - 1])); + if (err < 0) + goto done; + + err = flock_acquire(&table_locks[nlocks], table_name.buf, 0); + if (err < 0) { + /* + * When the table is locked already we may do a + * best-effort compaction and compact only the tables + * that we have managed to lock so far. This of course + * requires that we have been able to lock at least two + * tables, otherwise there would be nothing to compact. + * In that case, we return a lock error to our caller. + */ + if (err == REFTABLE_LOCK_ERROR && last - (i - 1) >= 2 && + flags & STACK_COMPACT_RANGE_BEST_EFFORT) { + err = 0; + /* + * The subtraction is to offset the index, the + * addition is to only compact up to the table + * of the preceding iteration. They obviously + * cancel each other out, but that may be + * non-obvious when it was omitted. + */ + first = (i - 1) + 1; + break; + } + + goto done; + } + + /* + * We need to close the lockfiles as we might otherwise easily + * run into file descriptor exhaustion when we compress a lot + * of tables. + */ + err = flock_close(&table_locks[nlocks++]); + if (err < 0) + goto done; + } + + /* + * We have locked all tables in our range and can thus release the + * "tables.list" lock while compacting the locked tables. This allows + * concurrent updates to the stack to proceed. + */ + err = flock_release(&tables_list_lock); + if (err < 0) { + err = REFTABLE_IO_ERROR; + goto done; + } + + /* + * Compact the now-locked tables into a new table. Note that compacting + * these tables may end up with an empty new table in case tombstones + * end up cancelling out all refs in that range. + */ + err = stack_compact_locked(st, first, last, expiry, &new_table); + if (err < 0) { + if (err != REFTABLE_EMPTY_TABLE_ERROR) + goto done; + is_empty_table = 1; + } + + /* + * Now that we have written the new, compacted table we need to re-lock + * "tables.list". We'll then replace the compacted range of tables with + * the new table. + */ + err = flock_acquire(&tables_list_lock, st->list_file, st->opts.lock_timeout_ms); + if (err < 0) + goto done; + + if (st->opts.default_permissions) { + if (chmod(tables_list_lock.path, + st->opts.default_permissions) < 0) { + err = REFTABLE_IO_ERROR; + goto done; + } + } + + /* + * As we have unlocked the stack while compacting our slice of tables + * it may have happened that a concurrently running process has updated + * the stack while we were compacting. In that case, we need to check + * whether the tables that we have just compacted still exist in the + * stack in the exact same order as we have compacted them. + * + * If they do exist, then it is fine to continue and replace those + * tables with our compacted version. If they don't, then we need to + * abort. + */ + err = stack_uptodate(st); + if (err < 0) + goto done; + if (err > 0) { + ssize_t new_offset = -1; + int fd; + + fd = open(st->list_file, O_RDONLY); + if (fd < 0) { + err = REFTABLE_IO_ERROR; + goto done; + } + + err = fd_read_lines(fd, &names); + close(fd); + if (err < 0) + goto done; + + /* + * Search for the offset of the first table that we have + * compacted in the updated "tables.list" file. + */ + for (size_t i = 0; names[i]; i++) { + if (strcmp(names[i], st->tables[first]->name)) + continue; + + /* + * We have found the first entry. Verify that all the + * subsequent tables we have compacted still exist in + * the modified stack in the exact same order as we + * have compacted them. + */ + for (size_t j = 1; j < last - first + 1; j++) { + const char *old = first + j < st->merged->tables_len ? + st->tables[first + j]->name : NULL; + const char *new = names[i + j]; + + /* + * If some entries are missing or in case the tables + * have changed then we need to bail out. Again, this + * shouldn't ever happen because we have locked the + * tables we are compacting. + */ + if (!old || !new || strcmp(old, new)) { + err = REFTABLE_OUTDATED_ERROR; + goto done; + } + } + + new_offset = i; + break; + } + + /* + * In case we didn't find our compacted tables in the stack we + * need to bail out. In theory, this should have never happened + * because we locked the tables we are compacting. + */ + if (new_offset < 0) { + err = REFTABLE_OUTDATED_ERROR; + goto done; + } + + /* + * We have found the new range that we want to replace, so + * let's update the range of tables that we want to replace. + */ + first_to_replace = new_offset; + last_to_replace = last + (new_offset - first); + } else { + /* + * `fd_read_lines()` uses a `NULL` sentinel to indicate that + * the array is at its end. As we use `free_names()` to free + * the array, we need to include this sentinel value here and + * thus have to allocate `tables_len + 1` many entries. + */ + REFTABLE_CALLOC_ARRAY(names, st->merged->tables_len + 1); + if (!names) { + err = REFTABLE_OUT_OF_MEMORY_ERROR; + goto done; + } + + for (size_t i = 0; i < st->merged->tables_len; i++) { + names[i] = reftable_strdup(st->tables[i]->name); + if (!names[i]) { + err = REFTABLE_OUT_OF_MEMORY_ERROR; + goto done; + } + } + first_to_replace = first; + last_to_replace = last; + } + + /* + * If the resulting compacted table is not empty, then we need to move + * it into place now. + */ + if (!is_empty_table) { + err = format_name(&new_table_name, st->tables[first]->min_update_index, + st->tables[last]->max_update_index); + if (err < 0) + goto done; + + err = reftable_buf_addstr(&new_table_name, ".ref"); + if (err < 0) + goto done; + + err = stack_filename(&new_table_path, st, new_table_name.buf); + if (err < 0) + goto done; + + err = tmpfile_rename(&new_table, new_table_path.buf); + if (err < 0) + goto done; + } + + /* + * Write the new "tables.list" contents with the compacted table we + * have just written. In case the compacted table became empty we + * simply skip writing it. + */ + for (i = 0; i < first_to_replace; i++) { + if ((err = reftable_buf_addstr(&tables_list_buf, names[i])) < 0 || + (err = reftable_buf_addstr(&tables_list_buf, "\n")) < 0) + goto done; + } + if (!is_empty_table) { + if ((err = reftable_buf_addstr(&tables_list_buf, new_table_name.buf)) < 0 || + (err = reftable_buf_addstr(&tables_list_buf, "\n")) < 0) + goto done; + } + for (i = last_to_replace + 1; names[i]; i++) { + if ((err = reftable_buf_addstr(&tables_list_buf, names[i])) < 0 || + (err = reftable_buf_addstr(&tables_list_buf, "\n")) < 0) + goto done; + } + + err = reftable_write_data(tables_list_lock.fd, + tables_list_buf.buf, tables_list_buf.len); + if (err < 0) { + err = REFTABLE_IO_ERROR; + unlink(new_table_path.buf); + goto done; + } + + err = fsync(tables_list_lock.fd); + if (err < 0) { + err = REFTABLE_IO_ERROR; + unlink(new_table_path.buf); + goto done; + } + + err = flock_commit(&tables_list_lock); + if (err < 0) { + err = REFTABLE_IO_ERROR; + unlink(new_table_path.buf); + goto done; + } + + /* + * Reload the stack before deleting the compacted tables. We can only + * delete the files after we closed them on Windows, so this needs to + * happen first. + */ + err = reftable_stack_reload_maybe_reuse(st, first < last); + if (err < 0) + goto done; + + /* + * Delete the old tables. They may still be in use by concurrent + * readers, so it is expected that unlinking tables may fail. + */ + for (i = 0; i < nlocks; i++) { + struct reftable_flock *table_lock = &table_locks[i]; + + reftable_buf_reset(&table_name); + err = reftable_buf_add(&table_name, table_lock->path, + strlen(table_lock->path) - strlen(".lock")); + if (err) + continue; + + unlink(table_name.buf); + } + +done: + flock_release(&tables_list_lock); + for (i = 0; table_locks && i < nlocks; i++) + flock_release(&table_locks[i]); + reftable_free(table_locks); + + tmpfile_delete(&new_table); + reftable_buf_release(&new_table_name); + reftable_buf_release(&new_table_path); + reftable_buf_release(&tables_list_buf); + reftable_buf_release(&table_name); + free_names(names); + + if (err == REFTABLE_LOCK_ERROR) + st->stats.failures++; + + return err; +} + +int reftable_stack_compact_all(struct reftable_stack *st, + struct reftable_log_expiry_config *config) +{ + size_t last = st->merged->tables_len ? st->merged->tables_len - 1 : 0; + return stack_compact_range(st, 0, last, config, 0); +} + +static int segment_size(struct segment *s) +{ + return s->end - s->start; +} + +struct segment suggest_compaction_segment(uint64_t *sizes, size_t n, + uint8_t factor) +{ + struct segment seg = { 0 }; + uint64_t bytes; + size_t i; + + if (!factor) + factor = DEFAULT_GEOMETRIC_FACTOR; + + /* + * If there are no tables or only a single one then we don't have to + * compact anything. The sequence is geometric by definition already. + */ + if (n <= 1) + return seg; + + /* + * Find the ending table of the compaction segment needed to restore the + * geometric sequence. Note that the segment end is exclusive. + * + * To do so, we iterate backwards starting from the most recent table + * until a valid segment end is found. If the preceding table is smaller + * than the current table multiplied by the geometric factor (2), the + * compaction segment end has been identified. + * + * Tables after the ending point are not added to the byte count because + * they are already valid members of the geometric sequence. Due to the + * properties of a geometric sequence, it is not possible for the sum of + * these tables to exceed the value of the ending point table. + * + * Example table size sequence requiring no compaction: + * 64, 32, 16, 8, 4, 2, 1 + * + * Example table size sequence where compaction segment end is set to + * the last table. Since the segment end is exclusive, the last table is + * excluded during subsequent compaction and the table with size 3 is + * the final table included: + * 64, 32, 16, 8, 4, 3, 1 + */ + for (i = n - 1; i > 0; i--) { + if (sizes[i - 1] < sizes[i] * factor) { + seg.end = i + 1; + bytes = sizes[i]; + break; + } + } + + /* + * Find the starting table of the compaction segment by iterating + * through the remaining tables and keeping track of the accumulated + * size of all tables seen from the segment end table. The previous + * table is compared to the accumulated size because the tables from the + * segment end are merged backwards recursively. + * + * Note that we keep iterating even after we have found the first + * starting point. This is because there may be tables in the stack + * preceding that first starting point which violate the geometric + * sequence. + * + * Example compaction segment start set to table with size 32: + * 128, 32, 16, 8, 4, 3, 1 + */ + for (; i > 0; i--) { + uint64_t curr = bytes; + bytes += sizes[i - 1]; + + if (sizes[i - 1] < curr * factor) { + seg.start = i - 1; + seg.bytes = bytes; + } + } + + return seg; +} + +static int stack_segments_for_compaction(struct reftable_stack *st, + struct segment *seg) +{ + int version = (st->opts.hash_id == REFTABLE_HASH_SHA1) ? 1 : 2; + int overhead = header_size(version) - 1; + uint64_t *sizes; + + REFTABLE_CALLOC_ARRAY(sizes, st->merged->tables_len); + if (!sizes) + return REFTABLE_OUT_OF_MEMORY_ERROR; + + for (size_t i = 0; i < st->merged->tables_len; i++) + sizes[i] = st->tables[i]->size - overhead; + + *seg = suggest_compaction_segment(sizes, st->merged->tables_len, + st->opts.auto_compaction_factor); + reftable_free(sizes); + + return 0; +} + +static int update_segment_if_compaction_required(struct reftable_stack *st, + struct segment *seg, + bool use_geometric, + bool *required) +{ + int err; + + if (st->merged->tables_len < 2) { + *required = false; + return 0; + } + + if (!use_geometric) { + *required = true; + return 0; + } + + err = stack_segments_for_compaction(st, seg); + if (err) + return err; + + *required = segment_size(seg) > 0; + return 0; +} + +int reftable_stack_compaction_required(struct reftable_stack *st, + bool use_heuristics, + bool *required) +{ + struct segment seg; + return update_segment_if_compaction_required(st, &seg, use_heuristics, + required); +} + +int reftable_stack_auto_compact(struct reftable_stack *st) +{ + struct segment seg; + bool required; + int err; + + err = update_segment_if_compaction_required(st, &seg, true, &required); + if (err) + return err; + + if (required) + return stack_compact_range(st, seg.start, seg.end - 1, + NULL, STACK_COMPACT_RANGE_BEST_EFFORT); + + return 0; +} + +struct reftable_compaction_stats * +reftable_stack_compaction_stats(struct reftable_stack *st) +{ + return &st->stats; +} + +int reftable_stack_read_ref(struct reftable_stack *st, const char *refname, + struct reftable_ref_record *ref) +{ + struct reftable_iterator it = { 0 }; + int ret; + + ret = reftable_merged_table_init_ref_iterator(st->merged, &it); + if (ret) + goto out; + + ret = reftable_iterator_seek_ref(&it, refname); + if (ret) + goto out; + + ret = reftable_iterator_next_ref(&it, ref); + if (ret) + goto out; + + if (strcmp(ref->refname, refname) || + reftable_ref_record_is_deletion(ref)) { + reftable_ref_record_release(ref); + ret = 1; + goto out; + } + +out: + reftable_iterator_destroy(&it); + return ret; +} + +int reftable_stack_read_log(struct reftable_stack *st, const char *refname, + struct reftable_log_record *log) +{ + struct reftable_iterator it = {0}; + int err; + + err = reftable_stack_init_log_iterator(st, &it); + if (err) + goto done; + + err = reftable_iterator_seek_log(&it, refname); + if (err) + goto done; + + err = reftable_iterator_next_log(&it, log); + if (err) + goto done; + + if (strcmp(log->refname, refname) || + reftable_log_record_is_deletion(log)) { + err = 1; + goto done; + } + +done: + if (err) { + reftable_log_record_release(log); + } + reftable_iterator_destroy(&it); + return err; +} + +static int is_table_name(const char *s) +{ + const char *dot = strrchr(s, '.'); + return dot && !strcmp(dot, ".ref"); +} + +static void remove_maybe_stale_table(struct reftable_stack *st, uint64_t max, + const char *name) +{ + int err = 0; + uint64_t update_idx = 0; + struct reftable_block_source src = { NULL }; + struct reftable_table *table = NULL; + struct reftable_buf table_path = REFTABLE_BUF_INIT; + + err = stack_filename(&table_path, st, name); + if (err < 0) + goto done; + + err = reftable_block_source_from_file(&src, table_path.buf); + if (err < 0) + goto done; + + err = reftable_table_new(&table, &src, name); + if (err < 0) + goto done; + + update_idx = reftable_table_max_update_index(table); + reftable_table_decref(table); + + if (update_idx <= max) { + unlink(table_path.buf); + } +done: + reftable_buf_release(&table_path); +} + +static int reftable_stack_clean_locked(struct reftable_stack *st) +{ + uint64_t max = reftable_merged_table_max_update_index( + reftable_stack_merged_table(st)); + DIR *dir = opendir(st->reftable_dir); + struct dirent *d = NULL; + if (!dir) { + return REFTABLE_IO_ERROR; + } + + while ((d = readdir(dir))) { + int found = 0; + if (!is_table_name(d->d_name)) + continue; + + for (size_t i = 0; !found && i < st->tables_len; i++) + found = !strcmp(reftable_table_name(st->tables[i]), d->d_name); + if (found) + continue; + + remove_maybe_stale_table(st, max, d->d_name); + } + + closedir(dir); + return 0; +} + +int reftable_stack_clean(struct reftable_stack *st) +{ + struct reftable_addition *add = NULL; + int err = reftable_stack_new_addition(&add, st, 0); + if (err < 0) { + goto done; + } + + err = reftable_stack_reload(st); + if (err < 0) { + goto done; + } + + err = reftable_stack_clean_locked(st); + +done: + reftable_addition_destroy(add); + return err; +} + +enum reftable_hash reftable_stack_hash_id(struct reftable_stack *st) +{ + return reftable_merged_table_hash_id(st->merged); +} diff --git a/deps/reftable/stack.h b/deps/reftable/stack.h new file mode 100644 index 000000000..bc28f2998 --- /dev/null +++ b/deps/reftable/stack.h @@ -0,0 +1,41 @@ +/* + * Copyright 2020 Google LLC + * + * Use of this source code is governed by a BSD-style + * license that can be found in the LICENSE file or at + * https://developers.google.com/open-source/licenses/bsd + */ + +#ifndef STACK_H +#define STACK_H + +#include "system.h" +#include "reftable-writer.h" +#include "reftable-stack.h" + +struct reftable_stack { + struct stat list_st; + char *list_file; + int list_fd; + + char *reftable_dir; + + struct reftable_write_options opts; + + struct reftable_table **tables; + size_t tables_len; + struct reftable_merged_table *merged; + struct reftable_compaction_stats stats; +}; + +int read_lines(const char *filename, char ***lines); + +struct segment { + size_t start, end; + uint64_t bytes; +}; + +struct segment suggest_compaction_segment(uint64_t *sizes, size_t n, + uint8_t factor); + +#endif diff --git a/deps/reftable/system.c b/deps/reftable/system.c new file mode 100644 index 000000000..174038cdd --- /dev/null +++ b/deps/reftable/system.c @@ -0,0 +1,259 @@ +#include "system.h" +#include "basics.h" +#include "rand.h" +#include "reftable-error.h" + +uint32_t reftable_rand(void) +{ + return (uint32_t) git_rand_next(); +} + +int tmpfile_from_pattern(struct reftable_tmpfile *out, const char *pattern) +{ + git_str path = GIT_STR_INIT; + unsigned tries = 32; + + if (git__suffixcmp(pattern, ".XXXXXX")) + return REFTABLE_API_ERROR; + + while (tries--) { + uint64_t rand = git_rand_next(); + int fd; + + git_str_sets(&path, pattern); + git_str_shorten(&path, 6); + git_str_encode_hexstr(&path, (void *)&rand, 6); + + if (git_str_oom(&path)) + return REFTABLE_OUT_OF_MEMORY_ERROR; + + if ((fd = p_open(path.ptr, O_CREAT | O_RDWR | O_EXCL | O_CLOEXEC, 0666)) < 0) + continue; + + out->path = git_str_detach(&path); + out->fd = fd; + return 0; + } + + git_str_dispose(&path); + return REFTABLE_IO_ERROR; +} + +int tmpfile_close(struct reftable_tmpfile *t) +{ + int ret; + + if (t->fd < 0) + return 0; + ret = close(t->fd); + t->fd = -1; + + if (ret < 0) + return REFTABLE_IO_ERROR; + return 0; +} + +int tmpfile_delete(struct reftable_tmpfile *t) +{ + int ret; + + if (!t->path) + return 0; + + tmpfile_close(t); + if ((ret = unlink(t->path)) < 0) + return REFTABLE_IO_ERROR; + + reftable_free((char *) t->path); + t->path = NULL; + + return 0; +} + +int tmpfile_rename(struct reftable_tmpfile *t, const char *path) +{ + int ret; + + if (!t->path) + return REFTABLE_API_ERROR; + + tmpfile_close(t); + + if ((ret = p_rename(t->path, path)) < 0) + return REFTABLE_IO_ERROR; + + reftable_free((char *) t->path); + t->path = NULL; + + return 0; +} + +struct libgit2_flock { + char *lock_path; + char *target_path; +}; + +int flock_acquire(struct reftable_flock *l, const char *target_path, + long timeout_ms) +{ + struct libgit2_flock *flock; + unsigned multiplier = 1, n = 1; + size_t lock_path_len; + uint64_t deadline; + int fd = -1, error; + + lock_path_len = strlen(target_path) + strlen(".lock") + 1; + if ((flock = reftable_calloc(sizeof(*flock), 1)) == NULL || + (flock->target_path = reftable_strdup(target_path)) == NULL || + (flock->lock_path = reftable_malloc(lock_path_len)) == NULL) { + error = REFTABLE_OUT_OF_MEMORY_ERROR; + goto out; + } + + snprintf(flock->lock_path, lock_path_len, "%s.lock", target_path); + + deadline = git_time_monotonic() + timeout_ms; + + while (1) { + uint64_t now, wait_ms; + + if ((fd = p_open(flock->lock_path, O_WRONLY | O_EXCL | O_CREAT, 0666)) >= 0) + break; + if (errno != EEXIST) { + error = REFTABLE_IO_ERROR; + goto out; + } + + now = git_time_monotonic(); + if (now > deadline) { + error = REFTABLE_LOCK_ERROR; + goto out; + } + + wait_ms = (750 + rand() % 500) * multiplier / 1000; + multiplier += 2 * n + 1; + + if (multiplier > 1000) + multiplier = 1000; + else + n++; + + p_poll(NULL, 0, (int) wait_ms); + } + + l->priv = flock; + l->path = flock->lock_path; + l->fd = fd; + + error = 0; + +out: + if (error) { + if (flock) { + reftable_free(flock->target_path); + reftable_free(flock->lock_path); + } + reftable_free(flock); + } + + return error; +} + +int flock_close(struct reftable_flock *l) +{ + int ret; + + if (l->fd < 0) + return 0; + + ret = p_close(l->fd); + l->fd = -1; + + if (ret < 0) + return REFTABLE_IO_ERROR; + return 0; +} + +static void libgit2_flock_release(struct reftable_flock *l) +{ + struct libgit2_flock *flock = l->priv; + reftable_free(flock->lock_path); + reftable_free(flock->target_path); + reftable_free(flock); + l->priv = NULL; + l->path = NULL; +} + +int flock_release(struct reftable_flock *l) +{ + struct libgit2_flock *flock = l->priv; + int ret; + + if (!flock) + return 0; + + flock_close(l); + + if ((ret = p_unlink(flock->lock_path)) < 0) + goto out; + +out: + libgit2_flock_release(l); + if (ret < 0) + return REFTABLE_IO_ERROR; + return 0; +} + +int flock_commit(struct reftable_flock *l) +{ + struct libgit2_flock *flock = l->priv; + int ret; + + flock_close(l); + + if (!flock) + return REFTABLE_API_ERROR; + + if ((ret = p_rename(flock->lock_path, flock->target_path)) < 0) + goto out; + +out: + libgit2_flock_release(l); + if (ret < 0) + return REFTABLE_IO_ERROR; + return 0; +} + +uint64_t reftable_time_ms(void) +{ + return git_time_monotonic(); +} + +int reftable_mmap(struct reftable_mmap *out, int fd, size_t len) +{ + git_map *mmap; + + mmap = git__malloc(sizeof(*mmap)); + if (!mmap) + return REFTABLE_OUT_OF_MEMORY_ERROR; + + if (p_mmap(mmap, len, GIT_PROT_READ, GIT_MAP_PRIVATE, fd, 0) < 0) + return REFTABLE_IO_ERROR; + + out->priv = mmap; + out->data = mmap->data; + out->size = mmap->len; + + return 0; +} + +int reftable_munmap(struct reftable_mmap *mmap) +{ + git_map *map = mmap->priv; + + if (p_munmap(map) < 0) + return REFTABLE_IO_ERROR; + git__free(map); + memset(mmap, 0, sizeof(*mmap)); + return 0; +} diff --git a/deps/reftable/system.h b/deps/reftable/system.h new file mode 100644 index 000000000..c0e2cbe0f --- /dev/null +++ b/deps/reftable/system.h @@ -0,0 +1,135 @@ +/* + * Copyright 2020 Google LLC + * + * Use of this source code is governed by a BSD-style + * license that can be found in the LICENSE file or at + * https://developers.google.com/open-source/licenses/bsd + */ + +#ifndef SYSTEM_H +#define SYSTEM_H + +/* + * This header defines the platform-agnostic interface that is to be + * implemented by the project to make it work on their respective supported + * systems, and to integrate it into the project itself. This header is not + * expected to be changed by the individual project. + */ + +#include "reftable-system.h" + +/* + * Return a random 32 bit integer. This function is expected to return + * pre-seeded data. + */ +uint32_t reftable_rand(void); + +/* + * An implementation-specific temporary file. By making this specific to the + * implementation it becomes possible to tie temporary files into any kind of + * signal or atexit handlers for cleanup on abnormal situations. + */ +struct reftable_tmpfile { + const char *path; + int fd; + void *priv; +}; +#define REFTABLE_TMPFILE_INIT ((struct reftable_tmpfile) { .fd = -1, }) + +/* + * Create a temporary file from a pattern similar to how mkstemp(3p) would. + * The `pattern` shall not be modified. On success, the structure at `out` has + * been initialized such that it is ready for use. Returns 0 on success, a + * reftable error code on error. + */ +int tmpfile_from_pattern(struct reftable_tmpfile *out, const char *pattern); + +/* + * Close the temporary file's file descriptor without removing the file itself. + * This is a no-op in case the file has already been closed beforehand. Returns + * 0 on success, a reftable error code on error. + */ +int tmpfile_close(struct reftable_tmpfile *t); + +/* + * Close the temporary file and delete it. This is a no-op in case the file has + * already been deleted or renamed beforehand. Returns 0 on success, a reftable + * error code on error. + */ +int tmpfile_delete(struct reftable_tmpfile *t); + +/* + * Rename the temporary file to the provided path. The temporary file must be + * active. Return 0 on success, a reftable error code on error. Deactivates the + * temporary file. + */ +int tmpfile_rename(struct reftable_tmpfile *t, const char *path); + +/* + * An implementation-specific file lock. Same as with `reftable_tmpfile`, + * making this specific to the implementation makes it possible to tie this + * into signal or atexit handlers such that we know to clean up stale locks on + * abnormal exits. + */ +struct reftable_flock { + const char *path; + int fd; + void *priv; +}; +#define REFTABLE_FLOCK_INIT ((struct reftable_flock){ .fd = -1, }) + +/* + * Acquire the lock for the given target path by exclusively creating a file + * with ".lock" appended to it. If that lock exists, we wait up to `timeout_ms` + * to acquire the lock. If `timeout_ms` is 0 we don't wait, if it is negative + * we block indefinitely. + * + * Retrun 0 on success, a reftable error code on error. Specifically, + * `REFTABLE_LOCK_ERROR` should be returned in case the target path is already + * locked. + */ +int flock_acquire(struct reftable_flock *l, const char *target_path, + long timeout_ms); + +/* + * Close the lockfile's file descriptor without removing the lock itself. This + * is a no-op in case the lockfile has already been closed beforehand. Returns + * 0 on success, a reftable error code on error. + */ +int flock_close(struct reftable_flock *l); + +/* + * Release the lock by unlinking the lockfile. This is a no-op in case the + * lockfile has already been released or committed beforehand. Returns 0 on + * success, a reftable error code on error. + */ +int flock_release(struct reftable_flock *l); + +/* + * Commit the lock by renaming the lockfile into place. Returns 0 on success, a + * reftable error code on error. + */ +int flock_commit(struct reftable_flock *l); + +/* Report the time in milliseconds. */ +uint64_t reftable_time_ms(void); + +struct reftable_mmap { + void *data; + size_t size; + void *priv; +}; + +/* + * Map the file into memory. Returns 0 on success, a reftable error code on + * error. + */ +int reftable_mmap(struct reftable_mmap *out, int fd, size_t len); + +/* + * Unmap the file from memory. Returns 0 on success, a reftable error code on + * error. + */ +int reftable_munmap(struct reftable_mmap *mmap); + +#endif diff --git a/deps/reftable/table.c b/deps/reftable/table.c new file mode 100644 index 000000000..56362df0e --- /dev/null +++ b/deps/reftable/table.c @@ -0,0 +1,779 @@ +/* + * Copyright 2020 Google LLC + * + * Use of this source code is governed by a BSD-style + * license that can be found in the LICENSE file or at + * https://developers.google.com/open-source/licenses/bsd + */ + +#include "table.h" + +#include "system.h" +#include "block.h" +#include "blocksource.h" +#include "constants.h" +#include "iter.h" +#include "record.h" +#include "reftable-error.h" + +static struct reftable_table_offsets * +table_offsets_for(struct reftable_table *t, uint8_t typ) +{ + switch (typ) { + case REFTABLE_BLOCK_TYPE_REF: + return &t->ref_offsets; + case REFTABLE_BLOCK_TYPE_LOG: + return &t->log_offsets; + case REFTABLE_BLOCK_TYPE_OBJ: + return &t->obj_offsets; + } + abort(); +} + +enum reftable_hash reftable_table_hash_id(struct reftable_table *t) +{ + return t->hash_id; +} + +const char *reftable_table_name(struct reftable_table *t) +{ + return t->name; +} + +static int parse_footer(struct reftable_table *t, uint8_t *footer, + uint8_t *header) +{ + uint8_t *f = footer; + uint8_t first_block_typ; + int err = 0; + uint32_t computed_crc; + uint32_t file_crc; + + if (memcmp(f, "REFT", 4)) { + err = REFTABLE_FORMAT_ERROR; + goto done; + } + f += 4; + + if (memcmp(footer, header, header_size(t->version))) { + err = REFTABLE_FORMAT_ERROR; + goto done; + } + + f++; + t->block_size = reftable_get_be24(f); + + f += 3; + t->min_update_index = reftable_get_be64(f); + f += 8; + t->max_update_index = reftable_get_be64(f); + f += 8; + + if (t->version == 1) { + t->hash_id = REFTABLE_HASH_SHA1; + } else { + switch (reftable_get_be32(f)) { + case REFTABLE_FORMAT_ID_SHA1: + t->hash_id = REFTABLE_HASH_SHA1; + break; + case REFTABLE_FORMAT_ID_SHA256: + t->hash_id = REFTABLE_HASH_SHA256; + break; + default: + err = REFTABLE_FORMAT_ERROR; + goto done; + } + + f += 4; + } + + t->ref_offsets.index_offset = reftable_get_be64(f); + f += 8; + + t->obj_offsets.offset = reftable_get_be64(f); + f += 8; + + t->object_id_len = t->obj_offsets.offset & ((1 << 5) - 1); + t->obj_offsets.offset >>= 5; + + t->obj_offsets.index_offset = reftable_get_be64(f); + f += 8; + t->log_offsets.offset = reftable_get_be64(f); + f += 8; + t->log_offsets.index_offset = reftable_get_be64(f); + f += 8; + + computed_crc = crc32(0, footer, f - footer); + file_crc = reftable_get_be32(f); + f += 4; + if (computed_crc != file_crc) { + err = REFTABLE_FORMAT_ERROR; + goto done; + } + + first_block_typ = header[header_size(t->version)]; + t->ref_offsets.is_present = (first_block_typ == REFTABLE_BLOCK_TYPE_REF); + t->ref_offsets.offset = 0; + t->log_offsets.is_present = (first_block_typ == REFTABLE_BLOCK_TYPE_LOG || + t->log_offsets.offset > 0); + t->obj_offsets.is_present = t->obj_offsets.offset > 0; + if (t->obj_offsets.is_present && !t->object_id_len) { + err = REFTABLE_FORMAT_ERROR; + goto done; + } + + err = 0; +done: + return err; +} + +struct table_iter { + struct reftable_table *table; + uint8_t typ; + uint64_t block_off; + struct reftable_block block; + struct block_iter bi; + int is_finished; +}; + +static int table_iter_init(struct table_iter *ti, struct reftable_table *t) +{ + struct block_iter bi = BLOCK_ITER_INIT; + memset(ti, 0, sizeof(*ti)); + reftable_table_incref(t); + ti->table = t; + ti->bi = bi; + return 0; +} + +static int table_iter_next_in_block(struct table_iter *ti, + struct reftable_record *rec) +{ + int res = block_iter_next(&ti->bi, rec); + if (res == 0 && reftable_record_type(rec) == REFTABLE_BLOCK_TYPE_REF) { + rec->u.ref.update_index += ti->table->min_update_index; + } + + return res; +} + +static void table_iter_block_done(struct table_iter *ti) +{ + reftable_block_release(&ti->block); + block_iter_reset(&ti->bi); +} + +int table_init_block(struct reftable_table *t, struct reftable_block *block, + uint64_t next_off, uint8_t want_typ) +{ + uint32_t header_off = next_off ? 0 : header_size(t->version); + int err; + + if (next_off >= t->size) + return 1; + + err = reftable_block_init(block, &t->source, next_off, header_off, + t->block_size, hash_size(t->hash_id), want_typ); + if (err) + reftable_block_release(block); + return err; +} + +static void table_iter_close(struct table_iter *ti) +{ + table_iter_block_done(ti); + block_iter_close(&ti->bi); + reftable_table_decref(ti->table); +} + +static int table_iter_next_block(struct table_iter *ti) +{ + uint64_t next_block_off = ti->block_off + ti->block.full_block_size; + int err; + + err = table_init_block(ti->table, &ti->block, next_block_off, ti->typ); + if (err > 0) + ti->is_finished = 1; + if (err) + return err; + + ti->block_off = next_block_off; + ti->is_finished = 0; + block_iter_init(&ti->bi, &ti->block); + + return 0; +} + +static int table_iter_next(struct table_iter *ti, struct reftable_record *rec) +{ + if (reftable_record_type(rec) != ti->typ) + return REFTABLE_API_ERROR; + + while (1) { + int err; + + if (ti->is_finished) + return 1; + + /* + * Check whether the current block still has more records. If + * so, return it. If the iterator returns positive then the + * current block has been exhausted. + */ + err = table_iter_next_in_block(ti, rec); + if (err <= 0) + return err; + + /* + * Otherwise, we need to continue to the next block in the + * table and retry. If there are no more blocks then the + * iterator is drained. + */ + err = table_iter_next_block(ti); + if (err) { + ti->is_finished = 1; + return err; + } + } +} + +static int table_iter_seek_to(struct table_iter *ti, uint64_t off, uint8_t typ) +{ + int err; + + err = table_init_block(ti->table, &ti->block, off, typ); + if (err != 0) + return err; + + ti->typ = reftable_block_type(&ti->block); + ti->block_off = off; + block_iter_init(&ti->bi, &ti->block); + ti->is_finished = 0; + return 0; +} + +static int table_iter_seek_start(struct table_iter *ti, uint8_t typ, int index) +{ + struct reftable_table_offsets *offs = table_offsets_for(ti->table, typ); + uint64_t off = offs->offset; + if (index) { + off = offs->index_offset; + if (off == 0) { + return 1; + } + typ = REFTABLE_BLOCK_TYPE_INDEX; + } + + return table_iter_seek_to(ti, off, typ); +} + +static int table_iter_seek_linear(struct table_iter *ti, + struct reftable_record *want) +{ + struct reftable_buf want_key = REFTABLE_BUF_INIT; + struct reftable_buf got_key = REFTABLE_BUF_INIT; + struct reftable_record rec; + int err; + + err = reftable_record_init(&rec, reftable_record_type(want)); + if (err < 0) + goto done; + + err = reftable_record_key(want, &want_key); + if (err < 0) + goto done; + + /* + * First we need to locate the block that must contain our record. To + * do so we scan through blocks linearly until we find the first block + * whose first key is bigger than our wanted key. Once we have found + * that block we know that the key must be contained in the preceding + * block. + * + * This algorithm is somewhat unfortunate because it means that we + * always have to seek one block too far and then back up. But as we + * can only decode the _first_ key of a block but not its _last_ key we + * have no other way to do this. + */ + while (1) { + struct table_iter next = *ti; + + /* + * We must be careful to not modify underlying data of `ti` + * because we may find that `next` does not contain our desired + * block, but that `ti` does. In that case, we would discard + * `next` and continue with `ti`. + * + * This also means that we cannot reuse allocated memory for + * `next` here. While it would be great if we could, it should + * in practice not be too bad given that we should only ever + * end up doing linear seeks with at most three blocks. As soon + * as we have more than three blocks we would have an index, so + * we would not do a linear search there anymore. + */ + memset(&next.block.block_data, 0, sizeof(next.block.block_data)); + next.block.zstream = NULL; + next.block.uncompressed_data = NULL; + next.block.uncompressed_cap = 0; + + err = table_iter_next_block(&next); + if (err < 0) + goto done; + if (err > 0) + break; + + err = reftable_block_first_key(&next.block, &got_key); + if (err < 0) + goto done; + + if (reftable_buf_cmp(&got_key, &want_key) > 0) { + table_iter_block_done(&next); + break; + } + + table_iter_block_done(ti); + *ti = next; + } + + /* + * We have located the block that must contain our record, so we seek + * the wanted key inside of it. If the block does not contain our key + * we know that the corresponding record does not exist. + */ + block_iter_init(&ti->bi, &ti->block); + err = block_iter_seek_key(&ti->bi, &want_key); + if (err < 0) + goto done; + err = 0; + +done: + reftable_record_release(&rec); + reftable_buf_release(&want_key); + reftable_buf_release(&got_key); + return err; +} + +static int table_iter_seek_indexed(struct table_iter *ti, + struct reftable_record *rec) +{ + struct reftable_record want_index = { + .type = REFTABLE_BLOCK_TYPE_INDEX, .u.idx = { .last_key = REFTABLE_BUF_INIT } + }; + struct reftable_record index_result = { + .type = REFTABLE_BLOCK_TYPE_INDEX, + .u.idx = { .last_key = REFTABLE_BUF_INIT }, + }; + int err; + + err = reftable_record_key(rec, &want_index.u.idx.last_key); + if (err < 0) + goto done; + + /* + * The index may consist of multiple levels, where each level may have + * multiple index blocks. We start by doing a linear search in the + * highest layer that identifies the relevant index block as well as + * the record inside that block that corresponds to our wanted key. + */ + err = table_iter_seek_linear(ti, &want_index); + if (err < 0) + goto done; + + /* + * Traverse down the levels until we find a non-index entry. + */ + while (1) { + /* + * In case we seek a record that does not exist the index iter + * will tell us that the iterator is over. This works because + * the last index entry of the current level will contain the + * last key it knows about. So in case our seeked key is larger + * than the last indexed key we know that it won't exist. + * + * There is one subtlety in the layout of the index section + * that makes this work as expected: the highest-level index is + * at end of the section and will point backwards and thus we + * start reading from the end of the index section, not the + * beginning. + * + * If that wasn't the case and the order was reversed then the + * linear seek would seek into the lower levels and traverse + * all levels of the index only to find out that the key does + * not exist. + */ + err = table_iter_next(ti, &index_result); + if (err != 0) + goto done; + + err = table_iter_seek_to(ti, index_result.u.idx.offset, 0); + if (err != 0) + goto done; + + block_iter_init(&ti->bi, &ti->block); + + err = block_iter_seek_key(&ti->bi, &want_index.u.idx.last_key); + if (err < 0) + goto done; + + if (ti->typ == reftable_record_type(rec)) { + err = 0; + break; + } + + if (ti->typ != REFTABLE_BLOCK_TYPE_INDEX) { + err = REFTABLE_FORMAT_ERROR; + goto done; + } + } + +done: + reftable_record_release(&want_index); + reftable_record_release(&index_result); + return err; +} + +static int table_iter_seek(struct table_iter *ti, + struct reftable_record *want) +{ + uint8_t typ = reftable_record_type(want); + struct reftable_table_offsets *offs = table_offsets_for(ti->table, typ); + int err; + + err = table_iter_seek_start(ti, reftable_record_type(want), + !!offs->index_offset); + if (err < 0) + goto out; + + if (offs->index_offset) + err = table_iter_seek_indexed(ti, want); + else + err = table_iter_seek_linear(ti, want); + if (err) + goto out; + +out: + return err; +} + +static int table_iter_seek_void(void *ti, struct reftable_record *want) +{ + return table_iter_seek(ti, want); +} + +static int table_iter_next_void(void *ti, struct reftable_record *rec) +{ + return table_iter_next(ti, rec); +} + +static void table_iter_close_void(void *ti) +{ + table_iter_close(ti); +} + +static struct reftable_iterator_vtable table_iter_vtable = { + .seek = &table_iter_seek_void, + .next = &table_iter_next_void, + .close = &table_iter_close_void, +}; + +static void iterator_from_table_iter(struct reftable_iterator *it, + struct table_iter *ti) +{ + assert(!it->ops); + it->iter_arg = ti; + it->ops = &table_iter_vtable; +} + +int table_init_iter(struct reftable_table *t, + struct reftable_iterator *it, + uint8_t typ) +{ + struct reftable_table_offsets *offs = table_offsets_for(t, typ); + + if (offs->is_present) { + struct table_iter *ti; + REFTABLE_ALLOC_ARRAY(ti, 1); + if (!ti) + return REFTABLE_OUT_OF_MEMORY_ERROR; + + table_iter_init(ti, t); + iterator_from_table_iter(it, ti); + } else { + iterator_set_empty(it); + } + + return 0; +} + +int reftable_table_init_ref_iterator(struct reftable_table *t, + struct reftable_iterator *it) +{ + return table_init_iter(t, it, REFTABLE_BLOCK_TYPE_REF); +} + +int reftable_table_init_log_iterator(struct reftable_table *t, + struct reftable_iterator *it) +{ + return table_init_iter(t, it, REFTABLE_BLOCK_TYPE_LOG); +} + +int reftable_table_new(struct reftable_table **out, + struct reftable_block_source *source, char const *name) +{ + struct reftable_block_data footer = { 0 }; + struct reftable_block_data header = { 0 }; + struct reftable_table *t; + uint64_t file_size = block_source_size(source); + uint32_t read_size; + ssize_t bytes_read; + int err; + + REFTABLE_CALLOC_ARRAY(t, 1); + if (!t) { + err = REFTABLE_OUT_OF_MEMORY_ERROR; + goto done; + } + + /* + * We need one extra byte to read the type of first block. We also + * pretend to always be reading v2 of the format because it is larger. + */ + read_size = header_size(2) + 1; + if (read_size > file_size) { + err = REFTABLE_FORMAT_ERROR; + goto done; + } + + bytes_read = block_source_read_data(source, &header, 0, read_size); + if (bytes_read < 0 || (size_t)bytes_read != read_size) { + err = REFTABLE_IO_ERROR; + goto done; + } + + if (memcmp(header.data, "REFT", 4)) { + err = REFTABLE_FORMAT_ERROR; + goto done; + } + t->version = header.data[4]; + if (t->version != 1 && t->version != 2) { + err = REFTABLE_FORMAT_ERROR; + goto done; + } + + t->size = file_size - footer_size(t->version); + t->source = *source; + t->name = reftable_strdup(name); + if (!t->name) { + err = REFTABLE_OUT_OF_MEMORY_ERROR; + goto done; + } + t->hash_id = 0; + t->refcount = 1; + + bytes_read = block_source_read_data(source, &footer, t->size, + footer_size(t->version)); + if (bytes_read < 0 || (size_t)bytes_read != footer_size(t->version)) { + err = REFTABLE_IO_ERROR; + goto done; + } + + err = parse_footer(t, footer.data, header.data); + if (err) + goto done; + + *out = t; + +done: + block_source_release_data(&footer); + block_source_release_data(&header); + if (err) { + if (t) + reftable_free(t->name); + reftable_free(t); + block_source_close(source); + } + return err; +} + +void reftable_table_incref(struct reftable_table *t) +{ + t->refcount++; +} + +void reftable_table_decref(struct reftable_table *t) +{ + if (!t) + return; + if (--t->refcount) + return; + block_source_close(&t->source); + REFTABLE_FREE_AND_NULL(t->name); + reftable_free(t); +} + +static int reftable_table_refs_for_indexed(struct reftable_table *t, + struct reftable_iterator *it, + uint8_t *oid) +{ + struct reftable_record want = { + .type = REFTABLE_BLOCK_TYPE_OBJ, + .u.obj = { + .hash_prefix = oid, + .hash_prefix_len = t->object_id_len, + }, + }; + struct reftable_iterator oit = { NULL }; + struct reftable_record got = { + .type = REFTABLE_BLOCK_TYPE_OBJ, + .u.obj = { 0 }, + }; + int err = 0; + struct indexed_table_ref_iter *itr = NULL; + + /* Look through the reverse index. */ + err = table_init_iter(t, &oit, REFTABLE_BLOCK_TYPE_OBJ); + if (err < 0) + goto done; + + err = iterator_seek(&oit, &want); + if (err != 0) + goto done; + + /* read out the reftable_obj_record */ + err = iterator_next(&oit, &got); + if (err < 0) + goto done; + + if (err > 0 || memcmp(want.u.obj.hash_prefix, got.u.obj.hash_prefix, + t->object_id_len)) { + /* didn't find it; return empty iterator */ + iterator_set_empty(it); + err = 0; + goto done; + } + + err = indexed_table_ref_iter_new(&itr, t, oid, hash_size(t->hash_id), + got.u.obj.offsets, + got.u.obj.offset_len); + if (err < 0) + goto done; + got.u.obj.offsets = NULL; + iterator_from_indexed_table_ref_iter(it, itr); + +done: + reftable_iterator_destroy(&oit); + reftable_record_release(&got); + return err; +} + +static int reftable_table_refs_for_unindexed(struct reftable_table *t, + struct reftable_iterator *it, + uint8_t *oid) +{ + struct table_iter *ti; + struct filtering_ref_iterator *filter = NULL; + struct filtering_ref_iterator empty = FILTERING_REF_ITERATOR_INIT; + uint32_t oid_len = hash_size(t->hash_id); + int err; + + REFTABLE_ALLOC_ARRAY(ti, 1); + if (!ti) { + err = REFTABLE_OUT_OF_MEMORY_ERROR; + goto out; + } + + table_iter_init(ti, t); + err = table_iter_seek_start(ti, REFTABLE_BLOCK_TYPE_REF, 0); + if (err < 0) + goto out; + + filter = reftable_malloc(sizeof(*filter)); + if (!filter) { + err = REFTABLE_OUT_OF_MEMORY_ERROR; + goto out; + } + *filter = empty; + + err = reftable_buf_add(&filter->oid, oid, oid_len); + if (err < 0) + goto out; + + iterator_from_table_iter(&filter->it, ti); + + iterator_from_filtering_ref_iterator(it, filter); + + err = 0; + +out: + if (err < 0) { + if (ti) + table_iter_close(ti); + reftable_free(ti); + } + return err; +} + +int reftable_table_refs_for(struct reftable_table *t, + struct reftable_iterator *it, uint8_t *oid) +{ + if (t->obj_offsets.is_present) + return reftable_table_refs_for_indexed(t, it, oid); + return reftable_table_refs_for_unindexed(t, it, oid); +} + +uint64_t reftable_table_max_update_index(struct reftable_table *t) +{ + return t->max_update_index; +} + +uint64_t reftable_table_min_update_index(struct reftable_table *t) +{ + return t->min_update_index; +} + +int reftable_table_iterator_init(struct reftable_table_iterator *it, + struct reftable_table *t) +{ + struct table_iter *ti; + int err; + + REFTABLE_ALLOC_ARRAY(ti, 1); + if (!ti) + return REFTABLE_OUT_OF_MEMORY_ERROR; + + err = table_iter_init(ti, t); + if (err < 0) + goto out; + + it->iter_arg = ti; + err = 0; + +out: + if (err < 0) + reftable_free(ti); + return err; +} + +void reftable_table_iterator_release(struct reftable_table_iterator *it) +{ + if (!it->iter_arg) + return; + table_iter_close(it->iter_arg); + reftable_free(it->iter_arg); + it->iter_arg = NULL; +} + +int reftable_table_iterator_next(struct reftable_table_iterator *it, + const struct reftable_block **out) +{ + struct table_iter *ti = it->iter_arg; + int err; + + err = table_iter_next_block(ti); + if (err) + return err; + + *out = &ti->block; + + return 0; +} diff --git a/deps/reftable/table.h b/deps/reftable/table.h new file mode 100644 index 000000000..c54703e62 --- /dev/null +++ b/deps/reftable/table.h @@ -0,0 +1,29 @@ +/* + * Copyright 2020 Google LLC + * + * Use of this source code is governed by a BSD-style + * license that can be found in the LICENSE file or at + * https://developers.google.com/open-source/licenses/bsd + */ + +#ifndef TABLE_H +#define TABLE_H + +#include "block.h" +#include "record.h" +#include "reftable-iterator.h" +#include "reftable-table.h" + +const char *reftable_table_name(struct reftable_table *t); + +int table_init_iter(struct reftable_table *t, + struct reftable_iterator *it, + uint8_t typ); + +/* + * Initialize a block by reading from the given table and offset. + */ +int table_init_block(struct reftable_table *t, struct reftable_block *block, + uint64_t next_off, uint8_t want_typ); + +#endif diff --git a/deps/reftable/tree.c b/deps/reftable/tree.c new file mode 100644 index 000000000..a52f7c0c7 --- /dev/null +++ b/deps/reftable/tree.c @@ -0,0 +1,74 @@ +/* + * Copyright 2020 Google LLC + * + * Use of this source code is governed by a BSD-style + * license that can be found in the LICENSE file or at + * https://developers.google.com/open-source/licenses/bsd + */ + +#include "system.h" +#include "tree.h" + +#include "basics.h" + +struct tree_node *tree_search(struct tree_node *tree, + void *key, + int (*compare)(const void *, const void *)) +{ + int res; + if (!tree) + return NULL; + res = compare(key, tree->key); + if (res < 0) + return tree_search(tree->left, key, compare); + else if (res > 0) + return tree_search(tree->right, key, compare); + return tree; +} + +struct tree_node *tree_insert(struct tree_node **rootp, + void *key, + int (*compare)(const void *, const void *)) +{ + int res; + + if (!*rootp) { + struct tree_node *n; + + REFTABLE_CALLOC_ARRAY(n, 1); + if (!n) + return NULL; + + n->key = key; + *rootp = n; + return *rootp; + } + + res = compare(key, (*rootp)->key); + if (res < 0) + return tree_insert(&(*rootp)->left, key, compare); + else if (res > 0) + return tree_insert(&(*rootp)->right, key, compare); + return *rootp; +} + +void infix_walk(struct tree_node *t, void (*action)(void *arg, void *key), + void *arg) +{ + if (t->left) + infix_walk(t->left, action, arg); + action(arg, t->key); + if (t->right) + infix_walk(t->right, action, arg); +} + +void tree_free(struct tree_node *t) +{ + if (!t) + return; + if (t->left) + tree_free(t->left); + if (t->right) + tree_free(t->right); + reftable_free(t); +} diff --git a/deps/reftable/tree.h b/deps/reftable/tree.h new file mode 100644 index 000000000..2c9c46529 --- /dev/null +++ b/deps/reftable/tree.h @@ -0,0 +1,45 @@ +/* + * Copyright 2020 Google LLC + * + * Use of this source code is governed by a BSD-style + * license that can be found in the LICENSE file or at + * https://developers.google.com/open-source/licenses/bsd + */ + +#ifndef TREE_H +#define TREE_H + +/* tree_node is a generic binary search tree. */ +struct tree_node { + void *key; + struct tree_node *left, *right; +}; + +/* + * Search the tree for the node matching the given key using `compare` as + * comparison function. Returns the node whose key matches or `NULL` in case + * the key does not exist in the tree. + */ +struct tree_node *tree_search(struct tree_node *tree, + void *key, + int (*compare)(const void *, const void *)); + +/* + * Insert a node into the tree. Returns the newly inserted node if the key does + * not yet exist. Otherwise it returns the preexisting node. Returns `NULL` + * when allocating the new node fails. + */ +struct tree_node *tree_insert(struct tree_node **rootp, + void *key, + int (*compare)(const void *, const void *)); + +/* performs an infix walk of the tree. */ +void infix_walk(struct tree_node *t, void (*action)(void *arg, void *key), + void *arg); + +/* + * deallocates the tree nodes recursively. Keys should be deallocated separately + * by walking over the tree. */ +void tree_free(struct tree_node *t); + +#endif diff --git a/deps/reftable/writer.c b/deps/reftable/writer.c new file mode 100644 index 000000000..0133b6497 --- /dev/null +++ b/deps/reftable/writer.c @@ -0,0 +1,887 @@ +/* + * Copyright 2020 Google LLC + * + * Use of this source code is governed by a BSD-style + * license that can be found in the LICENSE file or at + * https://developers.google.com/open-source/licenses/bsd + */ + +#include "writer.h" + +#include "system.h" + +#include "block.h" +#include "constants.h" +#include "record.h" +#include "tree.h" +#include "reftable-error.h" + +/* finishes a block, and writes it to storage */ +static int writer_flush_block(struct reftable_writer *w); + +/* deallocates memory related to the index */ +static void writer_clear_index(struct reftable_writer *w); + +/* finishes writing a 'r' (refs) or 'g' (reflogs) section */ +static int writer_finish_public_section(struct reftable_writer *w); + +static struct reftable_block_stats * +writer_reftable_block_stats(struct reftable_writer *w, uint8_t typ) +{ + switch (typ) { + case 'r': + return &w->stats.ref_stats; + case 'o': + return &w->stats.obj_stats; + case 'i': + return &w->stats.idx_stats; + case 'g': + return &w->stats.log_stats; + } + abort(); + return NULL; +} + +/* write data, queuing the padding for the next write. Returns negative for + * error. */ +static int padded_write(struct reftable_writer *w, uint8_t *data, size_t len, + int padding) +{ + int n = 0; + if (w->pending_padding > 0) { + uint8_t *zeroed; + int n; + + zeroed = reftable_calloc(w->pending_padding, sizeof(*zeroed)); + if (!zeroed) + return -1; + + n = w->write(w->write_arg, zeroed, w->pending_padding); + if (n < 0) { + reftable_free(zeroed); + return n; + } + + w->pending_padding = 0; + reftable_free(zeroed); + } + + w->pending_padding = padding; + n = w->write(w->write_arg, data, len); + if (n < 0) + return n; + n += padding; + return 0; +} + +static void options_set_defaults(struct reftable_write_options *opts) +{ + if (opts->restart_interval == 0) { + opts->restart_interval = 16; + } + + if (opts->hash_id == 0) { + opts->hash_id = REFTABLE_HASH_SHA1; + } + if (opts->block_size == 0) { + opts->block_size = DEFAULT_BLOCK_SIZE; + } +} + +static int writer_version(struct reftable_writer *w) +{ + return (w->opts.hash_id == 0 || w->opts.hash_id == REFTABLE_HASH_SHA1) ? + 1 : + 2; +} + +static int writer_write_header(struct reftable_writer *w, uint8_t *dest) +{ + memcpy(dest, "REFT", 4); + + dest[4] = writer_version(w); + + reftable_put_be24(dest + 5, w->opts.block_size); + reftable_put_be64(dest + 8, w->min_update_index); + reftable_put_be64(dest + 16, w->max_update_index); + if (writer_version(w) == 2) { + uint32_t hash_id; + + switch (w->opts.hash_id) { + case REFTABLE_HASH_SHA1: + hash_id = REFTABLE_FORMAT_ID_SHA1; + break; + case REFTABLE_HASH_SHA256: + hash_id = REFTABLE_FORMAT_ID_SHA256; + break; + default: + return -1; + } + + reftable_put_be32(dest + 24, hash_id); + } + + return header_size(writer_version(w)); +} + +static int writer_reinit_block_writer(struct reftable_writer *w, uint8_t typ) +{ + int block_start = 0, ret; + + if (w->next == 0) + block_start = header_size(writer_version(w)); + + reftable_buf_reset(&w->last_key); + ret = block_writer_init(&w->block_writer_data, typ, w->block, + w->opts.block_size, block_start, + hash_size(w->opts.hash_id)); + if (ret < 0) + return ret; + + w->block_writer = &w->block_writer_data; + w->block_writer->restart_interval = w->opts.restart_interval; + + return 0; +} + +int reftable_writer_new(struct reftable_writer **out, + ssize_t (*writer_func)(void *, const void *, size_t), + int (*flush_func)(void *), + void *writer_arg, const struct reftable_write_options *_opts) +{ + struct reftable_write_options opts = {0}; + struct reftable_writer *wp; + + wp = reftable_calloc(1, sizeof(*wp)); + if (!wp) + return REFTABLE_OUT_OF_MEMORY_ERROR; + + if (_opts) + opts = *_opts; + options_set_defaults(&opts); + if (opts.block_size >= (1 << 24)) + return REFTABLE_API_ERROR; + + reftable_buf_init(&wp->block_writer_data.last_key); + reftable_buf_init(&wp->last_key); + reftable_buf_init(&wp->scratch); + REFTABLE_CALLOC_ARRAY(wp->block, opts.block_size); + if (!wp->block) { + reftable_free(wp); + return REFTABLE_OUT_OF_MEMORY_ERROR; + } + wp->write = writer_func; + wp->write_arg = writer_arg; + wp->opts = opts; + wp->flush = flush_func; + writer_reinit_block_writer(wp, REFTABLE_BLOCK_TYPE_REF); + + *out = wp; + + return 0; +} + +int reftable_writer_set_limits(struct reftable_writer *w, uint64_t min, + uint64_t max) +{ + /* + * Set the min/max update index limits for the reftable writer. + * This must be called before adding any records, since: + * - The 'next' field gets set after writing the first block. + * - The 'last_key' field updates with each new record (but resets + * after sections). + * Returns REFTABLE_API_ERROR if called after writing has begun. + */ + if (w->next || w->last_key.len) + return REFTABLE_API_ERROR; + + w->min_update_index = min; + w->max_update_index = max; + + return 0; +} + +static void writer_release(struct reftable_writer *w) +{ + if (w) { + reftable_free(w->block); + w->block = NULL; + block_writer_release(&w->block_writer_data); + w->block_writer = NULL; + writer_clear_index(w); + reftable_buf_release(&w->last_key); + reftable_buf_release(&w->scratch); + } +} + +void reftable_writer_free(struct reftable_writer *w) +{ + writer_release(w); + reftable_free(w); +} + +struct obj_index_tree_node { + struct reftable_buf hash; + uint64_t *offsets; + size_t offset_len; + size_t offset_cap; +}; + +#define OBJ_INDEX_TREE_NODE_INIT \ + { \ + .hash = REFTABLE_BUF_INIT \ + } + +static int obj_index_tree_node_compare(const void *a, const void *b) +{ + return reftable_buf_cmp(&((const struct obj_index_tree_node *)a)->hash, + &((const struct obj_index_tree_node *)b)->hash); +} + +static int writer_index_hash(struct reftable_writer *w, struct reftable_buf *hash) +{ + uint64_t off = w->next; + struct obj_index_tree_node want = { .hash = *hash }; + struct obj_index_tree_node *key; + struct tree_node *node; + + node = tree_search(w->obj_index_tree, &want, &obj_index_tree_node_compare); + if (!node) { + struct obj_index_tree_node empty = OBJ_INDEX_TREE_NODE_INIT; + int err; + + key = reftable_malloc(sizeof(*key)); + if (!key) + return REFTABLE_OUT_OF_MEMORY_ERROR; + + *key = empty; + + reftable_buf_reset(&key->hash); + err = reftable_buf_add(&key->hash, hash->buf, hash->len); + if (err < 0) { + reftable_free(key); + return err; + } + tree_insert(&w->obj_index_tree, key, + &obj_index_tree_node_compare); + } else { + key = node->key; + } + + if (key->offset_len > 0 && key->offsets[key->offset_len - 1] == off) + return 0; + + REFTABLE_ALLOC_GROW_OR_NULL(key->offsets, key->offset_len + 1, + key->offset_cap); + if (!key->offsets) + return REFTABLE_OUT_OF_MEMORY_ERROR; + key->offsets[key->offset_len++] = off; + + return 0; +} + +static int writer_add_record(struct reftable_writer *w, + struct reftable_record *rec) +{ + int err; + + err = reftable_record_key(rec, &w->scratch); + if (err < 0) + goto done; + + if (reftable_buf_cmp(&w->last_key, &w->scratch) >= 0) { + err = REFTABLE_API_ERROR; + goto done; + } + + reftable_buf_reset(&w->last_key); + err = reftable_buf_add(&w->last_key, w->scratch.buf, w->scratch.len); + if (err < 0) + goto done; + + if (!w->block_writer) { + err = writer_reinit_block_writer(w, reftable_record_type(rec)); + if (err < 0) + goto done; + } + + if (block_writer_type(w->block_writer) != reftable_record_type(rec)) + return REFTABLE_API_ERROR; + + /* + * Try to add the record to the writer. If this succeeds then we're + * done. Otherwise the block writer may have hit the block size limit + * and needs to be flushed. + */ + err = block_writer_add(w->block_writer, rec); + if (err == 0) + goto done; + + if (err != REFTABLE_ENTRY_TOO_BIG_ERROR) + goto done; + /* + * The current block is full, so we need to flush and reinitialize the + * writer to start writing the next block. + */ + err = writer_flush_block(w); + if (err < 0) + goto done; + err = writer_reinit_block_writer(w, reftable_record_type(rec)); + if (err < 0) + goto done; + + /* + * Try to add the record to the writer again. If this still fails then + * the record does not fit into the block size. + */ + err = block_writer_add(w->block_writer, rec); + if (err) + goto done; + +done: + return err; +} + +int reftable_writer_add_ref(struct reftable_writer *w, + struct reftable_ref_record *ref) +{ + struct reftable_record rec = { + .type = REFTABLE_BLOCK_TYPE_REF, + .u = { + .ref = *ref + }, + }; + int err; + + if (!ref->refname || + ref->update_index < w->min_update_index || + ref->update_index > w->max_update_index) + return REFTABLE_API_ERROR; + + rec.u.ref.update_index -= w->min_update_index; + + err = writer_add_record(w, &rec); + if (err < 0) + goto out; + + if (!w->opts.skip_index_objects && reftable_ref_record_val1(ref)) { + reftable_buf_reset(&w->scratch); + err = reftable_buf_add(&w->scratch, (char *)reftable_ref_record_val1(ref), + hash_size(w->opts.hash_id)); + if (err < 0) + goto out; + + err = writer_index_hash(w, &w->scratch); + if (err < 0) + goto out; + } + + if (!w->opts.skip_index_objects && reftable_ref_record_val2(ref)) { + reftable_buf_reset(&w->scratch); + err = reftable_buf_add(&w->scratch, reftable_ref_record_val2(ref), + hash_size(w->opts.hash_id)); + if (err < 0) + goto out; + + err = writer_index_hash(w, &w->scratch); + if (err < 0) + goto out; + } + + err = 0; + +out: + return err; +} + +int reftable_writer_add_refs(struct reftable_writer *w, + struct reftable_ref_record *refs, size_t n) +{ + int err = 0; + + if (n) + qsort(refs, n, sizeof(*refs), reftable_ref_record_compare_name); + + for (size_t i = 0; err == 0 && i < n; i++) + err = reftable_writer_add_ref(w, &refs[i]); + + return err; +} + +static int reftable_writer_add_log_verbatim(struct reftable_writer *w, + struct reftable_log_record *log) +{ + struct reftable_record rec = { + .type = REFTABLE_BLOCK_TYPE_LOG, + .u = { + .log = *log, + }, + }; + if (w->block_writer && + block_writer_type(w->block_writer) == REFTABLE_BLOCK_TYPE_REF) { + int err = writer_finish_public_section(w); + if (err < 0) + return err; + } + + w->next -= w->pending_padding; + w->pending_padding = 0; + return writer_add_record(w, &rec); +} + +int reftable_writer_add_log(struct reftable_writer *w, + struct reftable_log_record *log) +{ + char *input_log_message = NULL; + struct reftable_buf cleaned_message = REFTABLE_BUF_INIT; + int err = 0; + + if (log->value_type == REFTABLE_LOG_DELETION) + return reftable_writer_add_log_verbatim(w, log); + + /* + * Verify only the upper limit of the update_index. Each reflog entry + * is tied to a specific update_index. Entries in the reflog can be + * replaced by adding a new entry with the same update_index, + * effectively canceling the old one. + * + * Consequently, reflog updates may include update_index values lower + * than the writer's min_update_index. + */ + if (log->update_index > w->max_update_index) + return REFTABLE_API_ERROR; + + if (!log->refname) + return REFTABLE_API_ERROR; + + input_log_message = log->value.update.message; + if (!w->opts.exact_log_message && log->value.update.message) { + err = reftable_buf_addstr(&cleaned_message, log->value.update.message); + if (err < 0) + goto done; + + while (cleaned_message.len && + cleaned_message.buf[cleaned_message.len - 1] == '\n') { + err = reftable_buf_setlen(&cleaned_message, + cleaned_message.len - 1); + if (err < 0) + goto done; + } + if (strchr(cleaned_message.buf, '\n')) { + /* multiple lines not allowed. */ + err = REFTABLE_API_ERROR; + goto done; + } + + err = reftable_buf_addstr(&cleaned_message, "\n"); + if (err < 0) + goto done; + + log->value.update.message = cleaned_message.buf; + } + + err = reftable_writer_add_log_verbatim(w, log); + log->value.update.message = input_log_message; +done: + reftable_buf_release(&cleaned_message); + return err; +} + +int reftable_writer_add_logs(struct reftable_writer *w, + struct reftable_log_record *logs, size_t n) +{ + int err = 0; + + if (n) + qsort(logs, n, sizeof(*logs), reftable_log_record_compare_key); + + for (size_t i = 0; err == 0 && i < n; i++) + err = reftable_writer_add_log(w, &logs[i]); + + return err; +} + +static int writer_finish_section(struct reftable_writer *w) +{ + struct reftable_block_stats *bstats = NULL; + uint8_t typ = block_writer_type(w->block_writer); + uint64_t index_start = 0; + int max_level = 0; + size_t threshold = w->opts.unpadded ? 1 : 3; + int before_blocks = w->stats.idx_stats.blocks; + int err; + + err = writer_flush_block(w); + if (err < 0) + return err; + + /* + * When the section we are about to index has a lot of blocks then the + * index itself may span across multiple blocks, as well. This would + * require a linear scan over index blocks only to find the desired + * indexed block, which is inefficient. Instead, we write a multi-level + * index where index records of level N+1 will refer to index blocks of + * level N. This isn't constant time, either, but at least logarithmic. + * + * This loop handles writing this multi-level index. Note that we write + * the lowest-level index pointing to the indexed blocks first. We then + * continue writing additional index levels until the current level has + * less blocks than the threshold so that the highest level will be at + * the end of the index section. + * + * Readers are thus required to start reading the index section from + * its end, which is why we set `index_start` to the beginning of the + * last index section. + */ + while (w->index_len > threshold) { + struct reftable_index_record *idx = NULL; + size_t i, idx_len; + + max_level++; + index_start = w->next; + err = writer_reinit_block_writer(w, REFTABLE_BLOCK_TYPE_INDEX); + if (err < 0) + return err; + + idx = w->index; + idx_len = w->index_len; + + w->index = NULL; + w->index_len = 0; + w->index_cap = 0; + for (i = 0; i < idx_len; i++) { + struct reftable_record rec = { + .type = REFTABLE_BLOCK_TYPE_INDEX, + .u = { + .idx = idx[i], + }, + }; + + err = writer_add_record(w, &rec); + if (err < 0) + return err; + } + + err = writer_flush_block(w); + if (err < 0) + return err; + + for (i = 0; i < idx_len; i++) + reftable_buf_release(&idx[i].last_key); + reftable_free(idx); + } + + /* + * The index may still contain a number of index blocks lower than the + * threshold. Clear it so that these entries don't leak into the next + * index section. + */ + writer_clear_index(w); + + bstats = writer_reftable_block_stats(w, typ); + bstats->index_blocks = w->stats.idx_stats.blocks - before_blocks; + bstats->index_offset = index_start; + bstats->max_index_level = max_level; + + /* Reinit lastKey, as the next section can start with any key. */ + reftable_buf_reset(&w->last_key); + + return 0; +} + +struct common_prefix_arg { + struct reftable_buf *last; + size_t max; +}; + +static void update_common(void *void_arg, void *key) +{ + struct common_prefix_arg *arg = void_arg; + struct obj_index_tree_node *entry = key; + if (arg->last) { + size_t n = common_prefix_size(&entry->hash, arg->last); + if (n > arg->max) + arg->max = n; + } + arg->last = &entry->hash; +} + +struct write_record_arg { + struct reftable_writer *w; + int err; +}; + +static void write_object_record(void *void_arg, void *key) +{ + struct write_record_arg *arg = void_arg; + struct obj_index_tree_node *entry = key; + struct reftable_record + rec = { .type = REFTABLE_BLOCK_TYPE_OBJ, + .u.obj = { + .hash_prefix = (uint8_t *)entry->hash.buf, + .hash_prefix_len = arg->w->stats.object_id_len, + .offsets = entry->offsets, + .offset_len = entry->offset_len, + } }; + if (arg->err < 0) + goto done; + + /* + * Try to add the record to the writer. If this succeeds then we're + * done. Otherwise the block writer may have hit the block size limit + * and needs to be flushed. + */ + arg->err = block_writer_add(arg->w->block_writer, &rec); + if (arg->err == 0) + goto done; + + if (arg->err != REFTABLE_ENTRY_TOO_BIG_ERROR) + goto done; + + /* + * The current block is full, so we need to flush and reinitialize the + * writer to start writing the next block. + */ + arg->err = writer_flush_block(arg->w); + if (arg->err < 0) + goto done; + + arg->err = writer_reinit_block_writer(arg->w, REFTABLE_BLOCK_TYPE_OBJ); + if (arg->err < 0) + goto done; + + /* + * If this still fails then we may need to reset record's offset + * length to reduce the data size to be written. + */ + arg->err = block_writer_add(arg->w->block_writer, &rec); + if (arg->err == 0) + goto done; + + if (arg->err != REFTABLE_ENTRY_TOO_BIG_ERROR) + goto done; + + rec.u.obj.offset_len = 0; + arg->err = block_writer_add(arg->w->block_writer, &rec); + + /* Should be able to write into a fresh block. */ + assert(arg->err == 0); + +done:; +} + +static void object_record_free(void *void_arg REFTABLE_UNUSED, void *key) +{ + struct obj_index_tree_node *entry = key; + + REFTABLE_FREE_AND_NULL(entry->offsets); + reftable_buf_release(&entry->hash); + reftable_free(entry); +} + +static int writer_dump_object_index(struct reftable_writer *w) +{ + struct write_record_arg closure = { .w = w }; + struct common_prefix_arg common = { + .max = 1, /* obj_id_len should be >= 2. */ + }; + int err; + + if (w->obj_index_tree) + infix_walk(w->obj_index_tree, &update_common, &common); + w->stats.object_id_len = common.max + 1; + + err = writer_reinit_block_writer(w, REFTABLE_BLOCK_TYPE_OBJ); + if (err < 0) + return err; + + if (w->obj_index_tree) + infix_walk(w->obj_index_tree, &write_object_record, &closure); + + if (closure.err < 0) + return closure.err; + return writer_finish_section(w); +} + +static int writer_finish_public_section(struct reftable_writer *w) +{ + uint8_t typ = 0; + int err = 0; + + if (!w->block_writer) + return 0; + + typ = block_writer_type(w->block_writer); + err = writer_finish_section(w); + if (err < 0) + return err; + if (typ == REFTABLE_BLOCK_TYPE_REF && !w->opts.skip_index_objects && + w->stats.ref_stats.index_blocks > 0) { + err = writer_dump_object_index(w); + if (err < 0) + return err; + } + + if (w->obj_index_tree) { + infix_walk(w->obj_index_tree, &object_record_free, NULL); + tree_free(w->obj_index_tree); + w->obj_index_tree = NULL; + } + + w->block_writer = NULL; + return 0; +} + +int reftable_writer_close(struct reftable_writer *w) +{ + uint8_t footer[72]; + uint8_t *p = footer; + int err = writer_finish_public_section(w); + int empty_table = w->next == 0; + if (err != 0) + goto done; + w->pending_padding = 0; + if (empty_table) { + /* Empty tables need a header anyway. */ + uint8_t header[28]; + int n = writer_write_header(w, header); + err = padded_write(w, header, n, 0); + if (err < 0) + goto done; + } + + p += writer_write_header(w, footer); + reftable_put_be64(p, w->stats.ref_stats.index_offset); + p += 8; + reftable_put_be64(p, (w->stats.obj_stats.offset) << 5 | w->stats.object_id_len); + p += 8; + reftable_put_be64(p, w->stats.obj_stats.index_offset); + p += 8; + + reftable_put_be64(p, w->stats.log_stats.offset); + p += 8; + reftable_put_be64(p, w->stats.log_stats.index_offset); + p += 8; + + reftable_put_be32(p, crc32(0, footer, p - footer)); + p += 4; + + err = w->flush(w->write_arg); + if (err < 0) { + err = REFTABLE_IO_ERROR; + goto done; + } + + err = padded_write(w, footer, footer_size(writer_version(w)), 0); + if (err < 0) + goto done; + + if (empty_table) { + err = REFTABLE_EMPTY_TABLE_ERROR; + goto done; + } + +done: + writer_release(w); + return err; +} + +static void writer_clear_index(struct reftable_writer *w) +{ + for (size_t i = 0; w->index && i < w->index_len; i++) + reftable_buf_release(&w->index[i].last_key); + REFTABLE_FREE_AND_NULL(w->index); + w->index_len = 0; + w->index_cap = 0; +} + +static int writer_flush_nonempty_block(struct reftable_writer *w) +{ + struct reftable_index_record index_record = { + .last_key = REFTABLE_BUF_INIT, + }; + uint8_t typ = block_writer_type(w->block_writer); + struct reftable_block_stats *bstats; + int raw_bytes, padding = 0, err; + uint64_t block_typ_off; + + /* + * Finish the current block. This will cause the block writer to emit + * restart points and potentially compress records in case we are + * writing a log block. + * + * Note that this is still happening in memory. + */ + raw_bytes = block_writer_finish(w->block_writer); + if (raw_bytes < 0) + return raw_bytes; + + /* + * By default, all records except for log records are padded to the + * block size. + */ + if (!w->opts.unpadded && typ != REFTABLE_BLOCK_TYPE_LOG) + padding = w->opts.block_size - raw_bytes; + + bstats = writer_reftable_block_stats(w, typ); + block_typ_off = (bstats->blocks == 0) ? w->next : 0; + if (block_typ_off > 0) + bstats->offset = block_typ_off; + bstats->entries += w->block_writer->entries; + bstats->restarts += w->block_writer->restart_len; + bstats->blocks++; + w->stats.blocks++; + + /* + * If this is the first block we're writing to the table then we need + * to also write the reftable header. + */ + if (!w->next) + writer_write_header(w, w->block); + + err = padded_write(w, w->block, raw_bytes, padding); + if (err < 0) + return err; + + /* + * Add an index record for every block that we're writing. If we end up + * having more than a threshold of index records we will end up writing + * an index section in `writer_finish_section()`. Each index record + * contains the last record key of the block it is indexing as well as + * the offset of that block. + * + * Note that this also applies when flushing index blocks, in which + * case we will end up with a multi-level index. + */ + REFTABLE_ALLOC_GROW_OR_NULL(w->index, w->index_len + 1, w->index_cap); + if (!w->index) + return REFTABLE_OUT_OF_MEMORY_ERROR; + + index_record.offset = w->next; + reftable_buf_reset(&index_record.last_key); + err = reftable_buf_add(&index_record.last_key, w->block_writer->last_key.buf, + w->block_writer->last_key.len); + if (err < 0) + return err; + w->index[w->index_len] = index_record; + w->index_len++; + + w->next += padding + raw_bytes; + w->block_writer = NULL; + + return 0; +} + +static int writer_flush_block(struct reftable_writer *w) +{ + if (!w->block_writer) + return 0; + if (w->block_writer->entries == 0) + return 0; + return writer_flush_nonempty_block(w); +} + +const struct reftable_stats *reftable_writer_stats(struct reftable_writer *w) +{ + return &w->stats; +} diff --git a/deps/reftable/writer.h b/deps/reftable/writer.h new file mode 100644 index 000000000..9f53610b2 --- /dev/null +++ b/deps/reftable/writer.h @@ -0,0 +1,53 @@ +/* + * Copyright 2020 Google LLC + * + * Use of this source code is governed by a BSD-style + * license that can be found in the LICENSE file or at + * https://developers.google.com/open-source/licenses/bsd + */ + +#ifndef WRITER_H +#define WRITER_H + +#include "basics.h" +#include "block.h" +#include "tree.h" +#include "reftable-writer.h" + +struct reftable_writer { + ssize_t (*write)(void *, const void *, size_t); + int (*flush)(void *); + void *write_arg; + int pending_padding; + struct reftable_buf last_key; + /* Scratch buffer used to avoid allocations. */ + struct reftable_buf scratch; + + /* offset of next block to write. */ + uint64_t next; + uint64_t min_update_index, max_update_index; + struct reftable_write_options opts; + + /* memory buffer for writing */ + uint8_t *block; + + /* writer for the current section. NULL or points to + * block_writer_data */ + struct block_writer *block_writer; + + struct block_writer block_writer_data; + + /* pending index records for the current section */ + struct reftable_index_record *index; + size_t index_len; + size_t index_cap; + + /* + * tree for use with tsearch; used to populate the 'o' inverse OID + * map */ + struct tree_node *obj_index_tree; + + struct reftable_stats stats; +}; + +#endif diff --git a/include/git2/refdb.h b/include/git2/refdb.h index a896bdd07..dc8f4e58f 100644 --- a/include/git2/refdb.h +++ b/include/git2/refdb.h @@ -23,7 +23,8 @@ GIT_BEGIN_DECL /** The type of the refdb as determined by "extensions.refStorage". */ typedef enum { - GIT_REFDB_FILES = 1 /**< Files backend using loose and packed refs. */ + GIT_REFDB_FILES = 1, /**< Files backend using loose and packed refs. */ + GIT_REFDB_REFTABLE = 2 /**< Reftable backend. */ } git_refdb_t; /** diff --git a/include/git2/sys/refdb_backend.h b/include/git2/sys/refdb_backend.h index 386c6ca26..6bacf3efd 100644 --- a/include/git2/sys/refdb_backend.h +++ b/include/git2/sys/refdb_backend.h @@ -383,6 +383,21 @@ GIT_EXTERN(int) git_refdb_backend_fs( git_refdb_backend **backend_out, git_repository *repo); +/** + * Constructor for the reftable-based refdb backend + * + * Under normal usage, this is called for you when the repository is + * opened / created that uses the reftable format, but you can use this to + * explicitly construct a reftable refdb backend for a repository. + * + * @param backend_out Output pointer to the git_refdb_backend object + * @param repo Git repository to access + * @return 0 on success, <0 error code on failure + */ +GIT_EXTERN(int) git_refdb_backend_reftable( + git_refdb_backend **backend_out, + git_repository *repo); + /** * Sets the custom backend to an existing reference DB * diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index f76bbecc1..894fe95d0 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -149,6 +149,10 @@ set(GIT_BUILD_CPU "${CMAKE_SYSTEM_PROCESSOR}") execute_process(COMMAND git rev-parse HEAD OUTPUT_VARIABLE GIT_BUILD_COMMIT OUTPUT_STRIP_TRAILING_WHITESPACE) +add_subdirectory("${PROJECT_SOURCE_DIR}/deps/reftable" "${PROJECT_BINARY_DIR}/deps/reftable") +list(APPEND LIBGIT2_DEPENDENCY_INCLUDES "${PROJECT_SOURCE_DIR}/deps/reftable") +list(APPEND LIBGIT2_DEPENDENCY_OBJECTS "$") + # # Include child projects # diff --git a/src/libgit2/libgit2.c b/src/libgit2/libgit2.c index 37e0bd012..c1aae36a5 100644 --- a/src/libgit2/libgit2.c +++ b/src/libgit2/libgit2.c @@ -16,6 +16,7 @@ #include "mwindow.h" #include "oid.h" #include "rand.h" +#include "refdb_reftable.h" #include "runtime.h" #include "settings.h" #include "sysdir.h" @@ -53,7 +54,8 @@ int git_libgit2_init(void) git_mbedtls_stream_global_init, git_mwindow_global_init, git_pool_global_init, - git_settings_global_init + git_settings_global_init, + git_reftable_global_init }; return git_runtime_init(init_fns, ARRAY_SIZE(init_fns)); diff --git a/src/libgit2/refdb.c b/src/libgit2/refdb.c index facc64364..3457a8797 100644 --- a/src/libgit2/refdb.c +++ b/src/libgit2/refdb.c @@ -56,6 +56,10 @@ int git_refdb_open(git_refdb **out, git_repository *repo) if ((error = git_refdb_backend_fs(&backend, repo)) < 0) goto out; break; + case GIT_REFDB_REFTABLE: + if ((error = git_refdb_backend_reftable(&backend, repo)) < 0) + goto out; + break; default: git_error_set(GIT_ERROR_REFERENCE, "unknown reference storage format"); error = GIT_EINVALID; diff --git a/src/libgit2/refdb.h b/src/libgit2/refdb.h index 6a5ae3299..a0151e774 100644 --- a/src/libgit2/refdb.h +++ b/src/libgit2/refdb.h @@ -137,6 +137,8 @@ GIT_INLINE(const char *) git_refdb_type_name(git_refdb_t type) switch (type) { case GIT_REFDB_FILES: return "files"; + case GIT_REFDB_REFTABLE: + return "reftable"; default: return "unknown"; } @@ -146,6 +148,8 @@ GIT_INLINE(git_refdb_t) git_refdb_type_fromstr(const char *name) { if (strcmp(name, "files") == 0) return GIT_REFDB_FILES; + if (strcmp(name, "reftable") == 0) + return GIT_REFDB_REFTABLE; return 0; } diff --git a/src/libgit2/refdb_fs.c b/src/libgit2/refdb_fs.c index 37dc5d761..90092434b 100644 --- a/src/libgit2/refdb_fs.c +++ b/src/libgit2/refdb_fs.c @@ -487,21 +487,6 @@ static const char *loose_parse_symbolic(git_str *file_content) return refname_start; } -/* - * Returns whether a reference is stored per worktree or not. - * Per-worktree references are: - * - * - all pseudorefs, e.g. HEAD and MERGE_HEAD - * - all references stored inside of "refs/bisect/" - */ -static bool is_per_worktree_ref(const char *ref_name) -{ - return git__prefixcmp(ref_name, "refs/") != 0 || - git__prefixcmp(ref_name, "refs/bisect/") == 0 || - git__prefixcmp(ref_name, "refs/worktree/") == 0 || - git__prefixcmp(ref_name, "refs/rewritten/") == 0; -} - int git_reference__lookup_loose( git_reference **out, const char *ref_dir, @@ -551,7 +536,7 @@ static int loose_lookup( { const char *ref_dir; - if (is_per_worktree_ref(ref_name)) + if (git_reference__is_per_worktree_ref(ref_name)) ref_dir = backend->gitpath; else ref_dir = backend->commonpath; @@ -995,11 +980,11 @@ static int iter_load_paths( git_str_puts(&ctx->ref_name, entry->path); if (worktree) { - if (!is_per_worktree_ref(ctx->ref_name.ptr)) + if (!git_reference__is_per_worktree_ref(ctx->ref_name.ptr)) continue; } else { if (git_repository_is_worktree(ctx->backend->repo) && - is_per_worktree_ref(ctx->ref_name.ptr)) + git_reference__is_per_worktree_ref(ctx->ref_name.ptr)) continue; } @@ -1261,7 +1246,7 @@ static int loose_lock(git_filebuf *file, refdb_fs_backend *backend, const char * return GIT_EINVALIDSPEC; } - if (is_per_worktree_ref(name)) + if (git_reference__is_per_worktree_ref(name)) basedir = backend->gitpath; else basedir = backend->commonpath; diff --git a/src/libgit2/refdb_reftable.c b/src/libgit2/refdb_reftable.c new file mode 100644 index 000000000..e9013f739 --- /dev/null +++ b/src/libgit2/refdb_reftable.c @@ -0,0 +1,1901 @@ +/* + * Copyright (C) the libgit2 contributors. All rights reserved. + * + * This file is part of libgit2, distributed under the GNU GPL v2 with + * a Linking Exception. For full terms see the included COPYING file. + */ + +#include "refdb_reftable.h" + +#include "refdb.h" +#include "reflog.h" +#include "signature.h" +#include "wildmatch.h" + +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include + +typedef enum { + REFDB_REFTABLE_STACK_MAIN, + REFDB_REFTABLE_STACK_WORKTREE, +} refdb_reftable_stack_t; + +typedef struct { + struct reftable_stack *stack; + refdb_reftable_stack_t which; +} refdb_reftable_stack; + +typedef struct { + git_refdb_backend parent; + git_repository *repo; + refdb_reftable_stack *stack; + refdb_reftable_stack *worktree_stack; +} refdb_reftable; + +typedef struct { + refdb_reftable_stack *stack; + struct reftable_iterator iter; + struct reftable_ref_record ref; + enum { + STACK_ITER_ADVANCE, + STACK_ITER_READY, + STACK_ITER_EXHAUSTED, + } state; +} refdb_reftable_stack_iterator; + +typedef struct { + git_reference_iterator parent; + refdb_reftable *backend; + refdb_reftable_stack_iterator main; + refdb_reftable_stack_iterator worktree; + const char *glob; +} refdb_reftable_iterator; + +static int refdb_reftable_error(int error, const char *msg) +{ + int class; + + switch ((enum reftable_error) error) { + case REFTABLE_NOT_EXIST_ERROR: + class = GIT_ENOTFOUND; + break; + case REFTABLE_LOCK_ERROR: + class = GIT_ELOCKED; + break; + case REFTABLE_API_ERROR: + class = GIT_EINVALID; + break; + case REFTABLE_REFNAME_ERROR: + class = GIT_EINVALIDSPEC; + break; + case REFTABLE_OUTDATED_ERROR: + class = GIT_EMODIFIED; + break; + default: + class = GIT_ERROR; + break; + } + + git_error_set(GIT_ERROR_REFERENCE, "%s: %s", + msg, reftable_error_str(error)); + return class; +} + +static void refdb_reftable_stack_free(void *_stack) +{ + refdb_reftable_stack *stack = _stack; + if (stack) { + reftable_stack_destroy(stack->stack); + git__free(stack); + } +} + +static void refdb_reftable_return_stack(refdb_reftable *backend, + refdb_reftable_stack *stack) +{ + if (!stack) + return; + + switch (stack->which) { + case REFDB_REFTABLE_STACK_WORKTREE: + if (git_atomic_compare_and_swap(&backend->worktree_stack, NULL, stack) != NULL) + refdb_reftable_stack_free(stack); + break; + case REFDB_REFTABLE_STACK_MAIN: + if (git_atomic_compare_and_swap(&backend->stack, NULL, stack) != NULL) + refdb_reftable_stack_free(stack); + break; + } +} + +static int refdb_reftable_stack_for(refdb_reftable_stack **out, + refdb_reftable *backend, refdb_reftable_stack_t which) +{ + struct reftable_write_options options = { 0 }; + refdb_reftable_stack **stack_ptr, *stack; + const char *parent_directory; + git_str path = GIT_STR_INIT; + int error; + + *out = NULL; + +#ifdef GIT_EXPERIMENTAL_SHA256 + switch (backend->repo->oid_type) { + case GIT_OID_SHA1: + options.hash_id = REFTABLE_HASH_SHA1; + break; + case GIT_OID_SHA256: + options.hash_id = REFTABLE_HASH_SHA256; + break; + default: + error = GIT_EINVALID; + goto out; + } +#else + options.hash_id = REFTABLE_HASH_SHA1; +#endif + options.lock_timeout_ms = 100; + + switch (which) { + case REFDB_REFTABLE_STACK_WORKTREE: + if (git_repository_is_worktree(backend->repo)) { + stack_ptr = &backend->worktree_stack; + parent_directory = backend->repo->gitdir; + break; + } + + /* + * The worktree stack was requested, but we're not + * in a worktree. + */ + + /* fallthru */ + case REFDB_REFTABLE_STACK_MAIN: + stack_ptr = &backend->stack; + parent_directory = backend->repo->commondir; + break; + default: + error = -1; + goto out; + } + + stack = git_atomic_swap(*stack_ptr, NULL); + if (stack) { + if ((error = reftable_stack_reload(stack->stack)) < 0) { + error = refdb_reftable_error(error, "failed reloading stack"); + goto out; + } + } else { + stack = git__calloc(1, sizeof(*stack)); + GIT_ERROR_CHECK_ALLOC(stack); + stack->which = which; + + if ((error = git_str_joinpath(&path, parent_directory, "reftable")) < 0 || + (error = reftable_new_stack(&stack->stack, path.ptr, &options)) < 0) { + refdb_reftable_stack_free(stack); + error = refdb_reftable_error(error, "failed loading stack"); + goto out; + } + } + + *out = stack; + error = 0; + +out: + git_str_dispose(&path); + return error; +} + +static int refdb_reftable_stack_for_refname(refdb_reftable_stack **out, + refdb_reftable *backend, + const char *refname) +{ + refdb_reftable_stack_t type = REFDB_REFTABLE_STACK_MAIN; + if (git_reference__is_per_worktree_ref(refname)) + type = REFDB_REFTABLE_STACK_WORKTREE; + return refdb_reftable_stack_for(out, backend, type); +} + +static int refdb_reftable_reference_from_record(git_reference **out, + struct reftable_ref_record *record, + git_oid_t type) +{ + git_reference *ref; + int error = 0; + + switch (record->value_type) { + case REFTABLE_REF_SYMREF: + ref = git_reference__alloc_symbolic(record->refname, record->value.symref); + break; + case REFTABLE_REF_VAL1: { + git_oid oid; + if ((error = git_oid_from_raw(&oid, record->value.val1, type)) < 0) + goto out; + ref = git_reference__alloc(record->refname, &oid, NULL); + break; + } + case REFTABLE_REF_VAL2: { + git_oid oid, peeled; + if ((error = git_oid_from_raw(&oid, record->value.val2.value, type)) < 0 || + (error = git_oid_from_raw(&peeled, record->value.val2.target_value, type)) < 0) + goto out; + ref = git_reference__alloc(record->refname, &oid, &peeled); + break; + } + default: + error = -1; + goto out; + } + + GIT_ERROR_CHECK_ALLOC(ref); + *out = ref; +out: + return error; +} + +static int refdb_reftable_check_refname_available(refdb_reftable_stack *stack, + const char *old_name, + const char *new_name, + int force) +{ + struct reftable_ref_record ref = { 0 }; + struct reftable_iterator iter = { 0 }; + struct reftable_merged_table *table; + git_str buf = GIT_STR_INIT; + int error; + + /* + * Check if the reference itself exists. If so, we only allow the + * update when forcing it. + */ + if ((error = reftable_stack_read_ref(stack->stack, new_name, &ref)) < 0) { + error = refdb_reftable_error(error, "could not read ref for collision checks"); + goto out; + } else if (error == 0) { + if (!force) { + git_error_set(GIT_ERROR_REFERENCE, + "failed to write reference '%s': a reference with " + "that name already exists.", new_name); + error = GIT_EEXISTS; + } else { + error = 0; + } + + goto out; + } + + /* + * Otherwise, we need to check whether there are any references nested + * below the new name. E.g., there must not be two refs refs/heads/foo + * and refs/heads/foo/bar. + */ + table = reftable_stack_merged_table(stack->stack); + GIT_ERROR_CHECK_ALLOC(table); + + if ((error = git_str_printf(&buf, "%s/", new_name)) < 0 || + (error = reftable_merged_table_init_ref_iterator(table, &iter)) < 0 || + (error = reftable_iterator_seek_ref(&iter, buf.ptr)) < 0) { + error = refdb_reftable_error(error, "could not check for nested conflicts"); + goto out; + } + + while (1) { + if ((error = reftable_iterator_next_ref(&iter, &ref)) < 0) { + error = refdb_reftable_error(error, "could not check for nested conflicts"); + goto out; + } else if (error > 0) { + /* The iterator didn't yield any more refs, so we're good. */ + break; + } else if (old_name && !git__strcmp(ref.refname, old_name)) { + /* + * This is the ref we're about to rename, so this is + * fine. We need to check subsequent refs though in + * case those might conflict. We do have to check + * subsequent refs though, as there might be other + * nested refs that conflict. + */ + continue; + } else if (git__strncmp(ref.refname, buf.ptr, buf.size)) { + /* + * This reference does not match our prefix. We have + * thus exhausted the new refs' prefix and can stop + * searching for conflicts. + */ + break; + } else { + git_error_set(GIT_ERROR_REFERENCE, + "cannot lock ref '%s', there are refs beneath that folder", new_name); + error = GIT_EDIRECTORY; + goto out; + } + } + + /* + * And last we need to check that there are no prefixes. E.g., there + * must be no ref "refs/heads" when we create "refs/heads/branch". + */ + if ((error = git_str_sets(&buf, new_name)) < 0) + goto out; + while (strchr(buf.ptr, '/')) { + git_str_rtruncate_at_char(&buf, '/'); + + /* + * If this is the reference we're about to rename we can abort + * searching. We know that there cannot be any conflicting ref + * any further up the hierarchy, as otherwise the old ref could + * not have existed, either. + */ + if (old_name && !git__strcmp(buf.ptr, old_name)) + break; + + if ((error = reftable_stack_read_ref(stack->stack, buf.ptr, &ref)) < 0) { + error = refdb_reftable_error(error, "could not read ref for collision checks"); + goto out; + } else if (error == 0) { + git_error_set(GIT_ERROR_REFERENCE, + "path to reference '%s' collides with existing one", new_name); + error = -1; + goto out; + } + } + + error = 0; +out: + reftable_ref_record_release(&ref); + reftable_iterator_destroy(&iter); + git_str_dispose(&buf); + return error; +} + +static int refdb_reftable_check_ref(refdb_reftable_stack *stack, + const char *refname, + const git_oid *expected_oid, + const char *expected_target) +{ + struct reftable_ref_record ref = { 0 }; + int error; + + if (!expected_oid && !expected_target) + return 0; + + if ((error = reftable_stack_read_ref(stack->stack, refname, &ref)) < 0) { + error = refdb_reftable_error(error, "failed reading reference"); + goto out; + } else if (error > 0 && expected_oid && git_oid_is_zero(expected_oid)) { + error = 0; + goto out; + } else if (error > 0) { + error = GIT_ENOTFOUND; + goto out; + } + + if (expected_oid && reftable_ref_record_val1(&ref) == NULL) { + error = GIT_EMODIFIED; + goto out; + } + + if (expected_target && ref.value_type != REFTABLE_REF_SYMREF) { + error = GIT_EMODIFIED; + goto out; + } + + if (expected_oid && reftable_ref_record_val1(&ref) != NULL) { +#ifdef GIT_EXPERIMENTAL_SHA256 + git_oid_t oid_type = expected_oid->type; +#else + git_oid_t oid_type = GIT_OID_SHA1; +#endif + git_oid oid; + + if ((error = git_oid_from_raw(&oid, reftable_ref_record_val1(&ref), oid_type)) < 0) + goto out; + if (!git_oid_equal(&oid, expected_oid)) { + error = GIT_EMODIFIED; + goto out; + } + } + + if (expected_target && ref.value_type == REFTABLE_REF_SYMREF) { + if (git__strcmp(expected_target, ref.value.symref)) { + error = GIT_EMODIFIED; + goto out; + } + } + + error = 0; +out: + reftable_ref_record_release(&ref); + return error; +} + +static int refdb_reftable_log_fill(struct reftable_log_record *out, + const git_signature *who, + const git_oid *old_id, + const git_oid *new_id, + const char *reference, + const char *message, + uint64_t update_index) +{ + memset(out, 0, sizeof(*out)); + out->refname = reference ? git__strdup(reference) : NULL; + out->update_index = update_index; + out->value_type = REFTABLE_LOG_UPDATE; + if (who) { + out->value.update.name = who->name ? git__strdup(who->name) : NULL; + out->value.update.email = who->email ? git__strdup(who->email) : NULL; + out->value.update.time = who->when.time; + out->value.update.tz_offset = who->when.offset; + } + if (old_id) + memcpy(out->value.update.old_hash, old_id->id, GIT_OID_MAX_SIZE); + if (new_id) + memcpy(out->value.update.new_hash, new_id->id, GIT_OID_MAX_SIZE); + out->value.update.message = message ? git__strdup(message) : NULL; + return 0; +} + +typedef struct { + const char *initial_head; + int error; +} refdb_reftable_write_head_data; + +static int refdb_reftable_write_head_table(struct reftable_writer *wr, void *cb_data) +{ + refdb_reftable_write_head_data *data = cb_data; + struct reftable_ref_record head = { 0 }; + int error; + + head.refname = (char *) GIT_HEAD_REF; + head.update_index = 1; + head.value_type = REFTABLE_REF_SYMREF; + head.value.symref = (char *) data->initial_head; + + if ((error = reftable_writer_set_limits(wr, 1, 1)) < 0 || + (error = reftable_writer_add_refs(wr, &head, 1)) < 0) { + data->error = refdb_reftable_error(error, "failed queueing initial head ref"); + goto out; + } + +out: + return error; +} + +static int refdb_reftable_init(git_refdb_backend *_backend, + const char *initial_head, + mode_t mode, + uint32_t flags) +{ + refdb_reftable *backend = GIT_CONTAINER_OF(_backend, refdb_reftable, parent); + refdb_reftable_stack *stack = NULL; + git_str path = GIT_STR_INIT; + mode_t dmode; + int error; + + if (mode == GIT_REPOSITORY_INIT_SHARED_UMASK) + dmode = 0777; + else if (mode == GIT_REPOSITORY_INIT_SHARED_GROUP) + dmode = (0775 | S_ISGID); + else if (mode == GIT_REPOSITORY_INIT_SHARED_ALL) + dmode = (0777 | S_ISGID); + else + dmode = mode; + + if ((error = git_str_joinpath(&path, backend->repo->gitdir, "reftable")) < 0 || + (error = git_futils_mkdir(path.ptr, dmode, 0) < 0)) + goto out; + + if (initial_head) { + int write_head = 1; + + if ((error = refdb_reftable_stack_for_refname(&stack, backend, GIT_HEAD_REF)) < 0) + goto out; + + if ((flags & GIT_REFDB_BACKEND_INIT_FORCE_HEAD) == 0) { + struct reftable_ref_record existing_ref = { 0 }; + + if ((error = reftable_stack_read_ref(stack->stack, GIT_HEAD_REF, &existing_ref)) < 0) { + error = refdb_reftable_error(error, "failed reference lookup"); + goto out; + } + + write_head = (error > 0); + } + + if (write_head) { + refdb_reftable_write_head_data data; + + data.initial_head = initial_head; + data.error = 0; + + if ((error = reftable_stack_add(stack->stack, refdb_reftable_write_head_table, + &data, REFTABLE_STACK_NEW_ADDITION_RELOAD)) < 0) { + if (data.error) + error = data.error; + else + error = refdb_reftable_error(error, "failed stack update"); + goto out; + } + } + } + +out: + refdb_reftable_return_stack(backend, stack); + git_str_dispose(&path); + return error; +} + +static int refdb_reftable_exists(int *exists, + git_refdb_backend *_backend, + const char *refname) +{ + refdb_reftable *backend = GIT_CONTAINER_OF(_backend, refdb_reftable, parent); + refdb_reftable_stack *stack; + struct reftable_ref_record ref = { 0 }; + int error; + + if ((error = refdb_reftable_stack_for_refname(&stack, backend, refname)) < 0) + goto out; + + if ((error = reftable_stack_read_ref(stack->stack, refname, &ref)) < 0) { + error = refdb_reftable_error(error, "failed reading reference"); + goto out; + } + + *exists = (error == 0); + +out: + refdb_reftable_return_stack(backend, stack); + reftable_ref_record_release(&ref); + return error; +} + +static int refdb_reftable_lookup(git_reference **out_ref, + git_refdb_backend *_backend, + const char *refname) +{ + refdb_reftable *backend = GIT_CONTAINER_OF(_backend, refdb_reftable, parent); + refdb_reftable_stack *stack; + struct reftable_ref_record ref = { 0 }; + int error; + + if ((error = refdb_reftable_stack_for_refname(&stack, backend, refname)) < 0) + goto out; + + if ((error = reftable_stack_read_ref(stack->stack, refname, &ref)) < 0) { + error = refdb_reftable_error(error, "failed reference lookup"); + goto out; + } else if (error > 0) { + git_error_set(GIT_ERROR_REFERENCE, "reference '%s' not found", refname); + error = GIT_ENOTFOUND; + goto out; + } + + if ((error = refdb_reftable_reference_from_record(out_ref, &ref, backend->repo->oid_type)) < 0) + goto out; + +out: + refdb_reftable_return_stack(backend, stack); + reftable_ref_record_release(&ref); + return error; +} + +static int refdb_reftable_stack_iter_maybe_advance(refdb_reftable_stack_iterator *it, + refdb_reftable_stack_t which, + const char *glob, bool is_worktree) +{ + if (it->state == STACK_ITER_READY || + it->state == STACK_ITER_EXHAUSTED) + return 0; + + while (1) { + int error; + + if ((error = reftable_iterator_next_ref(&it->iter, &it->ref)) != 0) { + if (error > 0) { + it->state = STACK_ITER_EXHAUSTED; + return 0; + } + return refdb_reftable_error(error, "failed retrieving next record"); + } + + switch (which) { + case REFDB_REFTABLE_STACK_MAIN: + if (is_worktree && git_reference__is_per_worktree_ref(it->ref.refname)) + continue; + break; + case REFDB_REFTABLE_STACK_WORKTREE: + if (!git_reference__is_per_worktree_ref(it->ref.refname)) + continue; + break; + } + + if (glob && wildmatch(glob, it->ref.refname, 0) != 0) + continue; + + it->state = STACK_ITER_READY; + return 0; + } +} + +static int refdb_reftable_merged_iter_next(struct reftable_ref_record **out, + refdb_reftable_iterator *it) +{ + refdb_reftable *backend = GIT_CONTAINER_OF(it->parent.db->backend, refdb_reftable, parent); + bool is_worktree = git_repository_is_worktree(backend->repo); + int error; + + if ((error = refdb_reftable_stack_iter_maybe_advance(&it->main, REFDB_REFTABLE_STACK_MAIN, + it->glob, is_worktree)) < 0) + return error; + + if (git_repository_is_worktree(backend->repo)) { + if ((error = refdb_reftable_stack_iter_maybe_advance(&it->worktree, REFDB_REFTABLE_STACK_WORKTREE, + it->glob, is_worktree)) < 0) + return error; + + if (it->main.state == STACK_ITER_READY && + it->worktree.state == STACK_ITER_READY) { + int cmp = git__strcmp(it->main.ref.refname, it->worktree.ref.refname); + if (cmp < 0) + goto yield_main; + else + goto yield_worktree; + } else if (it->main.state == STACK_ITER_READY) { + goto yield_main; + } else if (it->worktree.state == STACK_ITER_READY) { + goto yield_worktree; + } else { + return GIT_ITEROVER; + } + } else { + if (it->main.state == STACK_ITER_EXHAUSTED) + return GIT_ITEROVER; + goto yield_main; + } + +yield_main: + it->main.state = STACK_ITER_ADVANCE; + *out = &it->main.ref; + return 0; + +yield_worktree: + it->worktree.state = STACK_ITER_ADVANCE; + *out = &it->worktree.ref; + return 0; +} + +static int refdb_reftable_iterator_next(git_reference **out, git_reference_iterator *_it) +{ + refdb_reftable_iterator *it = GIT_CONTAINER_OF(_it, refdb_reftable_iterator, parent); + refdb_reftable *backend = GIT_CONTAINER_OF(it->parent.db->backend, refdb_reftable, parent); + struct reftable_ref_record *ref; + int error; + + if ((error = refdb_reftable_merged_iter_next(&ref, it)) < 0 || + (error = refdb_reftable_reference_from_record(out, ref, backend->repo->oid_type)) < 0) + return error; + + return 0; +} + +static int refdb_reftable_iterator_next_name(const char **out, git_reference_iterator *_it) +{ + refdb_reftable_iterator *it = GIT_CONTAINER_OF(_it, refdb_reftable_iterator, parent); + struct reftable_ref_record *ref; + int error; + + if ((error = refdb_reftable_merged_iter_next(&ref, it)) < 0) + return error; + *out = ref->refname; + + return 0; +} + +static void refdb_reftable_iterator_free(git_reference_iterator *_it) +{ + if (_it) { + refdb_reftable_iterator *it = GIT_CONTAINER_OF(_it, refdb_reftable_iterator, parent); + reftable_iterator_destroy(&it->main.iter); + reftable_iterator_destroy(&it->worktree.iter); + reftable_ref_record_release(&it->main.ref); + reftable_ref_record_release(&it->worktree.ref); + refdb_reftable_return_stack(it->backend, it->main.stack); + refdb_reftable_return_stack(it->backend, it->worktree.stack); + git__free((char *) it->glob); + git__free(it); + } +} + +static int refdb_reftable_iterator_new(git_reference_iterator **out, + git_refdb_backend *_backend, + const char *glob) +{ + refdb_reftable *backend = GIT_CONTAINER_OF(_backend, refdb_reftable, parent); + refdb_reftable_iterator *it = NULL; + char *needle = NULL; + int error; + + it = git__calloc(1, sizeof(*it)); + GIT_ERROR_CHECK_ALLOC(it); + it->backend = backend; + it->parent.next = refdb_reftable_iterator_next; + it->parent.next_name = refdb_reftable_iterator_next_name; + it->parent.free = refdb_reftable_iterator_free; + + if ((error = refdb_reftable_stack_for(&it->main.stack, backend, REFDB_REFTABLE_STACK_MAIN)) < 0 || + (error = reftable_merged_table_init_ref_iterator(reftable_stack_merged_table(it->main.stack->stack), + &it->main.iter) < 0)) + goto out; + + if (git_repository_is_worktree(backend->repo)) { + if ((error = refdb_reftable_stack_for(&it->worktree.stack, backend, REFDB_REFTABLE_STACK_WORKTREE)) < 0 || + (error = reftable_merged_table_init_ref_iterator(reftable_stack_merged_table(it->worktree.stack->stack), + &it->worktree.iter) < 0)) + goto out; + } + + if (glob) { + const char *separator = NULL; + const char *pos; + + for (pos = glob; *pos; pos++) { + switch (*pos) { + case '?': + case '*': + case '[': + case '\\': + break; + case '/': + separator = pos; + /* FALLTHROUGH */ + default: + continue; + } + break; + } + + if (separator) { + it->glob = git__strdup(glob); + } else { + git_str pattern = GIT_STR_INIT; + if ((git_str_printf(&pattern, "refs/%s", glob)) < 0) + goto out; + it->glob = git_str_detach(&pattern); + } + + needle = git__strndup(glob, glob - pos); + } else { + it->glob = git__strdup("refs/*"); + needle = git__strdup("refs/"); + } + GIT_ERROR_CHECK_ALLOC(it->glob); + GIT_ERROR_CHECK_ALLOC(needle); + + if ((error = reftable_iterator_seek_ref(&it->main.iter, needle)) < 0) { + error = refdb_reftable_error(error, "failed updating reftable for update"); + goto out; + } + + if (git_repository_is_worktree(backend->repo)) { + if ((error = reftable_iterator_seek_ref(&it->worktree.iter, needle)) < 0) { + error = refdb_reftable_error(error, "failed updating reftable for update"); + goto out; + } + } + + *out = &it->parent; +out: + if (error < 0 && it) + refdb_reftable_iterator_free(&it->parent); + git__free(needle); + return 0; +} + +typedef struct { + refdb_reftable *backend; + refdb_reftable_stack *stack; + const git_reference *ref; + int force; + const git_signature *who; + const char *message; + const git_oid *expected_oid; + const char *expected_target; + int error; +} refdb_reftable_write_table_data; + +static int refdb_reftable_write_table(struct reftable_writer *writer, void *cb_data) +{ + refdb_reftable_write_table_data *data = cb_data; + struct reftable_log_record log_records[2] = {{ 0 }}; + struct reftable_ref_record ref_record = { 0 }; + const char *new_target = NULL; + const git_oid *new_id = NULL; + int error, write_reflog; + uint64_t update_index; + size_t logs_nr = 0, i; + git_refdb *refdb; + + if (data->ref->type == GIT_REFERENCE_SYMBOLIC) + new_target = data->ref->target.symbolic; + else + new_id = &data->ref->target.oid; + + /* + * Verify that the current state of the refname matches the expected + * state for non-racy updates. + */ + if ((error = refdb_reftable_check_ref(data->stack, data->ref->name, data->expected_oid, data->expected_target)) < 0) { + data->error = error; + git_error_set(GIT_ERROR_REFERENCE, "old reference value does not match"); + goto out; + } + + if ((error = refdb_reftable_check_refname_available(data->stack, NULL, data->ref->name, data->force)) < 0) { + data->error = error; + goto out; + } + + /* + * Check whether the update is a no-op. If so, we want to skip the + * update completely, most importantly so that we don't write a reflog + * entry. + */ + if ((error = refdb_reftable_check_ref(data->stack, data->ref->name, new_id, new_target)) < 0) { + if (error == GIT_EMODIFIED) { + /* + * The reference is different than what we expected. + * Good, proceed with updating it. + */ + } else if (error == GIT_ENOTFOUND && new_id && git_oid_is_zero(new_id)) { + /* + * The reference does not exist, and we are about to + * delete it. As the current state already matches the + * desired state we don't have to do anything. + */ + error = 0; + goto out; + } else if (error == GIT_ENOTFOUND) { + /* + * The reference does not exist, but we want it to. + * Good, continue with the write. + */ + } else { + data->error = error; + goto out; + } + } else { + /* + * The reference already matches our desired value, so we do + * not need to write anything. + */ + error = 0; + goto out; + } + + update_index = reftable_stack_next_update_index(data->stack->stack); + + ref_record.refname = (char *) data->ref->name; + ref_record.update_index = update_index; + switch (git_reference_type(data->ref)) { + case GIT_REFERENCE_SYMBOLIC: + ref_record.value_type = REFTABLE_REF_SYMREF; + ref_record.value.symref = (char *) git_reference_symbolic_target(data->ref); + break; + case GIT_REFERENCE_DIRECT: { + git_object *peeled = NULL; + + if ((error = git_reference_peel(&peeled, data->ref, GIT_OBJECT_COMMIT)) == 0 && + !git_oid_equal(git_reference_target(data->ref), git_object_id(peeled))) { + ref_record.value_type = REFTABLE_REF_VAL2; + memcpy(ref_record.value.val2.value, git_reference_target(data->ref), GIT_OID_MAX_SIZE); + memcpy(ref_record.value.val2.target_value, git_object_id(peeled)->id, GIT_OID_MAX_SIZE); + } else { + ref_record.value_type = REFTABLE_REF_VAL1; + memcpy(ref_record.value.val1, git_reference_target(data->ref), GIT_OID_MAX_SIZE); + } + + git_object_free(peeled); + break; + } + default: + data->error = error = -1; + goto out; + } + + if ((error = git_repository_refdb__weakptr(&refdb, data->backend->repo)) < 0 || + (error = git_refdb_should_write_reflog(&write_reflog, refdb, data->ref)) < 0) { + data->error = error; + goto out; + } + + if (write_reflog) { + int write_head_reflog = 0; + git_oid old_id, new_id; + + git_oid_clear(&old_id, data->backend->repo->oid_type); + git_oid_clear(&new_id, data->backend->repo->oid_type); + + error = git_reference_name_to_id(&old_id, data->backend->repo, data->ref->name); + if (error < 0 && error != GIT_ENOTFOUND) { + data->error = error; + goto out; + } + + if (data->ref->type == GIT_REFERENCE_SYMBOLIC) { + error = git_reference_name_to_id(&new_id, data->backend->repo, + git_reference_symbolic_target(data->ref)); + if (error < 0 && error != GIT_ENOTFOUND) { + data->error = error; + goto out; + } + + /* Detaching HEAD does not create an entry. */ + if (!strcmp(data->ref->name, GIT_HEAD_REF) && error == GIT_ENOTFOUND) + write_reflog = 0; + /* Symbolic refs other than HEAD do not create an entry, either. */ + else if (strcmp(data->ref->name, GIT_HEAD_REF)) + write_reflog = 0; + } else { + git_oid_cpy(&new_id, git_reference_target(data->ref)); + } + + if (write_reflog && + (error = git_refdb_should_write_head_reflog(&write_head_reflog, refdb, data->ref)) < 0) { + data->error = error; + goto out; + } + + if (write_reflog && + (error = refdb_reftable_log_fill(&log_records[logs_nr++], data->who, &old_id, &new_id, + data->ref->name, data->message, update_index)) < 0) { + data->error = error; + goto out; + } + + if (write_head_reflog && + (error = refdb_reftable_log_fill(&log_records[logs_nr++], data->who, &old_id, &new_id, + GIT_HEAD_REF, data->message, update_index)) < 0) { + data->error = error; + goto out; + } + } + + if ((error = reftable_writer_set_limits(writer, update_index, update_index)) < 0 || + (error = reftable_writer_add_refs(writer, &ref_record, 1)) < 0 || + (error = reftable_writer_add_logs(writer, log_records, logs_nr)) < 0) { + data->error = refdb_reftable_error(error, "failed writing update table"); + goto out; + } + +out: + for (i = 0; i < logs_nr; i++) + reftable_log_record_release(&log_records[i]); + return error; +} + +static int refdb_reftable_write(git_refdb_backend *_backend, + const git_reference *ref, + int force, + const git_signature *who, + const char *message, + const git_oid *expected_oid, + const char *expected_target) +{ + refdb_reftable *backend = GIT_CONTAINER_OF(_backend, refdb_reftable, parent); + refdb_reftable_write_table_data data; + int error; + + data.backend = backend; + data.ref = ref; + data.force = force; + data.who = who; + data.message = message; + data.expected_oid = expected_oid; + data.expected_target = expected_target; + data.error = 0; + + if ((error = refdb_reftable_stack_for_refname(&data.stack, backend, ref->name)) < 0) + goto out; + + if ((error = reftable_stack_add(data.stack->stack, refdb_reftable_write_table, &data, + REFTABLE_STACK_NEW_ADDITION_RELOAD)) < 0) { + if (data.error) + error = data.error; + else + error = refdb_reftable_error(error, "failed stack update"); + goto out; + } + +out: + refdb_reftable_return_stack(backend, data.stack); + return error; +} + +static int refdb_reftable_updates_for_reflog_delete_or_rename(refdb_reftable_stack *stack, + const char *old_name, + const char *new_name, + struct reftable_log_record **out, + size_t *out_nr) +{ + struct reftable_log_record *updates = NULL; + struct reftable_log_record old_log = { 0 }; + struct reftable_iterator iter = { 0 }; + struct reftable_merged_table *table; + size_t updates_nr = 0; + int error; + + if (new_name) { + int valid; + + if ((error = git_reference_name_is_valid(&valid, new_name)) < 0) + goto out; + if (!valid) { + error = GIT_EINVALIDSPEC; + goto out; + } + } + + table = reftable_stack_merged_table(stack->stack); + GIT_ERROR_CHECK_ALLOC(table); + + if ((error = reftable_merged_table_init_log_iterator(table, &iter)) < 0 || + (error = reftable_iterator_seek_log(&iter, old_name)) < 0) { + error = refdb_reftable_error(error, "could not get old reflog entries"); + goto out; + } + + /* + * Deletion of reflogs means that we have to delete each reflog entry + * individually. If we want to rename, we have to also create the new + * entry at the same point in time. + */ + while (1) { + struct reftable_log_record deletion = { 0 }, creation = { 0 }; + + if ((error = reftable_iterator_next_log(&iter, &old_log)) < 0) { + error = refdb_reftable_error(error, "could not get old reflog entry"); + goto out; + } + if (error > 0 || strcmp(old_log.refname, old_name)) + break; + + deletion.refname = git__strdup(old_name); + deletion.value_type = REFTABLE_LOG_DELETION; + deletion.update_index = old_log.update_index; + + updates = git__reallocarray(updates, updates_nr + 1 + !!new_name, sizeof(*updates)); + updates[updates_nr++] = deletion; + + if (new_name) { + creation = old_log; + git__free(creation.refname); + creation.refname = git__strdup(new_name); + + /* Pass ownership of the record to `updates`. */ + memset(&old_log, 0, sizeof(old_log)); + updates[updates_nr++] = creation; + } + } + + *out = updates; + *out_nr = updates_nr; + updates = NULL; + error = 0; + +out: + reftable_log_record_release(&old_log); + reftable_iterator_destroy(&iter); + git__free(updates); + return error; +} + +typedef struct { + refdb_reftable_stack *stack; + const char *refname; + const git_oid *old_id; + const char *old_target; + int error; +} refdb_reftable_delete_data; + +static int refdb_reftable_write_delete_table(struct reftable_writer *writer, void *cb_data) +{ + refdb_reftable_delete_data *data = cb_data; + struct reftable_log_record *log_deletions = NULL; + struct reftable_ref_record ref = { 0 }; + size_t log_deletions_nr = 0, i; + int error; + + if ((error = refdb_reftable_check_ref(data->stack, data->refname, + data->old_id, data->old_target)) < 0) { + data->error = error; + goto out; + } + + ref.refname = (char *) data->refname; + ref.update_index = reftable_stack_next_update_index(data->stack->stack); + ref.value_type = REFTABLE_REF_DELETION; + + if ((error = refdb_reftable_updates_for_reflog_delete_or_rename(data->stack, data->refname, NULL, + &log_deletions, &log_deletions_nr)) < 0) { + data->error = error; + goto out; + } + + if ((error = reftable_writer_set_limits(writer, ref.update_index, ref.update_index)) < 0 || + (error = reftable_writer_add_refs(writer, &ref, 1)) < 0 || + (error = reftable_writer_add_logs(writer, log_deletions, log_deletions_nr)) < 0) { + data->error = refdb_reftable_error(error, "failed writing ref deletions"); + goto out; + } + +out: + for (i = 0; i < log_deletions_nr; i++) + reftable_log_record_release(&log_deletions[i]); + git__free(log_deletions); + return error; +} + +static int refdb_reftable_delete(git_refdb_backend *_backend, + const char *refname, + const git_oid *old_id, + const char *old_target) +{ + refdb_reftable *backend = GIT_CONTAINER_OF(_backend, refdb_reftable, parent); + refdb_reftable_delete_data data; + int error; + + data.refname = refname; + data.old_id = old_id; + data.old_target = old_target; + data.error = 0; + + if ((error = refdb_reftable_stack_for_refname(&data.stack, backend, refname)) < 0) + goto out; + + if ((error = reftable_stack_add(data.stack->stack, refdb_reftable_write_delete_table, &data, + REFTABLE_STACK_NEW_ADDITION_RELOAD)) < 0) { + if (data.error) + error = data.error; + else + error = refdb_reftable_error(error, "failed stack update"); + goto out; + } + +out: + refdb_reftable_return_stack(backend, data.stack); + return error; +} + +typedef struct { + refdb_reftable *backend; + refdb_reftable_stack *stack; + const char *old_name; + const char *new_name; + int force; + const git_signature *who; + const char *message; + git_reference **out; + int error; +} refdb_reftable_rename_data; + +static int refdb_reftable_write_rename_table(struct reftable_writer *writer, void *cb_data) +{ + refdb_reftable_rename_data *data = cb_data; + struct reftable_ref_record refs[2] = {{ 0 }}, existing = { 0 }, renamed = { 0 }; + struct reftable_log_record *logs = NULL; + uint64_t update_index; + size_t logs_nr = 0, i; + int error; + + if ((error = reftable_stack_read_ref(data->stack->stack, data->old_name, &existing)) < 0) { + data->error = refdb_reftable_error(error, "failed reading reference to be renamed"); + goto out; + } else if (error > 0) { + data->error = GIT_ENOTFOUND; + goto out; + } + + if ((error = refdb_reftable_check_refname_available(data->stack, data->old_name, + data->new_name, data->force)) < 0) { + data->error = error; + goto out; + } + + update_index = reftable_stack_next_update_index(data->stack->stack); + + if ((error = refdb_reftable_updates_for_reflog_delete_or_rename(data->stack, data->old_name, + data->new_name, &logs, &logs_nr)) < 0) { + data->error = error; + goto out; + } + + if (logs_nr) { + git_oid oid; + + switch (existing.value_type) { + case REFTABLE_REF_SYMREF: + if ((error = git_reference_name_to_id(&oid, data->backend->repo, + existing.value.symref)) < 0) { + if (error != GIT_ENOTFOUND) { + data->error = error; + goto out; + } + goto skip_log; + } + break; + case REFTABLE_REF_VAL1: + case REFTABLE_REF_VAL2: + if ((error = git_oid_from_raw(&oid, reftable_ref_record_val1(&existing), + data->backend->repo->oid_type)) < 0) { + data->error = error; + goto out; + } + break; + default: + data->error = error = -1; + goto out; + } + + logs = git__reallocarray(logs, logs_nr + 1, sizeof(*logs)); + if ((error = refdb_reftable_log_fill(&logs[logs_nr], data->who, &oid, + &oid, data->new_name, data->message, + update_index)) < 0) { + data->error = error; + goto out; + } + logs_nr++; + } + +skip_log: + refs[0].refname = (char *) data->old_name; + refs[0].update_index = update_index; + refs[0].value_type = REFTABLE_REF_DELETION; + refs[1].refname = (char *) data->new_name; + refs[1].update_index = update_index; + refs[1].value = existing.value; + refs[1].value_type = existing.value_type; + + /* Copy new record as the reftable library may sort it away under our feet. */ + renamed = refs[1]; + + if ((error = reftable_writer_set_limits(writer, update_index, update_index)) < 0 || + (error = reftable_writer_add_refs(writer, refs, 2)) < 0 || + (error = reftable_writer_add_logs(writer, logs, logs_nr)) < 0) { + data->error = refdb_reftable_error(error, "failed writing rename"); + goto out; + } + + if ((error = refdb_reftable_reference_from_record(data->out, &renamed, data->backend->repo->oid_type)) < 0) { + data->error = error; + goto out; + } + +out: + reftable_ref_record_release(&existing); + for (i = 0; i < logs_nr; i++) + reftable_log_record_release(&logs[i]); + git__free(logs); + return error; +} + +static int refdb_reftable_rename(git_reference **out, + git_refdb_backend *_backend, + const char *old_name, + const char *new_name, + int force, + const git_signature *who, + const char *message) +{ + refdb_reftable *backend = GIT_CONTAINER_OF(_backend, refdb_reftable, parent); + refdb_reftable_rename_data data; + int error; + + data.backend = backend; + data.old_name = old_name; + data.new_name = new_name; + data.force = force; + data.who = who; + data.message = message; + data.out = out; + data.error = 0; + + /* + * Are we in a worktree, but the references aren't both per-worktree + * refs? In that case they cannot be part of the same worktree, but we + * don't support cross-worktree renames yet. + */ + if (git_repository_is_worktree(backend->repo) && + git_reference__is_per_worktree_ref(old_name) != git_reference__is_per_worktree_ref(new_name)) { + error = GIT_EINVALID; + goto out; + } + + /* + * Otherwise, are both refs named worktree refs, but for different + * worktrees? If so, we need to bail out, as well. + */ + if (!git__prefixcmp(old_name, "refs/worktree/") && + !git__prefixcmp(new_name, "refs/worktree/")) { + const char *old_wtname_end = strchr(old_name + strlen("refs/worktree/"), '/'); + const char *new_wtname_end = strchr(new_name + strlen("refs/worktree/"), '/'); + size_t old_prefix_len, new_prefix_len; + + if (!old_wtname_end || !new_wtname_end) { + error = GIT_EINVALID; + goto out; + } + + old_prefix_len = p_strnlen(old_name, old_wtname_end - old_name); + new_prefix_len = p_strnlen(new_name, new_wtname_end - new_name); + + if (old_prefix_len != new_prefix_len) { + error = GIT_EINVALID; + goto out; + } + + if (git__strncmp(old_name, new_name, old_prefix_len)) { + error = GIT_EINVALID; + goto out; + } + } + + if ((error = refdb_reftable_stack_for_refname(&data.stack, backend, old_name)) < 0) + goto out; + + if ((error = reftable_stack_add(data.stack->stack, refdb_reftable_write_rename_table, &data, + REFTABLE_STACK_NEW_ADDITION_RELOAD)) < 0) { + if (data.error) + error = data.error; + else + error = refdb_reftable_error(error, "failed stack update"); + goto out; + } + +out: + refdb_reftable_return_stack(backend, data.stack); + return error; +} + +static void refdb_reftable_free(git_refdb_backend *_backend) +{ + refdb_reftable *backend = GIT_CONTAINER_OF(_backend, refdb_reftable, parent); + refdb_reftable_stack_free(backend->worktree_stack); + refdb_reftable_stack_free(backend->stack); + git__free(backend); +} + +static int refdb_reftable_has_log(git_refdb_backend *_backend, const char *refname) +{ + refdb_reftable *backend = GIT_CONTAINER_OF(_backend, refdb_reftable, parent); + struct reftable_log_record record = { 0 }; + refdb_reftable_stack *stack; + int error; + + if ((error = refdb_reftable_stack_for_refname(&stack, backend, refname)) < 0) + goto out; + + if ((error = reftable_stack_read_log(stack->stack, refname, &record)) < 0) { + error = refdb_reftable_error(error, "failed reading log record"); + goto out; + } + + error = (error == 0); + +out: + reftable_log_record_release(&record); + refdb_reftable_return_stack(backend, stack); + return error; +} + +typedef struct { + refdb_reftable_stack *stack; + const char *name; + int error; +} refdb_reftable_ensure_log_data; + +static int refdb_reftable_write_log_existence_table(struct reftable_writer *writer, void *cb_data) +{ + refdb_reftable_ensure_log_data *data = cb_data; + struct reftable_log_record log = { 0 }; + int error; + + if ((error = reftable_stack_read_log(data->stack->stack, data->name, &log)) < 0) { + data->error = refdb_reftable_error(error, "failed reading log record"); + goto out; + } else if (error > 0) { + /* The log exists already, there's no need to write a new marker. */ + error = 0; + goto out; + } + + log.refname = (char *)data->name; + log.update_index = reftable_stack_next_update_index(data->stack->stack); + log.value_type = REFTABLE_LOG_UPDATE; + + /* + * The reftable format encodes an empty reflog by setting both old and + * new object ID to the null object ID. These entries will not be + * yielded by our reader, but can be used to verify that the reflog + * exists. + */ + if ((error = reftable_writer_set_limits(writer, log.update_index, log.update_index)) < 0 || + (error = reftable_writer_add_logs(writer, &log, 1)) < 0) { + data->error = refdb_reftable_error(error, "writing reflog ensistence marker"); + goto out; + } + +out: + return error; +} + +static int refdb_reftable_ensure_log(git_refdb_backend *_backend, + const char *name) +{ + refdb_reftable *backend = GIT_CONTAINER_OF(_backend, refdb_reftable, parent); + refdb_reftable_ensure_log_data data; + int error; + + data.name = name; + data.error = 0; + + if ((error = refdb_reftable_stack_for_refname(&data.stack, backend, name)) < 0) + goto out; + + if ((error = reftable_stack_add(data.stack->stack, refdb_reftable_write_log_existence_table, &data, + REFTABLE_STACK_NEW_ADDITION_RELOAD)) < 0) { + if (data.error) + error = data.error; + else + error = refdb_reftable_error(error, "failed stack update"); + goto out; + } + +out: + refdb_reftable_return_stack(backend, data.stack); + return error; +} + +static int refdb_reftable_reflog_read(git_reflog **out, + git_refdb_backend *_backend, + const char *name) +{ + refdb_reftable *backend = GIT_CONTAINER_OF(_backend, refdb_reftable, parent); + struct reftable_merged_table *table = NULL; + struct reftable_log_record record = { 0 }; + struct reftable_iterator iter = { 0 }; + refdb_reftable_stack *stack; + git_reflog *reflog = NULL; + int error; + + if ((error = refdb_reftable_stack_for_refname(&stack, backend, name)) < 0) + goto out; + + reflog = git__calloc(1, sizeof(git_reflog)); + GIT_ERROR_CHECK_ALLOC(reflog); + reflog->ref_name = git__strdup(name); + GIT_ERROR_CHECK_ALLOC(reflog->ref_name); + reflog->oid_type = backend->repo->oid_type; + + if ((error = git_vector_init(&reflog->entries, 0, NULL)) < 0) + goto out; + + table = reftable_stack_merged_table(stack->stack); + GIT_ERROR_CHECK_ALLOC(table); + + if ((error = reftable_merged_table_init_log_iterator(table, &iter) < 0) || + (error = reftable_iterator_seek_log(&iter, name)) < 0) { + error = refdb_reftable_error(error, "could not get reflog entries"); + goto out; + } + + while (1) { + git_signature *signature; + git_reflog_entry *entry; + + if ((error = reftable_iterator_next_log(&iter, &record)) < 0) { + error = refdb_reftable_error(error, "could not get next reflog entry"); + goto out; + } + if (error > 0 || git__strcmp(record.refname, name)) + break; + + if ((error = git_signature_new(&signature, + record.value.update.name, + record.value.update.email, + record.value.update.time, + record.value.update.tz_offset)) < 0) + continue; + + entry = git__calloc(1, sizeof(*entry)); + GIT_ERROR_CHECK_ALLOC(entry); + entry->committer = signature; + + /* Compatibility hacks with the file-based reflog implementation. */ + if (record.value.update.message && record.value.update.message[0] == '\0') { + git__free(record.value.update.message); + } else if (record.value.update.message) { + size_t len = strlen(record.value.update.message); + while (len) { + if (!git__isspace(record.value.update.message[len - 1])) + break; + len--; + } + if (len) + entry->msg = git__strndup(record.value.update.message, len); + } + + if ((error = git_oid_from_raw(&entry->oid_old, record.value.update.old_hash, + backend->repo->oid_type)) < 0 || + (error = git_oid_from_raw(&entry->oid_cur, record.value.update.new_hash, + backend->repo->oid_type)) < 0) { + git_reflog_entry__free(entry); + goto out; + } + + if (git_oid_is_zero(&entry->oid_old) && git_oid_is_zero(&entry->oid_cur)) { + git_reflog_entry__free(entry); + continue; + } + + if ((error = git_vector_insert(&reflog->entries, entry)) < 0) { + git_reflog_entry__free(entry); + goto out; + } + } + error = 0; + + /* Logs are expected in recency-order. */ + git_vector_reverse(&reflog->entries); + + *out = reflog; + reflog = NULL; +out: + reftable_log_record_release(&record); + reftable_iterator_destroy(&iter); + refdb_reftable_return_stack(backend, stack); + git_reflog_free(reflog); + return error; +} + +typedef struct { + refdb_reftable_stack *stack; + git_reflog *reflog; + int error; +} refdb_reftable_write_reflog_data; + +static int refdb_reftable_write_reflog_table(struct reftable_writer *writer, void *cb_data) +{ + refdb_reftable_write_reflog_data *data = cb_data; + struct reftable_log_record *updates = NULL; + size_t reflog_entries, updates_nr = 0, i; + uint64_t min_update_index, update_index; + int error; + + /* + * We perform this operation by first deleting all existing reflog + * entries and then recreating the new ones. This may be highly + * suboptimal in the case where the reflog only has a couple of new + * entries. But right now the data structure doesn't provide enough + * information to tell which reflog entries need to be appended. + */ + if ((error = refdb_reftable_updates_for_reflog_delete_or_rename(data->stack, data->reflog->ref_name, + NULL, &updates, &updates_nr)) < 0) { + data->error = error; + goto out; + } + + if (updates_nr) { + update_index = 0; + min_update_index = UINT64_MAX; + + for (i = 0; i < updates_nr; i++) { + if (updates[i].update_index > update_index) + update_index = updates[i].update_index; + } + + update_index++; + } else { + update_index = reftable_stack_next_update_index(data->stack->stack); + min_update_index = reftable_stack_next_update_index(data->stack->stack); + } + + reflog_entries = git_reflog_entrycount(data->reflog); + updates = git__reallocarray(updates, updates_nr + reflog_entries, sizeof(*updates)); + + for (i = 0; i < reflog_entries; i++) { + const git_reflog_entry *entry; + + if ((entry = git_reflog_entry_byindex(data->reflog, reflog_entries - i - 1)) == NULL) { + data->error = error = -1; + goto out; + } + + if ((error = refdb_reftable_log_fill(&updates[updates_nr++], + entry->committer, &entry->oid_old, + &entry->oid_cur, data->reflog->ref_name, + entry->msg, update_index++)) < 0) { + data->error = error; + goto out; + } + } + + if ((error = reftable_writer_set_limits(writer, min_update_index, update_index)) < 0 || + (error = reftable_writer_add_logs(writer, updates, updates_nr)) < 0) { + data->error = refdb_reftable_error(error, "failed writing reflog records"); + goto out; + } + +out: + for (i = 0; i < updates_nr; i++) + reftable_log_record_release(&updates[i]); + git__free(updates); + return error; +} + +static int refdb_reftable_reflog_write(git_refdb_backend *_backend, git_reflog *reflog) +{ + refdb_reftable *backend = GIT_CONTAINER_OF(_backend, refdb_reftable, parent); + refdb_reftable_write_reflog_data data; + int error; + + data.reflog = reflog; + data.error = 0; + + if ((error = refdb_reftable_stack_for_refname(&data.stack, backend, reflog->ref_name)) < 0) + goto out; + + if ((error = reftable_stack_add(data.stack->stack, refdb_reftable_write_reflog_table, &data, + REFTABLE_STACK_NEW_ADDITION_RELOAD)) < 0) { + if (data.error) + error = data.error; + else + error = refdb_reftable_error(error, "failed stack update"); + goto out; + } + +out: + refdb_reftable_return_stack(backend, data.stack); + return error; +} + +typedef struct { + refdb_reftable_stack *stack; + const char *old_name; + const char *new_name; + int error; +} refdb_reftable_reflog_rename_data; + +static int refdb_reftable_reflog_write_rename_table(struct reftable_writer *writer, void *cb_data) +{ + refdb_reftable_reflog_rename_data *data = cb_data; + struct reftable_log_record *updates = NULL; + size_t updates_nr = 0, i; + int error; + + if ((error = refdb_reftable_updates_for_reflog_delete_or_rename(data->stack, data->old_name, + data->new_name, &updates, &updates_nr)) < 0) { + data->error = error; + goto out; + } + + if ((error = reftable_writer_set_limits(writer, updates[0].update_index, updates[0].update_index)) < 0 || + (error = reftable_writer_add_logs(writer, updates, updates_nr)) < 0) { + data->error = refdb_reftable_error(error, "writing rename log records"); + goto out; + } + +out: + for (i = 0; i < updates_nr; i++) + reftable_log_record_release(&updates[i]); + git__free(updates); + return error; +} + +static int refdb_reftable_reflog_rename(git_refdb_backend *_backend, const char *old_name, const char *new_name) +{ + refdb_reftable *backend = GIT_CONTAINER_OF(_backend, refdb_reftable, parent); + refdb_reftable_reflog_rename_data data; + int error; + + /* We do not (yet?) support renames across different worktree stacks. */ + if (git_repository_is_worktree(backend->repo) && + git_reference__is_per_worktree_ref(old_name) != git_reference__is_per_worktree_ref(new_name)) { + error = GIT_EINVALID; + goto out; + } + + data.old_name = old_name; + data.new_name = new_name; + data.error = 0; + + if ((error = refdb_reftable_stack_for_refname(&data.stack, backend, old_name)) < 0) + goto out; + + if ((error = reftable_stack_add(data.stack->stack, refdb_reftable_reflog_write_rename_table, &data, + REFTABLE_STACK_NEW_ADDITION_RELOAD)) < 0) { + if (data.error) + error = data.error; + else + error = refdb_reftable_error(error, "failed stack update"); + goto out; + } + +out: + refdb_reftable_return_stack(backend, data.stack); + return error; +} + +typedef struct { + refdb_reftable_stack *stack; + const char *name; + int error; +} refdb_reftable_reflog_delete_data; + +static int refdb_reftable_reflog_write_delete_table(struct reftable_writer *writer, void *cb_data) +{ + refdb_reftable_reflog_delete_data *data = cb_data; + struct reftable_log_record *deletions = NULL; + size_t deletions_nr; + int error; + + if ((error = refdb_reftable_updates_for_reflog_delete_or_rename(data->stack, data->name, NULL, + &deletions, &deletions_nr)) < 0) { + data->error = error; + goto out; + } + + if ((error = reftable_writer_set_limits(writer, deletions[0].update_index, deletions[0].update_index)) < 0 || + (error = reftable_writer_add_logs(writer, deletions, deletions_nr)) < 0) { + data->error = refdb_reftable_error(error, "writing reflog deletion records"); + goto out; + } + +out: + git__free(deletions); + return error; +} + +static int refdb_reftable_reflog_delete(git_refdb_backend *_backend, const char *name) +{ + refdb_reftable *backend = GIT_CONTAINER_OF(_backend, refdb_reftable, parent); + refdb_reftable_reflog_delete_data data; + int error; + + data.name = name; + data.error = 0; + + if ((error = refdb_reftable_stack_for_refname(&data.stack, backend, name)) < 0) + goto out; + + if ((error = reftable_stack_add(data.stack->stack, refdb_reftable_reflog_write_delete_table, &data, + REFTABLE_STACK_NEW_ADDITION_RELOAD)) < 0) { + if (data.error) + error = data.error; + else + error = refdb_reftable_error(error, "failed stack update"); + goto out; + } + +out: + refdb_reftable_return_stack(backend, data.stack); + return error; +} + +static int refdb_reftable_compress(git_refdb_backend *_backend) +{ + refdb_reftable *backend = GIT_CONTAINER_OF(_backend, refdb_reftable, parent); + refdb_reftable_stack *stack = NULL, *wt_stack = NULL; + int error; + + if ((error = refdb_reftable_stack_for(&stack, backend, REFDB_REFTABLE_STACK_MAIN)) < 0) + goto out; + + if ((error = reftable_stack_compact_all(stack->stack, NULL)) < 0) { + error = refdb_reftable_error(error, "could not compact stack"); + goto out; + } + + if (git_repository_is_worktree(backend->repo)) { + if ((error = refdb_reftable_stack_for(&wt_stack, backend, + REFDB_REFTABLE_STACK_WORKTREE)) < 0) + goto out; + + if ((error = reftable_stack_compact_all(wt_stack->stack, NULL)) < 0) { + error = refdb_reftable_error(error, "could not compact worktree stack"); + goto out; + } + } + +out: + refdb_reftable_return_stack(backend, wt_stack); + refdb_reftable_return_stack(backend, stack); + return error; +} + +int git_refdb_backend_reftable(git_refdb_backend **out, + git_repository *repository) +{ + git_str dir = GIT_STR_INIT; + refdb_reftable *backend = NULL; + int error; + + /* + * TODO: this backend does not yet have support for namespaces. So if + * we see a repository with a namespace enabled we error out. + */ + if (repository->namespace) { + git_error_set(GIT_ERROR_REFERENCE, + "reftable backend does not support namespaces"); + error = GIT_ENOTSUPPORTED; + goto out; + } + + backend = git__calloc(1, sizeof(refdb_reftable)); + GIT_ERROR_CHECK_ALLOC(backend); + + if ((error = git_refdb_init_backend(&backend->parent, GIT_REFDB_BACKEND_VERSION)) < 0) { + goto out; + } + + backend->repo = repository; + backend->parent.init = refdb_reftable_init; + backend->parent.exists = refdb_reftable_exists; + backend->parent.lookup = refdb_reftable_lookup; + backend->parent.iterator = refdb_reftable_iterator_new; + backend->parent.write = refdb_reftable_write; + backend->parent.rename = refdb_reftable_rename; + backend->parent.del = refdb_reftable_delete; + backend->parent.has_log = refdb_reftable_has_log; + backend->parent.ensure_log = refdb_reftable_ensure_log; + backend->parent.free = refdb_reftable_free; + backend->parent.reflog_read = refdb_reftable_reflog_read; + backend->parent.reflog_write = refdb_reftable_reflog_write; + backend->parent.reflog_rename = refdb_reftable_reflog_rename; + backend->parent.reflog_delete = refdb_reftable_reflog_delete; + backend->parent.compress = refdb_reftable_compress; + /* TODO: transaction API */ + + *out = (git_refdb_backend *)backend; + backend = NULL; + +out: + if (backend) + git__free(backend); + git_str_dispose(&dir); + return error; +} + +static void *reftable_git_malloc(size_t size) +{ + return git__allocator.gmalloc(size, __FILE__, __LINE__); +} + +static void *reftable_git_realloc(void *ptr, size_t new_size) +{ + return git__allocator.grealloc(ptr, new_size, __FILE__, __LINE__); +} + +static void reftable_git_free(void *ptr) +{ + git__allocator.gfree(ptr); +} + +int git_reftable_global_init(void) +{ + reftable_set_alloc(reftable_git_malloc, + reftable_git_realloc, + reftable_git_free); + return 0; +} diff --git a/src/libgit2/refdb_reftable.h b/src/libgit2/refdb_reftable.h new file mode 100644 index 000000000..6da571cc7 --- /dev/null +++ b/src/libgit2/refdb_reftable.h @@ -0,0 +1,14 @@ +/* + * Copyright (C) the libgit2 contributors. All rights reserved. + * + * This file is part of libgit2, distributed under the GNU GPL v2 with + * a Linking Exception. For full terms see the included COPYING file. + */ +#ifndef INCLUDE_refdb_reftable_h__ +#define INCLUDE_refdb_reftable_h__ + +#include "common.h" + +int git_reftable_global_init(void); + +#endif diff --git a/src/libgit2/refs.c b/src/libgit2/refs.c index 1e6537625..3174f3f68 100644 --- a/src/libgit2/refs.c +++ b/src/libgit2/refs.c @@ -1323,6 +1323,25 @@ int git_reference__is_pseudoref(const char *ref_name) return 0; } +int git_reference__is_per_worktree_ref(const char *ref_name) +{ + const char * const worktree_refs[] = { + "refs/bisect/", + "refs/worktree/", + "refs/rewritten/", + }; + size_t i; + + if (git__prefixcmp(ref_name, "refs/") != 0) + return 1; + + for (i = 0; i < ARRAY_SIZE(worktree_refs); i++) + if (git__prefixcmp(ref_name, worktree_refs[i]) == 0) + return 1; + + return 0; +} + static int peel_error(int error, const git_reference *ref, const char *msg) { git_error_set( diff --git a/src/libgit2/refs.h b/src/libgit2/refs.h index b3729ade7..9354f2f23 100644 --- a/src/libgit2/refs.h +++ b/src/libgit2/refs.h @@ -98,6 +98,15 @@ int git_reference__is_note(const char *ref_name); int git_reference__is_pseudoref(const char *ref_name); const char *git_reference__shorthand(const char *name); +/** + * Returns whether a reference is stored per worktree or not. + * Per-worktree references are: + * + * - all pseudorefs, e.g. HEAD and MERGE_HEAD + * - all references stored inside of "refs/bisect/" + */ +int git_reference__is_per_worktree_ref(const char *ref_name); + /* * A `git_reference_cmp` wrapper suitable for passing to generic * comparators, like `vector_cmp` / `tsort` / etc. diff --git a/src/util/git2_util.h b/src/util/git2_util.h index d47ce5f43..556671e6e 100644 --- a/src/util/git2_util.h +++ b/src/util/git2_util.h @@ -19,12 +19,13 @@ typedef struct git_str git_str; /** Declare a function as always inlined. */ #if defined(_MSC_VER) -# define GIT_INLINE(type) static __inline type +# define GIT_INLINE_KEYWORD __inline #elif defined(__GNUC__) -# define GIT_INLINE(type) static __inline__ type +# define GIT_INLINE_KEYWORD __inline__ #else -# define GIT_INLINE(type) static type +# define GIT_INLINE_KEYWORD #endif +#define GIT_INLINE(type) static GIT_INLINE_KEYWORD type /** Support for gcc/clang __has_builtin intrinsic */ #ifndef __has_builtin diff --git a/tests/libgit2/iterator/workdir.c b/tests/libgit2/iterator/workdir.c index 59feb4546..7aed7c397 100644 --- a/tests/libgit2/iterator/workdir.c +++ b/tests/libgit2/iterator/workdir.c @@ -608,7 +608,7 @@ void test_iterator_workdir__filesystem(void) void test_iterator_workdir__filesystem2(void) { git_iterator *i; - static const char *expect_base[] = { + static const char *expect_files[] = { "heads/br2", "heads/dir", "heads/executable", @@ -626,14 +626,21 @@ void test_iterator_workdir__filesystem2(void) "tags/foo/foo/bar", "tags/point_to_blob", "tags/test", - NULL, + }; + static const char *expect_reftable[] = { + "heads", }; g_repo = cl_git_sandbox_init("testrepo"); cl_git_pass(git_iterator_for_filesystem( &i, "testrepo/.git/refs", NULL)); - expect_iterator_items(i, 17, expect_base, 17, expect_base); + if (cl_repo_has_ref_format(g_repo, "files")) + expect_iterator_items(i, ARRAY_SIZE(expect_files), expect_files, + ARRAY_SIZE(expect_files), expect_files); + else + expect_iterator_items(i, ARRAY_SIZE(expect_reftable), expect_reftable, + ARRAY_SIZE(expect_reftable), expect_reftable); git_iterator_free(i); } diff --git a/tests/libgit2/refs/basic.c b/tests/libgit2/refs/basic.c index b1f770b99..25952f4ed 100644 --- a/tests/libgit2/refs/basic.c +++ b/tests/libgit2/refs/basic.c @@ -76,7 +76,10 @@ void test_refs_basic__longpaths(void) /* Adding one more character gives us a path that is too long. */ cl_git_pass(git_str_putc(&refname, 'z')); - cl_git_fail(git_reference_create(&two, g_repo, refname.ptr, &id, 0, NULL)); + if (cl_repo_has_ref_format(g_repo, "files")) + cl_git_fail(git_reference_create(&two, g_repo, refname.ptr, &id, 0, NULL)); + else + cl_git_pass(git_reference_create(&two, g_repo, refname.ptr, &id, 0, NULL)); git_reference_free(one); git_reference_free(two); diff --git a/tests/libgit2/refs/create.c b/tests/libgit2/refs/create.c index 42c43e519..9ff140eb3 100644 --- a/tests/libgit2/refs/create.c +++ b/tests/libgit2/refs/create.c @@ -281,7 +281,10 @@ static void test_win32_name(const char *name) ret = git_reference_create(&new_reference, g_repo, name, &id, 0, NULL); #ifdef GIT_WIN32 - cl_assert_equal_i(GIT_EINVALIDSPEC, ret); + if (cl_repo_has_ref_format(g_repo, "files")) + cl_assert_equal_i(GIT_EINVALIDSPEC, ret); + else + cl_git_pass(ret); #else cl_git_pass(ret); #endif diff --git a/tests/libgit2/refs/foreachglob.c b/tests/libgit2/refs/foreachglob.c index 4f0b91325..227aa74fd 100644 --- a/tests/libgit2/refs/foreachglob.c +++ b/tests/libgit2/refs/foreachglob.c @@ -8,10 +8,9 @@ void test_refs_foreachglob__initialize(void) { git_oid id; - cl_fixture_sandbox("testrepo.git"); - cl_git_pass(git_repository_open(&repo, "testrepo.git")); + repo = cl_git_sandbox_init("testrepo.git"); - cl_git_pass(git_oid_from_string(&id, "be3563ae3f795b2b4353bcce3a527ad0a4f7f644", GIT_OID_SHA1)); + cl_git_pass(git_oid_fromstr(&id, "be3563ae3f795b2b4353bcce3a527ad0a4f7f644")); cl_git_pass(git_reference_create(&fake_remote, repo, "refs/remotes/nulltoken/master", &id, 0, NULL)); } @@ -19,11 +18,7 @@ void test_refs_foreachglob__cleanup(void) { git_reference_free(fake_remote); fake_remote = NULL; - - git_repository_free(repo); - repo = NULL; - - cl_fixture_cleanup("testrepo.git"); + cl_git_sandbox_cleanup(); } static int count_cb(const char *reference_name, void *payload) diff --git a/tests/libgit2/refs/namespaces.c b/tests/libgit2/refs/namespaces.c index 19456b5a4..351978a5e 100644 --- a/tests/libgit2/refs/namespaces.c +++ b/tests/libgit2/refs/namespaces.c @@ -27,10 +27,16 @@ void test_refs_namespaces__get_and_set(void) void test_refs_namespaces__namespace_doesnt_show_normal_refs(void) { - static git_strarray ref_list; + static git_strarray ref_list = { 0 }; cl_git_pass(git_repository_set_namespace(g_repo, "namespace")); - cl_git_pass(git_reference_list(&ref_list, g_repo)); - cl_assert_equal_i(0, ref_list.count); + + if (cl_repo_has_ref_format(g_repo, "reftable")) { + cl_git_fail(git_reference_list(&ref_list, g_repo)); + } else { + cl_git_pass(git_reference_list(&ref_list, g_repo)); + cl_assert_equal_i(0, ref_list.count); + } + git_strarray_dispose(&ref_list); } diff --git a/tests/libgit2/refs/reflog/reflog.c b/tests/libgit2/refs/reflog/reflog.c index ff61a27a2..b57396676 100644 --- a/tests/libgit2/refs/reflog/reflog.c +++ b/tests/libgit2/refs/reflog/reflog.c @@ -285,6 +285,9 @@ void test_refs_reflog_reflog__cannot_write_a_moved_reflog(void) git_str master_log_path = GIT_STR_INIT, moved_log_path = GIT_STR_INIT; git_reflog *reflog; + if (!cl_repo_has_ref_format(g_repo, "files")) + cl_skip(); + cl_git_pass(git_reference_lookup(&master, g_repo, "refs/heads/master")); cl_git_pass(git_reflog_read(&reflog, g_repo, "refs/heads/master")); @@ -332,8 +335,12 @@ void test_refs_reflog_reflog__write_when_explicitly_active(void) git_reference *ref; git_oid id; + if (!cl_repo_has_ref_format(g_repo, "files")) + cl_skip(); + git_oid_from_string(&id, current_master_tip, GIT_OID_SHA1); - git_reference_ensure_log(g_repo, "refs/tags/foo"); + + cl_git_pass(git_reference_ensure_log(g_repo, "refs/tags/foo")); cl_git_pass(git_reference_create(&ref, g_repo, "refs/tags/foo", &id, 1, NULL)); git_reference_free(ref); diff --git a/tests/libgit2/refs/revparse.c b/tests/libgit2/refs/revparse.c index 46d5a7a1f..2c8f9f3ae 100644 --- a/tests/libgit2/refs/revparse.c +++ b/tests/libgit2/refs/revparse.c @@ -131,12 +131,12 @@ static void test_invalid_revspec(const char* invalid_spec) void test_refs_revparse__initialize(void) { - cl_git_pass(git_repository_open(&g_repo, cl_fixture("testrepo.git"))); + g_repo = cl_git_sandbox_init("testrepo.git"); } void test_refs_revparse__cleanup(void) { - git_repository_free(g_repo); + cl_git_sandbox_cleanup(); } void test_refs_revparse__nonexistant_object(void) @@ -346,7 +346,8 @@ static void create_fake_stash_reference_and_reflog(git_repository *repo) cl_git_pass(git_reference_rename(&new_master, master, "refs/fakestash", 0, NULL)); git_reference_free(master); - cl_assert_equal_i(true, git_fs_path_isfile(git_str_cstr(&log_path))); + if (cl_repo_has_ref_format(g_repo, "files")) + cl_assert_equal_i(true, git_fs_path_isfile(git_str_cstr(&log_path))); git_str_dispose(&log_path); git_reference_free(new_master); @@ -354,11 +355,9 @@ static void create_fake_stash_reference_and_reflog(git_repository *repo) void test_refs_revparse__reflog_of_a_ref_under_refs(void) { - git_repository *repo = cl_git_sandbox_init("testrepo.git"); + test_object_inrepo("refs/fakestash", NULL, g_repo); - test_object_inrepo("refs/fakestash", NULL, repo); - - create_fake_stash_reference_and_reflog(repo); + create_fake_stash_reference_and_reflog(g_repo); /* * $ git reflog -1 refs/fakestash @@ -373,12 +372,10 @@ void test_refs_revparse__reflog_of_a_ref_under_refs(void) * $ git reflog -1 fakestash@{0} * a65fedf fakestash@{0}: commit: checking in */ - test_object_inrepo("refs/fakestash", "a65fedf39aefe402d3bb6e24df4d4f5fe4547750", repo); - test_object_inrepo("refs/fakestash@{0}", "a65fedf39aefe402d3bb6e24df4d4f5fe4547750", repo); - test_object_inrepo("fakestash", "a65fedf39aefe402d3bb6e24df4d4f5fe4547750", repo); - test_object_inrepo("fakestash@{0}", "a65fedf39aefe402d3bb6e24df4d4f5fe4547750", repo); - - cl_git_sandbox_cleanup(); + test_object_inrepo("refs/fakestash", "a65fedf39aefe402d3bb6e24df4d4f5fe4547750", g_repo); + test_object_inrepo("refs/fakestash@{0}", "a65fedf39aefe402d3bb6e24df4d4f5fe4547750", g_repo); + test_object_inrepo("fakestash", "a65fedf39aefe402d3bb6e24df4d4f5fe4547750", g_repo); + test_object_inrepo("fakestash@{0}", "a65fedf39aefe402d3bb6e24df4d4f5fe4547750", g_repo); } void test_refs_revparse__revwalk(void) @@ -593,6 +590,7 @@ void test_refs_revparse__a_not_precise_enough_objectid_returns_EAMBIGUOUS(void) git_index *index; git_object *obj; + cl_git_sandbox_cleanup(); repo = cl_git_sandbox_init("testrepo"); cl_git_mkfile("testrepo/one.txt", "aabqhq\n"); @@ -613,37 +611,33 @@ void test_refs_revparse__a_not_precise_enough_objectid_returns_EAMBIGUOUS(void) void test_refs_revparse__issue_994(void) { - git_repository *repo; git_reference *head, *with_at; git_object *target; - repo = cl_git_sandbox_init("testrepo.git"); + cl_assert_equal_i(GIT_ENOTFOUND, + git_revparse_single(&target, g_repo, "origin/bim_with_3d@11296")); cl_assert_equal_i(GIT_ENOTFOUND, - git_revparse_single(&target, repo, "origin/bim_with_3d@11296")); - - cl_assert_equal_i(GIT_ENOTFOUND, - git_revparse_single(&target, repo, "refs/remotes/origin/bim_with_3d@11296")); + git_revparse_single(&target, g_repo, "refs/remotes/origin/bim_with_3d@11296")); - cl_git_pass(git_repository_head(&head, repo)); + cl_git_pass(git_repository_head(&head, g_repo)); cl_git_pass(git_reference_create( &with_at, - repo, + g_repo, "refs/remotes/origin/bim_with_3d@11296", git_reference_target(head), 0, NULL)); - cl_git_pass(git_revparse_single(&target, repo, "origin/bim_with_3d@11296")); + cl_git_pass(git_revparse_single(&target, g_repo, "origin/bim_with_3d@11296")); git_object_free(target); - cl_git_pass(git_revparse_single(&target, repo, "refs/remotes/origin/bim_with_3d@11296")); + cl_git_pass(git_revparse_single(&target, g_repo, "refs/remotes/origin/bim_with_3d@11296")); git_object_free(target); git_reference_free(with_at); git_reference_free(head); - cl_git_sandbox_cleanup(); } /** @@ -660,25 +654,21 @@ void test_refs_revparse__issue_994(void) */ void test_refs_revparse__try_to_retrieve_branch_before_described_tag(void) { - git_repository *repo; git_reference *branch; git_object *target; char sha[GIT_OID_SHA1_HEXSIZE + 1]; - repo = cl_git_sandbox_init("testrepo.git"); + test_object_inrepo("blah-7-gc47800c", "c47800c7266a2be04c571c04d5a6614691ea99bd", g_repo); - test_object_inrepo("blah-7-gc47800c", "c47800c7266a2be04c571c04d5a6614691ea99bd", repo); - - cl_git_pass(git_revparse_single(&target, repo, "HEAD~3")); - cl_git_pass(git_branch_create(&branch, repo, "blah-7-gc47800c", (git_commit *)target, 0)); + cl_git_pass(git_revparse_single(&target, g_repo, "HEAD~3")); + cl_git_pass(git_branch_create(&branch, g_repo, "blah-7-gc47800c", (git_commit *)target, 0)); git_oid_tostr(sha, GIT_OID_SHA1_HEXSIZE + 1, git_object_id(target)); - test_object_inrepo("blah-7-gc47800c", sha, repo); + test_object_inrepo("blah-7-gc47800c", sha, g_repo); git_reference_free(branch); git_object_free(target); - cl_git_sandbox_cleanup(); } /** @@ -698,26 +688,22 @@ void test_refs_revparse__try_to_retrieve_branch_before_described_tag(void) */ void test_refs_revparse__try_to_retrieve_sha_before_branch(void) { - git_repository *repo; git_reference *branch; git_object *target; char sha[GIT_OID_SHA1_HEXSIZE + 1]; - repo = cl_git_sandbox_init("testrepo.git"); + test_object_inrepo("a65fedf39aefe402d3bb6e24df4d4f5fe4547750", "a65fedf39aefe402d3bb6e24df4d4f5fe4547750", g_repo); - test_object_inrepo("a65fedf39aefe402d3bb6e24df4d4f5fe4547750", "a65fedf39aefe402d3bb6e24df4d4f5fe4547750", repo); - - cl_git_pass(git_revparse_single(&target, repo, "HEAD~3")); - cl_git_pass(git_branch_create(&branch, repo, "a65fedf39aefe402d3bb6e24df4d4f5fe4547750", (git_commit *)target, 0)); + cl_git_pass(git_revparse_single(&target, g_repo, "HEAD~3")); + cl_git_pass(git_branch_create(&branch, g_repo, "a65fedf39aefe402d3bb6e24df4d4f5fe4547750", (git_commit *)target, 0)); git_oid_tostr(sha, GIT_OID_SHA1_HEXSIZE + 1, git_object_id(target)); - test_object_inrepo("a65fedf39aefe402d3bb6e24df4d4f5fe4547750", "a65fedf39aefe402d3bb6e24df4d4f5fe4547750", repo); - test_object_inrepo("heads/a65fedf39aefe402d3bb6e24df4d4f5fe4547750", sha, repo); + test_object_inrepo("a65fedf39aefe402d3bb6e24df4d4f5fe4547750", "a65fedf39aefe402d3bb6e24df4d4f5fe4547750", g_repo); + test_object_inrepo("heads/a65fedf39aefe402d3bb6e24df4d4f5fe4547750", sha, g_repo); git_reference_free(branch); git_object_free(target); - cl_git_sandbox_cleanup(); } /** @@ -734,45 +720,37 @@ void test_refs_revparse__try_to_retrieve_sha_before_branch(void) */ void test_refs_revparse__try_to_retrieve_branch_before_abbrev_sha(void) { - git_repository *repo; git_reference *branch; git_object *target; char sha[GIT_OID_SHA1_HEXSIZE + 1]; - repo = cl_git_sandbox_init("testrepo.git"); + test_object_inrepo("c47800", "c47800c7266a2be04c571c04d5a6614691ea99bd", g_repo); - test_object_inrepo("c47800", "c47800c7266a2be04c571c04d5a6614691ea99bd", repo); - - cl_git_pass(git_revparse_single(&target, repo, "HEAD~3")); - cl_git_pass(git_branch_create(&branch, repo, "c47800", (git_commit *)target, 0)); + cl_git_pass(git_revparse_single(&target, g_repo, "HEAD~3")); + cl_git_pass(git_branch_create(&branch, g_repo, "c47800", (git_commit *)target, 0)); git_oid_tostr(sha, GIT_OID_SHA1_HEXSIZE + 1, git_object_id(target)); - test_object_inrepo("c47800", sha, repo); + test_object_inrepo("c47800", sha, g_repo); git_reference_free(branch); git_object_free(target); - cl_git_sandbox_cleanup(); } void test_refs_revparse__at_at_end_of_refname(void) { - git_repository *repo; git_reference *branch; git_object *target; - repo = cl_git_sandbox_init("testrepo.git"); - - cl_git_pass(git_revparse_single(&target, repo, "HEAD")); - cl_git_pass(git_branch_create(&branch, repo, "master@", (git_commit *)target, 0)); + cl_git_pass(git_revparse_single(&target, g_repo, "HEAD")); + cl_git_pass(git_branch_create(&branch, g_repo, "master@", (git_commit *)target, 0)); git_object_free(target); - test_id_inrepo("master@", "a65fedf39aefe402d3bb6e24df4d4f5fe4547750", NULL, GIT_REVSPEC_SINGLE, repo); + test_id_inrepo("master@", "a65fedf39aefe402d3bb6e24df4d4f5fe4547750", NULL, GIT_REVSPEC_SINGLE, g_repo); - cl_git_fail_with(GIT_ENOTFOUND, git_revparse_single(&target, repo, "foo@")); + cl_git_fail_with(GIT_ENOTFOUND, git_revparse_single(&target, g_repo, "foo@")); git_reference_free(branch); - cl_git_sandbox_cleanup(); } void test_refs_revparse__range(void) diff --git a/tests/libgit2/refs/shorthand.c b/tests/libgit2/refs/shorthand.c index e008adc74..6cf1d002b 100644 --- a/tests/libgit2/refs/shorthand.c +++ b/tests/libgit2/refs/shorthand.c @@ -15,13 +15,12 @@ void test_refs_shorthand__0(void) { git_repository *repo; - cl_git_pass(git_repository_open(&repo, cl_fixture("testrepo.git"))); - + repo = cl_git_sandbox_init("testrepo.git"); assert_shorthand(repo, "refs/heads/master", "master"); assert_shorthand(repo, "refs/tags/test", "test"); assert_shorthand(repo, "refs/remotes/test/master", "test/master"); assert_shorthand(repo, "refs/notes/fanout", "notes/fanout"); - git_repository_free(repo); + cl_git_sandbox_cleanup(); } diff --git a/tests/libgit2/refs/transactions.c b/tests/libgit2/refs/transactions.c index 17c0b22ed..37d4f2238 100644 --- a/tests/libgit2/refs/transactions.c +++ b/tests/libgit2/refs/transactions.c @@ -8,6 +8,8 @@ void test_refs_transactions__initialize(void) { g_repo = cl_git_sandbox_init("testrepo"); cl_git_pass(git_transaction_new(&g_tx, g_repo)); + if (!cl_repo_has_ref_format(g_repo, "files")) + cl_skip(); } void test_refs_transactions__cleanup(void) diff --git a/tests/libgit2/threads/refdb.c b/tests/libgit2/threads/refdb.c index a4630df6a..3b481d779 100644 --- a/tests/libgit2/threads/refdb.c +++ b/tests/libgit2/threads/refdb.c @@ -90,7 +90,7 @@ static void *create_refs(void *arg) cl_git_thread_pass(data, git_repository_refdb(&refdb, repo)); do { error = git_refdb_compress(refdb); - } while (error == GIT_ELOCKED); + } while (error == GIT_ELOCKED || error == GIT_EMODIFIED); cl_git_thread_pass(data, error); git_refdb_free(refdb); } @@ -136,7 +136,7 @@ static void *delete_refs(void *arg) cl_git_thread_pass(data, git_repository_refdb(&refdb, repo)); do { error = git_refdb_compress(refdb); - } while (error == GIT_ELOCKED); + } while (error == GIT_ELOCKED || error == GIT_EMODIFIED); cl_git_thread_pass(data, error); git_refdb_free(refdb); } @@ -162,6 +162,20 @@ void test_threads_refdb__edit_while_iterate(void) g_repo = cl_git_sandbox_init("testrepo2"); +#ifdef GIT_WIN32 + /* + * On Windows we still have issues with renaming the "table.list" file + * into place. This will require a bit of a rework of how we open files + * so that they are always opened with `FILE_SHARE_DELETE`. + * Furthermore, we'll have to start using POSIX-semantics when renaming + * files. + * + * For now, we just accept that this doesn't yet work. + */ + if (cl_repo_has_ref_format(g_repo, "reftable")) + cl_skip(); +#endif + cl_git_pass(git_reference_name_to_id(&head, g_repo, "HEAD")); /* make a bunch of references */ diff --git a/tests/resources/reftable/attr/.gitted/HEAD b/tests/resources/reftable/attr/.gitted/HEAD new file mode 100644 index 000000000..fe6d7e5fa --- /dev/null +++ b/tests/resources/reftable/attr/.gitted/HEAD @@ -0,0 +1 @@ +ref: refs/heads/.invalid diff --git a/tests/resources/reftable/attr/.gitted/config b/tests/resources/reftable/attr/.gitted/config new file mode 100644 index 000000000..0694d84cb --- /dev/null +++ b/tests/resources/reftable/attr/.gitted/config @@ -0,0 +1,8 @@ +[core] + repositoryformatversion = 1 + filemode = true + bare = false + logallrefupdates = true + ignorecase = true +[extensions] + refstorage = reftable diff --git a/tests/resources/reftable/attr/.gitted/description b/tests/resources/reftable/attr/.gitted/description new file mode 100644 index 000000000..498b267a8 --- /dev/null +++ b/tests/resources/reftable/attr/.gitted/description @@ -0,0 +1 @@ +Unnamed repository; edit this file 'description' to name the repository. diff --git a/tests/resources/reftable/attr/.gitted/index b/tests/resources/reftable/attr/.gitted/index new file mode 100644 index 000000000..439ffb151 Binary files /dev/null and b/tests/resources/reftable/attr/.gitted/index differ diff --git a/tests/resources/reftable/attr/.gitted/info/attributes b/tests/resources/reftable/attr/.gitted/info/attributes new file mode 100644 index 000000000..5fe62a37a --- /dev/null +++ b/tests/resources/reftable/attr/.gitted/info/attributes @@ -0,0 +1,4 @@ +* repoattr +a* foo !bar -baz +sub/*.txt reposub +sub/sub/*.txt reposubsub diff --git a/tests/resources/reftable/attr/.gitted/info/exclude b/tests/resources/reftable/attr/.gitted/info/exclude new file mode 100644 index 000000000..a5196d1be --- /dev/null +++ b/tests/resources/reftable/attr/.gitted/info/exclude @@ -0,0 +1,6 @@ +# git ls-files --others --exclude-from=.git/info/exclude +# Lines that start with '#' are comments. +# For a project mostly in C, the following would be a good set of +# exclude patterns (uncomment them if you want to use them): +# *.[oa] +# *~ diff --git a/tests/resources/reftable/attr/.gitted/objects/10/8bb4e7fd7b16490dc33ff7d972151e73d7166e b/tests/resources/reftable/attr/.gitted/objects/10/8bb4e7fd7b16490dc33ff7d972151e73d7166e new file mode 100644 index 000000000..edcf7520c Binary files /dev/null and b/tests/resources/reftable/attr/.gitted/objects/10/8bb4e7fd7b16490dc33ff7d972151e73d7166e differ diff --git a/tests/resources/reftable/attr/.gitted/objects/16/983da6643656bb44c43965ecb6855c6d574512 b/tests/resources/reftable/attr/.gitted/objects/16/983da6643656bb44c43965ecb6855c6d574512 new file mode 100644 index 000000000..e49c94acd Binary files /dev/null and b/tests/resources/reftable/attr/.gitted/objects/16/983da6643656bb44c43965ecb6855c6d574512 differ diff --git a/tests/resources/reftable/attr/.gitted/objects/21/7878ab49e1314388ea2e32dc6fdb58a1b969e0 b/tests/resources/reftable/attr/.gitted/objects/21/7878ab49e1314388ea2e32dc6fdb58a1b969e0 new file mode 100644 index 000000000..b537899f2 --- /dev/null +++ b/tests/resources/reftable/attr/.gitted/objects/21/7878ab49e1314388ea2e32dc6fdb58a1b969e0 @@ -0,0 +1,4 @@ +xQ +0D)nD#xmvJ߀7cx0Iۺ -+e"v☝pwcJH1x%HL>Dd xC\ʤzᔶd0Z#mغڰ +y +>{qK \ No newline at end of file diff --git a/tests/resources/reftable/attr/.gitted/objects/24/fa9a9fc4e202313e24b648087495441dab432b b/tests/resources/reftable/attr/.gitted/objects/24/fa9a9fc4e202313e24b648087495441dab432b new file mode 100644 index 000000000..e7099bbaa Binary files /dev/null and b/tests/resources/reftable/attr/.gitted/objects/24/fa9a9fc4e202313e24b648087495441dab432b differ diff --git a/tests/resources/reftable/attr/.gitted/objects/29/29de282ce999e95183aedac6451d3384559c4b b/tests/resources/reftable/attr/.gitted/objects/29/29de282ce999e95183aedac6451d3384559c4b new file mode 100644 index 000000000..ad84f0854 Binary files /dev/null and b/tests/resources/reftable/attr/.gitted/objects/29/29de282ce999e95183aedac6451d3384559c4b differ diff --git a/tests/resources/reftable/attr/.gitted/objects/2b/40c5aca159b04ea8d20ffe36cdf8b09369b14a b/tests/resources/reftable/attr/.gitted/objects/2b/40c5aca159b04ea8d20ffe36cdf8b09369b14a new file mode 100644 index 000000000..0e2368069 --- /dev/null +++ b/tests/resources/reftable/attr/.gitted/objects/2b/40c5aca159b04ea8d20ffe36cdf8b09369b14a @@ -0,0 +1 @@ +xmPj0=P8ZSc hR6{=ob"afv#3ά=7P%[8 yNlͣ>c;gӐkYX9b|D~Vؗ)vܕ \ No newline at end of file diff --git a/tests/resources/reftable/attr/.gitted/objects/2c/66e14f77196ea763fb1e41612c1aa2bc2d8ed2 b/tests/resources/reftable/attr/.gitted/objects/2c/66e14f77196ea763fb1e41612c1aa2bc2d8ed2 new file mode 100644 index 000000000..4b75d50eb Binary files /dev/null and b/tests/resources/reftable/attr/.gitted/objects/2c/66e14f77196ea763fb1e41612c1aa2bc2d8ed2 differ diff --git a/tests/resources/reftable/attr/.gitted/objects/2d/e7dfe3588f3c7e9ad59e7d50ba90e3329df9d9 b/tests/resources/reftable/attr/.gitted/objects/2d/e7dfe3588f3c7e9ad59e7d50ba90e3329df9d9 new file mode 100644 index 000000000..e0fd0468e Binary files /dev/null and b/tests/resources/reftable/attr/.gitted/objects/2d/e7dfe3588f3c7e9ad59e7d50ba90e3329df9d9 differ diff --git a/tests/resources/reftable/attr/.gitted/objects/37/0fe9ec224ce33e71f9e5ec2bd1142ce9937a6a b/tests/resources/reftable/attr/.gitted/objects/37/0fe9ec224ce33e71f9e5ec2bd1142ce9937a6a new file mode 100644 index 000000000..9c37c5946 Binary files /dev/null and b/tests/resources/reftable/attr/.gitted/objects/37/0fe9ec224ce33e71f9e5ec2bd1142ce9937a6a differ diff --git a/tests/resources/reftable/attr/.gitted/objects/3a/6df026462ebafe455af9867d27eda20a9e0974 b/tests/resources/reftable/attr/.gitted/objects/3a/6df026462ebafe455af9867d27eda20a9e0974 new file mode 100644 index 000000000..c74add826 Binary files /dev/null and b/tests/resources/reftable/attr/.gitted/objects/3a/6df026462ebafe455af9867d27eda20a9e0974 differ diff --git a/tests/resources/reftable/attr/.gitted/objects/3b/74db7ab381105dc0d28f8295a77f6a82989292 b/tests/resources/reftable/attr/.gitted/objects/3b/74db7ab381105dc0d28f8295a77f6a82989292 new file mode 100644 index 000000000..e5cef35fa Binary files /dev/null and b/tests/resources/reftable/attr/.gitted/objects/3b/74db7ab381105dc0d28f8295a77f6a82989292 differ diff --git a/tests/resources/reftable/attr/.gitted/objects/3e/42ffc54a663f9401cc25843d6c0e71a33e4249 b/tests/resources/reftable/attr/.gitted/objects/3e/42ffc54a663f9401cc25843d6c0e71a33e4249 new file mode 100644 index 000000000..091d79b14 Binary files /dev/null and b/tests/resources/reftable/attr/.gitted/objects/3e/42ffc54a663f9401cc25843d6c0e71a33e4249 differ diff --git a/tests/resources/reftable/attr/.gitted/objects/45/141a79a77842c59a63229403220a4e4be74e3d b/tests/resources/reftable/attr/.gitted/objects/45/141a79a77842c59a63229403220a4e4be74e3d new file mode 100644 index 000000000..5b58ef024 Binary files /dev/null and b/tests/resources/reftable/attr/.gitted/objects/45/141a79a77842c59a63229403220a4e4be74e3d differ diff --git a/tests/resources/reftable/attr/.gitted/objects/45/5a314fa848d52ae1f11d254da4f60858fc97f4 b/tests/resources/reftable/attr/.gitted/objects/45/5a314fa848d52ae1f11d254da4f60858fc97f4 new file mode 100644 index 000000000..f90f0d79c Binary files /dev/null and b/tests/resources/reftable/attr/.gitted/objects/45/5a314fa848d52ae1f11d254da4f60858fc97f4 differ diff --git a/tests/resources/reftable/attr/.gitted/objects/45/b983be36b73c0788dc9cbcb76cbb80fc7bb057 b/tests/resources/reftable/attr/.gitted/objects/45/b983be36b73c0788dc9cbcb76cbb80fc7bb057 new file mode 100644 index 000000000..7ca4ceed5 Binary files /dev/null and b/tests/resources/reftable/attr/.gitted/objects/45/b983be36b73c0788dc9cbcb76cbb80fc7bb057 differ diff --git a/tests/resources/reftable/attr/.gitted/objects/4d/713dc48e6b1bd75b0d61ad078ba9ca3a56745d b/tests/resources/reftable/attr/.gitted/objects/4d/713dc48e6b1bd75b0d61ad078ba9ca3a56745d new file mode 100644 index 000000000..eb1e8d0c5 --- /dev/null +++ b/tests/resources/reftable/attr/.gitted/objects/4d/713dc48e6b1bd75b0d61ad078ba9ca3a56745d @@ -0,0 +1,2 @@ +x @WŶ +|k 9n$}g:;51e4\k_]ރ٭hDk'~ \ No newline at end of file diff --git a/tests/resources/reftable/attr/.gitted/objects/4e/49ba8c5b6c32ff28cd9dcb60be34df50fcc485 b/tests/resources/reftable/attr/.gitted/objects/4e/49ba8c5b6c32ff28cd9dcb60be34df50fcc485 new file mode 100644 index 000000000..6fcc549b4 Binary files /dev/null and b/tests/resources/reftable/attr/.gitted/objects/4e/49ba8c5b6c32ff28cd9dcb60be34df50fcc485 differ diff --git a/tests/resources/reftable/attr/.gitted/objects/55/6f8c827b8e4a02ad5cab77dca2bcb3e226b0b3 b/tests/resources/reftable/attr/.gitted/objects/55/6f8c827b8e4a02ad5cab77dca2bcb3e226b0b3 new file mode 100644 index 000000000..4bcff1faa Binary files /dev/null and b/tests/resources/reftable/attr/.gitted/objects/55/6f8c827b8e4a02ad5cab77dca2bcb3e226b0b3 differ diff --git a/tests/resources/reftable/attr/.gitted/objects/58/19a185d77b03325aaf87cafc771db36f6ddca7 b/tests/resources/reftable/attr/.gitted/objects/58/19a185d77b03325aaf87cafc771db36f6ddca7 new file mode 100644 index 000000000..fe34eb63a Binary files /dev/null and b/tests/resources/reftable/attr/.gitted/objects/58/19a185d77b03325aaf87cafc771db36f6ddca7 differ diff --git a/tests/resources/reftable/attr/.gitted/objects/60/5812ab7fe421fdd325a935d35cb06a9234a7d7 b/tests/resources/reftable/attr/.gitted/objects/60/5812ab7fe421fdd325a935d35cb06a9234a7d7 new file mode 100644 index 000000000..b0cc51ee6 --- /dev/null +++ b/tests/resources/reftable/attr/.gitted/objects/60/5812ab7fe421fdd325a935d35cb06a9234a7d7 @@ -0,0 +1,2 @@ +xN 0;S˻BU J ?lٖygcáU RbacG;l㠝Dq֠ZʫAH<Ǒ3N=J2d3[0= +}ۤI™jM"x/[TwU&[/k(tJL \ No newline at end of file diff --git a/tests/resources/reftable/attr/.gitted/objects/6b/ab5c79cd5140d0f800917f550eb2a3dc32b0da b/tests/resources/reftable/attr/.gitted/objects/6b/ab5c79cd5140d0f800917f550eb2a3dc32b0da new file mode 100644 index 000000000..f51e11ccc --- /dev/null +++ b/tests/resources/reftable/attr/.gitted/objects/6b/ab5c79cd5140d0f800917f550eb2a3dc32b0da @@ -0,0 +1,3 @@ +x 0 E)@d'~@(#tQiQn޷(Pm"Ř2hs L+d{"{Z`u +O4Y[޷;@>MSOmʧh +* <- \ No newline at end of file diff --git a/tests/resources/reftable/attr/.gitted/objects/6d/968d62c89c7d9ea23a4c9a7b665d017c3d8ffd b/tests/resources/reftable/attr/.gitted/objects/6d/968d62c89c7d9ea23a4c9a7b665d017c3d8ffd new file mode 100644 index 000000000..e832241c9 Binary files /dev/null and b/tests/resources/reftable/attr/.gitted/objects/6d/968d62c89c7d9ea23a4c9a7b665d017c3d8ffd differ diff --git a/tests/resources/reftable/attr/.gitted/objects/71/7fc31f6b84f9d6fc3a4edbca259d7fc92beee2 b/tests/resources/reftable/attr/.gitted/objects/71/7fc31f6b84f9d6fc3a4edbca259d7fc92beee2 new file mode 100644 index 000000000..a80265cac Binary files /dev/null and b/tests/resources/reftable/attr/.gitted/objects/71/7fc31f6b84f9d6fc3a4edbca259d7fc92beee2 differ diff --git a/tests/resources/reftable/attr/.gitted/objects/8d/0b9df9bd30be7910ddda60548d485bc302b911 b/tests/resources/reftable/attr/.gitted/objects/8d/0b9df9bd30be7910ddda60548d485bc302b911 new file mode 100644 index 000000000..3dcf088e4 --- /dev/null +++ b/tests/resources/reftable/attr/.gitted/objects/8d/0b9df9bd30be7910ddda60548d485bc302b911 @@ -0,0 +1 @@ +xKj1D)zoli _"hiK2LG!7ȪJ,EPXDS ] /)}/UwR. jp##:?:|;F9܋r=_ )ơN/A[l!q}<Lfx4H\\q֏cjT \ No newline at end of file diff --git a/tests/resources/reftable/attr/.gitted/objects/93/61f40bb97239cf55811892e14de2e344168ba1 b/tests/resources/reftable/attr/.gitted/objects/93/61f40bb97239cf55811892e14de2e344168ba1 new file mode 100644 index 000000000..4b57836cd Binary files /dev/null and b/tests/resources/reftable/attr/.gitted/objects/93/61f40bb97239cf55811892e14de2e344168ba1 differ diff --git a/tests/resources/reftable/attr/.gitted/objects/94/da4faa0a6bfb8ee6ccf7153801a69202b31857 b/tests/resources/reftable/attr/.gitted/objects/94/da4faa0a6bfb8ee6ccf7153801a69202b31857 new file mode 100644 index 000000000..a9ddf5d20 Binary files /dev/null and b/tests/resources/reftable/attr/.gitted/objects/94/da4faa0a6bfb8ee6ccf7153801a69202b31857 differ diff --git a/tests/resources/reftable/attr/.gitted/objects/96/089fd31ce1d3ee2afb0ba09ba063066932f027 b/tests/resources/reftable/attr/.gitted/objects/96/089fd31ce1d3ee2afb0ba09ba063066932f027 new file mode 100644 index 000000000..efa62f912 Binary files /dev/null and b/tests/resources/reftable/attr/.gitted/objects/96/089fd31ce1d3ee2afb0ba09ba063066932f027 differ diff --git a/tests/resources/reftable/attr/.gitted/objects/99/eae476896f4907224978b88e5ecaa6c5bb67a9 b/tests/resources/reftable/attr/.gitted/objects/99/eae476896f4907224978b88e5ecaa6c5bb67a9 new file mode 100644 index 000000000..8f5acc70a Binary files /dev/null and b/tests/resources/reftable/attr/.gitted/objects/99/eae476896f4907224978b88e5ecaa6c5bb67a9 differ diff --git a/tests/resources/reftable/attr/.gitted/objects/9e/5bdc47d6a80f2be0ea3049ad74231b94609242 b/tests/resources/reftable/attr/.gitted/objects/9e/5bdc47d6a80f2be0ea3049ad74231b94609242 new file mode 100644 index 000000000..d6385ec8d Binary files /dev/null and b/tests/resources/reftable/attr/.gitted/objects/9e/5bdc47d6a80f2be0ea3049ad74231b94609242 differ diff --git a/tests/resources/reftable/attr/.gitted/objects/9f/b40b6675dde60b5697afceae91b66d908c02d9 b/tests/resources/reftable/attr/.gitted/objects/9f/b40b6675dde60b5697afceae91b66d908c02d9 new file mode 100644 index 000000000..7663ad0ad Binary files /dev/null and b/tests/resources/reftable/attr/.gitted/objects/9f/b40b6675dde60b5697afceae91b66d908c02d9 differ diff --git a/tests/resources/reftable/attr/.gitted/objects/a0/f7217ae99f5ac3e88534f5cea267febc5fa85b b/tests/resources/reftable/attr/.gitted/objects/a0/f7217ae99f5ac3e88534f5cea267febc5fa85b new file mode 100644 index 000000000..985c2e281 --- /dev/null +++ b/tests/resources/reftable/attr/.gitted/objects/a0/f7217ae99f5ac3e88534f5cea267febc5fa85b @@ -0,0 +1 @@ +x510 E}?΀;S␈Ԯۓv8O'F:2r)( &޷9ZAѹr9l %3Eo.Vi!"ZB;u3Cm {.7Z4avfgBLEeP;NQڬBLAnŲI 5I)M6ZQ[ +h3e: + }u};|)z&pbq?3TJ13JX \ No newline at end of file diff --git a/tests/resources/reftable/attr/.gitted/objects/a9/7cc019851d401a4f1d091cb91a15890a0dd1ba b/tests/resources/reftable/attr/.gitted/objects/a9/7cc019851d401a4f1d091cb91a15890a0dd1ba new file mode 100644 index 000000000..1a7ec0c55 --- /dev/null +++ b/tests/resources/reftable/attr/.gitted/objects/a9/7cc019851d401a4f1d091cb91a15890a0dd1ba @@ -0,0 +1,2 @@ +xQj0 DS[hc;PJ( $q޾ޠ_3oIK+BtI|Lgƈ ŐR4'=qFN64 +J1FrzW[rV6-i7.eVW;X, mwl|]ṬMɢdRwC[W9sj~Wy \ No newline at end of file diff --git a/tests/resources/reftable/attr/.gitted/objects/b4/35cd5689a0fb54afbeda4ac20368aa480e8f04 b/tests/resources/reftable/attr/.gitted/objects/b4/35cd5689a0fb54afbeda4ac20368aa480e8f04 new file mode 100644 index 000000000..ffe3473f4 Binary files /dev/null and b/tests/resources/reftable/attr/.gitted/objects/b4/35cd5689a0fb54afbeda4ac20368aa480e8f04 differ diff --git a/tests/resources/reftable/attr/.gitted/objects/c0/091889c0c77142b87a1fa5123a6398a61d33e7 b/tests/resources/reftable/attr/.gitted/objects/c0/091889c0c77142b87a1fa5123a6398a61d33e7 new file mode 100644 index 000000000..11dc63c79 Binary files /dev/null and b/tests/resources/reftable/attr/.gitted/objects/c0/091889c0c77142b87a1fa5123a6398a61d33e7 differ diff --git a/tests/resources/reftable/attr/.gitted/objects/c4/85abe35abd4aa6fd83b076a78bbea9e2e7e06c b/tests/resources/reftable/attr/.gitted/objects/c4/85abe35abd4aa6fd83b076a78bbea9e2e7e06c new file mode 100644 index 000000000..58569ca0e Binary files /dev/null and b/tests/resources/reftable/attr/.gitted/objects/c4/85abe35abd4aa6fd83b076a78bbea9e2e7e06c differ diff --git a/tests/resources/reftable/attr/.gitted/objects/c7/aadd770d5907a8475c29e9ee21a27b88bf675d b/tests/resources/reftable/attr/.gitted/objects/c7/aadd770d5907a8475c29e9ee21a27b88bf675d new file mode 100644 index 000000000..39aedb7d9 Binary files /dev/null and b/tests/resources/reftable/attr/.gitted/objects/c7/aadd770d5907a8475c29e9ee21a27b88bf675d differ diff --git a/tests/resources/reftable/attr/.gitted/objects/c9/6bbb2c2557a8325ae1559e3ba79cdcecb23076 b/tests/resources/reftable/attr/.gitted/objects/c9/6bbb2c2557a8325ae1559e3ba79cdcecb23076 new file mode 100644 index 000000000..589f9ad31 --- /dev/null +++ b/tests/resources/reftable/attr/.gitted/objects/c9/6bbb2c2557a8325ae1559e3ba79cdcecb23076 @@ -0,0 +1,2 @@ +x5A +0D]SεouJ~L0ͯ)xcfp]OOΊcB 6!뢘ó{,Ug˾{f% G \ No newline at end of file diff --git a/tests/resources/reftable/attr_index/.gitted/objects/59/d942b8be2784bc96db9b22202c10815c9a077b b/tests/resources/reftable/attr_index/.gitted/objects/59/d942b8be2784bc96db9b22202c10815c9a077b new file mode 100644 index 000000000..ff33737db --- /dev/null +++ b/tests/resources/reftable/attr_index/.gitted/objects/59/d942b8be2784bc96db9b22202c10815c9a077b @@ -0,0 +1 @@ +x 0 @@kR@]WI \qyϟ 祖QҔO`D6{tfm_sy@2("O- \ No newline at end of file diff --git a/tests/resources/reftable/cherrypick/.gitted/objects/0d/447a6c2528b06616cde3b209a4b4ea3dcb8d65 b/tests/resources/reftable/cherrypick/.gitted/objects/0d/447a6c2528b06616cde3b209a4b4ea3dcb8d65 new file mode 100644 index 000000000..9a3ea3209 Binary files /dev/null and b/tests/resources/reftable/cherrypick/.gitted/objects/0d/447a6c2528b06616cde3b209a4b4ea3dcb8d65 differ diff --git a/tests/resources/reftable/cherrypick/.gitted/objects/11/24c2c1ae07b26fded662d6c3f3631d9dc16f88 b/tests/resources/reftable/cherrypick/.gitted/objects/11/24c2c1ae07b26fded662d6c3f3631d9dc16f88 new file mode 100644 index 000000000..62abc3c5b Binary files /dev/null and b/tests/resources/reftable/cherrypick/.gitted/objects/11/24c2c1ae07b26fded662d6c3f3631d9dc16f88 differ diff --git a/tests/resources/reftable/cherrypick/.gitted/objects/12/905f4ea5b76f9d3fdcfe73e462201c06ae632a b/tests/resources/reftable/cherrypick/.gitted/objects/12/905f4ea5b76f9d3fdcfe73e462201c06ae632a new file mode 100644 index 000000000..162844a70 Binary files /dev/null and b/tests/resources/reftable/cherrypick/.gitted/objects/12/905f4ea5b76f9d3fdcfe73e462201c06ae632a differ diff --git a/tests/resources/reftable/cherrypick/.gitted/objects/19/c5c7207054604b69c84d08a7571ef9672bb5c2 b/tests/resources/reftable/cherrypick/.gitted/objects/19/c5c7207054604b69c84d08a7571ef9672bb5c2 new file mode 100644 index 000000000..d5cd6d3f2 Binary files /dev/null and b/tests/resources/reftable/cherrypick/.gitted/objects/19/c5c7207054604b69c84d08a7571ef9672bb5c2 differ diff --git a/tests/resources/reftable/cherrypick/.gitted/objects/1c/2116845780455ecf916538c1cc27c4222452af b/tests/resources/reftable/cherrypick/.gitted/objects/1c/2116845780455ecf916538c1cc27c4222452af new file mode 100644 index 000000000..f9a841d4f Binary files /dev/null and b/tests/resources/reftable/cherrypick/.gitted/objects/1c/2116845780455ecf916538c1cc27c4222452af differ diff --git a/tests/resources/reftable/cherrypick/.gitted/objects/1c/c85eb4ff0a8438fde1b14274c6f87f891b36a0 b/tests/resources/reftable/cherrypick/.gitted/objects/1c/c85eb4ff0a8438fde1b14274c6f87f891b36a0 new file mode 100644 index 000000000..98b792b64 Binary files /dev/null and b/tests/resources/reftable/cherrypick/.gitted/objects/1c/c85eb4ff0a8438fde1b14274c6f87f891b36a0 differ diff --git a/tests/resources/reftable/cherrypick/.gitted/objects/1e/1cb7391d25dcd8daba88f1f627f3045982286c b/tests/resources/reftable/cherrypick/.gitted/objects/1e/1cb7391d25dcd8daba88f1f627f3045982286c new file mode 100644 index 000000000..10a5be6fe Binary files /dev/null and b/tests/resources/reftable/cherrypick/.gitted/objects/1e/1cb7391d25dcd8daba88f1f627f3045982286c differ diff --git a/tests/resources/reftable/cherrypick/.gitted/objects/20/fc1a4c9d994021f43d33ab75e4252e27ca661d b/tests/resources/reftable/cherrypick/.gitted/objects/20/fc1a4c9d994021f43d33ab75e4252e27ca661d new file mode 100644 index 000000000..c8b26cd01 Binary files /dev/null and b/tests/resources/reftable/cherrypick/.gitted/objects/20/fc1a4c9d994021f43d33ab75e4252e27ca661d differ diff --git a/tests/resources/reftable/cherrypick/.gitted/objects/28/d9eb4208074ad1cc84e71ccc908b34573f05d2 b/tests/resources/reftable/cherrypick/.gitted/objects/28/d9eb4208074ad1cc84e71ccc908b34573f05d2 new file mode 100644 index 000000000..80363b016 Binary files /dev/null and b/tests/resources/reftable/cherrypick/.gitted/objects/28/d9eb4208074ad1cc84e71ccc908b34573f05d2 differ diff --git a/tests/resources/reftable/cherrypick/.gitted/objects/2a/26c7e88b285613b302ba76712bc998863f3cbc b/tests/resources/reftable/cherrypick/.gitted/objects/2a/26c7e88b285613b302ba76712bc998863f3cbc new file mode 100644 index 000000000..283113999 --- /dev/null +++ b/tests/resources/reftable/cherrypick/.gitted/objects/2a/26c7e88b285613b302ba76712bc998863f3cbc @@ -0,0 +1 @@ +xMj0)f_j]`$*N1C=@{^YZlLOҙUzub/X1"iuWN9b҄ZS&r4mrY:Qo+6{/{?gҎ`\k-U_u+5Οx9a?7W \ No newline at end of file diff --git a/tests/resources/reftable/cherrypick/.gitted/objects/2a/c3b376093de405b0a951bff578655b1c2b7fa1 b/tests/resources/reftable/cherrypick/.gitted/objects/2a/c3b376093de405b0a951bff578655b1c2b7fa1 new file mode 100644 index 000000000..a3294d764 --- /dev/null +++ b/tests/resources/reftable/cherrypick/.gitted/objects/2a/c3b376093de405b0a951bff578655b1c2b7fa1 @@ -0,0 +1 @@ +xJ0E]+fIwGLk ܞ{VG{כ*A9Ěc:PܔCJBk\2]}jPQD6b95xuO7v}{[c3 ޢԮ#E̻yɚgToPM/X \ No newline at end of file diff --git a/tests/resources/reftable/cherrypick/.gitted/objects/2c/acbcaabf785f1ac231e8519849d4ad38692f2c b/tests/resources/reftable/cherrypick/.gitted/objects/2c/acbcaabf785f1ac231e8519849d4ad38692f2c new file mode 100644 index 000000000..74b48dd6b Binary files /dev/null and b/tests/resources/reftable/cherrypick/.gitted/objects/2c/acbcaabf785f1ac231e8519849d4ad38692f2c differ diff --git a/tests/resources/reftable/cherrypick/.gitted/objects/35/cb210149022c7379b0a67b0dec13cc628ff87d b/tests/resources/reftable/cherrypick/.gitted/objects/35/cb210149022c7379b0a67b0dec13cc628ff87d new file mode 100644 index 000000000..c0466f46a Binary files /dev/null and b/tests/resources/reftable/cherrypick/.gitted/objects/35/cb210149022c7379b0a67b0dec13cc628ff87d differ diff --git a/tests/resources/reftable/cherrypick/.gitted/objects/38/c05a857e831a7e759d83778bfc85d003e21c45 b/tests/resources/reftable/cherrypick/.gitted/objects/38/c05a857e831a7e759d83778bfc85d003e21c45 new file mode 100644 index 000000000..d4f1cf8ac Binary files /dev/null and b/tests/resources/reftable/cherrypick/.gitted/objects/38/c05a857e831a7e759d83778bfc85d003e21c45 differ diff --git a/tests/resources/reftable/cherrypick/.gitted/objects/3f/9eed8946df9e2c737d3b8dc0b8e78959aacd92 b/tests/resources/reftable/cherrypick/.gitted/objects/3f/9eed8946df9e2c737d3b8dc0b8e78959aacd92 new file mode 100644 index 000000000..8c4d6d94f --- /dev/null +++ b/tests/resources/reftable/cherrypick/.gitted/objects/3f/9eed8946df9e2c737d3b8dc0b8e78959aacd92 @@ -0,0 +1,5 @@ +xMj0)fjH]dԸDq#޾ +-t=YJ`HOt.DSJN.1I#gUo $ eR8ɇgj/F] +,MW8j-zپVxyk37d){pc +hn +bNzgUǡ}6xz*V8 \ No newline at end of file diff --git a/tests/resources/reftable/cherrypick/.gitted/objects/40/9a1bec58bf35348e8b62b72bb9c1f45cf5a587 b/tests/resources/reftable/cherrypick/.gitted/objects/40/9a1bec58bf35348e8b62b72bb9c1f45cf5a587 new file mode 100644 index 000000000..60d5dca4a Binary files /dev/null and b/tests/resources/reftable/cherrypick/.gitted/objects/40/9a1bec58bf35348e8b62b72bb9c1f45cf5a587 differ diff --git a/tests/resources/reftable/cherrypick/.gitted/objects/44/cd2ed2052c9c68f9a439d208e9614dc2a55c70 b/tests/resources/reftable/cherrypick/.gitted/objects/44/cd2ed2052c9c68f9a439d208e9614dc2a55c70 new file mode 100644 index 000000000..8697c4e66 --- /dev/null +++ b/tests/resources/reftable/cherrypick/.gitted/objects/44/cd2ed2052c9c68f9a439d208e9614dc2a55c70 @@ -0,0 +1 @@ +xN0C9+推$M$đX&i!M%{ gɲZpכ.0c$etBPpLꃛ,RITtA4E.TFrI lOkNl,۴oxcoO[o3wZO`lD.V=vWzd(ءux8O.K%M?Z \ No newline at end of file diff --git a/tests/resources/reftable/cherrypick/.gitted/objects/48/7434cace79238a7091e2220611d4f20a765690 b/tests/resources/reftable/cherrypick/.gitted/objects/48/7434cace79238a7091e2220611d4f20a765690 new file mode 100644 index 000000000..a1fa599e1 Binary files /dev/null and b/tests/resources/reftable/cherrypick/.gitted/objects/48/7434cace79238a7091e2220611d4f20a765690 differ diff --git a/tests/resources/reftable/cherrypick/.gitted/objects/49/20ad2f17162dcc8823ad491444dcb87f5899c9 b/tests/resources/reftable/cherrypick/.gitted/objects/49/20ad2f17162dcc8823ad491444dcb87f5899c9 new file mode 100644 index 000000000..bf96fccad Binary files /dev/null and b/tests/resources/reftable/cherrypick/.gitted/objects/49/20ad2f17162dcc8823ad491444dcb87f5899c9 differ diff --git a/tests/resources/reftable/cherrypick/.gitted/objects/4b/825dc642cb6eb9a060e54bf8d69288fbee4904 b/tests/resources/reftable/cherrypick/.gitted/objects/4b/825dc642cb6eb9a060e54bf8d69288fbee4904 new file mode 100644 index 000000000..adf64119a Binary files /dev/null and b/tests/resources/reftable/cherrypick/.gitted/objects/4b/825dc642cb6eb9a060e54bf8d69288fbee4904 differ diff --git a/tests/resources/reftable/cherrypick/.gitted/objects/4c/532774cc1fea37f6efc2256763a64d38c8cdde b/tests/resources/reftable/cherrypick/.gitted/objects/4c/532774cc1fea37f6efc2256763a64d38c8cdde new file mode 100644 index 000000000..2e56d7403 Binary files /dev/null and b/tests/resources/reftable/cherrypick/.gitted/objects/4c/532774cc1fea37f6efc2256763a64d38c8cdde differ diff --git a/tests/resources/reftable/cherrypick/.gitted/objects/51/145af30d411a50195b66517d825e69bf57ed22 b/tests/resources/reftable/cherrypick/.gitted/objects/51/145af30d411a50195b66517d825e69bf57ed22 new file mode 100644 index 000000000..3e01376bd Binary files /dev/null and b/tests/resources/reftable/cherrypick/.gitted/objects/51/145af30d411a50195b66517d825e69bf57ed22 differ diff --git a/tests/resources/reftable/cherrypick/.gitted/objects/54/61de53ffadbf15be4dd6345997c15689573209 b/tests/resources/reftable/cherrypick/.gitted/objects/54/61de53ffadbf15be4dd6345997c15689573209 new file mode 100644 index 000000000..7d2b233a6 --- /dev/null +++ b/tests/resources/reftable/cherrypick/.gitted/objects/54/61de53ffadbf15be4dd6345997c15689573209 @@ -0,0 +1,4 @@ +xMj0)fjH]dԸDq#޾ +-t=YJ`HOt.DSJN.1I#gUo $ eR8ɇgj/F] +,MW8j-zپVxyk37d){pc +hn?Js=C:O #6V< \ No newline at end of file diff --git a/tests/resources/reftable/cherrypick/.gitted/objects/54/784f10955e92ab27e4fa832e40cb2baf1edbdc b/tests/resources/reftable/cherrypick/.gitted/objects/54/784f10955e92ab27e4fa832e40cb2baf1edbdc new file mode 100644 index 000000000..2a5bcec27 Binary files /dev/null and b/tests/resources/reftable/cherrypick/.gitted/objects/54/784f10955e92ab27e4fa832e40cb2baf1edbdc differ diff --git a/tests/resources/reftable/cherrypick/.gitted/objects/56/3f6473a3858f99b80e5f93c660512ed38e1e6f b/tests/resources/reftable/cherrypick/.gitted/objects/56/3f6473a3858f99b80e5f93c660512ed38e1e6f new file mode 100644 index 000000000..8847ed689 Binary files /dev/null and b/tests/resources/reftable/cherrypick/.gitted/objects/56/3f6473a3858f99b80e5f93c660512ed38e1e6f differ diff --git a/tests/resources/reftable/cherrypick/.gitted/objects/58/a957ef0061c1a8ef995c855dfab4f5da8d6617 b/tests/resources/reftable/cherrypick/.gitted/objects/58/a957ef0061c1a8ef995c855dfab4f5da8d6617 new file mode 100644 index 000000000..f161a1941 Binary files /dev/null and b/tests/resources/reftable/cherrypick/.gitted/objects/58/a957ef0061c1a8ef995c855dfab4f5da8d6617 differ diff --git a/tests/resources/reftable/cherrypick/.gitted/objects/5d/c7e1f440ce74d5503a0dfbc6c30e091475f774 b/tests/resources/reftable/cherrypick/.gitted/objects/5d/c7e1f440ce74d5503a0dfbc6c30e091475f774 new file mode 100644 index 000000000..77deeaf0b Binary files /dev/null and b/tests/resources/reftable/cherrypick/.gitted/objects/5d/c7e1f440ce74d5503a0dfbc6c30e091475f774 differ diff --git a/tests/resources/reftable/cherrypick/.gitted/objects/5e/2206cda1c56430ad107a6866a829c159e0b9ea b/tests/resources/reftable/cherrypick/.gitted/objects/5e/2206cda1c56430ad107a6866a829c159e0b9ea new file mode 100644 index 000000000..aa30f501f --- /dev/null +++ b/tests/resources/reftable/cherrypick/.gitted/objects/5e/2206cda1c56430ad107a6866a829c159e0b9ea @@ -0,0 +1 @@ +x+)JMU044d040031QHI5+(aU E9s\uIXvKY;7nM3KdF"cx?35זzѨ1* \ No newline at end of file diff --git a/tests/resources/reftable/cherrypick/.gitted/objects/5f/77a2a13935ac62a629553f8944ad57b1ed8b4a b/tests/resources/reftable/cherrypick/.gitted/objects/5f/77a2a13935ac62a629553f8944ad57b1ed8b4a new file mode 100644 index 000000000..5e622a1fa Binary files /dev/null and b/tests/resources/reftable/cherrypick/.gitted/objects/5f/77a2a13935ac62a629553f8944ad57b1ed8b4a differ diff --git a/tests/resources/reftable/cherrypick/.gitted/objects/63/c0d92b95253c4a40d3883f423a54be47d2c4c8 b/tests/resources/reftable/cherrypick/.gitted/objects/63/c0d92b95253c4a40d3883f423a54be47d2c4c8 new file mode 100644 index 000000000..eafe2c30a Binary files /dev/null and b/tests/resources/reftable/cherrypick/.gitted/objects/63/c0d92b95253c4a40d3883f423a54be47d2c4c8 differ diff --git a/tests/resources/reftable/cherrypick/.gitted/objects/6c/e83eb5f0fd34a10c3d25c6b36d2ed7ec0d6ce7 b/tests/resources/reftable/cherrypick/.gitted/objects/6c/e83eb5f0fd34a10c3d25c6b36d2ed7ec0d6ce7 new file mode 100644 index 000000000..1c1f5034d Binary files /dev/null and b/tests/resources/reftable/cherrypick/.gitted/objects/6c/e83eb5f0fd34a10c3d25c6b36d2ed7ec0d6ce7 differ diff --git a/tests/resources/reftable/cherrypick/.gitted/objects/6d/1c2afe5eeb9e497528e2780ac468a5465cbc96 b/tests/resources/reftable/cherrypick/.gitted/objects/6d/1c2afe5eeb9e497528e2780ac468a5465cbc96 new file mode 100644 index 000000000..a98378a70 --- /dev/null +++ b/tests/resources/reftable/cherrypick/.gitted/objects/6d/1c2afe5eeb9e497528e2780ac468a5465cbc96 @@ -0,0 +1 @@ +x=j@@{ fvLpgp3̎FժmҾɺ,s7U$ 1 :HEc.d*1Qp5nzTh}A"I.SA:Hys }Z\YvminpymGYo`$DծBO{L|f^OA \ No newline at end of file diff --git a/tests/resources/reftable/cherrypick/.gitted/objects/74/f06b5bfec6d33d7264f73606b57a7c0b963819 b/tests/resources/reftable/cherrypick/.gitted/objects/74/f06b5bfec6d33d7264f73606b57a7c0b963819 new file mode 100644 index 000000000..732011fce Binary files /dev/null and b/tests/resources/reftable/cherrypick/.gitted/objects/74/f06b5bfec6d33d7264f73606b57a7c0b963819 differ diff --git a/tests/resources/reftable/cherrypick/.gitted/objects/82/8b08c52d2cba30952e0e008f60b25b5ba0d41a b/tests/resources/reftable/cherrypick/.gitted/objects/82/8b08c52d2cba30952e0e008f60b25b5ba0d41a new file mode 100644 index 000000000..302014bff Binary files /dev/null and b/tests/resources/reftable/cherrypick/.gitted/objects/82/8b08c52d2cba30952e0e008f60b25b5ba0d41a differ diff --git a/tests/resources/reftable/cherrypick/.gitted/objects/85/36dd6f0ec3ddecb9f9b6c8c64c6d322cd01211 b/tests/resources/reftable/cherrypick/.gitted/objects/85/36dd6f0ec3ddecb9f9b6c8c64c6d322cd01211 new file mode 100644 index 000000000..db6faa9e2 Binary files /dev/null and b/tests/resources/reftable/cherrypick/.gitted/objects/85/36dd6f0ec3ddecb9f9b6c8c64c6d322cd01211 differ diff --git a/tests/resources/reftable/cherrypick/.gitted/objects/85/a4a1d791973644f24c72f5e89420d3064cc452 b/tests/resources/reftable/cherrypick/.gitted/objects/85/a4a1d791973644f24c72f5e89420d3064cc452 new file mode 100644 index 000000000..7fe69b6f8 Binary files /dev/null and b/tests/resources/reftable/cherrypick/.gitted/objects/85/a4a1d791973644f24c72f5e89420d3064cc452 differ diff --git a/tests/resources/reftable/cherrypick/.gitted/objects/8b/5c30499a71001189b647f4d5b57fa8f04897ce b/tests/resources/reftable/cherrypick/.gitted/objects/8b/5c30499a71001189b647f4d5b57fa8f04897ce new file mode 100644 index 000000000..8b1638fbb Binary files /dev/null and b/tests/resources/reftable/cherrypick/.gitted/objects/8b/5c30499a71001189b647f4d5b57fa8f04897ce differ diff --git a/tests/resources/reftable/cherrypick/.gitted/objects/96/4ea3da044d9083181a88ba6701de9e35778bf4 b/tests/resources/reftable/cherrypick/.gitted/objects/96/4ea3da044d9083181a88ba6701de9e35778bf4 new file mode 100644 index 000000000..2dec33f69 Binary files /dev/null and b/tests/resources/reftable/cherrypick/.gitted/objects/96/4ea3da044d9083181a88ba6701de9e35778bf4 differ diff --git a/tests/resources/reftable/cherrypick/.gitted/objects/9c/c39fca3765a2facbe31157f7d60c2602193f36 b/tests/resources/reftable/cherrypick/.gitted/objects/9c/c39fca3765a2facbe31157f7d60c2602193f36 new file mode 100644 index 000000000..00314454f Binary files /dev/null and b/tests/resources/reftable/cherrypick/.gitted/objects/9c/c39fca3765a2facbe31157f7d60c2602193f36 differ diff --git a/tests/resources/reftable/cherrypick/.gitted/objects/9c/cb9bf50c011fd58dcbaa65df917bf79539717f b/tests/resources/reftable/cherrypick/.gitted/objects/9c/cb9bf50c011fd58dcbaa65df917bf79539717f new file mode 100644 index 000000000..1266aff36 Binary files /dev/null and b/tests/resources/reftable/cherrypick/.gitted/objects/9c/cb9bf50c011fd58dcbaa65df917bf79539717f differ diff --git a/tests/resources/reftable/cherrypick/.gitted/objects/a1/0b59f4280491afe6e430c30654a7acc67d4a33 b/tests/resources/reftable/cherrypick/.gitted/objects/a1/0b59f4280491afe6e430c30654a7acc67d4a33 new file mode 100644 index 000000000..7aa0a5dcd Binary files /dev/null and b/tests/resources/reftable/cherrypick/.gitted/objects/a1/0b59f4280491afe6e430c30654a7acc67d4a33 differ diff --git a/tests/resources/reftable/cherrypick/.gitted/objects/a2/1b4bfe7a04ab18024fb57f4ae9a52a1acef394 b/tests/resources/reftable/cherrypick/.gitted/objects/a2/1b4bfe7a04ab18024fb57f4ae9a52a1acef394 new file mode 100644 index 000000000..07b7195d2 Binary files /dev/null and b/tests/resources/reftable/cherrypick/.gitted/objects/a2/1b4bfe7a04ab18024fb57f4ae9a52a1acef394 differ diff --git a/tests/resources/reftable/cherrypick/.gitted/objects/a4/3a050c588d4e92f11a6b139680923e9728477d b/tests/resources/reftable/cherrypick/.gitted/objects/a4/3a050c588d4e92f11a6b139680923e9728477d new file mode 100644 index 000000000..4713fb2db --- /dev/null +++ b/tests/resources/reftable/cherrypick/.gitted/objects/a4/3a050c588d4e92f11a6b139680923e9728477d @@ -0,0 +1 @@ +xMj0uHBb4.J2G㽔qW9l=#`5GsDD5(ꋪlX!p!e$2N2{9IїWemו:y/om7pB]Q mw`^þA6 mT \ No newline at end of file diff --git a/tests/resources/reftable/cherrypick/.gitted/objects/a5/8ca3fee5eb68b11adc2703e5843f968c9dad1e b/tests/resources/reftable/cherrypick/.gitted/objects/a5/8ca3fee5eb68b11adc2703e5843f968c9dad1e new file mode 100644 index 000000000..1c3f2fb01 Binary files /dev/null and b/tests/resources/reftable/cherrypick/.gitted/objects/a5/8ca3fee5eb68b11adc2703e5843f968c9dad1e differ diff --git a/tests/resources/reftable/cherrypick/.gitted/objects/a6/61b5dec1004e2c62654ded3762370c27cf266b b/tests/resources/reftable/cherrypick/.gitted/objects/a6/61b5dec1004e2c62654ded3762370c27cf266b new file mode 100644 index 000000000..d94a9541f Binary files /dev/null and b/tests/resources/reftable/cherrypick/.gitted/objects/a6/61b5dec1004e2c62654ded3762370c27cf266b differ diff --git a/tests/resources/reftable/cherrypick/.gitted/objects/a6/9ef8fcbb9a2c509a7dbf4f23d257eb551d5610 b/tests/resources/reftable/cherrypick/.gitted/objects/a6/9ef8fcbb9a2c509a7dbf4f23d257eb551d5610 new file mode 100644 index 000000000..69feba205 --- /dev/null +++ b/tests/resources/reftable/cherrypick/.gitted/objects/a6/9ef8fcbb9a2c509a7dbf4f23d257eb551d5610 @@ -0,0 +1 @@ +x10@ѭuA,!] `,/hrǰGHKs՛*he8J*(&rTlJI؅$JD%YF}ipt:kot9楞`p)95]?}nsSnjGPOL \ No newline at end of file diff --git a/tests/resources/reftable/cherrypick/.gitted/objects/a8/3c6f70297b805dedc549e6583582966f6ebcab b/tests/resources/reftable/cherrypick/.gitted/objects/a8/3c6f70297b805dedc549e6583582966f6ebcab new file mode 100644 index 000000000..5a6db508e Binary files /dev/null and b/tests/resources/reftable/cherrypick/.gitted/objects/a8/3c6f70297b805dedc549e6583582966f6ebcab differ diff --git a/tests/resources/reftable/cherrypick/.gitted/objects/a9/020cd240774e4d672732bcb82d516d9685da76 b/tests/resources/reftable/cherrypick/.gitted/objects/a9/020cd240774e4d672732bcb82d516d9685da76 new file mode 100644 index 000000000..61741aff9 Binary files /dev/null and b/tests/resources/reftable/cherrypick/.gitted/objects/a9/020cd240774e4d672732bcb82d516d9685da76 differ diff --git a/tests/resources/reftable/cherrypick/.gitted/objects/ab/4115f808bc585b60f822da7020af86d20f62c8 b/tests/resources/reftable/cherrypick/.gitted/objects/ab/4115f808bc585b60f822da7020af86d20f62c8 new file mode 100644 index 000000000..08c4bef57 Binary files /dev/null and b/tests/resources/reftable/cherrypick/.gitted/objects/ab/4115f808bc585b60f822da7020af86d20f62c8 differ diff --git a/tests/resources/reftable/cherrypick/.gitted/objects/ab/e4603bc7cd5b8167a267e0e2418fd2348f8cff b/tests/resources/reftable/cherrypick/.gitted/objects/ab/e4603bc7cd5b8167a267e0e2418fd2348f8cff new file mode 100644 index 000000000..4e4fe6f12 --- /dev/null +++ b/tests/resources/reftable/cherrypick/.gitted/objects/ab/e4603bc7cd5b8167a267e0e2418fd2348f8cff @@ -0,0 +1,4 @@ +xKN0DY?B쐐8DӞHNqܞF'ƇT!`*<+,YZ +%LވلM쓖X$N$S.cq89 +Dޚo{xFL)Ɣ}em] ^wv~z,&?iGz\//rS`^ +=ݣXfZ \ No newline at end of file diff --git a/tests/resources/reftable/cherrypick/.gitted/objects/b8/26e9b36e22e949ec885e7a1f3db496bbab6cd0 b/tests/resources/reftable/cherrypick/.gitted/objects/b8/26e9b36e22e949ec885e7a1f3db496bbab6cd0 new file mode 100644 index 000000000..e3bf3a017 Binary files /dev/null and b/tests/resources/reftable/cherrypick/.gitted/objects/b8/26e9b36e22e949ec885e7a1f3db496bbab6cd0 differ diff --git a/tests/resources/reftable/cherrypick/.gitted/objects/ba/fbf6912c09505ac60575cd43d3f2aba3bd84d8 b/tests/resources/reftable/cherrypick/.gitted/objects/ba/fbf6912c09505ac60575cd43d3f2aba3bd84d8 new file mode 100644 index 000000000..956da8b71 Binary files /dev/null and b/tests/resources/reftable/cherrypick/.gitted/objects/ba/fbf6912c09505ac60575cd43d3f2aba3bd84d8 differ diff --git a/tests/resources/reftable/cherrypick/.gitted/objects/bb/14296ffa9dfbf935ec9ce2f9ed7808d952226b b/tests/resources/reftable/cherrypick/.gitted/objects/bb/14296ffa9dfbf935ec9ce2f9ed7808d952226b new file mode 100644 index 000000000..b5583685a Binary files /dev/null and b/tests/resources/reftable/cherrypick/.gitted/objects/bb/14296ffa9dfbf935ec9ce2f9ed7808d952226b differ diff --git a/tests/resources/reftable/cherrypick/.gitted/objects/bc/4dd0744364d1db380a9811bd264c101065231e b/tests/resources/reftable/cherrypick/.gitted/objects/bc/4dd0744364d1db380a9811bd264c101065231e new file mode 100644 index 000000000..01d88a283 Binary files /dev/null and b/tests/resources/reftable/cherrypick/.gitted/objects/bc/4dd0744364d1db380a9811bd264c101065231e differ diff --git a/tests/resources/reftable/cherrypick/.gitted/objects/bd/65d4083845ed5ed4e1fe5feb85ac395d0760c8 b/tests/resources/reftable/cherrypick/.gitted/objects/bd/65d4083845ed5ed4e1fe5feb85ac395d0760c8 new file mode 100644 index 000000000..6a0eccb5e --- /dev/null +++ b/tests/resources/reftable/cherrypick/.gitted/objects/bd/65d4083845ed5ed4e1fe5feb85ac395d0760c8 @@ -0,0 +1,2 @@ +xA +B!֞bA6BD[o^@$ݾj-ڛtf]#":dKi 51S@Rq:q>qehM}P!:Cxεu!xXϟC>}ṟ,I炓ĥE9{0;KZq_˺Yt3V \ No newline at end of file diff --git a/tests/resources/reftable/cherrypick/.gitted/objects/cf/c4f0999a8367568e049af4f72e452d40828a15 b/tests/resources/reftable/cherrypick/.gitted/objects/cf/c4f0999a8367568e049af4f72e452d40828a15 new file mode 100644 index 000000000..d7deb0bff Binary files /dev/null and b/tests/resources/reftable/cherrypick/.gitted/objects/cf/c4f0999a8367568e049af4f72e452d40828a15 differ diff --git a/tests/resources/reftable/cherrypick/.gitted/objects/d0/f21e17beb5b9d953b1d8349049818a4f2edd1e b/tests/resources/reftable/cherrypick/.gitted/objects/d0/f21e17beb5b9d953b1d8349049818a4f2edd1e new file mode 100644 index 000000000..65c846fa4 --- /dev/null +++ b/tests/resources/reftable/cherrypick/.gitted/objects/d0/f21e17beb5b9d953b1d8349049818a4f2edd1e @@ -0,0 +1 @@ +xAj0E)f_,]z<]"޾!<^l4f=iM0Hir: <kiFGhI}S] 4F qfʚl蔵6svׯ[i ]R-7  uà:OI)p[!/=;&WY \ No newline at end of file diff --git a/tests/resources/reftable/cherrypick/.gitted/objects/d3/d77487660ee3c0194ee01dc5eaf478782b1c7e b/tests/resources/reftable/cherrypick/.gitted/objects/d3/d77487660ee3c0194ee01dc5eaf478782b1c7e new file mode 100644 index 000000000..b42df7e50 --- /dev/null +++ b/tests/resources/reftable/cherrypick/.gitted/objects/d3/d77487660ee3c0194ee01dc5eaf478782b1c7e @@ -0,0 +1 @@ +xKJ1a9E!I@df%x!AooGp-~[[l O2AW 6Rّ=yFW @Փ5l(drXG[.cEKѻgmV!Pso0v *Wd \ No newline at end of file diff --git a/tests/resources/reftable/cherrypick/.gitted/objects/e2/33b9ed408a95e9d4b65fec7fc34943a556deb2 b/tests/resources/reftable/cherrypick/.gitted/objects/e2/33b9ed408a95e9d4b65fec7fc34943a556deb2 new file mode 100644 index 000000000..b344c9cc8 Binary files /dev/null and b/tests/resources/reftable/cherrypick/.gitted/objects/e2/33b9ed408a95e9d4b65fec7fc34943a556deb2 differ diff --git a/tests/resources/reftable/cherrypick/.gitted/objects/e5/183bfd18e3a0a691fadde2f0d5610b73282d31 b/tests/resources/reftable/cherrypick/.gitted/objects/e5/183bfd18e3a0a691fadde2f0d5610b73282d31 new file mode 100644 index 000000000..fdc05714f Binary files /dev/null and b/tests/resources/reftable/cherrypick/.gitted/objects/e5/183bfd18e3a0a691fadde2f0d5610b73282d31 differ diff --git a/tests/resources/reftable/cherrypick/.gitted/objects/e6/ae8889c40c77d7be02758235b5b3f7a4f2a129 b/tests/resources/reftable/cherrypick/.gitted/objects/e6/ae8889c40c77d7be02758235b5b3f7a4f2a129 new file mode 100644 index 000000000..3345907db Binary files /dev/null and b/tests/resources/reftable/cherrypick/.gitted/objects/e6/ae8889c40c77d7be02758235b5b3f7a4f2a129 differ diff --git a/tests/resources/reftable/cherrypick/.gitted/objects/e7/811a2bc55635f182750f0420da5ad232c1af91 b/tests/resources/reftable/cherrypick/.gitted/objects/e7/811a2bc55635f182750f0420da5ad232c1af91 new file mode 100644 index 000000000..238873025 Binary files /dev/null and b/tests/resources/reftable/cherrypick/.gitted/objects/e7/811a2bc55635f182750f0420da5ad232c1af91 differ diff --git a/tests/resources/reftable/cherrypick/.gitted/objects/e9/b63f3655b2ad80c0ff587389b5a9589a3a7110 b/tests/resources/reftable/cherrypick/.gitted/objects/e9/b63f3655b2ad80c0ff587389b5a9589a3a7110 new file mode 100644 index 000000000..ab0a27f37 --- /dev/null +++ b/tests/resources/reftable/cherrypick/.gitted/objects/e9/b63f3655b2ad80c0ff587389b5a9589a3a7110 @@ -0,0 +1,2 @@ +xMj0@u<!Eɣ?$/rzn}]HG+z"*k +AHch]n RN-3Kp~}PK,J=dz#G?Vֲu:NvVfi cO;iZjEu y^-P@ \ No newline at end of file diff --git a/tests/resources/reftable/cherrypick/.gitted/objects/eb/da71fe44dcb60c53b8fbd53208a1204d32e959 b/tests/resources/reftable/cherrypick/.gitted/objects/eb/da71fe44dcb60c53b8fbd53208a1204d32e959 new file mode 100644 index 000000000..19d0c5288 Binary files /dev/null and b/tests/resources/reftable/cherrypick/.gitted/objects/eb/da71fe44dcb60c53b8fbd53208a1204d32e959 differ diff --git a/tests/resources/reftable/cherrypick/.gitted/objects/f0/5ed049854c1596a7cc0e957fab34961077f3ae b/tests/resources/reftable/cherrypick/.gitted/objects/f0/5ed049854c1596a7cc0e957fab34961077f3ae new file mode 100644 index 000000000..ab454399e Binary files /dev/null and b/tests/resources/reftable/cherrypick/.gitted/objects/f0/5ed049854c1596a7cc0e957fab34961077f3ae differ diff --git a/tests/resources/reftable/cherrypick/.gitted/objects/f0/a4e1c66bb548cd2b22eebefda703872e969775 b/tests/resources/reftable/cherrypick/.gitted/objects/f0/a4e1c66bb548cd2b22eebefda703872e969775 new file mode 100644 index 000000000..558dd0a44 Binary files /dev/null and b/tests/resources/reftable/cherrypick/.gitted/objects/f0/a4e1c66bb548cd2b22eebefda703872e969775 differ diff --git a/tests/resources/reftable/cherrypick/.gitted/objects/f2/ec8c8cf1a9fb7aa047a25a4308bfe860237ad4 b/tests/resources/reftable/cherrypick/.gitted/objects/f2/ec8c8cf1a9fb7aa047a25a4308bfe860237ad4 new file mode 100644 index 000000000..a0117515c Binary files /dev/null and b/tests/resources/reftable/cherrypick/.gitted/objects/f2/ec8c8cf1a9fb7aa047a25a4308bfe860237ad4 differ diff --git a/tests/resources/reftable/cherrypick/.gitted/objects/f5/684c96bf40c709877b56404cd8a5dd2d2a7978 b/tests/resources/reftable/cherrypick/.gitted/objects/f5/684c96bf40c709877b56404cd8a5dd2d2a7978 new file mode 100644 index 000000000..83bb5a0cc Binary files /dev/null and b/tests/resources/reftable/cherrypick/.gitted/objects/f5/684c96bf40c709877b56404cd8a5dd2d2a7978 differ diff --git a/tests/resources/reftable/cherrypick/.gitted/objects/f9/0f9dcbdac2cce5cc166346160e19cb693ef4e8 b/tests/resources/reftable/cherrypick/.gitted/objects/f9/0f9dcbdac2cce5cc166346160e19cb693ef4e8 new file mode 100644 index 000000000..71be9f834 Binary files /dev/null and b/tests/resources/reftable/cherrypick/.gitted/objects/f9/0f9dcbdac2cce5cc166346160e19cb693ef4e8 differ diff --git a/tests/resources/reftable/cherrypick/.gitted/refs/heads b/tests/resources/reftable/cherrypick/.gitted/refs/heads new file mode 100644 index 000000000..3e639a56a --- /dev/null +++ b/tests/resources/reftable/cherrypick/.gitted/refs/heads @@ -0,0 +1 @@ +this repository uses the reftable format diff --git a/tests/resources/reftable/cherrypick/.gitted/reftable/0x000000000001-0x000000000001-af6d249f.ref b/tests/resources/reftable/cherrypick/.gitted/reftable/0x000000000001-0x000000000001-af6d249f.ref new file mode 100644 index 000000000..ec80a362d Binary files /dev/null and b/tests/resources/reftable/cherrypick/.gitted/reftable/0x000000000001-0x000000000001-af6d249f.ref differ diff --git a/tests/resources/reftable/cherrypick/.gitted/reftable/tables.list b/tests/resources/reftable/cherrypick/.gitted/reftable/tables.list new file mode 100644 index 000000000..258d0235a --- /dev/null +++ b/tests/resources/reftable/cherrypick/.gitted/reftable/tables.list @@ -0,0 +1 @@ +0x000000000001-0x000000000001-af6d249f.ref diff --git a/tests/resources/reftable/cherrypick/file1.txt b/tests/resources/reftable/cherrypick/file1.txt new file mode 100644 index 000000000..38c05a857 --- /dev/null +++ b/tests/resources/reftable/cherrypick/file1.txt @@ -0,0 +1,15 @@ +!File 1 +File 1 +File 1 +File 1 +File 1 +File 1 +File 1 +File 1 +File 1 +File 1 +File 1 +File 1 +File 1 +File 1 +File 1 diff --git a/tests/resources/reftable/cherrypick/file2.txt b/tests/resources/reftable/cherrypick/file2.txt new file mode 100644 index 000000000..a661b5dec --- /dev/null +++ b/tests/resources/reftable/cherrypick/file2.txt @@ -0,0 +1,15 @@ +!File 2 +File 2 +File 2 +File 2 +File 2 +File 2 +File 2 +File 2 +File 2 +File 2 +File 2 +File 2 +File 2 +File 2 +File 2 diff --git a/tests/resources/reftable/cherrypick/file3.txt b/tests/resources/reftable/cherrypick/file3.txt new file mode 100644 index 000000000..85a4a1d79 --- /dev/null +++ b/tests/resources/reftable/cherrypick/file3.txt @@ -0,0 +1,15 @@ +!File 3 +File 3 +File 3 +File 3 +File 3 +File 3 +File 3 +File 3 +File 3 +File 3 +File 3 +File 3 +File 3 +File 3 +File 3 diff --git a/tests/resources/reftable/crlf/.gitattributes b/tests/resources/reftable/crlf/.gitattributes new file mode 100644 index 000000000..fa1385d99 --- /dev/null +++ b/tests/resources/reftable/crlf/.gitattributes @@ -0,0 +1 @@ +* -text diff --git a/tests/resources/reftable/crlf/.gitted/HEAD b/tests/resources/reftable/crlf/.gitted/HEAD new file mode 100644 index 000000000..fe6d7e5fa --- /dev/null +++ b/tests/resources/reftable/crlf/.gitted/HEAD @@ -0,0 +1 @@ +ref: refs/heads/.invalid diff --git a/tests/resources/reftable/crlf/.gitted/config b/tests/resources/reftable/crlf/.gitted/config new file mode 100644 index 000000000..b5d62785d --- /dev/null +++ b/tests/resources/reftable/crlf/.gitted/config @@ -0,0 +1,4 @@ +[extensions] + refstorage = reftable +[core] + repositoryformatversion = 1 diff --git a/tests/resources/reftable/crlf/.gitted/index b/tests/resources/reftable/crlf/.gitted/index new file mode 100644 index 000000000..e8d43e97e Binary files /dev/null and b/tests/resources/reftable/crlf/.gitted/index differ diff --git a/tests/resources/reftable/crlf/.gitted/objects/04/4bcd5c9bf5ebdd51e514a9a36457018f06f6e1 b/tests/resources/reftable/crlf/.gitted/objects/04/4bcd5c9bf5ebdd51e514a9a36457018f06f6e1 new file mode 100644 index 000000000..a32a9b282 --- /dev/null +++ b/tests/resources/reftable/crlf/.gitted/objects/04/4bcd5c9bf5ebdd51e514a9a36457018f06f6e1 @@ -0,0 +1 @@ +x-j0D{W4H++C(ɡ]aJU|}̃ʺ. кVE@vȔvBx=%l sDxH!x3E9AhPdUTk {k+Av`C2|h괟lR{~/]`z-̥<]M5?]udr&K! \ No newline at end of file diff --git a/tests/resources/reftable/crlf/.gitted/objects/04/de00b358f13389948756732158eaaaefa1448c b/tests/resources/reftable/crlf/.gitted/objects/04/de00b358f13389948756732158eaaaefa1448c new file mode 100644 index 000000000..c3b7598c0 Binary files /dev/null and b/tests/resources/reftable/crlf/.gitted/objects/04/de00b358f13389948756732158eaaaefa1448c differ diff --git a/tests/resources/reftable/crlf/.gitted/objects/09/7722be9b67b48dfe3b19396d02fd535300ee46 b/tests/resources/reftable/crlf/.gitted/objects/09/7722be9b67b48dfe3b19396d02fd535300ee46 new file mode 100644 index 000000000..5c5c24cd5 Binary files /dev/null and b/tests/resources/reftable/crlf/.gitted/objects/09/7722be9b67b48dfe3b19396d02fd535300ee46 differ diff --git a/tests/resources/reftable/crlf/.gitted/objects/0a/a76e474d259bd7c13eb726a1396c381db55c88 b/tests/resources/reftable/crlf/.gitted/objects/0a/a76e474d259bd7c13eb726a1396c381db55c88 new file mode 100644 index 000000000..e118d6656 Binary files /dev/null and b/tests/resources/reftable/crlf/.gitted/objects/0a/a76e474d259bd7c13eb726a1396c381db55c88 differ diff --git a/tests/resources/reftable/crlf/.gitted/objects/0d/06894e14df22e066763ae906e0ed3eb79c205f b/tests/resources/reftable/crlf/.gitted/objects/0d/06894e14df22e066763ae906e0ed3eb79c205f new file mode 100644 index 000000000..b7a1f3290 Binary files /dev/null and b/tests/resources/reftable/crlf/.gitted/objects/0d/06894e14df22e066763ae906e0ed3eb79c205f differ diff --git a/tests/resources/reftable/crlf/.gitted/objects/0e/052888828a954ca17e5882638e3c6a083e75c0 b/tests/resources/reftable/crlf/.gitted/objects/0e/052888828a954ca17e5882638e3c6a083e75c0 new file mode 100644 index 000000000..746143f85 Binary files /dev/null and b/tests/resources/reftable/crlf/.gitted/objects/0e/052888828a954ca17e5882638e3c6a083e75c0 differ diff --git a/tests/resources/reftable/crlf/.gitted/objects/0f/f5a53f19bfd2b5eea1ba550295c47515678987 b/tests/resources/reftable/crlf/.gitted/objects/0f/f5a53f19bfd2b5eea1ba550295c47515678987 new file mode 100644 index 000000000..5366acd8c Binary files /dev/null and b/tests/resources/reftable/crlf/.gitted/objects/0f/f5a53f19bfd2b5eea1ba550295c47515678987 differ diff --git a/tests/resources/reftable/crlf/.gitted/objects/16/78031ee023a23bd3515e4e1693b661a69f0a73 b/tests/resources/reftable/crlf/.gitted/objects/16/78031ee023a23bd3515e4e1693b661a69f0a73 new file mode 100644 index 000000000..4aa4ffb1d Binary files /dev/null and b/tests/resources/reftable/crlf/.gitted/objects/16/78031ee023a23bd3515e4e1693b661a69f0a73 differ diff --git a/tests/resources/reftable/crlf/.gitted/objects/16/c72b67861f8524a5bebc05cd20472d3fca00da b/tests/resources/reftable/crlf/.gitted/objects/16/c72b67861f8524a5bebc05cd20472d3fca00da new file mode 100644 index 000000000..e2b199458 Binary files /dev/null and b/tests/resources/reftable/crlf/.gitted/objects/16/c72b67861f8524a5bebc05cd20472d3fca00da differ diff --git a/tests/resources/reftable/crlf/.gitted/objects/18/c637c5d9aba6eed226ee1840cd1ca2e6c4e4c5 b/tests/resources/reftable/crlf/.gitted/objects/18/c637c5d9aba6eed226ee1840cd1ca2e6c4e4c5 new file mode 100644 index 000000000..790eb1324 Binary files /dev/null and b/tests/resources/reftable/crlf/.gitted/objects/18/c637c5d9aba6eed226ee1840cd1ca2e6c4e4c5 differ diff --git a/tests/resources/reftable/crlf/.gitted/objects/20/3555c5676d75cd80d69b50beb1f4b588c59ceb b/tests/resources/reftable/crlf/.gitted/objects/20/3555c5676d75cd80d69b50beb1f4b588c59ceb new file mode 100644 index 000000000..8038a9b10 Binary files /dev/null and b/tests/resources/reftable/crlf/.gitted/objects/20/3555c5676d75cd80d69b50beb1f4b588c59ceb differ diff --git a/tests/resources/reftable/crlf/.gitted/objects/23/f4582779e60bfa7f14750ad507399a58876611 b/tests/resources/reftable/crlf/.gitted/objects/23/f4582779e60bfa7f14750ad507399a58876611 new file mode 100644 index 000000000..4a4e4dc9e Binary files /dev/null and b/tests/resources/reftable/crlf/.gitted/objects/23/f4582779e60bfa7f14750ad507399a58876611 differ diff --git a/tests/resources/reftable/crlf/.gitted/objects/2a/d3df895f68f4dda6a0a815c620b909bdd27c05 b/tests/resources/reftable/crlf/.gitted/objects/2a/d3df895f68f4dda6a0a815c620b909bdd27c05 new file mode 100644 index 000000000..f5421cf6a Binary files /dev/null and b/tests/resources/reftable/crlf/.gitted/objects/2a/d3df895f68f4dda6a0a815c620b909bdd27c05 differ diff --git a/tests/resources/reftable/crlf/.gitted/objects/2b/55b4b94f655c857635b6a9005c056aa7de3532 b/tests/resources/reftable/crlf/.gitted/objects/2b/55b4b94f655c857635b6a9005c056aa7de3532 new file mode 100644 index 000000000..031fd6681 --- /dev/null +++ b/tests/resources/reftable/crlf/.gitted/objects/2b/55b4b94f655c857635b6a9005c056aa7de3532 @@ -0,0 +1,2 @@ +x-Kj0D)z2tca].O VȄ zRݶԛAvyIfLi.υPɘL0d<=&b{O.09o4ŜI˔ +G_jk -Yھ~XTW ذ NjqKu:_ǣ]na.ZZk7!<#WF \ No newline at end of file diff --git a/tests/resources/reftable/crlf/.gitted/objects/2b/d9d81b51a867352bab307b89cbb5b4a69adfe1 b/tests/resources/reftable/crlf/.gitted/objects/2b/d9d81b51a867352bab307b89cbb5b4a69adfe1 new file mode 100644 index 000000000..96d952e85 Binary files /dev/null and b/tests/resources/reftable/crlf/.gitted/objects/2b/d9d81b51a867352bab307b89cbb5b4a69adfe1 differ diff --git a/tests/resources/reftable/crlf/.gitted/objects/2c/03f9f407b576eae80327864bab572e282a33ea b/tests/resources/reftable/crlf/.gitted/objects/2c/03f9f407b576eae80327864bab572e282a33ea new file mode 100644 index 000000000..0e4afbbba Binary files /dev/null and b/tests/resources/reftable/crlf/.gitted/objects/2c/03f9f407b576eae80327864bab572e282a33ea differ diff --git a/tests/resources/reftable/crlf/.gitted/objects/33/cdead44e1c3ec178e39a4a69085280dbacf01b b/tests/resources/reftable/crlf/.gitted/objects/33/cdead44e1c3ec178e39a4a69085280dbacf01b new file mode 100644 index 000000000..72dc780a0 Binary files /dev/null and b/tests/resources/reftable/crlf/.gitted/objects/33/cdead44e1c3ec178e39a4a69085280dbacf01b differ diff --git a/tests/resources/reftable/crlf/.gitted/objects/38/1cfe630df902bc29271a202d3277981180e4a6 b/tests/resources/reftable/crlf/.gitted/objects/38/1cfe630df902bc29271a202d3277981180e4a6 new file mode 100644 index 000000000..0cf707296 Binary files /dev/null and b/tests/resources/reftable/crlf/.gitted/objects/38/1cfe630df902bc29271a202d3277981180e4a6 differ diff --git a/tests/resources/reftable/crlf/.gitted/objects/3f/96bdca0e37616026afaa325c148cec4aa62d04 b/tests/resources/reftable/crlf/.gitted/objects/3f/96bdca0e37616026afaa325c148cec4aa62d04 new file mode 100644 index 000000000..a204fc983 Binary files /dev/null and b/tests/resources/reftable/crlf/.gitted/objects/3f/96bdca0e37616026afaa325c148cec4aa62d04 differ diff --git a/tests/resources/reftable/crlf/.gitted/objects/41/7786fc35b3c71aa546e3f95eb5da3c8dad8c41 b/tests/resources/reftable/crlf/.gitted/objects/41/7786fc35b3c71aa546e3f95eb5da3c8dad8c41 new file mode 100644 index 000000000..ec57bdeba Binary files /dev/null and b/tests/resources/reftable/crlf/.gitted/objects/41/7786fc35b3c71aa546e3f95eb5da3c8dad8c41 differ diff --git a/tests/resources/reftable/crlf/.gitted/objects/47/fbc2c28a18df0dc773276a253eb85c7516ca50 b/tests/resources/reftable/crlf/.gitted/objects/47/fbc2c28a18df0dc773276a253eb85c7516ca50 new file mode 100644 index 000000000..d16db9633 Binary files /dev/null and b/tests/resources/reftable/crlf/.gitted/objects/47/fbc2c28a18df0dc773276a253eb85c7516ca50 differ diff --git a/tests/resources/reftable/crlf/.gitted/objects/4b/825dc642cb6eb9a060e54bf8d69288fbee4904 b/tests/resources/reftable/crlf/.gitted/objects/4b/825dc642cb6eb9a060e54bf8d69288fbee4904 new file mode 100644 index 000000000..adf64119a Binary files /dev/null and b/tests/resources/reftable/crlf/.gitted/objects/4b/825dc642cb6eb9a060e54bf8d69288fbee4904 differ diff --git a/tests/resources/reftable/crlf/.gitted/objects/5a/fb6a14a864e30787857dd92af837e8cdd2cb1b b/tests/resources/reftable/crlf/.gitted/objects/5a/fb6a14a864e30787857dd92af837e8cdd2cb1b new file mode 100644 index 000000000..11a25c581 Binary files /dev/null and b/tests/resources/reftable/crlf/.gitted/objects/5a/fb6a14a864e30787857dd92af837e8cdd2cb1b differ diff --git a/tests/resources/reftable/crlf/.gitted/objects/68/03c385642cebc8103fddd526ef395d75678a7e b/tests/resources/reftable/crlf/.gitted/objects/68/03c385642cebc8103fddd526ef395d75678a7e new file mode 100644 index 000000000..f8d489fcb --- /dev/null +++ b/tests/resources/reftable/crlf/.gitted/objects/68/03c385642cebc8103fddd526ef395d75678a7e @@ -0,0 +1,2 @@ +xKj0Ьu}, !d &hZ0QvgWuz9OAHv Bh9!EM}cf52v%m` /=ZË MoeV3 +fr1pѓj8.[_ K^@kѡYj \ No newline at end of file diff --git a/tests/resources/reftable/crlf/.gitted/objects/69/597764abeaa1a403ebf589d2ea579c6a8f877e b/tests/resources/reftable/crlf/.gitted/objects/69/597764abeaa1a403ebf589d2ea579c6a8f877e new file mode 100644 index 000000000..ee4f4273d --- /dev/null +++ b/tests/resources/reftable/crlf/.gitted/objects/69/597764abeaa1a403ebf589d2ea579c6a8f877e @@ -0,0 +1 @@ +xэ0 a3Owr&%`NĎ-J!1|si`ݸkUȢr.*{zgr>ɱcbn\ui c.x"D,N,VuՒ.umgzL=@[kIǦismbY>!nJL \ No newline at end of file diff --git a/tests/resources/reftable/crlf/.gitted/objects/6a/e3e9c11a51f0aabebcffcbd5c00f4beed143c9 b/tests/resources/reftable/crlf/.gitted/objects/6a/e3e9c11a51f0aabebcffcbd5c00f4beed143c9 new file mode 100644 index 000000000..6c18a3ad2 Binary files /dev/null and b/tests/resources/reftable/crlf/.gitted/objects/6a/e3e9c11a51f0aabebcffcbd5c00f4beed143c9 differ diff --git a/tests/resources/reftable/crlf/.gitted/objects/6c/589757f65a970a6cc07c71c3f3d2528c611cbc b/tests/resources/reftable/crlf/.gitted/objects/6c/589757f65a970a6cc07c71c3f3d2528c611cbc new file mode 100644 index 000000000..fe4da8ce0 --- /dev/null +++ b/tests/resources/reftable/crlf/.gitted/objects/6c/589757f65a970a6cc07c71c3f3d2528c611cbc @@ -0,0 +1,2 @@ +x-KN0Y;PYpr5j#ǀ=nnF3iUUp$dKbN)OL)`Pf'VpCVY$SճcqVI:W +oZ^tvӁGW9gL2<kM+Ko |\ʺ;Nݱ>$81ÛeUe r}.Q \ No newline at end of file diff --git a/tests/resources/reftable/crlf/.gitted/objects/77/afe26d93c49279ca90604c125496920753fede b/tests/resources/reftable/crlf/.gitted/objects/77/afe26d93c49279ca90604c125496920753fede new file mode 100644 index 000000000..a377cb04d Binary files /dev/null and b/tests/resources/reftable/crlf/.gitted/objects/77/afe26d93c49279ca90604c125496920753fede differ diff --git a/tests/resources/reftable/crlf/.gitted/objects/78/db270c1841841f75a8157321bdcb50ab12e6c3 b/tests/resources/reftable/crlf/.gitted/objects/78/db270c1841841f75a8157321bdcb50ab12e6c3 new file mode 100644 index 000000000..8a55bb082 Binary files /dev/null and b/tests/resources/reftable/crlf/.gitted/objects/78/db270c1841841f75a8157321bdcb50ab12e6c3 differ diff --git a/tests/resources/reftable/crlf/.gitted/objects/79/9770d1cff46753a57db7a066159b5610da6e3a b/tests/resources/reftable/crlf/.gitted/objects/79/9770d1cff46753a57db7a066159b5610da6e3a new file mode 100644 index 000000000..5c701b867 Binary files /dev/null and b/tests/resources/reftable/crlf/.gitted/objects/79/9770d1cff46753a57db7a066159b5610da6e3a differ diff --git a/tests/resources/reftable/crlf/.gitted/objects/7c/ce67e58173e2b01f7db124ceaabe3183d19c49 b/tests/resources/reftable/crlf/.gitted/objects/7c/ce67e58173e2b01f7db124ceaabe3183d19c49 new file mode 100644 index 000000000..8e836aba1 Binary files /dev/null and b/tests/resources/reftable/crlf/.gitted/objects/7c/ce67e58173e2b01f7db124ceaabe3183d19c49 differ diff --git a/tests/resources/reftable/crlf/.gitted/objects/85/340755cfe5e28c2835781978bb1cece91b3d0f b/tests/resources/reftable/crlf/.gitted/objects/85/340755cfe5e28c2835781978bb1cece91b3d0f new file mode 100644 index 000000000..e83fbc290 Binary files /dev/null and b/tests/resources/reftable/crlf/.gitted/objects/85/340755cfe5e28c2835781978bb1cece91b3d0f differ diff --git a/tests/resources/reftable/crlf/.gitted/objects/92/0e90a663bea5d740989d5f935f6dfb473a0c5d b/tests/resources/reftable/crlf/.gitted/objects/92/0e90a663bea5d740989d5f935f6dfb473a0c5d new file mode 100644 index 000000000..f872be6e9 Binary files /dev/null and b/tests/resources/reftable/crlf/.gitted/objects/92/0e90a663bea5d740989d5f935f6dfb473a0c5d differ diff --git a/tests/resources/reftable/crlf/.gitted/objects/96/87e444bcbb85645cb496080434c292f1b57182 b/tests/resources/reftable/crlf/.gitted/objects/96/87e444bcbb85645cb496080434c292f1b57182 new file mode 100644 index 000000000..5df64d849 --- /dev/null +++ b/tests/resources/reftable/crlf/.gitted/objects/96/87e444bcbb85645cb496080434c292f1b57182 @@ -0,0 +1 @@ +xAJ1@Q9E!T:Y ޢRMAoGp/m7L*LQ)yEU(JqfP2Q1%L$QS ,xѾoz|xz󰾱I 0{S@x轻}_wU+H50'2=T \ No newline at end of file diff --git a/tests/resources/reftable/crlf/.gitted/objects/97/449da2d225557c558ac244384d487e66c3e591 b/tests/resources/reftable/crlf/.gitted/objects/97/449da2d225557c558ac244384d487e66c3e591 new file mode 100644 index 000000000..d3917a433 Binary files /dev/null and b/tests/resources/reftable/crlf/.gitted/objects/97/449da2d225557c558ac244384d487e66c3e591 differ diff --git a/tests/resources/reftable/crlf/.gitted/objects/9a/6c3533fef19abd6eec8e61206b5c51982b80d9 b/tests/resources/reftable/crlf/.gitted/objects/9a/6c3533fef19abd6eec8e61206b5c51982b80d9 new file mode 100644 index 000000000..78fc8aeb7 Binary files /dev/null and b/tests/resources/reftable/crlf/.gitted/objects/9a/6c3533fef19abd6eec8e61206b5c51982b80d9 differ diff --git a/tests/resources/reftable/crlf/.gitted/objects/9d/29b5bb165bf65637ffcb5ededb82ddd7c3fd13 b/tests/resources/reftable/crlf/.gitted/objects/9d/29b5bb165bf65637ffcb5ededb82ddd7c3fd13 new file mode 100644 index 000000000..106332d55 Binary files /dev/null and b/tests/resources/reftable/crlf/.gitted/objects/9d/29b5bb165bf65637ffcb5ededb82ddd7c3fd13 differ diff --git a/tests/resources/reftable/crlf/.gitted/objects/a2/34455d62297f1856c4603686150c59fcb0aafe b/tests/resources/reftable/crlf/.gitted/objects/a2/34455d62297f1856c4603686150c59fcb0aafe new file mode 100644 index 000000000..7d204f4c8 Binary files /dev/null and b/tests/resources/reftable/crlf/.gitted/objects/a2/34455d62297f1856c4603686150c59fcb0aafe differ diff --git a/tests/resources/reftable/crlf/.gitted/objects/a9/a2e8913c1dbe2812fac5e6b4e0a4bd5d0d5966 b/tests/resources/reftable/crlf/.gitted/objects/a9/a2e8913c1dbe2812fac5e6b4e0a4bd5d0d5966 new file mode 100644 index 000000000..33d59f1f1 --- /dev/null +++ b/tests/resources/reftable/crlf/.gitted/objects/a9/a2e8913c1dbe2812fac5e6b4e0a4bd5d0d5966 @@ -0,0 +1 @@ +xKOR02aH.I$  \ No newline at end of file diff --git a/tests/resources/reftable/crlf/.gitted/objects/aa/f083a9cb53dac3669dcfa0e48921580d629ec7 b/tests/resources/reftable/crlf/.gitted/objects/aa/f083a9cb53dac3669dcfa0e48921580d629ec7 new file mode 100644 index 000000000..38775d005 Binary files /dev/null and b/tests/resources/reftable/crlf/.gitted/objects/aa/f083a9cb53dac3669dcfa0e48921580d629ec7 differ diff --git a/tests/resources/reftable/crlf/.gitted/objects/af/6fcf6da196f615d7cda269b55b5c4ecfb4a5b3 b/tests/resources/reftable/crlf/.gitted/objects/af/6fcf6da196f615d7cda269b55b5c4ecfb4a5b3 new file mode 100644 index 000000000..0acc9744e Binary files /dev/null and b/tests/resources/reftable/crlf/.gitted/objects/af/6fcf6da196f615d7cda269b55b5c4ecfb4a5b3 differ diff --git a/tests/resources/reftable/crlf/.gitted/objects/bb/29a7b46b5d4ba3ea17b238ae561b81d59dc818 b/tests/resources/reftable/crlf/.gitted/objects/bb/29a7b46b5d4ba3ea17b238ae561b81d59dc818 new file mode 100644 index 000000000..a08789b54 Binary files /dev/null and b/tests/resources/reftable/crlf/.gitted/objects/bb/29a7b46b5d4ba3ea17b238ae561b81d59dc818 differ diff --git a/tests/resources/reftable/crlf/.gitted/objects/c3/e11722855ff260bd27418988ac1467c4e9e73a b/tests/resources/reftable/crlf/.gitted/objects/c3/e11722855ff260bd27418988ac1467c4e9e73a new file mode 100644 index 000000000..5f96dc76c Binary files /dev/null and b/tests/resources/reftable/crlf/.gitted/objects/c3/e11722855ff260bd27418988ac1467c4e9e73a differ diff --git a/tests/resources/reftable/crlf/.gitted/objects/c8/d0b1ebcaccdd8f968c4aae3c2175e7fed651fe b/tests/resources/reftable/crlf/.gitted/objects/c8/d0b1ebcaccdd8f968c4aae3c2175e7fed651fe new file mode 100644 index 000000000..21e2ce093 --- /dev/null +++ b/tests/resources/reftable/crlf/.gitted/objects/c8/d0b1ebcaccdd8f968c4aae3c2175e7fed651fe @@ -0,0 +1,2 @@ +x-Kn0C)f8od (t4#؈e9~;$RKI1*1;tf9Edb&1LʈPyk 0#*FeYtٱ{7opkuI^ec3Z? NRI)c +[^}|+?wTX #ވ,L!5C^V>=R~ \ No newline at end of file diff --git a/tests/resources/reftable/crlf/.gitted/objects/cd/574f5a2baa4c79504f8837b730fa0b11defe99 b/tests/resources/reftable/crlf/.gitted/objects/cd/574f5a2baa4c79504f8837b730fa0b11defe99 new file mode 100644 index 000000000..e8d020246 Binary files /dev/null and b/tests/resources/reftable/crlf/.gitted/objects/cd/574f5a2baa4c79504f8837b730fa0b11defe99 differ diff --git a/tests/resources/reftable/crlf/.gitted/objects/cd/d3dacc5c0501d5ea57bbdf90e3d80176606139 b/tests/resources/reftable/crlf/.gitted/objects/cd/d3dacc5c0501d5ea57bbdf90e3d80176606139 new file mode 100644 index 000000000..72cf3b0fd Binary files /dev/null and b/tests/resources/reftable/crlf/.gitted/objects/cd/d3dacc5c0501d5ea57bbdf90e3d80176606139 differ diff --git a/tests/resources/reftable/crlf/.gitted/objects/d1/1e7ef63ba7db1db3b1b99cdbafc57a8549f8a4 b/tests/resources/reftable/crlf/.gitted/objects/d1/1e7ef63ba7db1db3b1b99cdbafc57a8549f8a4 new file mode 100644 index 000000000..05d88fc86 Binary files /dev/null and b/tests/resources/reftable/crlf/.gitted/objects/d1/1e7ef63ba7db1db3b1b99cdbafc57a8549f8a4 differ diff --git a/tests/resources/reftable/crlf/.gitted/objects/dc/88e3b917de821e25962bea7ec1f55c4ce2112c b/tests/resources/reftable/crlf/.gitted/objects/dc/88e3b917de821e25962bea7ec1f55c4ce2112c new file mode 100644 index 000000000..3db13aa79 Binary files /dev/null and b/tests/resources/reftable/crlf/.gitted/objects/dc/88e3b917de821e25962bea7ec1f55c4ce2112c differ diff --git a/tests/resources/reftable/crlf/.gitted/objects/de/5bfa165999d9d6c6dbafad2a7e709f93ec30fd b/tests/resources/reftable/crlf/.gitted/objects/de/5bfa165999d9d6c6dbafad2a7e709f93ec30fd new file mode 100644 index 000000000..e288b975f Binary files /dev/null and b/tests/resources/reftable/crlf/.gitted/objects/de/5bfa165999d9d6c6dbafad2a7e709f93ec30fd differ diff --git a/tests/resources/reftable/crlf/.gitted/objects/e5/062da7d7802cf492975eda580f09ac4876bd88 b/tests/resources/reftable/crlf/.gitted/objects/e5/062da7d7802cf492975eda580f09ac4876bd88 new file mode 100644 index 000000000..62835b9e1 --- /dev/null +++ b/tests/resources/reftable/crlf/.gitted/objects/e5/062da7d7802cf492975eda580f09ac4876bd88 @@ -0,0 +1 @@ +xQ1D)j'd2")xN,3x^AQj)UD`iJֻ>Fc:D&Rr.1#DǓ,HPϖ}9rPGŏ6 ~ a/ }IDx$kj&_֨GZכ›| ǸU \ No newline at end of file diff --git a/tests/resources/reftable/crlf/.gitted/objects/e6/9de29bb2d1d6434b8b29ae775ad8c2e48c5391 b/tests/resources/reftable/crlf/.gitted/objects/e6/9de29bb2d1d6434b8b29ae775ad8c2e48c5391 new file mode 100644 index 000000000..711223894 Binary files /dev/null and b/tests/resources/reftable/crlf/.gitted/objects/e6/9de29bb2d1d6434b8b29ae775ad8c2e48c5391 differ diff --git a/tests/resources/reftable/crlf/.gitted/objects/ea/030d3c6cec212069eca698cabaa5b4550f1511 b/tests/resources/reftable/crlf/.gitted/objects/ea/030d3c6cec212069eca698cabaa5b4550f1511 new file mode 100644 index 000000000..117dc725a Binary files /dev/null and b/tests/resources/reftable/crlf/.gitted/objects/ea/030d3c6cec212069eca698cabaa5b4550f1511 differ diff --git a/tests/resources/reftable/crlf/.gitted/objects/ef/0dcd356d77221e9c27f4f3928ad28e80b87ceb b/tests/resources/reftable/crlf/.gitted/objects/ef/0dcd356d77221e9c27f4f3928ad28e80b87ceb new file mode 100644 index 000000000..33aceda12 Binary files /dev/null and b/tests/resources/reftable/crlf/.gitted/objects/ef/0dcd356d77221e9c27f4f3928ad28e80b87ceb differ diff --git a/tests/resources/reftable/crlf/.gitted/objects/f2/b745d7f47d114a3a6b31a7b628e61e804d1a58 b/tests/resources/reftable/crlf/.gitted/objects/f2/b745d7f47d114a3a6b31a7b628e61e804d1a58 new file mode 100644 index 000000000..7b2e7a116 Binary files /dev/null and b/tests/resources/reftable/crlf/.gitted/objects/f2/b745d7f47d114a3a6b31a7b628e61e804d1a58 differ diff --git a/tests/resources/reftable/crlf/.gitted/objects/f4/d25b796d86387205a5498175d66e91d1e5006a b/tests/resources/reftable/crlf/.gitted/objects/f4/d25b796d86387205a5498175d66e91d1e5006a new file mode 100644 index 000000000..792b1659d Binary files /dev/null and b/tests/resources/reftable/crlf/.gitted/objects/f4/d25b796d86387205a5498175d66e91d1e5006a differ diff --git a/tests/resources/reftable/crlf/.gitted/objects/fe/085d9ace90cc675b87df15e1aeed0c3a31407f b/tests/resources/reftable/crlf/.gitted/objects/fe/085d9ace90cc675b87df15e1aeed0c3a31407f new file mode 100644 index 000000000..2e8d10b76 Binary files /dev/null and b/tests/resources/reftable/crlf/.gitted/objects/fe/085d9ace90cc675b87df15e1aeed0c3a31407f differ diff --git a/tests/resources/reftable/crlf/.gitted/objects/fe/ab3713c4659bb22700042b3c55b8d60d0a952b b/tests/resources/reftable/crlf/.gitted/objects/fe/ab3713c4659bb22700042b3c55b8d60d0a952b new file mode 100644 index 000000000..8552c7bf7 Binary files /dev/null and b/tests/resources/reftable/crlf/.gitted/objects/fe/ab3713c4659bb22700042b3c55b8d60d0a952b differ diff --git a/tests/resources/reftable/crlf/.gitted/refs/heads b/tests/resources/reftable/crlf/.gitted/refs/heads new file mode 100644 index 000000000..3e639a56a --- /dev/null +++ b/tests/resources/reftable/crlf/.gitted/refs/heads @@ -0,0 +1 @@ +this repository uses the reftable format diff --git a/tests/resources/reftable/crlf/.gitted/reftable/0x000000000001-0x000000000001-d1a3766d.ref b/tests/resources/reftable/crlf/.gitted/reftable/0x000000000001-0x000000000001-d1a3766d.ref new file mode 100644 index 000000000..fe098cfd0 Binary files /dev/null and b/tests/resources/reftable/crlf/.gitted/reftable/0x000000000001-0x000000000001-d1a3766d.ref differ diff --git a/tests/resources/reftable/crlf/.gitted/reftable/tables.list b/tests/resources/reftable/crlf/.gitted/reftable/tables.list new file mode 100644 index 000000000..1baca663a --- /dev/null +++ b/tests/resources/reftable/crlf/.gitted/reftable/tables.list @@ -0,0 +1 @@ +0x000000000001-0x000000000001-d1a3766d.ref diff --git a/tests/resources/reftable/crlf/all-crlf b/tests/resources/reftable/crlf/all-crlf new file mode 100644 index 000000000..a9a2e8913 --- /dev/null +++ b/tests/resources/reftable/crlf/all-crlf @@ -0,0 +1,4 @@ +crlf +crlf +crlf +crlf diff --git a/tests/resources/reftable/crlf/all-crlf-utf8bom b/tests/resources/reftable/crlf/all-crlf-utf8bom new file mode 100644 index 000000000..0aa76e474 --- /dev/null +++ b/tests/resources/reftable/crlf/all-crlf-utf8bom @@ -0,0 +1,4 @@ +crlf +crlf +crlf +crlf diff --git a/tests/resources/reftable/crlf/all-lf b/tests/resources/reftable/crlf/all-lf new file mode 100644 index 000000000..799770d1c --- /dev/null +++ b/tests/resources/reftable/crlf/all-lf @@ -0,0 +1,5 @@ +lf +lf +lf +lf +lf diff --git a/tests/resources/reftable/crlf/all-lf-utf8bom b/tests/resources/reftable/crlf/all-lf-utf8bom new file mode 100644 index 000000000..7cce67e58 --- /dev/null +++ b/tests/resources/reftable/crlf/all-lf-utf8bom @@ -0,0 +1,5 @@ +lf +lf +lf +lf +lf diff --git a/tests/resources/reftable/crlf/binary-all-crlf b/tests/resources/reftable/crlf/binary-all-crlf new file mode 100644 index 000000000..85340755c --- /dev/null +++ b/tests/resources/reftable/crlf/binary-all-crlf @@ -0,0 +1,4 @@ +one +two +three +four diff --git a/tests/resources/reftable/crlf/binary-all-lf b/tests/resources/reftable/crlf/binary-all-lf new file mode 100644 index 000000000..af6fcf6da --- /dev/null +++ b/tests/resources/reftable/crlf/binary-all-lf @@ -0,0 +1,4 @@ +one +two +three +four diff --git a/tests/resources/reftable/crlf/binary-mixed-lf-cr b/tests/resources/reftable/crlf/binary-mixed-lf-cr new file mode 100644 index 000000000..203555c56 --- /dev/null +++ b/tests/resources/reftable/crlf/binary-mixed-lf-cr @@ -0,0 +1,3 @@ +one +two three +four \ No newline at end of file diff --git a/tests/resources/reftable/crlf/binary-mixed-lf-cr-crlf b/tests/resources/reftable/crlf/binary-mixed-lf-cr-crlf new file mode 100644 index 000000000..aaf083a9c --- /dev/null +++ b/tests/resources/reftable/crlf/binary-mixed-lf-cr-crlf @@ -0,0 +1,3 @@ +one +two three +four \ No newline at end of file diff --git a/tests/resources/reftable/crlf/few-utf8-chars-crlf b/tests/resources/reftable/crlf/few-utf8-chars-crlf new file mode 100644 index 000000000..0e0528888 --- /dev/null +++ b/tests/resources/reftable/crlf/few-utf8-chars-crlf @@ -0,0 +1,22 @@ +⚽The rest is ASCII01. +The rest is ASCII02. +The rest is ASCII03. +The rest is ASCII04. +The rest is ASCII05. +The rest is ASCII06. +The rest is ASCII07. +The rest is ASCII08. +The rest is ASCII09. +The rest is ASCII10. +The rest is ASCII11. +The rest is ASCII12. +The rest is ASCII13. +The rest is ASCII14. +The rest is ASCII15. +The rest is ASCII16. +The rest is ASCII17. +The rest is ASCII18. +The rest is ASCII19. +The rest is ASCII20. +The rest is ASCII21. +The rest is ASCII22. diff --git a/tests/resources/reftable/crlf/few-utf8-chars-lf b/tests/resources/reftable/crlf/few-utf8-chars-lf new file mode 100644 index 000000000..f4d25b796 --- /dev/null +++ b/tests/resources/reftable/crlf/few-utf8-chars-lf @@ -0,0 +1,22 @@ +⚽The rest is ASCII01. +The rest is ASCII02. +The rest is ASCII03. +The rest is ASCII04. +The rest is ASCII05. +The rest is ASCII06. +The rest is ASCII07. +The rest is ASCII08. +The rest is ASCII09. +The rest is ASCII10. +The rest is ASCII11. +The rest is ASCII12. +The rest is ASCII13. +The rest is ASCII14. +The rest is ASCII15. +The rest is ASCII16. +The rest is ASCII17. +The rest is ASCII18. +The rest is ASCII19. +The rest is ASCII20. +The rest is ASCII21. +The rest is ASCII22. diff --git a/tests/resources/reftable/crlf/many-utf8-chars-crlf b/tests/resources/reftable/crlf/many-utf8-chars-crlf new file mode 100644 index 000000000..cd574f5a2 --- /dev/null +++ b/tests/resources/reftable/crlf/many-utf8-chars-crlf @@ -0,0 +1,4 @@ +Lets sing! +♫♪♬♩ +Eat food +🍅🍕 diff --git a/tests/resources/reftable/crlf/many-utf8-chars-lf b/tests/resources/reftable/crlf/many-utf8-chars-lf new file mode 100644 index 000000000..9a6c3533f --- /dev/null +++ b/tests/resources/reftable/crlf/many-utf8-chars-lf @@ -0,0 +1,4 @@ +Lets sing! +♫♪♬♩ +Eat food +🍅🍕 diff --git a/tests/resources/reftable/crlf/mixed-lf-cr b/tests/resources/reftable/crlf/mixed-lf-cr new file mode 100644 index 000000000..d11e7ef63 --- /dev/null +++ b/tests/resources/reftable/crlf/mixed-lf-cr @@ -0,0 +1,3 @@ +one +two three +four \ No newline at end of file diff --git a/tests/resources/reftable/crlf/mixed-lf-cr-crlf b/tests/resources/reftable/crlf/mixed-lf-cr-crlf new file mode 100644 index 000000000..417786fc3 --- /dev/null +++ b/tests/resources/reftable/crlf/mixed-lf-cr-crlf @@ -0,0 +1,3 @@ +one +two three +four \ No newline at end of file diff --git a/tests/resources/reftable/crlf/more-crlf b/tests/resources/reftable/crlf/more-crlf new file mode 100644 index 000000000..0ff5a53f1 --- /dev/null +++ b/tests/resources/reftable/crlf/more-crlf @@ -0,0 +1,5 @@ +crlf +crlf +lf +crlf +crlf diff --git a/tests/resources/reftable/crlf/more-crlf-utf8bom b/tests/resources/reftable/crlf/more-crlf-utf8bom new file mode 100644 index 000000000..ea030d3c6 --- /dev/null +++ b/tests/resources/reftable/crlf/more-crlf-utf8bom @@ -0,0 +1,5 @@ +crlf +crlf +lf +crlf +crlf diff --git a/tests/resources/reftable/crlf/more-lf b/tests/resources/reftable/crlf/more-lf new file mode 100644 index 000000000..04de00b35 --- /dev/null +++ b/tests/resources/reftable/crlf/more-lf @@ -0,0 +1,5 @@ +lf +lf +crlf +lf +lf diff --git a/tests/resources/reftable/crlf/more-lf-utf8bom b/tests/resources/reftable/crlf/more-lf-utf8bom new file mode 100644 index 000000000..dc88e3b91 --- /dev/null +++ b/tests/resources/reftable/crlf/more-lf-utf8bom @@ -0,0 +1,5 @@ +lf +lf +crlf +lf +lf diff --git a/tests/resources/reftable/crlf/zero-byte b/tests/resources/reftable/crlf/zero-byte new file mode 100644 index 000000000..e69de29bb diff --git a/tests/resources/reftable/deprecated-mode.git/HEAD b/tests/resources/reftable/deprecated-mode.git/HEAD new file mode 100644 index 000000000..fe6d7e5fa --- /dev/null +++ b/tests/resources/reftable/deprecated-mode.git/HEAD @@ -0,0 +1 @@ +ref: refs/heads/.invalid diff --git a/tests/resources/reftable/deprecated-mode.git/config b/tests/resources/reftable/deprecated-mode.git/config new file mode 100644 index 000000000..0c3a01063 --- /dev/null +++ b/tests/resources/reftable/deprecated-mode.git/config @@ -0,0 +1,8 @@ +[core] + bare = true + repositoryformatversion = 1 + filemode = false + logallrefupdates = true + ignorecase = true +[extensions] + refstorage = reftable diff --git a/tests/resources/reftable/deprecated-mode.git/description b/tests/resources/reftable/deprecated-mode.git/description new file mode 100644 index 000000000..498b267a8 --- /dev/null +++ b/tests/resources/reftable/deprecated-mode.git/description @@ -0,0 +1 @@ +Unnamed repository; edit this file 'description' to name the repository. diff --git a/tests/resources/reftable/deprecated-mode.git/index b/tests/resources/reftable/deprecated-mode.git/index new file mode 100644 index 000000000..682740603 Binary files /dev/null and b/tests/resources/reftable/deprecated-mode.git/index differ diff --git a/tests/resources/reftable/deprecated-mode.git/info/exclude b/tests/resources/reftable/deprecated-mode.git/info/exclude new file mode 100644 index 000000000..6d05881d3 --- /dev/null +++ b/tests/resources/reftable/deprecated-mode.git/info/exclude @@ -0,0 +1,2 @@ +# File patterns to ignore; see `git help ignore` for more information. +# Lines that start with '#' are comments. diff --git a/tests/resources/reftable/deprecated-mode.git/objects/06/262edc257418e9987caf999f9a7a3e1547adff b/tests/resources/reftable/deprecated-mode.git/objects/06/262edc257418e9987caf999f9a7a3e1547adff new file mode 100644 index 000000000..a030cf7a7 Binary files /dev/null and b/tests/resources/reftable/deprecated-mode.git/objects/06/262edc257418e9987caf999f9a7a3e1547adff differ diff --git a/tests/resources/reftable/deprecated-mode.git/objects/08/10fb7818088ff5ac41ee49199b51473b1bd6c7 b/tests/resources/reftable/deprecated-mode.git/objects/08/10fb7818088ff5ac41ee49199b51473b1bd6c7 new file mode 100644 index 000000000..52d56936a Binary files /dev/null and b/tests/resources/reftable/deprecated-mode.git/objects/08/10fb7818088ff5ac41ee49199b51473b1bd6c7 differ diff --git a/tests/resources/reftable/deprecated-mode.git/objects/1b/05fdaa881ee45b48cbaa5e9b037d667a47745e b/tests/resources/reftable/deprecated-mode.git/objects/1b/05fdaa881ee45b48cbaa5e9b037d667a47745e new file mode 100644 index 000000000..ae7765a70 Binary files /dev/null and b/tests/resources/reftable/deprecated-mode.git/objects/1b/05fdaa881ee45b48cbaa5e9b037d667a47745e differ diff --git a/tests/resources/reftable/deprecated-mode.git/objects/3d/0970ec547fc41ef8a5882dde99c6adce65b021 b/tests/resources/reftable/deprecated-mode.git/objects/3d/0970ec547fc41ef8a5882dde99c6adce65b021 new file mode 100644 index 000000000..595283e89 Binary files /dev/null and b/tests/resources/reftable/deprecated-mode.git/objects/3d/0970ec547fc41ef8a5882dde99c6adce65b021 differ diff --git a/tests/resources/reftable/deprecated-mode.git/refs/heads b/tests/resources/reftable/deprecated-mode.git/refs/heads new file mode 100644 index 000000000..3e639a56a --- /dev/null +++ b/tests/resources/reftable/deprecated-mode.git/refs/heads @@ -0,0 +1 @@ +this repository uses the reftable format diff --git a/tests/resources/reftable/deprecated-mode.git/reftable/0x000000000001-0x000000000001-474a5f2c.ref b/tests/resources/reftable/deprecated-mode.git/reftable/0x000000000001-0x000000000001-474a5f2c.ref new file mode 100644 index 000000000..1d2b6f97b Binary files /dev/null and b/tests/resources/reftable/deprecated-mode.git/reftable/0x000000000001-0x000000000001-474a5f2c.ref differ diff --git a/tests/resources/reftable/deprecated-mode.git/reftable/tables.list b/tests/resources/reftable/deprecated-mode.git/reftable/tables.list new file mode 100644 index 000000000..74bfb92e1 --- /dev/null +++ b/tests/resources/reftable/deprecated-mode.git/reftable/tables.list @@ -0,0 +1 @@ +0x000000000001-0x000000000001-474a5f2c.ref diff --git a/tests/resources/reftable/describe/.gitted/HEAD b/tests/resources/reftable/describe/.gitted/HEAD new file mode 100644 index 000000000..fe6d7e5fa --- /dev/null +++ b/tests/resources/reftable/describe/.gitted/HEAD @@ -0,0 +1 @@ +ref: refs/heads/.invalid diff --git a/tests/resources/reftable/describe/.gitted/config b/tests/resources/reftable/describe/.gitted/config new file mode 100644 index 000000000..9bec4bcc7 --- /dev/null +++ b/tests/resources/reftable/describe/.gitted/config @@ -0,0 +1,10 @@ +[core] + repositoryformatversion = 1 + filemode = false + bare = false + logallrefupdates = true + symlinks = false + ignorecase = true + hideDotFiles = dotGitOnly +[extensions] + refstorage = reftable diff --git a/tests/resources/reftable/describe/.gitted/index b/tests/resources/reftable/describe/.gitted/index new file mode 100644 index 000000000..f5f35e26b Binary files /dev/null and b/tests/resources/reftable/describe/.gitted/index differ diff --git a/tests/resources/reftable/describe/.gitted/objects/03/00021985931292d0611b9232e757035fefc04d b/tests/resources/reftable/describe/.gitted/objects/03/00021985931292d0611b9232e757035fefc04d new file mode 100644 index 000000000..4b98de8fb Binary files /dev/null and b/tests/resources/reftable/describe/.gitted/objects/03/00021985931292d0611b9232e757035fefc04d differ diff --git a/tests/resources/reftable/describe/.gitted/objects/10/8b485d8268ea595df8ffea74f0f4b186577d32 b/tests/resources/reftable/describe/.gitted/objects/10/8b485d8268ea595df8ffea74f0f4b186577d32 new file mode 100644 index 000000000..0d6187b10 Binary files /dev/null and b/tests/resources/reftable/describe/.gitted/objects/10/8b485d8268ea595df8ffea74f0f4b186577d32 differ diff --git a/tests/resources/reftable/describe/.gitted/objects/10/bd08b099ecb79184c60183f5c94ca915f427ad b/tests/resources/reftable/describe/.gitted/objects/10/bd08b099ecb79184c60183f5c94ca915f427ad new file mode 100644 index 000000000..3540cfae0 Binary files /dev/null and b/tests/resources/reftable/describe/.gitted/objects/10/bd08b099ecb79184c60183f5c94ca915f427ad differ diff --git a/tests/resources/reftable/describe/.gitted/objects/17/8481050188cf00d7d9cd5a11e43ab8fab9294f b/tests/resources/reftable/describe/.gitted/objects/17/8481050188cf00d7d9cd5a11e43ab8fab9294f new file mode 100644 index 000000000..f2eaf83e5 Binary files /dev/null and b/tests/resources/reftable/describe/.gitted/objects/17/8481050188cf00d7d9cd5a11e43ab8fab9294f differ diff --git a/tests/resources/reftable/describe/.gitted/objects/19/1faf88a5826a99f475baaf8b13652c4e40bfe6 b/tests/resources/reftable/describe/.gitted/objects/19/1faf88a5826a99f475baaf8b13652c4e40bfe6 new file mode 100644 index 000000000..e44246b17 Binary files /dev/null and b/tests/resources/reftable/describe/.gitted/objects/19/1faf88a5826a99f475baaf8b13652c4e40bfe6 differ diff --git a/tests/resources/reftable/describe/.gitted/objects/1e/016431ec7b22dd3e23f3e6f5f68f358f9227cf b/tests/resources/reftable/describe/.gitted/objects/1e/016431ec7b22dd3e23f3e6f5f68f358f9227cf new file mode 100644 index 000000000..a8769814b Binary files /dev/null and b/tests/resources/reftable/describe/.gitted/objects/1e/016431ec7b22dd3e23f3e6f5f68f358f9227cf differ diff --git a/tests/resources/reftable/describe/.gitted/objects/22/3b7836fb19fdf64ba2d3cd6173c6a283141f78 b/tests/resources/reftable/describe/.gitted/objects/22/3b7836fb19fdf64ba2d3cd6173c6a283141f78 new file mode 100644 index 000000000..faf1fbe7c Binary files /dev/null and b/tests/resources/reftable/describe/.gitted/objects/22/3b7836fb19fdf64ba2d3cd6173c6a283141f78 differ diff --git a/tests/resources/reftable/describe/.gitted/objects/25/d5edf8c0ef17e8a13b8da75913dcec4ea7afc1 b/tests/resources/reftable/describe/.gitted/objects/25/d5edf8c0ef17e8a13b8da75913dcec4ea7afc1 new file mode 100644 index 000000000..3353bf9ea Binary files /dev/null and b/tests/resources/reftable/describe/.gitted/objects/25/d5edf8c0ef17e8a13b8da75913dcec4ea7afc1 differ diff --git a/tests/resources/reftable/describe/.gitted/objects/2b/df67abb163a4ffb2d7f3f0880c9fe5068ce782 b/tests/resources/reftable/describe/.gitted/objects/2b/df67abb163a4ffb2d7f3f0880c9fe5068ce782 new file mode 100644 index 000000000..d0398e6e3 Binary files /dev/null and b/tests/resources/reftable/describe/.gitted/objects/2b/df67abb163a4ffb2d7f3f0880c9fe5068ce782 differ diff --git a/tests/resources/reftable/describe/.gitted/objects/31/fc9136820b507e938a9c6b88bf2c567a9f6f4b b/tests/resources/reftable/describe/.gitted/objects/31/fc9136820b507e938a9c6b88bf2c567a9f6f4b new file mode 100644 index 000000000..7752a9558 Binary files /dev/null and b/tests/resources/reftable/describe/.gitted/objects/31/fc9136820b507e938a9c6b88bf2c567a9f6f4b differ diff --git a/tests/resources/reftable/describe/.gitted/objects/42/8f9554a2eec22de29898819b579466af7c1583 b/tests/resources/reftable/describe/.gitted/objects/42/8f9554a2eec22de29898819b579466af7c1583 new file mode 100644 index 000000000..f27d552fd Binary files /dev/null and b/tests/resources/reftable/describe/.gitted/objects/42/8f9554a2eec22de29898819b579466af7c1583 differ diff --git a/tests/resources/reftable/describe/.gitted/objects/4d/6558b8fa764baeb0f19c1e857df91e0eda5a0f b/tests/resources/reftable/describe/.gitted/objects/4d/6558b8fa764baeb0f19c1e857df91e0eda5a0f new file mode 100644 index 000000000..311ee2fad Binary files /dev/null and b/tests/resources/reftable/describe/.gitted/objects/4d/6558b8fa764baeb0f19c1e857df91e0eda5a0f differ diff --git a/tests/resources/reftable/describe/.gitted/objects/4f/2d9ce01ad5249cabdc6565366af8aff85b1525 b/tests/resources/reftable/describe/.gitted/objects/4f/2d9ce01ad5249cabdc6565366af8aff85b1525 new file mode 100644 index 000000000..f04379f35 Binary files /dev/null and b/tests/resources/reftable/describe/.gitted/objects/4f/2d9ce01ad5249cabdc6565366af8aff85b1525 differ diff --git a/tests/resources/reftable/describe/.gitted/objects/52/912fbab0715dec53d43053966e78ad213ba359 b/tests/resources/reftable/describe/.gitted/objects/52/912fbab0715dec53d43053966e78ad213ba359 new file mode 100644 index 000000000..5deb7ec06 Binary files /dev/null and b/tests/resources/reftable/describe/.gitted/objects/52/912fbab0715dec53d43053966e78ad213ba359 differ diff --git a/tests/resources/reftable/describe/.gitted/objects/56/26abf0f72e58d7a153368ba57db4c673c0e171 b/tests/resources/reftable/describe/.gitted/objects/56/26abf0f72e58d7a153368ba57db4c673c0e171 new file mode 100644 index 000000000..4d5447467 Binary files /dev/null and b/tests/resources/reftable/describe/.gitted/objects/56/26abf0f72e58d7a153368ba57db4c673c0e171 differ diff --git a/tests/resources/reftable/describe/.gitted/objects/61/26a5f9c57ebc81e64370ec3095184ad92dab1c b/tests/resources/reftable/describe/.gitted/objects/61/26a5f9c57ebc81e64370ec3095184ad92dab1c new file mode 100644 index 000000000..e71707f4b Binary files /dev/null and b/tests/resources/reftable/describe/.gitted/objects/61/26a5f9c57ebc81e64370ec3095184ad92dab1c differ diff --git a/tests/resources/reftable/describe/.gitted/objects/62/d8fe9f6db631bd3a19140699101c9e281c9f9d b/tests/resources/reftable/describe/.gitted/objects/62/d8fe9f6db631bd3a19140699101c9e281c9f9d new file mode 100644 index 000000000..734f7dc42 Binary files /dev/null and b/tests/resources/reftable/describe/.gitted/objects/62/d8fe9f6db631bd3a19140699101c9e281c9f9d differ diff --git a/tests/resources/reftable/describe/.gitted/objects/65/a91bc2262480dce4c5979519aae6668368eb4e b/tests/resources/reftable/describe/.gitted/objects/65/a91bc2262480dce4c5979519aae6668368eb4e new file mode 100644 index 000000000..ef9f53a39 Binary files /dev/null and b/tests/resources/reftable/describe/.gitted/objects/65/a91bc2262480dce4c5979519aae6668368eb4e differ diff --git a/tests/resources/reftable/describe/.gitted/objects/68/0166b6cd31f76354fee2572618e6b0142d05e6 b/tests/resources/reftable/describe/.gitted/objects/68/0166b6cd31f76354fee2572618e6b0142d05e6 new file mode 100644 index 000000000..36f198686 --- /dev/null +++ b/tests/resources/reftable/describe/.gitted/objects/68/0166b6cd31f76354fee2572618e6b0142d05e6 @@ -0,0 +1,2 @@ +xK @]sٛ4|cJ[QhK% \ No newline at end of file diff --git a/tests/resources/reftable/describe/.gitted/objects/aa/d8d5cef3915ab78b3227abaaac99b62db9eb54 b/tests/resources/reftable/describe/.gitted/objects/aa/d8d5cef3915ab78b3227abaaac99b62db9eb54 new file mode 100644 index 000000000..4cbaff192 Binary files /dev/null and b/tests/resources/reftable/describe/.gitted/objects/aa/d8d5cef3915ab78b3227abaaac99b62db9eb54 differ diff --git a/tests/resources/reftable/describe/.gitted/objects/aa/ddd4f14847e0e323924ec262c2343249a84f8b b/tests/resources/reftable/describe/.gitted/objects/aa/ddd4f14847e0e323924ec262c2343249a84f8b new file mode 100644 index 000000000..651ec782e Binary files /dev/null and b/tests/resources/reftable/describe/.gitted/objects/aa/ddd4f14847e0e323924ec262c2343249a84f8b differ diff --git a/tests/resources/reftable/describe/.gitted/objects/b2/40c0fb88c5a629e00ebc1275fa1f33e364a705 b/tests/resources/reftable/describe/.gitted/objects/b2/40c0fb88c5a629e00ebc1275fa1f33e364a705 new file mode 100644 index 000000000..fe86e7c7c --- /dev/null +++ b/tests/resources/reftable/describe/.gitted/objects/b2/40c0fb88c5a629e00ebc1275fa1f33e364a705 @@ -0,0 +1,3 @@ +xM +  AͧQ(WJc,ܿ7 j-+EnerY9 Xg* 8df +Ad预[NB yEfqho^ѫ>՗}޹\P‘$~ ش9GG \ No newline at end of file diff --git a/tests/resources/reftable/describe/.gitted/objects/ce/1c4f8b6120122e23d4442925d98c56c41917d8 b/tests/resources/reftable/describe/.gitted/objects/ce/1c4f8b6120122e23d4442925d98c56c41917d8 new file mode 100644 index 000000000..408c5da33 Binary files /dev/null and b/tests/resources/reftable/describe/.gitted/objects/ce/1c4f8b6120122e23d4442925d98c56c41917d8 differ diff --git a/tests/resources/reftable/describe/.gitted/objects/d5/aab219a814ddbe4b3aaedf03cdea491b218ec4 b/tests/resources/reftable/describe/.gitted/objects/d5/aab219a814ddbe4b3aaedf03cdea491b218ec4 new file mode 100644 index 000000000..4512d16d6 Binary files /dev/null and b/tests/resources/reftable/describe/.gitted/objects/d5/aab219a814ddbe4b3aaedf03cdea491b218ec4 differ diff --git a/tests/resources/reftable/describe/.gitted/objects/f2/ad6c76f0115a6ba5b00456a849810e7ec0af20 b/tests/resources/reftable/describe/.gitted/objects/f2/ad6c76f0115a6ba5b00456a849810e7ec0af20 new file mode 100644 index 000000000..a36463115 Binary files /dev/null and b/tests/resources/reftable/describe/.gitted/objects/f2/ad6c76f0115a6ba5b00456a849810e7ec0af20 differ diff --git a/tests/resources/reftable/describe/.gitted/objects/f7/0f10e4db19068f79bc43844b49f3eece45c4e8 b/tests/resources/reftable/describe/.gitted/objects/f7/0f10e4db19068f79bc43844b49f3eece45c4e8 new file mode 100644 index 000000000..2e15b4fb0 Binary files /dev/null and b/tests/resources/reftable/describe/.gitted/objects/f7/0f10e4db19068f79bc43844b49f3eece45c4e8 differ diff --git a/tests/resources/reftable/describe/.gitted/objects/f7/19efd430d52bcfc8566a43b2eb655688d38871 b/tests/resources/reftable/describe/.gitted/objects/f7/19efd430d52bcfc8566a43b2eb655688d38871 new file mode 100644 index 000000000..b2d51d93b Binary files /dev/null and b/tests/resources/reftable/describe/.gitted/objects/f7/19efd430d52bcfc8566a43b2eb655688d38871 differ diff --git a/tests/resources/reftable/describe/.gitted/refs/heads b/tests/resources/reftable/describe/.gitted/refs/heads new file mode 100644 index 000000000..3e639a56a --- /dev/null +++ b/tests/resources/reftable/describe/.gitted/refs/heads @@ -0,0 +1 @@ +this repository uses the reftable format diff --git a/tests/resources/reftable/describe/.gitted/reftable/0x000000000001-0x00000000000e-7064cca6.ref b/tests/resources/reftable/describe/.gitted/reftable/0x000000000001-0x00000000000e-7064cca6.ref new file mode 100644 index 000000000..45f024937 Binary files /dev/null and b/tests/resources/reftable/describe/.gitted/reftable/0x000000000001-0x00000000000e-7064cca6.ref differ diff --git a/tests/resources/reftable/describe/.gitted/reftable/tables.list b/tests/resources/reftable/describe/.gitted/reftable/tables.list new file mode 100644 index 000000000..aa957c80a --- /dev/null +++ b/tests/resources/reftable/describe/.gitted/reftable/tables.list @@ -0,0 +1 @@ +0x000000000001-0x00000000000e-7064cca6.ref diff --git a/tests/resources/reftable/describe/another b/tests/resources/reftable/describe/another new file mode 100644 index 000000000..a3d00fa8a --- /dev/null +++ b/tests/resources/reftable/describe/another @@ -0,0 +1 @@ +DDD diff --git a/tests/resources/reftable/describe/file b/tests/resources/reftable/describe/file new file mode 100644 index 000000000..fd66be08d --- /dev/null +++ b/tests/resources/reftable/describe/file @@ -0,0 +1 @@ +X diff --git a/tests/resources/reftable/describe/side b/tests/resources/reftable/describe/side new file mode 100644 index 000000000..fd66be08d --- /dev/null +++ b/tests/resources/reftable/describe/side @@ -0,0 +1 @@ +X diff --git a/tests/resources/reftable/diff/.gitted/HEAD b/tests/resources/reftable/diff/.gitted/HEAD new file mode 100644 index 000000000..fe6d7e5fa --- /dev/null +++ b/tests/resources/reftable/diff/.gitted/HEAD @@ -0,0 +1 @@ +ref: refs/heads/.invalid diff --git a/tests/resources/reftable/diff/.gitted/config b/tests/resources/reftable/diff/.gitted/config new file mode 100644 index 000000000..a144490a1 --- /dev/null +++ b/tests/resources/reftable/diff/.gitted/config @@ -0,0 +1,8 @@ +[core] + repositoryformatversion = 1 + filemode = true + bare = false + logallrefupdates = true + ignorecase = false +[extensions] + refstorage = reftable diff --git a/tests/resources/reftable/diff/.gitted/description b/tests/resources/reftable/diff/.gitted/description new file mode 100644 index 000000000..498b267a8 --- /dev/null +++ b/tests/resources/reftable/diff/.gitted/description @@ -0,0 +1 @@ +Unnamed repository; edit this file 'description' to name the repository. diff --git a/tests/resources/reftable/diff/.gitted/index b/tests/resources/reftable/diff/.gitted/index new file mode 100644 index 000000000..e1071874e Binary files /dev/null and b/tests/resources/reftable/diff/.gitted/index differ diff --git a/tests/resources/reftable/diff/.gitted/info/exclude b/tests/resources/reftable/diff/.gitted/info/exclude new file mode 100644 index 000000000..a5196d1be --- /dev/null +++ b/tests/resources/reftable/diff/.gitted/info/exclude @@ -0,0 +1,6 @@ +# git ls-files --others --exclude-from=.git/info/exclude +# Lines that start with '#' are comments. +# For a project mostly in C, the following would be a good set of +# exclude patterns (uncomment them if you want to use them): +# *.[oa] +# *~ diff --git a/tests/resources/reftable/diff/.gitted/objects/29/ab7053bb4dde0298e03e2c179e890b7dd465a7 b/tests/resources/reftable/diff/.gitted/objects/29/ab7053bb4dde0298e03e2c179e890b7dd465a7 new file mode 100644 index 000000000..94f9a676d Binary files /dev/null and b/tests/resources/reftable/diff/.gitted/objects/29/ab7053bb4dde0298e03e2c179e890b7dd465a7 differ diff --git a/tests/resources/reftable/diff/.gitted/objects/3e/5bcbad2a68e5bc60a53b8388eea53a1a7ab847 b/tests/resources/reftable/diff/.gitted/objects/3e/5bcbad2a68e5bc60a53b8388eea53a1a7ab847 new file mode 100644 index 000000000..9fed523dc Binary files /dev/null and b/tests/resources/reftable/diff/.gitted/objects/3e/5bcbad2a68e5bc60a53b8388eea53a1a7ab847 differ diff --git a/tests/resources/reftable/diff/.gitted/objects/54/6c735f16a3b44d9784075c2c0dab2ac9bf1989 b/tests/resources/reftable/diff/.gitted/objects/54/6c735f16a3b44d9784075c2c0dab2ac9bf1989 new file mode 100644 index 000000000..d7df4d6a1 Binary files /dev/null and b/tests/resources/reftable/diff/.gitted/objects/54/6c735f16a3b44d9784075c2c0dab2ac9bf1989 differ diff --git a/tests/resources/reftable/diff/.gitted/objects/7a/9e0b02e63179929fed24f0a3e0f19168114d10 b/tests/resources/reftable/diff/.gitted/objects/7a/9e0b02e63179929fed24f0a3e0f19168114d10 new file mode 100644 index 000000000..9bc25eb34 Binary files /dev/null and b/tests/resources/reftable/diff/.gitted/objects/7a/9e0b02e63179929fed24f0a3e0f19168114d10 differ diff --git a/tests/resources/reftable/diff/.gitted/objects/7b/808f723a8ca90df319682c221187235af76693 b/tests/resources/reftable/diff/.gitted/objects/7b/808f723a8ca90df319682c221187235af76693 new file mode 100644 index 000000000..2fd266be6 Binary files /dev/null and b/tests/resources/reftable/diff/.gitted/objects/7b/808f723a8ca90df319682c221187235af76693 differ diff --git a/tests/resources/reftable/diff/.gitted/objects/88/789109439c1e1c3cd45224001edee5304ed53c b/tests/resources/reftable/diff/.gitted/objects/88/789109439c1e1c3cd45224001edee5304ed53c new file mode 100644 index 000000000..7598b5914 --- /dev/null +++ b/tests/resources/reftable/diff/.gitted/objects/88/789109439c1e1c3cd45224001edee5304ed53c @@ -0,0 +1 @@ +x+)JMU07g040031QH/H-+(a)[wz {j%;ʊRSrS4W4そN+a \ No newline at end of file diff --git a/tests/resources/reftable/diff/.gitted/objects/cb/8294e696339863df760b2ff5d1e275bee72455 b/tests/resources/reftable/diff/.gitted/objects/cb/8294e696339863df760b2ff5d1e275bee72455 new file mode 100644 index 000000000..86ebe04fe Binary files /dev/null and b/tests/resources/reftable/diff/.gitted/objects/cb/8294e696339863df760b2ff5d1e275bee72455 differ diff --git a/tests/resources/reftable/diff/.gitted/objects/d7/0d245ed97ed2aa596dd1af6536e4bfdb047b69 b/tests/resources/reftable/diff/.gitted/objects/d7/0d245ed97ed2aa596dd1af6536e4bfdb047b69 new file mode 100644 index 000000000..99304c4aa --- /dev/null +++ b/tests/resources/reftable/diff/.gitted/objects/d7/0d245ed97ed2aa596dd1af6536e4bfdb047b69 @@ -0,0 +1 @@ +x !m_RB:XkVpWp 9{ ,^z#7JygԚA i1Y2VyR)𢒨'm[;-lO_#%v8 \ No newline at end of file diff --git a/tests/resources/reftable/diff/.gitted/refs/heads b/tests/resources/reftable/diff/.gitted/refs/heads new file mode 100644 index 000000000..3e639a56a --- /dev/null +++ b/tests/resources/reftable/diff/.gitted/refs/heads @@ -0,0 +1 @@ +this repository uses the reftable format diff --git a/tests/resources/reftable/diff/.gitted/reftable/0x000000000001-0x000000000002-2dabe91a.ref b/tests/resources/reftable/diff/.gitted/reftable/0x000000000001-0x000000000002-2dabe91a.ref new file mode 100644 index 000000000..addc2ce5b Binary files /dev/null and b/tests/resources/reftable/diff/.gitted/reftable/0x000000000001-0x000000000002-2dabe91a.ref differ diff --git a/tests/resources/reftable/diff/.gitted/reftable/tables.list b/tests/resources/reftable/diff/.gitted/reftable/tables.list new file mode 100644 index 000000000..0ae26185d --- /dev/null +++ b/tests/resources/reftable/diff/.gitted/reftable/tables.list @@ -0,0 +1 @@ +0x000000000001-0x000000000002-2dabe91a.ref diff --git a/tests/resources/reftable/diff/another.txt b/tests/resources/reftable/diff/another.txt new file mode 100644 index 000000000..d0e0bae4d --- /dev/null +++ b/tests/resources/reftable/diff/another.txt @@ -0,0 +1,38 @@ +Git is fast. With Git, nearly all operations are performed locally, giving +it an huge speed advantage on centralized systems that constantly have to +communicate with a server somewh3r3. + +For testing, large AWS instances were set up in the same availability +zone. Git and SVN were installed on both machines, the Ruby repository was +copied to both Git and SVN servers, and common operations were performed on +both. + +In some cases the commands don't match up exactly. Here, matching on the +lowest common denominator was attempted. For example, the 'commit' tests +also include the time to push for Git, though most of the time you would not +actually be pushing to the server immediately after a commit where the two +commands cannot be separated in SVN. + +Note that this is the best case scenario for SVN - a server with no load +with an 80MB/s bandwidth connection to the client machine. Nearly all of +these times would be even worse for SVN if that connection was slower, while +many of the Git times would not be affected. + +Clearly, in many of these common version control operations, Git is one or +two orders of magnitude faster than SVN, even under ideal conditions for +SVN. + +Let's see how common operations stack up against Subversion, a common +centralized version control system that is similar to CVS or +Perforce. Smaller is faster. + +One place where Git is slower is in the initial clone operation. Here, Git +One place where Git is slower is in the initial clone operation. Here, Git +One place where Git is slower is in the initial clone operation. Here, Git +seen in the above charts, it's not considerably slower for an operation that +is only performed once. + +It's also interesting to note that the size of the data on the client side +is very similar even though Git also has every version of every file for the +entire history of the project. This illustrates how efficient it is at +compressing and storing data on the client side. \ No newline at end of file diff --git a/tests/resources/reftable/diff/readme.txt b/tests/resources/reftable/diff/readme.txt new file mode 100644 index 000000000..beedf288d --- /dev/null +++ b/tests/resources/reftable/diff/readme.txt @@ -0,0 +1,36 @@ +The Git feature that r3ally mak3s it stand apart from n3arly 3v3ry other SCM +out there is its branching model. + +Git allows and encourages you to have multiple local branches that can be +entirely independent of each other. The creation, merging, and deletion of +those lines of development takes seconds. + +Git allows and encourages you to have multiple local branches that can be +entirely independent of each other. The creation, merging, and deletion of +those lines of development takes seconds. + +This means that you can do things like: + +Role-Bas3d Codelin3s. Have a branch that always contains only what goes to +production, another that you merge work into for testing, and several +smaller ones for day to day work. + +Feature Based Workflow. Create new branches for each new feature you're +working on so you can seamlessly switch back and forth between them, then +delete each branch when that feature gets merged into your main line. + +Disposable Experimentation. Create a branch to experiment in, realize it's +not going to work, and just delete it - abandoning the work—with nobody else +ever seeing it (even if you've pushed other branches in the meantime). + +Notably, when you push to a remote repository, you do not have to push all +share it with others. + +Git allows and encourages you to have multiple local branches that can be +entirely independent of each other. The creation, merging, and deletion of +those lines of development takes seconds. + +There are ways to accomplish some of this with other systems, but the work +involved is much more difficult and error-prone. Git makes this process +incredibly easy and it changes the way most developers work when they learn +it.! diff --git a/tests/resources/reftable/diff_format_email/.gitted/HEAD b/tests/resources/reftable/diff_format_email/.gitted/HEAD new file mode 100644 index 000000000..fe6d7e5fa --- /dev/null +++ b/tests/resources/reftable/diff_format_email/.gitted/HEAD @@ -0,0 +1 @@ +ref: refs/heads/.invalid diff --git a/tests/resources/reftable/diff_format_email/.gitted/config b/tests/resources/reftable/diff_format_email/.gitted/config new file mode 100644 index 000000000..622302e60 --- /dev/null +++ b/tests/resources/reftable/diff_format_email/.gitted/config @@ -0,0 +1,9 @@ +[core] + repositoryformatversion = 1 + filemode = true + bare = false + logallrefupdates = true + ignorecase = true + precomposeunicode = true +[extensions] + refstorage = reftable diff --git a/tests/resources/reftable/diff_format_email/.gitted/index b/tests/resources/reftable/diff_format_email/.gitted/index new file mode 100644 index 000000000..7053c2159 Binary files /dev/null and b/tests/resources/reftable/diff_format_email/.gitted/index differ diff --git a/tests/resources/reftable/diff_format_email/.gitted/info/exclude b/tests/resources/reftable/diff_format_email/.gitted/info/exclude new file mode 100644 index 000000000..a5196d1be --- /dev/null +++ b/tests/resources/reftable/diff_format_email/.gitted/info/exclude @@ -0,0 +1,6 @@ +# git ls-files --others --exclude-from=.git/info/exclude +# Lines that start with '#' are comments. +# For a project mostly in C, the following would be a good set of +# exclude patterns (uncomment them if you want to use them): +# *.[oa] +# *~ diff --git a/tests/resources/reftable/diff_format_email/.gitted/objects/06/b7b69a62cbd1e53c6c4e0c3f16473dcfdb4af6 b/tests/resources/reftable/diff_format_email/.gitted/objects/06/b7b69a62cbd1e53c6c4e0c3f16473dcfdb4af6 new file mode 100644 index 000000000..37588f169 Binary files /dev/null and b/tests/resources/reftable/diff_format_email/.gitted/objects/06/b7b69a62cbd1e53c6c4e0c3f16473dcfdb4af6 differ diff --git a/tests/resources/reftable/diff_format_email/.gitted/objects/07/594f324ebcf92902334c6016e30e716431dfbc b/tests/resources/reftable/diff_format_email/.gitted/objects/07/594f324ebcf92902334c6016e30e716431dfbc new file mode 100644 index 000000000..bd273796a Binary files /dev/null and b/tests/resources/reftable/diff_format_email/.gitted/objects/07/594f324ebcf92902334c6016e30e716431dfbc differ diff --git a/tests/resources/reftable/diff_format_email/.gitted/objects/0a/37045ca6d8503e9bcf06a12abbbc8e92664cce b/tests/resources/reftable/diff_format_email/.gitted/objects/0a/37045ca6d8503e9bcf06a12abbbc8e92664cce new file mode 100644 index 000000000..1ece99cde Binary files /dev/null and b/tests/resources/reftable/diff_format_email/.gitted/objects/0a/37045ca6d8503e9bcf06a12abbbc8e92664cce differ diff --git a/tests/resources/reftable/diff_format_email/.gitted/objects/0d/593fca18d1ab11deb6e8025c9fe417456fe883 b/tests/resources/reftable/diff_format_email/.gitted/objects/0d/593fca18d1ab11deb6e8025c9fe417456fe883 new file mode 100644 index 000000000..e49e10778 Binary files /dev/null and b/tests/resources/reftable/diff_format_email/.gitted/objects/0d/593fca18d1ab11deb6e8025c9fe417456fe883 differ diff --git a/tests/resources/reftable/diff_format_email/.gitted/objects/0d/b2a262bc8c5c3cba55254730045a8258da7a37 b/tests/resources/reftable/diff_format_email/.gitted/objects/0d/b2a262bc8c5c3cba55254730045a8258da7a37 new file mode 100644 index 000000000..1399d7f1a --- /dev/null +++ b/tests/resources/reftable/diff_format_email/.gitted/objects/0d/b2a262bc8c5c3cba55254730045a8258da7a37 @@ -0,0 +1,2 @@ +xA +0@Q9f6 ztBCm-i ?4VUS)EhET|}Bd66=&98Kƀ<Ɓd6*ܸՒfx4-ulp6鱗\z""k4w]yQPV2j>TI \ No newline at end of file diff --git a/tests/resources/reftable/diff_format_email/.gitted/objects/10/808fe9c9be5a190c0ba68d1a002233fb363508 b/tests/resources/reftable/diff_format_email/.gitted/objects/10/808fe9c9be5a190c0ba68d1a002233fb363508 new file mode 100644 index 000000000..90313feec Binary files /dev/null and b/tests/resources/reftable/diff_format_email/.gitted/objects/10/808fe9c9be5a190c0ba68d1a002233fb363508 differ diff --git a/tests/resources/reftable/diff_format_email/.gitted/objects/13/ecf3d572dbc5e5b32c8ba067d1d1e0939572e8 b/tests/resources/reftable/diff_format_email/.gitted/objects/13/ecf3d572dbc5e5b32c8ba067d1d1e0939572e8 new file mode 100644 index 000000000..360dc3bc7 Binary files /dev/null and b/tests/resources/reftable/diff_format_email/.gitted/objects/13/ecf3d572dbc5e5b32c8ba067d1d1e0939572e8 differ diff --git a/tests/resources/reftable/diff_format_email/.gitted/objects/17/cfad36e93db7706b16bef5ef842ba1e5ca06ab b/tests/resources/reftable/diff_format_email/.gitted/objects/17/cfad36e93db7706b16bef5ef842ba1e5ca06ab new file mode 100644 index 000000000..603aa496a Binary files /dev/null and b/tests/resources/reftable/diff_format_email/.gitted/objects/17/cfad36e93db7706b16bef5ef842ba1e5ca06ab differ diff --git a/tests/resources/reftable/diff_format_email/.gitted/objects/1a/9932083f96b0db42552103d40076f62fa8235e b/tests/resources/reftable/diff_format_email/.gitted/objects/1a/9932083f96b0db42552103d40076f62fa8235e new file mode 100644 index 000000000..b6f04538e Binary files /dev/null and b/tests/resources/reftable/diff_format_email/.gitted/objects/1a/9932083f96b0db42552103d40076f62fa8235e differ diff --git a/tests/resources/reftable/diff_format_email/.gitted/objects/1a/e3be57f869687d983066a0f5d2aaea1b82ddc5 b/tests/resources/reftable/diff_format_email/.gitted/objects/1a/e3be57f869687d983066a0f5d2aaea1b82ddc5 new file mode 100644 index 000000000..be85c78ba Binary files /dev/null and b/tests/resources/reftable/diff_format_email/.gitted/objects/1a/e3be57f869687d983066a0f5d2aaea1b82ddc5 differ diff --git a/tests/resources/reftable/diff_format_email/.gitted/objects/1b/525b0a6c5218b069b601ce91fce8eaf0a54e20 b/tests/resources/reftable/diff_format_email/.gitted/objects/1b/525b0a6c5218b069b601ce91fce8eaf0a54e20 new file mode 100644 index 000000000..e8145edfd Binary files /dev/null and b/tests/resources/reftable/diff_format_email/.gitted/objects/1b/525b0a6c5218b069b601ce91fce8eaf0a54e20 differ diff --git a/tests/resources/reftable/diff_format_email/.gitted/objects/1e/82c3b234e37da82e5b23e0e2a70bca68ee12c6 b/tests/resources/reftable/diff_format_email/.gitted/objects/1e/82c3b234e37da82e5b23e0e2a70bca68ee12c6 new file mode 100644 index 000000000..3ae87cfa9 Binary files /dev/null and b/tests/resources/reftable/diff_format_email/.gitted/objects/1e/82c3b234e37da82e5b23e0e2a70bca68ee12c6 differ diff --git a/tests/resources/reftable/diff_format_email/.gitted/objects/1e/875da9b1e67f853b2eec3e202c21c867097234 b/tests/resources/reftable/diff_format_email/.gitted/objects/1e/875da9b1e67f853b2eec3e202c21c867097234 new file mode 100644 index 000000000..f80b3612c Binary files /dev/null and b/tests/resources/reftable/diff_format_email/.gitted/objects/1e/875da9b1e67f853b2eec3e202c21c867097234 differ diff --git a/tests/resources/reftable/diff_format_email/.gitted/objects/20/609dbbc32bbfc827528eec3fcea2d024e6dd8a b/tests/resources/reftable/diff_format_email/.gitted/objects/20/609dbbc32bbfc827528eec3fcea2d024e6dd8a new file mode 100644 index 000000000..190c3f272 Binary files /dev/null and b/tests/resources/reftable/diff_format_email/.gitted/objects/20/609dbbc32bbfc827528eec3fcea2d024e6dd8a differ diff --git a/tests/resources/reftable/diff_format_email/.gitted/objects/23/f92946d3f38bd090f700d3e8e7b728ffc58264 b/tests/resources/reftable/diff_format_email/.gitted/objects/23/f92946d3f38bd090f700d3e8e7b728ffc58264 new file mode 100644 index 000000000..42f49ae8a Binary files /dev/null and b/tests/resources/reftable/diff_format_email/.gitted/objects/23/f92946d3f38bd090f700d3e8e7b728ffc58264 differ diff --git a/tests/resources/reftable/diff_format_email/.gitted/objects/24/97c5249408494e66e25070a8c74e49eaeeb6c3 b/tests/resources/reftable/diff_format_email/.gitted/objects/24/97c5249408494e66e25070a8c74e49eaeeb6c3 new file mode 100644 index 000000000..e1ede9ae9 Binary files /dev/null and b/tests/resources/reftable/diff_format_email/.gitted/objects/24/97c5249408494e66e25070a8c74e49eaeeb6c3 differ diff --git a/tests/resources/reftable/diff_format_email/.gitted/objects/24/9a4263be23b4d1c02484cb840b6eca4c6cf74d b/tests/resources/reftable/diff_format_email/.gitted/objects/24/9a4263be23b4d1c02484cb840b6eca4c6cf74d new file mode 100644 index 000000000..1b8d68951 Binary files /dev/null and b/tests/resources/reftable/diff_format_email/.gitted/objects/24/9a4263be23b4d1c02484cb840b6eca4c6cf74d differ diff --git a/tests/resources/reftable/diff_format_email/.gitted/objects/25/2a3e19fd2c6fb7b20c111142c5bd5fb9ea6b8e b/tests/resources/reftable/diff_format_email/.gitted/objects/25/2a3e19fd2c6fb7b20c111142c5bd5fb9ea6b8e new file mode 100644 index 000000000..10c34009d Binary files /dev/null and b/tests/resources/reftable/diff_format_email/.gitted/objects/25/2a3e19fd2c6fb7b20c111142c5bd5fb9ea6b8e differ diff --git a/tests/resources/reftable/diff_format_email/.gitted/objects/27/93544db9060bab4f9169e5b89c82f9fa7c7fa6 b/tests/resources/reftable/diff_format_email/.gitted/objects/27/93544db9060bab4f9169e5b89c82f9fa7c7fa6 new file mode 100644 index 000000000..689f5b9a1 Binary files /dev/null and b/tests/resources/reftable/diff_format_email/.gitted/objects/27/93544db9060bab4f9169e5b89c82f9fa7c7fa6 differ diff --git a/tests/resources/reftable/diff_format_email/.gitted/objects/29/1f1ff3cbb9a6f153678d9657679e3d4bf257df b/tests/resources/reftable/diff_format_email/.gitted/objects/29/1f1ff3cbb9a6f153678d9657679e3d4bf257df new file mode 100644 index 000000000..6af5dda9d Binary files /dev/null and b/tests/resources/reftable/diff_format_email/.gitted/objects/29/1f1ff3cbb9a6f153678d9657679e3d4bf257df differ diff --git a/tests/resources/reftable/diff_format_email/.gitted/objects/2f/f7b811eee62a73959350b1f7349f6f4d0c882d b/tests/resources/reftable/diff_format_email/.gitted/objects/2f/f7b811eee62a73959350b1f7349f6f4d0c882d new file mode 100644 index 000000000..d2b911d0e Binary files /dev/null and b/tests/resources/reftable/diff_format_email/.gitted/objects/2f/f7b811eee62a73959350b1f7349f6f4d0c882d differ diff --git a/tests/resources/reftable/diff_format_email/.gitted/objects/39/91dce9e71a0641ca49a6a4eea6c9e7ff402ed4 b/tests/resources/reftable/diff_format_email/.gitted/objects/39/91dce9e71a0641ca49a6a4eea6c9e7ff402ed4 new file mode 100644 index 000000000..69d213dcb Binary files /dev/null and b/tests/resources/reftable/diff_format_email/.gitted/objects/39/91dce9e71a0641ca49a6a4eea6c9e7ff402ed4 differ diff --git a/tests/resources/reftable/diff_format_email/.gitted/objects/39/ed6bbd76bca81c50db3aaca261456284f5d5b8 b/tests/resources/reftable/diff_format_email/.gitted/objects/39/ed6bbd76bca81c50db3aaca261456284f5d5b8 new file mode 100644 index 000000000..e08f03cf3 Binary files /dev/null and b/tests/resources/reftable/diff_format_email/.gitted/objects/39/ed6bbd76bca81c50db3aaca261456284f5d5b8 differ diff --git a/tests/resources/reftable/diff_format_email/.gitted/objects/45/eef2a9317e179984649de247269e38cd5d99cf b/tests/resources/reftable/diff_format_email/.gitted/objects/45/eef2a9317e179984649de247269e38cd5d99cf new file mode 100644 index 000000000..e5014565b --- /dev/null +++ b/tests/resources/reftable/diff_format_email/.gitted/objects/45/eef2a9317e179984649de247269e38cd5d99cf @@ -0,0 +1,2 @@ +xJ0ay_IIqwo0Lo+$&[zU&FY,:YCT8B UsH,BL)(r.ca }+^Y>mp՚_ sG)&k}GhzRļi* +Rrs X \ No newline at end of file diff --git a/tests/resources/reftable/diff_format_email/.gitted/objects/4a/076277b884c519a932be67e346db2ac80a98fa b/tests/resources/reftable/diff_format_email/.gitted/objects/4a/076277b884c519a932be67e346db2ac80a98fa new file mode 100644 index 000000000..b855408e8 Binary files /dev/null and b/tests/resources/reftable/diff_format_email/.gitted/objects/4a/076277b884c519a932be67e346db2ac80a98fa differ diff --git a/tests/resources/reftable/diff_format_email/.gitted/objects/4c/3bd7182ad66ea7aa20ba47ae82812b710d169c b/tests/resources/reftable/diff_format_email/.gitted/objects/4c/3bd7182ad66ea7aa20ba47ae82812b710d169c new file mode 100644 index 000000000..65740b42c Binary files /dev/null and b/tests/resources/reftable/diff_format_email/.gitted/objects/4c/3bd7182ad66ea7aa20ba47ae82812b710d169c differ diff --git a/tests/resources/reftable/diff_format_email/.gitted/objects/4c/a10087e696d2ba78d07b146a118e9a7096ed4f b/tests/resources/reftable/diff_format_email/.gitted/objects/4c/a10087e696d2ba78d07b146a118e9a7096ed4f new file mode 100644 index 000000000..b05e7d634 Binary files /dev/null and b/tests/resources/reftable/diff_format_email/.gitted/objects/4c/a10087e696d2ba78d07b146a118e9a7096ed4f differ diff --git a/tests/resources/reftable/diff_format_email/.gitted/objects/4d/de2b17d1c982cd988f21d24350a214401e4a1e b/tests/resources/reftable/diff_format_email/.gitted/objects/4d/de2b17d1c982cd988f21d24350a214401e4a1e new file mode 100644 index 000000000..57a8dfed1 Binary files /dev/null and b/tests/resources/reftable/diff_format_email/.gitted/objects/4d/de2b17d1c982cd988f21d24350a214401e4a1e differ diff --git a/tests/resources/reftable/diff_format_email/.gitted/objects/4f/31e0248ac800a1edc78b74f74e86f5eba90e87 b/tests/resources/reftable/diff_format_email/.gitted/objects/4f/31e0248ac800a1edc78b74f74e86f5eba90e87 new file mode 100644 index 000000000..0f31b97d6 Binary files /dev/null and b/tests/resources/reftable/diff_format_email/.gitted/objects/4f/31e0248ac800a1edc78b74f74e86f5eba90e87 differ diff --git a/tests/resources/reftable/diff_format_email/.gitted/objects/50/17c9456d013b2c7712d29aab73b681c880f509 b/tests/resources/reftable/diff_format_email/.gitted/objects/50/17c9456d013b2c7712d29aab73b681c880f509 new file mode 100644 index 000000000..5b96aa5ea Binary files /dev/null and b/tests/resources/reftable/diff_format_email/.gitted/objects/50/17c9456d013b2c7712d29aab73b681c880f509 differ diff --git a/tests/resources/reftable/diff_format_email/.gitted/objects/50/438cfa585c1d15cf3650ed1bf641da937cc261 b/tests/resources/reftable/diff_format_email/.gitted/objects/50/438cfa585c1d15cf3650ed1bf641da937cc261 new file mode 100644 index 000000000..8db9090bc Binary files /dev/null and b/tests/resources/reftable/diff_format_email/.gitted/objects/50/438cfa585c1d15cf3650ed1bf641da937cc261 differ diff --git a/tests/resources/reftable/diff_format_email/.gitted/objects/52/19b9784f9a92d7bd7cb567a6d6a21bfb86697e b/tests/resources/reftable/diff_format_email/.gitted/objects/52/19b9784f9a92d7bd7cb567a6d6a21bfb86697e new file mode 100644 index 000000000..534e3b07d Binary files /dev/null and b/tests/resources/reftable/diff_format_email/.gitted/objects/52/19b9784f9a92d7bd7cb567a6d6a21bfb86697e differ diff --git a/tests/resources/reftable/diff_format_email/.gitted/objects/52/c3cd1ff6234b95fecbaf9ef13624da17697b8d b/tests/resources/reftable/diff_format_email/.gitted/objects/52/c3cd1ff6234b95fecbaf9ef13624da17697b8d new file mode 100644 index 000000000..4bbc0ea43 Binary files /dev/null and b/tests/resources/reftable/diff_format_email/.gitted/objects/52/c3cd1ff6234b95fecbaf9ef13624da17697b8d differ diff --git a/tests/resources/reftable/diff_format_email/.gitted/objects/53/525d4cc3ef3ba4a5cbf69492fdffb4e4a74558 b/tests/resources/reftable/diff_format_email/.gitted/objects/53/525d4cc3ef3ba4a5cbf69492fdffb4e4a74558 new file mode 100644 index 000000000..b74d31f4f Binary files /dev/null and b/tests/resources/reftable/diff_format_email/.gitted/objects/53/525d4cc3ef3ba4a5cbf69492fdffb4e4a74558 differ diff --git a/tests/resources/reftable/diff_format_email/.gitted/objects/53/92ef3c959f744b892bbebb168bbbb7b05c03f3 b/tests/resources/reftable/diff_format_email/.gitted/objects/53/92ef3c959f744b892bbebb168bbbb7b05c03f3 new file mode 100644 index 000000000..308c599ab Binary files /dev/null and b/tests/resources/reftable/diff_format_email/.gitted/objects/53/92ef3c959f744b892bbebb168bbbb7b05c03f3 differ diff --git a/tests/resources/reftable/diff_format_email/.gitted/objects/55/0d730ba1b8c4937ea170b37c7ba91d792c0aaa b/tests/resources/reftable/diff_format_email/.gitted/objects/55/0d730ba1b8c4937ea170b37c7ba91d792c0aaa new file mode 100644 index 000000000..680e48762 Binary files /dev/null and b/tests/resources/reftable/diff_format_email/.gitted/objects/55/0d730ba1b8c4937ea170b37c7ba91d792c0aaa differ diff --git a/tests/resources/reftable/diff_format_email/.gitted/objects/62/7e7e12d87e07a83fad5b6bfa25e86ead4a5270 b/tests/resources/reftable/diff_format_email/.gitted/objects/62/7e7e12d87e07a83fad5b6bfa25e86ead4a5270 new file mode 100644 index 000000000..269a5bcf4 --- /dev/null +++ b/tests/resources/reftable/diff_format_email/.gitted/objects/62/7e7e12d87e07a83fad5b6bfa25e86ead4a5270 @@ -0,0 +1 @@ +xMN0YGر] !8@%$Nqb5#{Jq+`ޛE!*RR8=5(MT b)⺗AQގE3` W3- cZLO{}O3 Bh.Px쇾gޏ$;f\Ntkzc⊼O{|L3Hx5&hN]G5oxY ܺRL޾7SnG15jl׎׵~1f.f_* wt6 T; \ No newline at end of file diff --git a/tests/resources/reftable/diff_format_email/.gitted/objects/66/81f1844dc677e5ff07ffd993461f5c441e6af5 b/tests/resources/reftable/diff_format_email/.gitted/objects/66/81f1844dc677e5ff07ffd993461f5c441e6af5 new file mode 100644 index 000000000..86a38289b Binary files /dev/null and b/tests/resources/reftable/diff_format_email/.gitted/objects/66/81f1844dc677e5ff07ffd993461f5c441e6af5 differ diff --git a/tests/resources/reftable/diff_format_email/.gitted/objects/69/ddefb5c245e2f9ee62bd4cabd8ebe60a01e448 b/tests/resources/reftable/diff_format_email/.gitted/objects/69/ddefb5c245e2f9ee62bd4cabd8ebe60a01e448 new file mode 100644 index 000000000..81b606f4e Binary files /dev/null and b/tests/resources/reftable/diff_format_email/.gitted/objects/69/ddefb5c245e2f9ee62bd4cabd8ebe60a01e448 differ diff --git a/tests/resources/reftable/diff_format_email/.gitted/objects/6b/6c2067c6d968f9bddb9b900ee1ab7e5b067430 b/tests/resources/reftable/diff_format_email/.gitted/objects/6b/6c2067c6d968f9bddb9b900ee1ab7e5b067430 new file mode 100644 index 000000000..aa9d7b0cd --- /dev/null +++ b/tests/resources/reftable/diff_format_email/.gitted/objects/6b/6c2067c6d968f9bddb9b900ee1ab7e5b067430 @@ -0,0 +1,2 @@ +x; +1a X)$sD3{.+sšsj޵ 'fg=Cm⤄A LqGh~u$+g+H[^`ȏQW \ No newline at end of file diff --git a/tests/resources/reftable/diff_format_email/.gitted/objects/7a/de76dd34bba4733cf9878079f9fd4a456a9189 b/tests/resources/reftable/diff_format_email/.gitted/objects/7a/de76dd34bba4733cf9878079f9fd4a456a9189 new file mode 100644 index 000000000..cf9bdaa5f --- /dev/null +++ b/tests/resources/reftable/diff_format_email/.gitted/objects/7a/de76dd34bba4733cf9878079f9fd4a456a9189 @@ -0,0 +1,3 @@ +xA +0E]d4M"`m5IޢGp>X4aWn3 y ,[FHoD-e +:ёcz0FbCÊ:_HNcwRHqN'6xF {4j[j$0U_y*&R \ No newline at end of file diff --git a/tests/resources/reftable/diff_format_email/.gitted/objects/7a/ff11da95ca2be0bfb74b06e7cc1c480559dbe7 b/tests/resources/reftable/diff_format_email/.gitted/objects/7a/ff11da95ca2be0bfb74b06e7cc1c480559dbe7 new file mode 100644 index 000000000..d8c9934f7 Binary files /dev/null and b/tests/resources/reftable/diff_format_email/.gitted/objects/7a/ff11da95ca2be0bfb74b06e7cc1c480559dbe7 differ diff --git a/tests/resources/reftable/diff_format_email/.gitted/objects/7f/4c6d9d6ba363e3352f7c21807ca3a7835072b2 b/tests/resources/reftable/diff_format_email/.gitted/objects/7f/4c6d9d6ba363e3352f7c21807ca3a7835072b2 new file mode 100644 index 000000000..1be0e7927 --- /dev/null +++ b/tests/resources/reftable/diff_format_email/.gitted/objects/7f/4c6d9d6ba363e3352f7c21807ca3a7835072b2 @@ -0,0 +1 @@ +xKj1EьLZ[JǢR@vzO/@SNOfG!c+6+ ]ER \ No newline at end of file diff --git a/tests/resources/reftable/diff_format_email/.gitted/objects/8d/fa038554d5b682a51bda8ee3038cee6c63be76 b/tests/resources/reftable/diff_format_email/.gitted/objects/8d/fa038554d5b682a51bda8ee3038cee6c63be76 new file mode 100644 index 000000000..b5e08f901 Binary files /dev/null and b/tests/resources/reftable/diff_format_email/.gitted/objects/8d/fa038554d5b682a51bda8ee3038cee6c63be76 differ diff --git a/tests/resources/reftable/diff_format_email/.gitted/objects/8f/6fa527fd62979afab1d2346828c7e801daac32 b/tests/resources/reftable/diff_format_email/.gitted/objects/8f/6fa527fd62979afab1d2346828c7e801daac32 new file mode 100644 index 000000000..287367816 Binary files /dev/null and b/tests/resources/reftable/diff_format_email/.gitted/objects/8f/6fa527fd62979afab1d2346828c7e801daac32 differ diff --git a/tests/resources/reftable/diff_format_email/.gitted/objects/92/64b96c6d104d0e07ae33d3007b6a48246c6f92 b/tests/resources/reftable/diff_format_email/.gitted/objects/92/64b96c6d104d0e07ae33d3007b6a48246c6f92 new file mode 100644 index 000000000..75b047a64 Binary files /dev/null and b/tests/resources/reftable/diff_format_email/.gitted/objects/92/64b96c6d104d0e07ae33d3007b6a48246c6f92 differ diff --git a/tests/resources/reftable/diff_format_email/.gitted/objects/94/350226b3aa14efac831c803a51f7a09f3fc31a b/tests/resources/reftable/diff_format_email/.gitted/objects/94/350226b3aa14efac831c803a51f7a09f3fc31a new file mode 100644 index 000000000..a5286bc68 Binary files /dev/null and b/tests/resources/reftable/diff_format_email/.gitted/objects/94/350226b3aa14efac831c803a51f7a09f3fc31a differ diff --git a/tests/resources/reftable/diff_format_email/.gitted/objects/94/75e21dcbc515af8f641576400e4b450e5f4c03 b/tests/resources/reftable/diff_format_email/.gitted/objects/94/75e21dcbc515af8f641576400e4b450e5f4c03 new file mode 100644 index 000000000..9e26e34cd Binary files /dev/null and b/tests/resources/reftable/diff_format_email/.gitted/objects/94/75e21dcbc515af8f641576400e4b450e5f4c03 differ diff --git a/tests/resources/reftable/diff_format_email/.gitted/objects/94/aaae8954e8bb613de636071da663a621695911 b/tests/resources/reftable/diff_format_email/.gitted/objects/94/aaae8954e8bb613de636071da663a621695911 new file mode 100644 index 000000000..5fc167e79 Binary files /dev/null and b/tests/resources/reftable/diff_format_email/.gitted/objects/94/aaae8954e8bb613de636071da663a621695911 differ diff --git a/tests/resources/reftable/diff_format_email/.gitted/objects/94/f84b3e65e8bcbe8bffef2c885339343a802dd4 b/tests/resources/reftable/diff_format_email/.gitted/objects/94/f84b3e65e8bcbe8bffef2c885339343a802dd4 new file mode 100644 index 000000000..03b484808 Binary files /dev/null and b/tests/resources/reftable/diff_format_email/.gitted/objects/94/f84b3e65e8bcbe8bffef2c885339343a802dd4 differ diff --git a/tests/resources/reftable/diff_format_email/.gitted/objects/9a/2d780ac2ea0aeabdb9d2a876e6bbfff17b2c44 b/tests/resources/reftable/diff_format_email/.gitted/objects/9a/2d780ac2ea0aeabdb9d2a876e6bbfff17b2c44 new file mode 100644 index 000000000..be48c275e Binary files /dev/null and b/tests/resources/reftable/diff_format_email/.gitted/objects/9a/2d780ac2ea0aeabdb9d2a876e6bbfff17b2c44 differ diff --git a/tests/resources/reftable/diff_format_email/.gitted/objects/9a/c0329b8b7a4046210d8b8b02ac02055667de63 b/tests/resources/reftable/diff_format_email/.gitted/objects/9a/c0329b8b7a4046210d8b8b02ac02055667de63 new file mode 100644 index 000000000..f322a7ce4 Binary files /dev/null and b/tests/resources/reftable/diff_format_email/.gitted/objects/9a/c0329b8b7a4046210d8b8b02ac02055667de63 differ diff --git a/tests/resources/reftable/diff_format_email/.gitted/objects/9a/c35ff15cd8864aeafd889e4826a3150f0b06c4 b/tests/resources/reftable/diff_format_email/.gitted/objects/9a/c35ff15cd8864aeafd889e4826a3150f0b06c4 new file mode 100644 index 000000000..75cd71426 Binary files /dev/null and b/tests/resources/reftable/diff_format_email/.gitted/objects/9a/c35ff15cd8864aeafd889e4826a3150f0b06c4 differ diff --git a/tests/resources/reftable/diff_format_email/.gitted/objects/9b/997daca2a0beb5cc44b32c64f100a9a26d4d4b b/tests/resources/reftable/diff_format_email/.gitted/objects/9b/997daca2a0beb5cc44b32c64f100a9a26d4d4b new file mode 100644 index 000000000..d84ab8dcc Binary files /dev/null and b/tests/resources/reftable/diff_format_email/.gitted/objects/9b/997daca2a0beb5cc44b32c64f100a9a26d4d4b differ diff --git a/tests/resources/reftable/diff_format_email/.gitted/objects/a3/ac918e3a6604294b239cb956363e83d71abb3b b/tests/resources/reftable/diff_format_email/.gitted/objects/a3/ac918e3a6604294b239cb956363e83d71abb3b new file mode 100644 index 000000000..a693df5c8 --- /dev/null +++ b/tests/resources/reftable/diff_format_email/.gitted/objects/a3/ac918e3a6604294b239cb956363e83d71abb3b @@ -0,0 +1 @@ +xMJ1@a9ETDf7 xJRD5^nm]ihbSK5p)RD.V|ۄԢEBR"rPKi6|6!;e}^yK7KC H桏)uҠ;hQK \ No newline at end of file diff --git a/tests/resources/reftable/diff_format_email/.gitted/objects/a5/ac978d4f2a1784f847f41223a34c3e78934238 b/tests/resources/reftable/diff_format_email/.gitted/objects/a5/ac978d4f2a1784f847f41223a34c3e78934238 new file mode 100644 index 000000000..f0483943b Binary files /dev/null and b/tests/resources/reftable/diff_format_email/.gitted/objects/a5/ac978d4f2a1784f847f41223a34c3e78934238 differ diff --git a/tests/resources/reftable/diff_format_email/.gitted/objects/a7/29eab45c84563135e8631d4010230bc0479f1f b/tests/resources/reftable/diff_format_email/.gitted/objects/a7/29eab45c84563135e8631d4010230bc0479f1f new file mode 100644 index 000000000..5c1faf009 Binary files /dev/null and b/tests/resources/reftable/diff_format_email/.gitted/objects/a7/29eab45c84563135e8631d4010230bc0479f1f differ diff --git a/tests/resources/reftable/diff_format_email/.gitted/objects/a7/a65f98355b5a7567bcc395f6f7936c9252cf57 b/tests/resources/reftable/diff_format_email/.gitted/objects/a7/a65f98355b5a7567bcc395f6f7936c9252cf57 new file mode 100644 index 000000000..36a4b7be6 Binary files /dev/null and b/tests/resources/reftable/diff_format_email/.gitted/objects/a7/a65f98355b5a7567bcc395f6f7936c9252cf57 differ diff --git a/tests/resources/reftable/diff_format_email/.gitted/objects/a9/7157a0d0571698728b6f2f7675b456c98c5961 b/tests/resources/reftable/diff_format_email/.gitted/objects/a9/7157a0d0571698728b6f2f7675b456c98c5961 new file mode 100644 index 000000000..3baf494be Binary files /dev/null and b/tests/resources/reftable/diff_format_email/.gitted/objects/a9/7157a0d0571698728b6f2f7675b456c98c5961 differ diff --git a/tests/resources/reftable/diff_format_email/.gitted/objects/af/8f41d0cb7a3079a8f8e231ea2ab8b97837ce13 b/tests/resources/reftable/diff_format_email/.gitted/objects/af/8f41d0cb7a3079a8f8e231ea2ab8b97837ce13 new file mode 100644 index 000000000..f0dcaa9ac Binary files /dev/null and b/tests/resources/reftable/diff_format_email/.gitted/objects/af/8f41d0cb7a3079a8f8e231ea2ab8b97837ce13 differ diff --git a/tests/resources/reftable/diff_format_email/.gitted/objects/b0/5cecf1949d192b6df852b3f71853ef820ee235 b/tests/resources/reftable/diff_format_email/.gitted/objects/b0/5cecf1949d192b6df852b3f71853ef820ee235 new file mode 100644 index 000000000..28e148f41 Binary files /dev/null and b/tests/resources/reftable/diff_format_email/.gitted/objects/b0/5cecf1949d192b6df852b3f71853ef820ee235 differ diff --git a/tests/resources/reftable/diff_format_email/.gitted/objects/b4/f457c219dbb3517be908d4e70f0ada2fd8b8f9 b/tests/resources/reftable/diff_format_email/.gitted/objects/b4/f457c219dbb3517be908d4e70f0ada2fd8b8f9 new file mode 100644 index 000000000..0c74e7696 Binary files /dev/null and b/tests/resources/reftable/diff_format_email/.gitted/objects/b4/f457c219dbb3517be908d4e70f0ada2fd8b8f9 differ diff --git a/tests/resources/reftable/diff_format_email/.gitted/objects/bb/07a00e58b260c4eb9a82f8afbc1d80ad9739bf b/tests/resources/reftable/diff_format_email/.gitted/objects/bb/07a00e58b260c4eb9a82f8afbc1d80ad9739bf new file mode 100644 index 000000000..d2cb6d0d6 Binary files /dev/null and b/tests/resources/reftable/diff_format_email/.gitted/objects/bb/07a00e58b260c4eb9a82f8afbc1d80ad9739bf differ diff --git a/tests/resources/reftable/diff_format_email/.gitted/objects/bd/474b2519cc15eab801ff851cc7d50f0dee49a1 b/tests/resources/reftable/diff_format_email/.gitted/objects/bd/474b2519cc15eab801ff851cc7d50f0dee49a1 new file mode 100644 index 000000000..2dc82087b Binary files /dev/null and b/tests/resources/reftable/diff_format_email/.gitted/objects/bd/474b2519cc15eab801ff851cc7d50f0dee49a1 differ diff --git a/tests/resources/reftable/diff_format_email/.gitted/objects/bd/f7ba6bc5c4e57ca6595928dcbe6753c8a663ff b/tests/resources/reftable/diff_format_email/.gitted/objects/bd/f7ba6bc5c4e57ca6595928dcbe6753c8a663ff new file mode 100644 index 000000000..af0232aa1 Binary files /dev/null and b/tests/resources/reftable/diff_format_email/.gitted/objects/bd/f7ba6bc5c4e57ca6595928dcbe6753c8a663ff differ diff --git a/tests/resources/reftable/diff_format_email/.gitted/objects/c7/1a05d36025c806496a74d46d7d596eb23295c4 b/tests/resources/reftable/diff_format_email/.gitted/objects/c7/1a05d36025c806496a74d46d7d596eb23295c4 new file mode 100644 index 000000000..2822fe3e4 Binary files /dev/null and b/tests/resources/reftable/diff_format_email/.gitted/objects/c7/1a05d36025c806496a74d46d7d596eb23295c4 differ diff --git a/tests/resources/reftable/diff_format_email/.gitted/objects/cb/a89408dc016f4caddb6dc886fcb58f587a78df b/tests/resources/reftable/diff_format_email/.gitted/objects/cb/a89408dc016f4caddb6dc886fcb58f587a78df new file mode 100644 index 000000000..e03c74935 --- /dev/null +++ b/tests/resources/reftable/diff_format_email/.gitted/objects/cb/a89408dc016f4caddb6dc886fcb58f587a78df @@ -0,0 +1,3 @@ +xK +0FaYE悤Cq&8t7[![p NĹIM~* }ʬ'lilxqԤw6kK +cX̱ ^0Wy^+ja,㲴:rCYvttZUOrRbmᯈc$M \ No newline at end of file diff --git a/tests/resources/reftable/diff_format_email/.gitted/objects/cd/471f0d8770371e1bc78bcbb38db4c7e4106bd2 b/tests/resources/reftable/diff_format_email/.gitted/objects/cd/471f0d8770371e1bc78bcbb38db4c7e4106bd2 new file mode 100644 index 000000000..155b45273 Binary files /dev/null and b/tests/resources/reftable/diff_format_email/.gitted/objects/cd/471f0d8770371e1bc78bcbb38db4c7e4106bd2 differ diff --git a/tests/resources/reftable/diff_format_email/.gitted/objects/cd/ed722d05305c6b181f188c118d2d9810f39bb8 b/tests/resources/reftable/diff_format_email/.gitted/objects/cd/ed722d05305c6b181f188c118d2d9810f39bb8 new file mode 100644 index 000000000..fd9363612 Binary files /dev/null and b/tests/resources/reftable/diff_format_email/.gitted/objects/cd/ed722d05305c6b181f188c118d2d9810f39bb8 differ diff --git a/tests/resources/reftable/diff_format_email/.gitted/objects/ce/2792fcae8d704a56901754a0583a7418a21d8a b/tests/resources/reftable/diff_format_email/.gitted/objects/ce/2792fcae8d704a56901754a0583a7418a21d8a new file mode 100644 index 000000000..5863cec1b Binary files /dev/null and b/tests/resources/reftable/diff_format_email/.gitted/objects/ce/2792fcae8d704a56901754a0583a7418a21d8a differ diff --git a/tests/resources/reftable/diff_format_email/.gitted/objects/d1/4aa252e52a709d03a3d3d0d965e177eb0a674e b/tests/resources/reftable/diff_format_email/.gitted/objects/d1/4aa252e52a709d03a3d3d0d965e177eb0a674e new file mode 100644 index 000000000..a5d4d78e9 --- /dev/null +++ b/tests/resources/reftable/diff_format_email/.gitted/objects/d1/4aa252e52a709d03a3d3d0d965e177eb0a674e @@ -0,0 +1 @@ +x+)JMU01e040075UHI5+(+JKMMaXYB،|-a'{"z \ No newline at end of file diff --git a/tests/resources/reftable/diff_format_email/.gitted/objects/d3/b6b38486f620b5b532a8cc6e0198ab7c3f52e4 b/tests/resources/reftable/diff_format_email/.gitted/objects/d3/b6b38486f620b5b532a8cc6e0198ab7c3f52e4 new file mode 100644 index 000000000..5b2e664f4 Binary files /dev/null and b/tests/resources/reftable/diff_format_email/.gitted/objects/d3/b6b38486f620b5b532a8cc6e0198ab7c3f52e4 differ diff --git a/tests/resources/reftable/diff_format_email/.gitted/objects/d5/ff67764c82f729b13c26a09576570d884d9687 b/tests/resources/reftable/diff_format_email/.gitted/objects/d5/ff67764c82f729b13c26a09576570d884d9687 new file mode 100644 index 000000000..e838eeb25 Binary files /dev/null and b/tests/resources/reftable/diff_format_email/.gitted/objects/d5/ff67764c82f729b13c26a09576570d884d9687 differ diff --git a/tests/resources/reftable/diff_format_email/.gitted/objects/d7/bb447df12c6a8aba8727005482fb211f11297a b/tests/resources/reftable/diff_format_email/.gitted/objects/d7/bb447df12c6a8aba8727005482fb211f11297a new file mode 100644 index 000000000..85eb8141c Binary files /dev/null and b/tests/resources/reftable/diff_format_email/.gitted/objects/d7/bb447df12c6a8aba8727005482fb211f11297a differ diff --git a/tests/resources/reftable/diff_format_email/.gitted/objects/db/e8727e4806ae88ccc3f0755cae8f8cb7efa2cc b/tests/resources/reftable/diff_format_email/.gitted/objects/db/e8727e4806ae88ccc3f0755cae8f8cb7efa2cc new file mode 100644 index 000000000..8e250ece2 Binary files /dev/null and b/tests/resources/reftable/diff_format_email/.gitted/objects/db/e8727e4806ae88ccc3f0755cae8f8cb7efa2cc differ diff --git a/tests/resources/reftable/diff_format_email/.gitted/objects/e1/2af77c510e8ce4c261a3758736109c2c2dd1f0 b/tests/resources/reftable/diff_format_email/.gitted/objects/e1/2af77c510e8ce4c261a3758736109c2c2dd1f0 new file mode 100644 index 000000000..92a89a2cf Binary files /dev/null and b/tests/resources/reftable/diff_format_email/.gitted/objects/e1/2af77c510e8ce4c261a3758736109c2c2dd1f0 differ diff --git a/tests/resources/reftable/diff_format_email/.gitted/objects/e6/9de29bb2d1d6434b8b29ae775ad8c2e48c5391 b/tests/resources/reftable/diff_format_email/.gitted/objects/e6/9de29bb2d1d6434b8b29ae775ad8c2e48c5391 new file mode 100644 index 000000000..711223894 Binary files /dev/null and b/tests/resources/reftable/diff_format_email/.gitted/objects/e6/9de29bb2d1d6434b8b29ae775ad8c2e48c5391 differ diff --git a/tests/resources/reftable/diff_format_email/.gitted/objects/e9/091231467304a5ef112de02361d795ef051ee1 b/tests/resources/reftable/diff_format_email/.gitted/objects/e9/091231467304a5ef112de02361d795ef051ee1 new file mode 100644 index 000000000..43a006231 Binary files /dev/null and b/tests/resources/reftable/diff_format_email/.gitted/objects/e9/091231467304a5ef112de02361d795ef051ee1 differ diff --git a/tests/resources/reftable/diff_format_email/.gitted/objects/eb/d0b64ca4dd3e5dbcd9d1a12a1f2b84f893a22d b/tests/resources/reftable/diff_format_email/.gitted/objects/eb/d0b64ca4dd3e5dbcd9d1a12a1f2b84f893a22d new file mode 100644 index 000000000..0515fd8dd Binary files /dev/null and b/tests/resources/reftable/diff_format_email/.gitted/objects/eb/d0b64ca4dd3e5dbcd9d1a12a1f2b84f893a22d differ diff --git a/tests/resources/reftable/diff_format_email/.gitted/objects/ee/251372f131d82e575f16fe51c778406d88f8c2 b/tests/resources/reftable/diff_format_email/.gitted/objects/ee/251372f131d82e575f16fe51c778406d88f8c2 new file mode 100644 index 000000000..ee1edad9a --- /dev/null +++ b/tests/resources/reftable/diff_format_email/.gitted/objects/ee/251372f131d82e575f16fe51c778406d88f8c2 @@ -0,0 +1,2 @@ +xM +0@a9Ed3+o)-x4Imp*9Su$\0Nuؐ1^%u/X$e,BPLK# 9FpPĵ S^+/u,˰~y|~^Z-CƓHh^iĦj"R,HrK \ No newline at end of file diff --git a/tests/resources/reftable/diff_format_email/.gitted/objects/f3/d35bd592fefd8280fc0c302fa9f27dbdd721a3 b/tests/resources/reftable/diff_format_email/.gitted/objects/f3/d35bd592fefd8280fc0c302fa9f27dbdd721a3 new file mode 100644 index 000000000..62d747cf6 --- /dev/null +++ b/tests/resources/reftable/diff_format_email/.gitted/objects/f3/d35bd592fefd8280fc0c302fa9f27dbdd721a3 @@ -0,0 +1 @@ +xA @Qלb&fhi)1bA1b#L&=ۿx?̥dN*3x`C]p-&H]ScpYk|[LB0Yq4Qu] ;KlHB \ No newline at end of file diff --git a/tests/resources/reftable/diff_format_email/.gitted/objects/f4/07be01334e07bfb8f57cd2078f0ee3eb61e085 b/tests/resources/reftable/diff_format_email/.gitted/objects/f4/07be01334e07bfb8f57cd2078f0ee3eb61e085 new file mode 100644 index 000000000..d858a87b5 --- /dev/null +++ b/tests/resources/reftable/diff_format_email/.gitted/objects/f4/07be01334e07bfb8f57cd2078f0ee3eb61e085 @@ -0,0 +1 @@ +xMN0 @a98HCBNvL~ܞ8omkЫ*pń31M6L1'4'rJ\!bk=Kts zgd!6mmir[u.^ѫM, \ No newline at end of file diff --git a/tests/resources/reftable/grafted.git/objects/6c/f192eb71cd3243c9fbbe2551012c4449de3fcf b/tests/resources/reftable/grafted.git/objects/6c/f192eb71cd3243c9fbbe2551012c4449de3fcf new file mode 100644 index 000000000..a437f2432 Binary files /dev/null and b/tests/resources/reftable/grafted.git/objects/6c/f192eb71cd3243c9fbbe2551012c4449de3fcf differ diff --git a/tests/resources/reftable/grafted.git/objects/7c/9da502b2744b70522bb694cd607fb00104a233 b/tests/resources/reftable/grafted.git/objects/7c/9da502b2744b70522bb694cd607fb00104a233 new file mode 100644 index 000000000..b363584fd Binary files /dev/null and b/tests/resources/reftable/grafted.git/objects/7c/9da502b2744b70522bb694cd607fb00104a233 differ diff --git a/tests/resources/reftable/grafted.git/objects/8a/00e91619098618be97c0d2ceabb05a2c58edd9 b/tests/resources/reftable/grafted.git/objects/8a/00e91619098618be97c0d2ceabb05a2c58edd9 new file mode 100644 index 000000000..887778a60 --- /dev/null +++ b/tests/resources/reftable/grafted.git/objects/8a/00e91619098618be97c0d2ceabb05a2c58edd9 @@ -0,0 +1,2 @@ +xA +0E]t4Dt <$@J#ч@B5@b$'[ig&V/^6H ]J<AbH,2ȎSne{R˶T8ovשp |d~_u1 RŨߚNC \ No newline at end of file diff --git a/tests/resources/reftable/grafted.git/objects/a0/4de168dd5c43aa2af594d794d62e922f8b3b34 b/tests/resources/reftable/grafted.git/objects/a0/4de168dd5c43aa2af594d794d62e922f8b3b34 new file mode 100644 index 000000000..1ed3ed906 Binary files /dev/null and b/tests/resources/reftable/grafted.git/objects/a0/4de168dd5c43aa2af594d794d62e922f8b3b34 differ diff --git a/tests/resources/reftable/grafted.git/objects/b2/b4f9e5fe5dacbb2f98bd71d1dc86c7b571ddd1 b/tests/resources/reftable/grafted.git/objects/b2/b4f9e5fe5dacbb2f98bd71d1dc86c7b571ddd1 new file mode 100644 index 000000000..2adc85721 Binary files /dev/null and b/tests/resources/reftable/grafted.git/objects/b2/b4f9e5fe5dacbb2f98bd71d1dc86c7b571ddd1 differ diff --git a/tests/resources/reftable/grafted.git/objects/ba/54010f8d41532eb130eba420f50248881f7fc2 b/tests/resources/reftable/grafted.git/objects/ba/54010f8d41532eb130eba420f50248881f7fc2 new file mode 100644 index 000000000..52a887274 Binary files /dev/null and b/tests/resources/reftable/grafted.git/objects/ba/54010f8d41532eb130eba420f50248881f7fc2 differ diff --git a/tests/resources/reftable/grafted.git/objects/d7/224d49d6d5aff6ade596ed74f4bcd4f77b29e2 b/tests/resources/reftable/grafted.git/objects/d7/224d49d6d5aff6ade596ed74f4bcd4f77b29e2 new file mode 100644 index 000000000..5b41b6778 --- /dev/null +++ b/tests/resources/reftable/grafted.git/objects/d7/224d49d6d5aff6ade596ed74f4bcd4f77b29e2 @@ -0,0 +1,2 @@ +xA +0E]dҐDx=$hI_Gp/Ԁ,"%p&/1ތԓƀq֓z"ZMG%6co|Ϝ(^8IJr^kú|e.|mѠuH*lW%Q%Y ZڧbUoaRj \ No newline at end of file diff --git a/tests/resources/reftable/grafted.git/objects/db/8e43f297a313c439530c977b733aaa8c10d54e b/tests/resources/reftable/grafted.git/objects/db/8e43f297a313c439530c977b733aaa8c10d54e new file mode 100644 index 000000000..b9cf5947b Binary files /dev/null and b/tests/resources/reftable/grafted.git/objects/db/8e43f297a313c439530c977b733aaa8c10d54e differ diff --git a/tests/resources/reftable/grafted.git/objects/e4/14f42f4e6bc6934563a2349a8600f0ab68618e b/tests/resources/reftable/grafted.git/objects/e4/14f42f4e6bc6934563a2349a8600f0ab68618e new file mode 100644 index 000000000..1a14959c4 Binary files /dev/null and b/tests/resources/reftable/grafted.git/objects/e4/14f42f4e6bc6934563a2349a8600f0ab68618e differ diff --git a/tests/resources/reftable/grafted.git/objects/e6/7b587a57850c69f6f9351ee10c7c8a41dacc78 b/tests/resources/reftable/grafted.git/objects/e6/7b587a57850c69f6f9351ee10c7c8a41dacc78 new file mode 100644 index 000000000..213f9ac22 Binary files /dev/null and b/tests/resources/reftable/grafted.git/objects/e6/7b587a57850c69f6f9351ee10c7c8a41dacc78 differ diff --git a/tests/resources/reftable/grafted.git/objects/f0/7330bc2e4ed4bd0bf2301505f6c6bbad01aa2a b/tests/resources/reftable/grafted.git/objects/f0/7330bc2e4ed4bd0bf2301505f6c6bbad01aa2a new file mode 100644 index 000000000..f2d648892 Binary files /dev/null and b/tests/resources/reftable/grafted.git/objects/f0/7330bc2e4ed4bd0bf2301505f6c6bbad01aa2a differ diff --git a/tests/resources/reftable/grafted.git/objects/f5/03807ffa920e407a600cfaee96b7152259acc7 b/tests/resources/reftable/grafted.git/objects/f5/03807ffa920e407a600cfaee96b7152259acc7 new file mode 100644 index 000000000..21436c177 --- /dev/null +++ b/tests/resources/reftable/grafted.git/objects/f5/03807ffa920e407a600cfaee96b7152259acc7 @@ -0,0 +1,2 @@ +xA +0E]J&6) @@#xZ)z{D/ɋMb9P&yyBF&7헙Qw =KPV;Oߖ:P+3Ə6Z+:Qw\Hy>zA \ No newline at end of file diff --git a/tests/resources/reftable/grafted.git/refs/heads b/tests/resources/reftable/grafted.git/refs/heads new file mode 100644 index 000000000..3e639a56a --- /dev/null +++ b/tests/resources/reftable/grafted.git/refs/heads @@ -0,0 +1 @@ +this repository uses the reftable format diff --git a/tests/resources/reftable/grafted.git/reftable/0x000000000001-0x000000000001-2faa4162.ref b/tests/resources/reftable/grafted.git/reftable/0x000000000001-0x000000000001-2faa4162.ref new file mode 100644 index 000000000..540f1cd5f Binary files /dev/null and b/tests/resources/reftable/grafted.git/reftable/0x000000000001-0x000000000001-2faa4162.ref differ diff --git a/tests/resources/reftable/grafted.git/reftable/tables.list b/tests/resources/reftable/grafted.git/reftable/tables.list new file mode 100644 index 000000000..fef4d0208 --- /dev/null +++ b/tests/resources/reftable/grafted.git/reftable/tables.list @@ -0,0 +1 @@ +0x000000000001-0x000000000001-2faa4162.ref diff --git a/tests/resources/reftable/icase/.gitted/HEAD b/tests/resources/reftable/icase/.gitted/HEAD new file mode 100644 index 000000000..fe6d7e5fa --- /dev/null +++ b/tests/resources/reftable/icase/.gitted/HEAD @@ -0,0 +1 @@ +ref: refs/heads/.invalid diff --git a/tests/resources/reftable/icase/.gitted/config b/tests/resources/reftable/icase/.gitted/config new file mode 100644 index 000000000..53ccf173f --- /dev/null +++ b/tests/resources/reftable/icase/.gitted/config @@ -0,0 +1,9 @@ +[core] + repositoryformatversion = 1 + filemode = true + bare = false + logallrefupdates = true + ignorecase = true + precomposeunicode = false +[extensions] + refstorage = reftable diff --git a/tests/resources/reftable/icase/.gitted/description b/tests/resources/reftable/icase/.gitted/description new file mode 100644 index 000000000..498b267a8 --- /dev/null +++ b/tests/resources/reftable/icase/.gitted/description @@ -0,0 +1 @@ +Unnamed repository; edit this file 'description' to name the repository. diff --git a/tests/resources/reftable/icase/.gitted/index b/tests/resources/reftable/icase/.gitted/index new file mode 100644 index 000000000..f8288ec13 Binary files /dev/null and b/tests/resources/reftable/icase/.gitted/index differ diff --git a/tests/resources/reftable/icase/.gitted/info/exclude b/tests/resources/reftable/icase/.gitted/info/exclude new file mode 100644 index 000000000..a5196d1be --- /dev/null +++ b/tests/resources/reftable/icase/.gitted/info/exclude @@ -0,0 +1,6 @@ +# git ls-files --others --exclude-from=.git/info/exclude +# Lines that start with '#' are comments. +# For a project mostly in C, the following would be a good set of +# exclude patterns (uncomment them if you want to use them): +# *.[oa] +# *~ diff --git a/tests/resources/reftable/icase/.gitted/objects/3e/257c57f136a1cb8f2b8e9a2e5bc8ec0258bdce b/tests/resources/reftable/icase/.gitted/objects/3e/257c57f136a1cb8f2b8e9a2e5bc8ec0258bdce new file mode 100644 index 000000000..10691c788 Binary files /dev/null and b/tests/resources/reftable/icase/.gitted/objects/3e/257c57f136a1cb8f2b8e9a2e5bc8ec0258bdce differ diff --git a/tests/resources/reftable/icase/.gitted/objects/4d/d6027d083575c7431396dc2a3174afeb393c93 b/tests/resources/reftable/icase/.gitted/objects/4d/d6027d083575c7431396dc2a3174afeb393c93 new file mode 100644 index 000000000..8ca70df17 Binary files /dev/null and b/tests/resources/reftable/icase/.gitted/objects/4d/d6027d083575c7431396dc2a3174afeb393c93 differ diff --git a/tests/resources/reftable/icase/.gitted/objects/62/e0af52c199ec731fe4ad230041cd3286192d49 b/tests/resources/reftable/icase/.gitted/objects/62/e0af52c199ec731fe4ad230041cd3286192d49 new file mode 100644 index 000000000..e264aeab3 Binary files /dev/null and b/tests/resources/reftable/icase/.gitted/objects/62/e0af52c199ec731fe4ad230041cd3286192d49 differ diff --git a/tests/resources/reftable/icase/.gitted/objects/76/d6e1d231b1085fcce151427e9899335de74be6 b/tests/resources/reftable/icase/.gitted/objects/76/d6e1d231b1085fcce151427e9899335de74be6 new file mode 100644 index 000000000..24a4b3ee3 --- /dev/null +++ b/tests/resources/reftable/icase/.gitted/objects/76/d6e1d231b1085fcce151427e9899335de74be6 @@ -0,0 +1,3 @@ +x 1ENӀc XdƉ&/usԛ8}2 SH, +am1ЋEѷ9CJ$ nܷA +bଃjO_SO9%)9 \ No newline at end of file diff --git a/tests/resources/reftable/icase/.gitted/objects/d4/4e18fb93b7107b5cd1b95d601591d77869a1b6 b/tests/resources/reftable/icase/.gitted/objects/d4/4e18fb93b7107b5cd1b95d601591d77869a1b6 new file mode 100644 index 000000000..32d8c499f Binary files /dev/null and b/tests/resources/reftable/icase/.gitted/objects/d4/4e18fb93b7107b5cd1b95d601591d77869a1b6 differ diff --git a/tests/resources/reftable/icase/.gitted/refs/heads b/tests/resources/reftable/icase/.gitted/refs/heads new file mode 100644 index 000000000..3e639a56a --- /dev/null +++ b/tests/resources/reftable/icase/.gitted/refs/heads @@ -0,0 +1 @@ +this repository uses the reftable format diff --git a/tests/resources/reftable/icase/.gitted/reftable/0x000000000001-0x000000000001-7e331181.ref b/tests/resources/reftable/icase/.gitted/reftable/0x000000000001-0x000000000001-7e331181.ref new file mode 100644 index 000000000..e3a9e7c02 Binary files /dev/null and b/tests/resources/reftable/icase/.gitted/reftable/0x000000000001-0x000000000001-7e331181.ref differ diff --git a/tests/resources/reftable/icase/.gitted/reftable/tables.list b/tests/resources/reftable/icase/.gitted/reftable/tables.list new file mode 100644 index 000000000..4ae640eaf --- /dev/null +++ b/tests/resources/reftable/icase/.gitted/reftable/tables.list @@ -0,0 +1 @@ +0x000000000001-0x000000000001-7e331181.ref diff --git a/tests/resources/reftable/icase/B b/tests/resources/reftable/icase/B new file mode 100644 index 000000000..d44e18fb9 --- /dev/null +++ b/tests/resources/reftable/icase/B @@ -0,0 +1 @@ +start diff --git a/tests/resources/reftable/icase/D b/tests/resources/reftable/icase/D new file mode 100644 index 000000000..d44e18fb9 --- /dev/null +++ b/tests/resources/reftable/icase/D @@ -0,0 +1 @@ +start diff --git a/tests/resources/reftable/icase/F b/tests/resources/reftable/icase/F new file mode 100644 index 000000000..d44e18fb9 --- /dev/null +++ b/tests/resources/reftable/icase/F @@ -0,0 +1 @@ +start diff --git a/tests/resources/reftable/icase/H b/tests/resources/reftable/icase/H new file mode 100644 index 000000000..d44e18fb9 --- /dev/null +++ b/tests/resources/reftable/icase/H @@ -0,0 +1 @@ +start diff --git a/tests/resources/reftable/icase/J b/tests/resources/reftable/icase/J new file mode 100644 index 000000000..d44e18fb9 --- /dev/null +++ b/tests/resources/reftable/icase/J @@ -0,0 +1 @@ +start diff --git a/tests/resources/reftable/icase/L/1 b/tests/resources/reftable/icase/L/1 new file mode 100644 index 000000000..62e0af52c --- /dev/null +++ b/tests/resources/reftable/icase/L/1 @@ -0,0 +1 @@ +sub diff --git a/tests/resources/reftable/icase/L/B b/tests/resources/reftable/icase/L/B new file mode 100644 index 000000000..62e0af52c --- /dev/null +++ b/tests/resources/reftable/icase/L/B @@ -0,0 +1 @@ +sub diff --git a/tests/resources/reftable/icase/L/D b/tests/resources/reftable/icase/L/D new file mode 100644 index 000000000..62e0af52c --- /dev/null +++ b/tests/resources/reftable/icase/L/D @@ -0,0 +1 @@ +sub diff --git a/tests/resources/reftable/icase/L/a b/tests/resources/reftable/icase/L/a new file mode 100644 index 000000000..62e0af52c --- /dev/null +++ b/tests/resources/reftable/icase/L/a @@ -0,0 +1 @@ +sub diff --git a/tests/resources/reftable/icase/L/c b/tests/resources/reftable/icase/L/c new file mode 100644 index 000000000..62e0af52c --- /dev/null +++ b/tests/resources/reftable/icase/L/c @@ -0,0 +1 @@ +sub diff --git a/tests/resources/reftable/icase/a b/tests/resources/reftable/icase/a new file mode 100644 index 000000000..d44e18fb9 --- /dev/null +++ b/tests/resources/reftable/icase/a @@ -0,0 +1 @@ +start diff --git a/tests/resources/reftable/icase/c b/tests/resources/reftable/icase/c new file mode 100644 index 000000000..d44e18fb9 --- /dev/null +++ b/tests/resources/reftable/icase/c @@ -0,0 +1 @@ +start diff --git a/tests/resources/reftable/icase/e b/tests/resources/reftable/icase/e new file mode 100644 index 000000000..d44e18fb9 --- /dev/null +++ b/tests/resources/reftable/icase/e @@ -0,0 +1 @@ +start diff --git a/tests/resources/reftable/icase/g b/tests/resources/reftable/icase/g new file mode 100644 index 000000000..d44e18fb9 --- /dev/null +++ b/tests/resources/reftable/icase/g @@ -0,0 +1 @@ +start diff --git a/tests/resources/reftable/icase/i b/tests/resources/reftable/icase/i new file mode 100644 index 000000000..d44e18fb9 --- /dev/null +++ b/tests/resources/reftable/icase/i @@ -0,0 +1 @@ +start diff --git a/tests/resources/reftable/icase/k/1 b/tests/resources/reftable/icase/k/1 new file mode 100644 index 000000000..62e0af52c --- /dev/null +++ b/tests/resources/reftable/icase/k/1 @@ -0,0 +1 @@ +sub diff --git a/tests/resources/reftable/icase/k/B b/tests/resources/reftable/icase/k/B new file mode 100644 index 000000000..62e0af52c --- /dev/null +++ b/tests/resources/reftable/icase/k/B @@ -0,0 +1 @@ +sub diff --git a/tests/resources/reftable/icase/k/D b/tests/resources/reftable/icase/k/D new file mode 100644 index 000000000..62e0af52c --- /dev/null +++ b/tests/resources/reftable/icase/k/D @@ -0,0 +1 @@ +sub diff --git a/tests/resources/reftable/icase/k/a b/tests/resources/reftable/icase/k/a new file mode 100644 index 000000000..62e0af52c --- /dev/null +++ b/tests/resources/reftable/icase/k/a @@ -0,0 +1 @@ +sub diff --git a/tests/resources/reftable/icase/k/c b/tests/resources/reftable/icase/k/c new file mode 100644 index 000000000..62e0af52c --- /dev/null +++ b/tests/resources/reftable/icase/k/c @@ -0,0 +1 @@ +sub diff --git a/tests/resources/reftable/indexv4/.gitted/HEAD b/tests/resources/reftable/indexv4/.gitted/HEAD new file mode 100644 index 000000000..fe6d7e5fa --- /dev/null +++ b/tests/resources/reftable/indexv4/.gitted/HEAD @@ -0,0 +1 @@ +ref: refs/heads/.invalid diff --git a/tests/resources/reftable/indexv4/.gitted/config b/tests/resources/reftable/indexv4/.gitted/config new file mode 100644 index 000000000..65e78696a --- /dev/null +++ b/tests/resources/reftable/indexv4/.gitted/config @@ -0,0 +1,7 @@ +[core] + repositoryformatversion = 1 + filemode = true + bare = false + logallrefupdates = true +[extensions] + refstorage = reftable diff --git a/tests/resources/reftable/indexv4/.gitted/index b/tests/resources/reftable/indexv4/.gitted/index new file mode 100644 index 000000000..e8fc61736 Binary files /dev/null and b/tests/resources/reftable/indexv4/.gitted/index differ diff --git a/tests/resources/reftable/indexv4/.gitted/objects/4c/9109b3e671d851eec87e0e72f6305b582e7e99 b/tests/resources/reftable/indexv4/.gitted/objects/4c/9109b3e671d851eec87e0e72f6305b582e7e99 new file mode 100644 index 000000000..cedd594b0 Binary files /dev/null and b/tests/resources/reftable/indexv4/.gitted/objects/4c/9109b3e671d851eec87e0e72f6305b582e7e99 differ diff --git a/tests/resources/reftable/indexv4/.gitted/objects/b0/952dbb50bed5f01e03e31b296184cb183e54a7 b/tests/resources/reftable/indexv4/.gitted/objects/b0/952dbb50bed5f01e03e31b296184cb183e54a7 new file mode 100644 index 000000000..0ddc1d1a9 Binary files /dev/null and b/tests/resources/reftable/indexv4/.gitted/objects/b0/952dbb50bed5f01e03e31b296184cb183e54a7 differ diff --git a/tests/resources/reftable/indexv4/.gitted/objects/e6/9de29bb2d1d6434b8b29ae775ad8c2e48c5391 b/tests/resources/reftable/indexv4/.gitted/objects/e6/9de29bb2d1d6434b8b29ae775ad8c2e48c5391 new file mode 100644 index 000000000..711223894 Binary files /dev/null and b/tests/resources/reftable/indexv4/.gitted/objects/e6/9de29bb2d1d6434b8b29ae775ad8c2e48c5391 differ diff --git a/tests/resources/reftable/indexv4/.gitted/refs/heads b/tests/resources/reftable/indexv4/.gitted/refs/heads new file mode 100644 index 000000000..3e639a56a --- /dev/null +++ b/tests/resources/reftable/indexv4/.gitted/refs/heads @@ -0,0 +1 @@ +this repository uses the reftable format diff --git a/tests/resources/reftable/indexv4/.gitted/reftable/0x000000000001-0x000000000001-973fa032.ref b/tests/resources/reftable/indexv4/.gitted/reftable/0x000000000001-0x000000000001-973fa032.ref new file mode 100644 index 000000000..a58e94d50 Binary files /dev/null and b/tests/resources/reftable/indexv4/.gitted/reftable/0x000000000001-0x000000000001-973fa032.ref differ diff --git a/tests/resources/reftable/indexv4/.gitted/reftable/tables.list b/tests/resources/reftable/indexv4/.gitted/reftable/tables.list new file mode 100644 index 000000000..2b30a7a6f --- /dev/null +++ b/tests/resources/reftable/indexv4/.gitted/reftable/tables.list @@ -0,0 +1 @@ +0x000000000001-0x000000000001-973fa032.ref diff --git a/tests/resources/reftable/indexv4/file.tx b/tests/resources/reftable/indexv4/file.tx new file mode 100644 index 000000000..e69de29bb diff --git a/tests/resources/reftable/indexv4/file.txt b/tests/resources/reftable/indexv4/file.txt new file mode 100644 index 000000000..e69de29bb diff --git a/tests/resources/reftable/indexv4/file.txz b/tests/resources/reftable/indexv4/file.txz new file mode 100644 index 000000000..e69de29bb diff --git a/tests/resources/reftable/indexv4/foo b/tests/resources/reftable/indexv4/foo new file mode 100644 index 000000000..e69de29bb diff --git a/tests/resources/reftable/indexv4/zzz b/tests/resources/reftable/indexv4/zzz new file mode 100644 index 000000000..e69de29bb diff --git a/tests/resources/reftable/issue_1397/.gitted/HEAD b/tests/resources/reftable/issue_1397/.gitted/HEAD new file mode 100644 index 000000000..fe6d7e5fa --- /dev/null +++ b/tests/resources/reftable/issue_1397/.gitted/HEAD @@ -0,0 +1 @@ +ref: refs/heads/.invalid diff --git a/tests/resources/reftable/issue_1397/.gitted/config b/tests/resources/reftable/issue_1397/.gitted/config new file mode 100644 index 000000000..143bbc961 --- /dev/null +++ b/tests/resources/reftable/issue_1397/.gitted/config @@ -0,0 +1,8 @@ +[core] + bare = false + repositoryformatversion = 1 + filemode = false + logallrefupdates = true + ignorecase = true +[extensions] + refstorage = reftable diff --git a/tests/resources/reftable/issue_1397/.gitted/index b/tests/resources/reftable/issue_1397/.gitted/index new file mode 100644 index 000000000..fa0f541d6 Binary files /dev/null and b/tests/resources/reftable/issue_1397/.gitted/index differ diff --git a/tests/resources/reftable/issue_1397/.gitted/objects/7f/483a738f867e5b21c8f377d70311f011eb48b5 b/tests/resources/reftable/issue_1397/.gitted/objects/7f/483a738f867e5b21c8f377d70311f011eb48b5 new file mode 100644 index 000000000..63bcb5d76 --- /dev/null +++ b/tests/resources/reftable/issue_1397/.gitted/objects/7f/483a738f867e5b21c8f377d70311f011eb48b5 @@ -0,0 +1,3 @@ +xQN0 as +!'nTBC+e\vӯǾofPPL8FΆ%_ċb4IܗtkULdeId<3/|0j1֣\Gcwe]~ߊS +)GxEqsUڇ8mk~yI \ No newline at end of file diff --git a/tests/resources/reftable/issue_1397/.gitted/objects/83/12e0889a9cbab77c732b6bc39b51a683e3a318 b/tests/resources/reftable/issue_1397/.gitted/objects/83/12e0889a9cbab77c732b6bc39b51a683e3a318 new file mode 100644 index 000000000..06b59fede Binary files /dev/null and b/tests/resources/reftable/issue_1397/.gitted/objects/83/12e0889a9cbab77c732b6bc39b51a683e3a318 differ diff --git a/tests/resources/reftable/issue_1397/.gitted/objects/8a/7ef047fc933edb62e84e7977b0612ec3f6f283 b/tests/resources/reftable/issue_1397/.gitted/objects/8a/7ef047fc933edb62e84e7977b0612ec3f6f283 new file mode 100644 index 000000000..19cfbeae2 Binary files /dev/null and b/tests/resources/reftable/issue_1397/.gitted/objects/8a/7ef047fc933edb62e84e7977b0612ec3f6f283 differ diff --git a/tests/resources/reftable/issue_1397/.gitted/objects/8e/8f80088a9274fd23584992f587083ca1bcbbac b/tests/resources/reftable/issue_1397/.gitted/objects/8e/8f80088a9274fd23584992f587083ca1bcbbac new file mode 100644 index 000000000..f5c776b17 Binary files /dev/null and b/tests/resources/reftable/issue_1397/.gitted/objects/8e/8f80088a9274fd23584992f587083ca1bcbbac differ diff --git a/tests/resources/reftable/issue_1397/.gitted/objects/f2/c62dea0372a0578e053697d5c1ba1ac05e774a b/tests/resources/reftable/issue_1397/.gitted/objects/f2/c62dea0372a0578e053697d5c1ba1ac05e774a new file mode 100644 index 000000000..f932f3618 Binary files /dev/null and b/tests/resources/reftable/issue_1397/.gitted/objects/f2/c62dea0372a0578e053697d5c1ba1ac05e774a differ diff --git a/tests/resources/reftable/issue_1397/.gitted/objects/ff/3578d64d199d5b48d92bbb569e0a273e411741 b/tests/resources/reftable/issue_1397/.gitted/objects/ff/3578d64d199d5b48d92bbb569e0a273e411741 new file mode 100644 index 000000000..fbd731727 Binary files /dev/null and b/tests/resources/reftable/issue_1397/.gitted/objects/ff/3578d64d199d5b48d92bbb569e0a273e411741 differ diff --git a/tests/resources/reftable/issue_1397/.gitted/refs/heads b/tests/resources/reftable/issue_1397/.gitted/refs/heads new file mode 100644 index 000000000..3e639a56a --- /dev/null +++ b/tests/resources/reftable/issue_1397/.gitted/refs/heads @@ -0,0 +1 @@ +this repository uses the reftable format diff --git a/tests/resources/reftable/issue_1397/.gitted/reftable/0x000000000001-0x000000000001-4f5ae694.ref b/tests/resources/reftable/issue_1397/.gitted/reftable/0x000000000001-0x000000000001-4f5ae694.ref new file mode 100644 index 000000000..98b560ead Binary files /dev/null and b/tests/resources/reftable/issue_1397/.gitted/reftable/0x000000000001-0x000000000001-4f5ae694.ref differ diff --git a/tests/resources/reftable/issue_1397/.gitted/reftable/tables.list b/tests/resources/reftable/issue_1397/.gitted/reftable/tables.list new file mode 100644 index 000000000..8ffab5e29 --- /dev/null +++ b/tests/resources/reftable/issue_1397/.gitted/reftable/tables.list @@ -0,0 +1 @@ +0x000000000001-0x000000000001-4f5ae694.ref diff --git a/tests/resources/reftable/issue_1397/crlf_file.txt b/tests/resources/reftable/issue_1397/crlf_file.txt new file mode 100644 index 000000000..8312e0889 --- /dev/null +++ b/tests/resources/reftable/issue_1397/crlf_file.txt @@ -0,0 +1,3 @@ +first line +second line +both with crlf \ No newline at end of file diff --git a/tests/resources/reftable/issue_1397/some_other_crlf_file.txt b/tests/resources/reftable/issue_1397/some_other_crlf_file.txt new file mode 100644 index 000000000..8e8f80088 --- /dev/null +++ b/tests/resources/reftable/issue_1397/some_other_crlf_file.txt @@ -0,0 +1,3 @@ +first line +second line with some change +both with crlf \ No newline at end of file diff --git a/tests/resources/reftable/issue_592/.gitted/COMMIT_EDITMSG b/tests/resources/reftable/issue_592/.gitted/COMMIT_EDITMSG new file mode 100644 index 000000000..5852f4463 --- /dev/null +++ b/tests/resources/reftable/issue_592/.gitted/COMMIT_EDITMSG @@ -0,0 +1 @@ +Initial commit diff --git a/tests/resources/reftable/issue_592/.gitted/HEAD b/tests/resources/reftable/issue_592/.gitted/HEAD new file mode 100644 index 000000000..fe6d7e5fa --- /dev/null +++ b/tests/resources/reftable/issue_592/.gitted/HEAD @@ -0,0 +1 @@ +ref: refs/heads/.invalid diff --git a/tests/resources/reftable/issue_592/.gitted/config b/tests/resources/reftable/issue_592/.gitted/config new file mode 100644 index 000000000..15959e7b7 --- /dev/null +++ b/tests/resources/reftable/issue_592/.gitted/config @@ -0,0 +1,10 @@ +[core] + repositoryformatversion = 1 + filemode = false + bare = false + logallrefupdates = true + symlinks = false + ignorecase = true + hideDotFiles = dotGitOnly +[extensions] + refstorage = reftable diff --git a/tests/resources/reftable/issue_592/.gitted/index b/tests/resources/reftable/issue_592/.gitted/index new file mode 100644 index 000000000..be7a29d99 Binary files /dev/null and b/tests/resources/reftable/issue_592/.gitted/index differ diff --git a/tests/resources/reftable/issue_592/.gitted/info/exclude b/tests/resources/reftable/issue_592/.gitted/info/exclude new file mode 100644 index 000000000..a5196d1be --- /dev/null +++ b/tests/resources/reftable/issue_592/.gitted/info/exclude @@ -0,0 +1,6 @@ +# git ls-files --others --exclude-from=.git/info/exclude +# Lines that start with '#' are comments. +# For a project mostly in C, the following would be a good set of +# exclude patterns (uncomment them if you want to use them): +# *.[oa] +# *~ diff --git a/tests/resources/reftable/issue_592/.gitted/objects/06/07ee9d4ccce8e4c4fa13c2c7d727e7faba4e0e b/tests/resources/reftable/issue_592/.gitted/objects/06/07ee9d4ccce8e4c4fa13c2c7d727e7faba4e0e new file mode 100644 index 000000000..05dec10f7 Binary files /dev/null and b/tests/resources/reftable/issue_592/.gitted/objects/06/07ee9d4ccce8e4c4fa13c2c7d727e7faba4e0e differ diff --git a/tests/resources/reftable/issue_592/.gitted/objects/49/363a72a90d9424240258cd3759f23788ecf1d8 b/tests/resources/reftable/issue_592/.gitted/objects/49/363a72a90d9424240258cd3759f23788ecf1d8 new file mode 100644 index 000000000..e997e1b49 Binary files /dev/null and b/tests/resources/reftable/issue_592/.gitted/objects/49/363a72a90d9424240258cd3759f23788ecf1d8 differ diff --git a/tests/resources/reftable/issue_592/.gitted/objects/4d/383e87f0371ba8fa353f3912db6862b2625e85 b/tests/resources/reftable/issue_592/.gitted/objects/4d/383e87f0371ba8fa353f3912db6862b2625e85 new file mode 100644 index 000000000..c49a8be58 --- /dev/null +++ b/tests/resources/reftable/issue_592/.gitted/objects/4d/383e87f0371ba8fa353f3912db6862b2625e85 @@ -0,0 +1,2 @@ +xM +0]o/IDz bz H9v2t =k,p+͏>4U=^(tAF2̟3sL|%cYuZv{=r_G}K> \ No newline at end of file diff --git a/tests/resources/reftable/issue_592/.gitted/objects/71/44be264b61825fbff68046fe999bdfe96a1792 b/tests/resources/reftable/issue_592/.gitted/objects/71/44be264b61825fbff68046fe999bdfe96a1792 new file mode 100644 index 000000000..25d44d938 Binary files /dev/null and b/tests/resources/reftable/issue_592/.gitted/objects/71/44be264b61825fbff68046fe999bdfe96a1792 differ diff --git a/tests/resources/reftable/issue_592/.gitted/objects/be/de83ee10b5b3f00239660b00acec2d55fd0b84 b/tests/resources/reftable/issue_592/.gitted/objects/be/de83ee10b5b3f00239660b00acec2d55fd0b84 new file mode 100644 index 000000000..1d6e38d37 Binary files /dev/null and b/tests/resources/reftable/issue_592/.gitted/objects/be/de83ee10b5b3f00239660b00acec2d55fd0b84 differ diff --git a/tests/resources/reftable/issue_592/.gitted/objects/e3/8fcc7a6060f5eb5b876e836b52ae4769363f21 b/tests/resources/reftable/issue_592/.gitted/objects/e3/8fcc7a6060f5eb5b876e836b52ae4769363f21 new file mode 100644 index 000000000..36c5b9aab Binary files /dev/null and b/tests/resources/reftable/issue_592/.gitted/objects/e3/8fcc7a6060f5eb5b876e836b52ae4769363f21 differ diff --git a/tests/resources/reftable/issue_592/.gitted/objects/f1/adef63cb08891a0942b76fc4b9c50c6c494bc7 b/tests/resources/reftable/issue_592/.gitted/objects/f1/adef63cb08891a0942b76fc4b9c50c6c494bc7 new file mode 100644 index 000000000..c08ecd5ed Binary files /dev/null and b/tests/resources/reftable/issue_592/.gitted/objects/f1/adef63cb08891a0942b76fc4b9c50c6c494bc7 differ diff --git a/tests/resources/reftable/issue_592/.gitted/refs/heads b/tests/resources/reftable/issue_592/.gitted/refs/heads new file mode 100644 index 000000000..3e639a56a --- /dev/null +++ b/tests/resources/reftable/issue_592/.gitted/refs/heads @@ -0,0 +1 @@ +this repository uses the reftable format diff --git a/tests/resources/reftable/issue_592/.gitted/reftable/0x000000000001-0x000000000002-bfcf19ef.ref b/tests/resources/reftable/issue_592/.gitted/reftable/0x000000000001-0x000000000002-bfcf19ef.ref new file mode 100644 index 000000000..b7eb30099 Binary files /dev/null and b/tests/resources/reftable/issue_592/.gitted/reftable/0x000000000001-0x000000000002-bfcf19ef.ref differ diff --git a/tests/resources/reftable/issue_592/.gitted/reftable/tables.list b/tests/resources/reftable/issue_592/.gitted/reftable/tables.list new file mode 100644 index 000000000..3c90016e9 --- /dev/null +++ b/tests/resources/reftable/issue_592/.gitted/reftable/tables.list @@ -0,0 +1 @@ +0x000000000001-0x000000000002-bfcf19ef.ref diff --git a/tests/resources/reftable/issue_592/a.txt b/tests/resources/reftable/issue_592/a.txt new file mode 100644 index 000000000..f1adef63c --- /dev/null +++ b/tests/resources/reftable/issue_592/a.txt @@ -0,0 +1 @@ +nothing here diff --git a/tests/resources/reftable/issue_592/c/a.txt b/tests/resources/reftable/issue_592/c/a.txt new file mode 100644 index 000000000..f1adef63c --- /dev/null +++ b/tests/resources/reftable/issue_592/c/a.txt @@ -0,0 +1 @@ +nothing here diff --git a/tests/resources/reftable/issue_592/l.txt b/tests/resources/reftable/issue_592/l.txt new file mode 100644 index 000000000..f1adef63c --- /dev/null +++ b/tests/resources/reftable/issue_592/l.txt @@ -0,0 +1 @@ +nothing here diff --git a/tests/resources/reftable/issue_592/t/a.txt b/tests/resources/reftable/issue_592/t/a.txt new file mode 100644 index 000000000..f1adef63c --- /dev/null +++ b/tests/resources/reftable/issue_592/t/a.txt @@ -0,0 +1 @@ +nothing here diff --git a/tests/resources/reftable/issue_592/t/b.txt b/tests/resources/reftable/issue_592/t/b.txt new file mode 100644 index 000000000..f1adef63c --- /dev/null +++ b/tests/resources/reftable/issue_592/t/b.txt @@ -0,0 +1 @@ +nothing here diff --git a/tests/resources/reftable/issue_592b/.gitted/HEAD b/tests/resources/reftable/issue_592b/.gitted/HEAD new file mode 100644 index 000000000..fe6d7e5fa --- /dev/null +++ b/tests/resources/reftable/issue_592b/.gitted/HEAD @@ -0,0 +1 @@ +ref: refs/heads/.invalid diff --git a/tests/resources/reftable/issue_592b/.gitted/config b/tests/resources/reftable/issue_592b/.gitted/config new file mode 100644 index 000000000..0694d84cb --- /dev/null +++ b/tests/resources/reftable/issue_592b/.gitted/config @@ -0,0 +1,8 @@ +[core] + repositoryformatversion = 1 + filemode = true + bare = false + logallrefupdates = true + ignorecase = true +[extensions] + refstorage = reftable diff --git a/tests/resources/reftable/issue_592b/.gitted/description b/tests/resources/reftable/issue_592b/.gitted/description new file mode 100644 index 000000000..498b267a8 --- /dev/null +++ b/tests/resources/reftable/issue_592b/.gitted/description @@ -0,0 +1 @@ +Unnamed repository; edit this file 'description' to name the repository. diff --git a/tests/resources/reftable/issue_592b/.gitted/index b/tests/resources/reftable/issue_592b/.gitted/index new file mode 100644 index 000000000..596438216 Binary files /dev/null and b/tests/resources/reftable/issue_592b/.gitted/index differ diff --git a/tests/resources/reftable/issue_592b/.gitted/info/exclude b/tests/resources/reftable/issue_592b/.gitted/info/exclude new file mode 100644 index 000000000..a5196d1be --- /dev/null +++ b/tests/resources/reftable/issue_592b/.gitted/info/exclude @@ -0,0 +1,6 @@ +# git ls-files --others --exclude-from=.git/info/exclude +# Lines that start with '#' are comments. +# For a project mostly in C, the following would be a good set of +# exclude patterns (uncomment them if you want to use them): +# *.[oa] +# *~ diff --git a/tests/resources/reftable/issue_592b/.gitted/objects/3f/bf1852f72fd268e36457b13a18cdd9a4c9ea35 b/tests/resources/reftable/issue_592b/.gitted/objects/3f/bf1852f72fd268e36457b13a18cdd9a4c9ea35 new file mode 100644 index 000000000..6eaf64b46 --- /dev/null +++ b/tests/resources/reftable/issue_592b/.gitted/objects/3f/bf1852f72fd268e36457b13a18cdd9a4c9ea35 @@ -0,0 +1,2 @@ +xK +1]}%BwnAq xzVƃv ɂc&%9@9xdu.]".=EבO+ۘBEk\N_<>E U%9 \ No newline at end of file diff --git a/tests/resources/reftable/issue_592b/.gitted/objects/6f/a891d3e578c83e1c03bdb9e0fdd8e6e934157f b/tests/resources/reftable/issue_592b/.gitted/objects/6f/a891d3e578c83e1c03bdb9e0fdd8e6e934157f new file mode 100644 index 000000000..c4becfe2f Binary files /dev/null and b/tests/resources/reftable/issue_592b/.gitted/objects/6f/a891d3e578c83e1c03bdb9e0fdd8e6e934157f differ diff --git a/tests/resources/reftable/issue_592b/.gitted/objects/80/07d41d5794e6ce4d4d2c97e370d5a9aa6d5213 b/tests/resources/reftable/issue_592b/.gitted/objects/80/07d41d5794e6ce4d4d2c97e370d5a9aa6d5213 new file mode 100644 index 000000000..aea14f2af Binary files /dev/null and b/tests/resources/reftable/issue_592b/.gitted/objects/80/07d41d5794e6ce4d4d2c97e370d5a9aa6d5213 differ diff --git a/tests/resources/reftable/issue_592b/.gitted/objects/a6/5fb6583a7c425284142f285bc359a2d6565513 b/tests/resources/reftable/issue_592b/.gitted/objects/a6/5fb6583a7c425284142f285bc359a2d6565513 new file mode 100644 index 000000000..9b7407221 Binary files /dev/null and b/tests/resources/reftable/issue_592b/.gitted/objects/a6/5fb6583a7c425284142f285bc359a2d6565513 differ diff --git a/tests/resources/reftable/issue_592b/.gitted/objects/ae/be7a55922c7097ef91ca3a7bc327a901d87c2c b/tests/resources/reftable/issue_592b/.gitted/objects/ae/be7a55922c7097ef91ca3a7bc327a901d87c2c new file mode 100644 index 000000000..1494ed822 Binary files /dev/null and b/tests/resources/reftable/issue_592b/.gitted/objects/ae/be7a55922c7097ef91ca3a7bc327a901d87c2c differ diff --git a/tests/resources/reftable/issue_592b/.gitted/objects/b3/44b055867fcdc1f01eaa75056a43e868eb4fbc b/tests/resources/reftable/issue_592b/.gitted/objects/b3/44b055867fcdc1f01eaa75056a43e868eb4fbc new file mode 100644 index 000000000..7a6626636 Binary files /dev/null and b/tests/resources/reftable/issue_592b/.gitted/objects/b3/44b055867fcdc1f01eaa75056a43e868eb4fbc differ diff --git a/tests/resources/reftable/issue_592b/.gitted/objects/f7/d75fbfad8b1d2e307ced287ea78aad403cdce3 b/tests/resources/reftable/issue_592b/.gitted/objects/f7/d75fbfad8b1d2e307ced287ea78aad403cdce3 new file mode 100644 index 000000000..65a1fd0d0 Binary files /dev/null and b/tests/resources/reftable/issue_592b/.gitted/objects/f7/d75fbfad8b1d2e307ced287ea78aad403cdce3 differ diff --git a/tests/resources/reftable/issue_592b/.gitted/refs/heads b/tests/resources/reftable/issue_592b/.gitted/refs/heads new file mode 100644 index 000000000..3e639a56a --- /dev/null +++ b/tests/resources/reftable/issue_592b/.gitted/refs/heads @@ -0,0 +1 @@ +this repository uses the reftable format diff --git a/tests/resources/reftable/issue_592b/.gitted/reftable/0x000000000001-0x000000000001-1fdbee3a.ref b/tests/resources/reftable/issue_592b/.gitted/reftable/0x000000000001-0x000000000001-1fdbee3a.ref new file mode 100644 index 000000000..58d144b6b Binary files /dev/null and b/tests/resources/reftable/issue_592b/.gitted/reftable/0x000000000001-0x000000000001-1fdbee3a.ref differ diff --git a/tests/resources/reftable/issue_592b/.gitted/reftable/tables.list b/tests/resources/reftable/issue_592b/.gitted/reftable/tables.list new file mode 100644 index 000000000..87c560827 --- /dev/null +++ b/tests/resources/reftable/issue_592b/.gitted/reftable/tables.list @@ -0,0 +1 @@ +0x000000000001-0x000000000001-1fdbee3a.ref diff --git a/tests/resources/reftable/issue_592b/gitignore b/tests/resources/reftable/issue_592b/gitignore new file mode 100644 index 000000000..8007d41d5 --- /dev/null +++ b/tests/resources/reftable/issue_592b/gitignore @@ -0,0 +1 @@ +ignored/ diff --git a/tests/resources/reftable/issue_592b/ignored/contained/ignored3.txt b/tests/resources/reftable/issue_592b/ignored/contained/ignored3.txt new file mode 100644 index 000000000..b5dc7b073 --- /dev/null +++ b/tests/resources/reftable/issue_592b/ignored/contained/ignored3.txt @@ -0,0 +1 @@ +I'm ignored diff --git a/tests/resources/reftable/issue_592b/ignored/contained/tracked3.txt b/tests/resources/reftable/issue_592b/ignored/contained/tracked3.txt new file mode 100644 index 000000000..b344b0558 --- /dev/null +++ b/tests/resources/reftable/issue_592b/ignored/contained/tracked3.txt @@ -0,0 +1 @@ +You added me anyhow diff --git a/tests/resources/reftable/issue_592b/ignored/ignored2.txt b/tests/resources/reftable/issue_592b/ignored/ignored2.txt new file mode 100644 index 000000000..b5dc7b073 --- /dev/null +++ b/tests/resources/reftable/issue_592b/ignored/ignored2.txt @@ -0,0 +1 @@ +I'm ignored diff --git a/tests/resources/reftable/issue_592b/ignored/tracked2.txt b/tests/resources/reftable/issue_592b/ignored/tracked2.txt new file mode 100644 index 000000000..6fa891d3e --- /dev/null +++ b/tests/resources/reftable/issue_592b/ignored/tracked2.txt @@ -0,0 +1 @@ +You like me diff --git a/tests/resources/reftable/issue_592b/ignored1.txt b/tests/resources/reftable/issue_592b/ignored1.txt new file mode 100644 index 000000000..b5dc7b073 --- /dev/null +++ b/tests/resources/reftable/issue_592b/ignored1.txt @@ -0,0 +1 @@ +I'm ignored diff --git a/tests/resources/reftable/issue_592b/tracked1.txt b/tests/resources/reftable/issue_592b/tracked1.txt new file mode 100644 index 000000000..6fa891d3e --- /dev/null +++ b/tests/resources/reftable/issue_592b/tracked1.txt @@ -0,0 +1 @@ +You like me diff --git a/tests/resources/reftable/mailmap/.gitted/HEAD b/tests/resources/reftable/mailmap/.gitted/HEAD new file mode 100644 index 000000000..fe6d7e5fa --- /dev/null +++ b/tests/resources/reftable/mailmap/.gitted/HEAD @@ -0,0 +1 @@ +ref: refs/heads/.invalid diff --git a/tests/resources/reftable/mailmap/.gitted/config b/tests/resources/reftable/mailmap/.gitted/config new file mode 100644 index 000000000..65e78696a --- /dev/null +++ b/tests/resources/reftable/mailmap/.gitted/config @@ -0,0 +1,7 @@ +[core] + repositoryformatversion = 1 + filemode = true + bare = false + logallrefupdates = true +[extensions] + refstorage = reftable diff --git a/tests/resources/reftable/mailmap/.gitted/description b/tests/resources/reftable/mailmap/.gitted/description new file mode 100644 index 000000000..498b267a8 --- /dev/null +++ b/tests/resources/reftable/mailmap/.gitted/description @@ -0,0 +1 @@ +Unnamed repository; edit this file 'description' to name the repository. diff --git a/tests/resources/reftable/mailmap/.gitted/index b/tests/resources/reftable/mailmap/.gitted/index new file mode 100644 index 000000000..af175ca30 Binary files /dev/null and b/tests/resources/reftable/mailmap/.gitted/index differ diff --git a/tests/resources/reftable/mailmap/.gitted/info/exclude b/tests/resources/reftable/mailmap/.gitted/info/exclude new file mode 100644 index 000000000..a5196d1be --- /dev/null +++ b/tests/resources/reftable/mailmap/.gitted/info/exclude @@ -0,0 +1,6 @@ +# git ls-files --others --exclude-from=.git/info/exclude +# Lines that start with '#' are comments. +# For a project mostly in C, the following would be a good set of +# exclude patterns (uncomment them if you want to use them): +# *.[oa] +# *~ diff --git a/tests/resources/reftable/mailmap/.gitted/objects/00/1387531bed84262f137837125d4d998a9ba65d b/tests/resources/reftable/mailmap/.gitted/objects/00/1387531bed84262f137837125d4d998a9ba65d new file mode 100644 index 000000000..1c564909a Binary files /dev/null and b/tests/resources/reftable/mailmap/.gitted/objects/00/1387531bed84262f137837125d4d998a9ba65d differ diff --git a/tests/resources/reftable/mailmap/.gitted/objects/02/7b2816ae0d7a08ba656d0417c09b4eac18cf00 b/tests/resources/reftable/mailmap/.gitted/objects/02/7b2816ae0d7a08ba656d0417c09b4eac18cf00 new file mode 100644 index 000000000..a4e8249af Binary files /dev/null and b/tests/resources/reftable/mailmap/.gitted/objects/02/7b2816ae0d7a08ba656d0417c09b4eac18cf00 differ diff --git a/tests/resources/reftable/mailmap/.gitted/objects/09/20975110511365e56aec2263082d0c3d56d1fa b/tests/resources/reftable/mailmap/.gitted/objects/09/20975110511365e56aec2263082d0c3d56d1fa new file mode 100644 index 000000000..49bceea46 Binary files /dev/null and b/tests/resources/reftable/mailmap/.gitted/objects/09/20975110511365e56aec2263082d0c3d56d1fa differ diff --git a/tests/resources/reftable/mailmap/.gitted/objects/0c/d99501dfbec781a22ff7b84426b7bb308e709a b/tests/resources/reftable/mailmap/.gitted/objects/0c/d99501dfbec781a22ff7b84426b7bb308e709a new file mode 100644 index 000000000..23149a4ee Binary files /dev/null and b/tests/resources/reftable/mailmap/.gitted/objects/0c/d99501dfbec781a22ff7b84426b7bb308e709a differ diff --git a/tests/resources/reftable/mailmap/.gitted/objects/1e/1212e7674820c17f7b8797aee7bf38ece0e838 b/tests/resources/reftable/mailmap/.gitted/objects/1e/1212e7674820c17f7b8797aee7bf38ece0e838 new file mode 100644 index 000000000..89a859807 --- /dev/null +++ b/tests/resources/reftable/mailmap/.gitted/objects/1e/1212e7674820c17f7b8797aee7bf38ece0e838 @@ -0,0 +1,2 @@ +xu] +0})f7iZ(;l#5zz |LDZ/@B:i8bc163,:h|BIKZ,49Ĕ}#rxeh~x{>`=YƊ*-:D뱢 Q^ohUEq߭3d>I \ No newline at end of file diff --git a/tests/resources/reftable/mailmap/.gitted/objects/36/370b71f5aad1dd46bec5e14145280a843c9f49 b/tests/resources/reftable/mailmap/.gitted/objects/36/370b71f5aad1dd46bec5e14145280a843c9f49 new file mode 100644 index 000000000..5e8e3e596 Binary files /dev/null and b/tests/resources/reftable/mailmap/.gitted/objects/36/370b71f5aad1dd46bec5e14145280a843c9f49 differ diff --git a/tests/resources/reftable/mailmap/.gitted/objects/3a/1295dbc9234c0c5947c72803618c7112a01447 b/tests/resources/reftable/mailmap/.gitted/objects/3a/1295dbc9234c0c5947c72803618c7112a01447 new file mode 100644 index 000000000..347828cb6 --- /dev/null +++ b/tests/resources/reftable/mailmap/.gitted/objects/3a/1295dbc9234c0c5947c72803618c7112a01447 @@ -0,0 +1,2 @@ +xmA +0D]$m(";$??(-dV34*(V0.>H #TQEeNd+"t]j]P}hvl{g5$s]0P[yVRY?<0̋#,?s!5_ԏ$^H \ No newline at end of file diff --git a/tests/resources/reftable/mailmap/.gitted/objects/3f/134546ae8fbe95a39dd20ea8c12b5fb0f48afb b/tests/resources/reftable/mailmap/.gitted/objects/3f/134546ae8fbe95a39dd20ea8c12b5fb0f48afb new file mode 100644 index 000000000..489c6104d --- /dev/null +++ b/tests/resources/reftable/mailmap/.gitted/objects/3f/134546ae8fbe95a39dd20ea8c12b5fb0f48afb @@ -0,0 +1,3 @@ +xmMn0) {lbGB(Teqcd\ zze^H<@s("6<{5G[t6PkqK +mq(zg[K̶"Kv -; ʞ~FBﴼ 6 +vH)jX5iZёri3Zp֏iUeoO \ No newline at end of file diff --git a/tests/resources/reftable/mailmap/.gitted/objects/43/179dc93939196f59b25387b5e44e9e8794f84c b/tests/resources/reftable/mailmap/.gitted/objects/43/179dc93939196f59b25387b5e44e9e8794f84c new file mode 100644 index 000000000..2f3693aa6 --- /dev/null +++ b/tests/resources/reftable/mailmap/.gitted/objects/43/179dc93939196f59b25387b5e44e9e8794f84c @@ -0,0 +1,2 @@ +xmA +0P9\4"ŵx1bHzzp?l aP6.'f-+ԕcU-:|ƋLCA<D:coc 7bYP5^¾ D듧 yK}xb_ˈA: \ No newline at end of file diff --git a/tests/resources/reftable/mailmap/.gitted/objects/46/b5bb908c78b575cac9f9e6e42ff9ba3f769a46 b/tests/resources/reftable/mailmap/.gitted/objects/46/b5bb908c78b575cac9f9e6e42ff9ba3f769a46 new file mode 100644 index 000000000..62c9db041 Binary files /dev/null and b/tests/resources/reftable/mailmap/.gitted/objects/46/b5bb908c78b575cac9f9e6e42ff9ba3f769a46 differ diff --git a/tests/resources/reftable/mailmap/.gitted/objects/4b/4d2010ba256ef339c1d1854d20249da7478f01 b/tests/resources/reftable/mailmap/.gitted/objects/4b/4d2010ba256ef339c1d1854d20249da7478f01 new file mode 100644 index 000000000..169c7e7b4 Binary files /dev/null and b/tests/resources/reftable/mailmap/.gitted/objects/4b/4d2010ba256ef339c1d1854d20249da7478f01 differ diff --git a/tests/resources/reftable/mailmap/.gitted/objects/4b/825dc642cb6eb9a060e54bf8d69288fbee4904 b/tests/resources/reftable/mailmap/.gitted/objects/4b/825dc642cb6eb9a060e54bf8d69288fbee4904 new file mode 100644 index 000000000..adf64119a Binary files /dev/null and b/tests/resources/reftable/mailmap/.gitted/objects/4b/825dc642cb6eb9a060e54bf8d69288fbee4904 differ diff --git a/tests/resources/reftable/mailmap/.gitted/objects/4d/61d588546529ad27b2d77a3d6b05460ecb4be0 b/tests/resources/reftable/mailmap/.gitted/objects/4d/61d588546529ad27b2d77a3d6b05460ecb4be0 new file mode 100644 index 000000000..dabbf4ef3 Binary files /dev/null and b/tests/resources/reftable/mailmap/.gitted/objects/4d/61d588546529ad27b2d77a3d6b05460ecb4be0 differ diff --git a/tests/resources/reftable/mailmap/.gitted/objects/50/d69f4e64be2cff2cedde8f9b7f970257caf4dd b/tests/resources/reftable/mailmap/.gitted/objects/50/d69f4e64be2cff2cedde8f9b7f970257caf4dd new file mode 100644 index 000000000..e6b337e1e --- /dev/null +++ b/tests/resources/reftable/mailmap/.gitted/objects/50/d69f4e64be2cff2cedde8f9b7f970257caf4dd @@ -0,0 +1 @@ +xmMj0) HcBY+6e(Qt~>y m>&&ޓ=gOĞR Bֹ6Zy\&c%(-mp FJQ'8Eŷ2,%/ uS+8!4V7xiaVdϗLrU2k\z`KN \ No newline at end of file diff --git a/tests/resources/reftable/mailmap/.gitted/objects/61/293f4c3d7500d227a755a7a8258e28e53449b2 b/tests/resources/reftable/mailmap/.gitted/objects/61/293f4c3d7500d227a755a7a8258e28e53449b2 new file mode 100644 index 000000000..409e6fd74 Binary files /dev/null and b/tests/resources/reftable/mailmap/.gitted/objects/61/293f4c3d7500d227a755a7a8258e28e53449b2 differ diff --git a/tests/resources/reftable/mailmap/.gitted/objects/62/7f0bd2f4fb5e949b79ba450d84676fa876b1c8 b/tests/resources/reftable/mailmap/.gitted/objects/62/7f0bd2f4fb5e949b79ba450d84676fa876b1c8 new file mode 100644 index 000000000..6009c30cd Binary files /dev/null and b/tests/resources/reftable/mailmap/.gitted/objects/62/7f0bd2f4fb5e949b79ba450d84676fa876b1c8 differ diff --git a/tests/resources/reftable/mailmap/.gitted/objects/68/dfd5e5cb6138488680246d134f47ce559f4cf1 b/tests/resources/reftable/mailmap/.gitted/objects/68/dfd5e5cb6138488680246d134f47ce559f4cf1 new file mode 100644 index 000000000..ac5229f73 Binary files /dev/null and b/tests/resources/reftable/mailmap/.gitted/objects/68/dfd5e5cb6138488680246d134f47ce559f4cf1 differ diff --git a/tests/resources/reftable/mailmap/.gitted/objects/69/b9768d022706dab26e2af4dd5a13f42039e36f b/tests/resources/reftable/mailmap/.gitted/objects/69/b9768d022706dab26e2af4dd5a13f42039e36f new file mode 100644 index 000000000..bda7a5d46 Binary files /dev/null and b/tests/resources/reftable/mailmap/.gitted/objects/69/b9768d022706dab26e2af4dd5a13f42039e36f differ diff --git a/tests/resources/reftable/mailmap/.gitted/objects/6a/0fc44893d4867166f9d321f78c269b3e42b08b b/tests/resources/reftable/mailmap/.gitted/objects/6a/0fc44893d4867166f9d321f78c269b3e42b08b new file mode 100644 index 000000000..9c7003111 Binary files /dev/null and b/tests/resources/reftable/mailmap/.gitted/objects/6a/0fc44893d4867166f9d321f78c269b3e42b08b differ diff --git a/tests/resources/reftable/mailmap/.gitted/objects/6c/dec08ab9bfcd5a3d889f27bbed650317e3ec13 b/tests/resources/reftable/mailmap/.gitted/objects/6c/dec08ab9bfcd5a3d889f27bbed650317e3ec13 new file mode 100644 index 000000000..856ba31f0 Binary files /dev/null and b/tests/resources/reftable/mailmap/.gitted/objects/6c/dec08ab9bfcd5a3d889f27bbed650317e3ec13 differ diff --git a/tests/resources/reftable/mailmap/.gitted/objects/71/00e631fb4d5deba31fdc8acc98f4fb5c1573fd b/tests/resources/reftable/mailmap/.gitted/objects/71/00e631fb4d5deba31fdc8acc98f4fb5c1573fd new file mode 100644 index 000000000..3b20e6df2 Binary files /dev/null and b/tests/resources/reftable/mailmap/.gitted/objects/71/00e631fb4d5deba31fdc8acc98f4fb5c1573fd differ diff --git a/tests/resources/reftable/mailmap/.gitted/objects/7e/cbb98d860b304f622b38ce9ab8f08d14d981a8 b/tests/resources/reftable/mailmap/.gitted/objects/7e/cbb98d860b304f622b38ce9ab8f08d14d981a8 new file mode 100644 index 000000000..53e775ee4 Binary files /dev/null and b/tests/resources/reftable/mailmap/.gitted/objects/7e/cbb98d860b304f622b38ce9ab8f08d14d981a8 differ diff --git a/tests/resources/reftable/mailmap/.gitted/objects/7e/e7b9a4a2a1eda925f6260338c063d8211d5ad5 b/tests/resources/reftable/mailmap/.gitted/objects/7e/e7b9a4a2a1eda925f6260338c063d8211d5ad5 new file mode 100644 index 000000000..0d4e94b29 --- /dev/null +++ b/tests/resources/reftable/mailmap/.gitted/objects/7e/e7b9a4a2a1eda925f6260338c063d8211d5ad5 @@ -0,0 +1,2 @@ +x +0D=+z* =~AFMMA޴m'sag+ XgEB[o$dtF;0(d=wb\R8k̫('8-Xޚk: 9ʋGm r</ ]hHS?9.p o3KљQ'" \ No newline at end of file diff --git a/tests/resources/reftable/mailmap/.gitted/objects/83/714a9223f3e072b85f0d4301cd2081fff3acf2 b/tests/resources/reftable/mailmap/.gitted/objects/83/714a9223f3e072b85f0d4301cd2081fff3acf2 new file mode 100644 index 000000000..a50f87e48 Binary files /dev/null and b/tests/resources/reftable/mailmap/.gitted/objects/83/714a9223f3e072b85f0d4301cd2081fff3acf2 differ diff --git a/tests/resources/reftable/mailmap/.gitted/objects/87/ce8d4920a30ddb9547334e7c65806518863ff1 b/tests/resources/reftable/mailmap/.gitted/objects/87/ce8d4920a30ddb9547334e7c65806518863ff1 new file mode 100644 index 000000000..b8c480805 --- /dev/null +++ b/tests/resources/reftable/mailmap/.gitted/objects/87/ce8d4920a30ddb9547334e7c65806518863ff1 @@ -0,0 +1,2 @@ +x}NKjC1 ڧd?=[PݖAe^KRt5f)0 >n1ZCeʚ +XbM8E݇t; HVT3WR!Ų(7fN>rH_ _^'3e !nXûܾl]awXl}=GW=MV \ No newline at end of file diff --git a/tests/resources/reftable/mailmap/.gitted/objects/8c/f0547fcb649b44ebaf39b8104982bb0abb4e69 b/tests/resources/reftable/mailmap/.gitted/objects/8c/f0547fcb649b44ebaf39b8104982bb0abb4e69 new file mode 100644 index 000000000..402a48e79 Binary files /dev/null and b/tests/resources/reftable/mailmap/.gitted/objects/8c/f0547fcb649b44ebaf39b8104982bb0abb4e69 differ diff --git a/tests/resources/reftable/mailmap/.gitted/objects/94/7ff75c33ac7941a32fe9900118b6ba85ab2be9 b/tests/resources/reftable/mailmap/.gitted/objects/94/7ff75c33ac7941a32fe9900118b6ba85ab2be9 new file mode 100644 index 000000000..8b23320fd Binary files /dev/null and b/tests/resources/reftable/mailmap/.gitted/objects/94/7ff75c33ac7941a32fe9900118b6ba85ab2be9 differ diff --git a/tests/resources/reftable/mailmap/.gitted/objects/95/d03c49d94de67d5a05553a1bb22e78f7cdf5ca b/tests/resources/reftable/mailmap/.gitted/objects/95/d03c49d94de67d5a05553a1bb22e78f7cdf5ca new file mode 100644 index 000000000..cd91a3f8c --- /dev/null +++ b/tests/resources/reftable/mailmap/.gitted/objects/95/d03c49d94de67d5a05553a1bb22e78f7cdf5ca @@ -0,0 +1 @@ +xmKn0 D)x$R`h@tcğ@Qo7۲L/B Ad;s7I؏2.Vh1p$^fYHъ2t#[=m)ry[.>%`ia;Vtfǯ3kSC=CxWs|L \ No newline at end of file diff --git a/tests/resources/reftable/mailmap/.gitted/objects/96/78a4325710507f7bf598a0fde5ebbd88148614 b/tests/resources/reftable/mailmap/.gitted/objects/96/78a4325710507f7bf598a0fde5ebbd88148614 new file mode 100644 index 000000000..887436602 Binary files /dev/null and b/tests/resources/reftable/mailmap/.gitted/objects/96/78a4325710507f7bf598a0fde5ebbd88148614 differ diff --git a/tests/resources/reftable/mailmap/.gitted/objects/a1/6db1cbb8817dddcf199c12d3c81221cf8eefc4 b/tests/resources/reftable/mailmap/.gitted/objects/a1/6db1cbb8817dddcf199c12d3c81221cf8eefc4 new file mode 100644 index 000000000..d23d8cc5f --- /dev/null +++ b/tests/resources/reftable/mailmap/.gitted/objects/a1/6db1cbb8817dddcf199c12d3c81221cf8eefc4 @@ -0,0 +1 @@ +x+)JMU06c040031QHI+(aUإV_+ \ No newline at end of file diff --git a/tests/resources/reftable/mailmap/.gitted/objects/a7/054a4b356b3ecdec60cee66e50beaa5b863755 b/tests/resources/reftable/mailmap/.gitted/objects/a7/054a4b356b3ecdec60cee66e50beaa5b863755 new file mode 100644 index 000000000..06a3abc4f --- /dev/null +++ b/tests/resources/reftable/mailmap/.gitted/objects/a7/054a4b356b3ecdec60cee66e50beaa5b863755 @@ -0,0 +1,3 @@ +xmNKj0Z 4I`]lz44&[Jٽ/e +G]E$|bIH]. 1!ՍW+&]I9jc3f^4G +iF+eYaKe8' `|ETlǪp qnn_vh7uL_{zPG \ No newline at end of file diff --git a/tests/resources/reftable/mailmap/.gitted/objects/a7/eb40274887baeb01a958ead80d106b5977312c b/tests/resources/reftable/mailmap/.gitted/objects/a7/eb40274887baeb01a958ead80d106b5977312c new file mode 100644 index 000000000..39f70c203 Binary files /dev/null and b/tests/resources/reftable/mailmap/.gitted/objects/a7/eb40274887baeb01a958ead80d106b5977312c differ diff --git a/tests/resources/reftable/mailmap/.gitted/objects/c9/e5462de8ec453e94d85f26f64b80ea76fda6d4 b/tests/resources/reftable/mailmap/.gitted/objects/c9/e5462de8ec453e94d85f26f64b80ea76fda6d4 new file mode 100644 index 000000000..dbf952372 Binary files /dev/null and b/tests/resources/reftable/mailmap/.gitted/objects/c9/e5462de8ec453e94d85f26f64b80ea76fda6d4 differ diff --git a/tests/resources/reftable/mailmap/.gitted/objects/d3/e5e624cc7bfb09ac1960ebb6c458021b098f87 b/tests/resources/reftable/mailmap/.gitted/objects/d3/e5e624cc7bfb09ac1960ebb6c458021b098f87 new file mode 100644 index 000000000..c69ebe842 Binary files /dev/null and b/tests/resources/reftable/mailmap/.gitted/objects/d3/e5e624cc7bfb09ac1960ebb6c458021b098f87 differ diff --git a/tests/resources/reftable/mailmap/.gitted/objects/f6/3578091d884c3066a003c50eb6c85ae7542269 b/tests/resources/reftable/mailmap/.gitted/objects/f6/3578091d884c3066a003c50eb6c85ae7542269 new file mode 100644 index 000000000..16fd91867 --- /dev/null +++ b/tests/resources/reftable/mailmap/.gitted/objects/f6/3578091d884c3066a003c50eb6c85ae7542269 @@ -0,0 +1,2 @@ +x[j0EUB_2ҌmE-$;߹.\u`z8`dm)YK32x(S`t$ρ%ю#/\3`!‡Z]޼+3+,}ZL{ \ No newline at end of file diff --git a/tests/resources/reftable/mailmap/.gitted/objects/fe/dd34e8baffdb2acfe9a6860bf339287ca942bc b/tests/resources/reftable/mailmap/.gitted/objects/fe/dd34e8baffdb2acfe9a6860bf339287ca942bc new file mode 100644 index 000000000..a13b83df8 Binary files /dev/null and b/tests/resources/reftable/mailmap/.gitted/objects/fe/dd34e8baffdb2acfe9a6860bf339287ca942bc differ diff --git a/tests/resources/reftable/mailmap/.gitted/objects/fe/ef8f2135df4835496e4d576b1f1bd23510e1c5 b/tests/resources/reftable/mailmap/.gitted/objects/fe/ef8f2135df4835496e4d576b1f1bd23510e1c5 new file mode 100644 index 000000000..31f979bc1 --- /dev/null +++ b/tests/resources/reftable/mailmap/.gitted/objects/fe/ef8f2135df4835496e4d576b1f1bd23510e1c5 @@ -0,0 +1 @@ +xmK1]u%J 22/#7(4 ,`2x-QR) -+Thu#Aیi᱀U똳7 >^j#eLIЭti幃}}8 3jeCVYΗ=:j%]Ŀ,pK \ No newline at end of file diff --git a/tests/resources/reftable/mailmap/.gitted/refs/heads b/tests/resources/reftable/mailmap/.gitted/refs/heads new file mode 100644 index 000000000..3e639a56a --- /dev/null +++ b/tests/resources/reftable/mailmap/.gitted/refs/heads @@ -0,0 +1 @@ +this repository uses the reftable format diff --git a/tests/resources/reftable/mailmap/.gitted/reftable/0x000000000001-0x000000000001-d239cfda.ref b/tests/resources/reftable/mailmap/.gitted/reftable/0x000000000001-0x000000000001-d239cfda.ref new file mode 100644 index 000000000..004471c28 Binary files /dev/null and b/tests/resources/reftable/mailmap/.gitted/reftable/0x000000000001-0x000000000001-d239cfda.ref differ diff --git a/tests/resources/reftable/mailmap/.gitted/reftable/tables.list b/tests/resources/reftable/mailmap/.gitted/reftable/tables.list new file mode 100644 index 000000000..184930f75 --- /dev/null +++ b/tests/resources/reftable/mailmap/.gitted/reftable/tables.list @@ -0,0 +1 @@ +0x000000000001-0x000000000001-d239cfda.ref diff --git a/tests/resources/reftable/mailmap/.mailmap b/tests/resources/reftable/mailmap/.mailmap new file mode 100644 index 000000000..7da2ed605 --- /dev/null +++ b/tests/resources/reftable/mailmap/.mailmap @@ -0,0 +1,9 @@ +# Simple Comment line + +Some Dude nick1 +Other Author nick2 +Other Author +Phil Hill # Comment at end of line + Joseph +Santa Claus +Untracked diff --git a/tests/resources/reftable/mailmap/file.txt b/tests/resources/reftable/mailmap/file.txt new file mode 100644 index 000000000..68dfd5e5c --- /dev/null +++ b/tests/resources/reftable/mailmap/file.txt @@ -0,0 +1,10 @@ +Added by Brad +Added by Brad L. +Added by nick1 +Added by nick2 +Added by nick3 +Added by Some Garbage +Added by unknown +Added by Joseph +Added by Clause +Added by Charles diff --git a/tests/resources/reftable/mailmap/file_override b/tests/resources/reftable/mailmap/file_override new file mode 100644 index 000000000..94293a971 --- /dev/null +++ b/tests/resources/reftable/mailmap/file_override @@ -0,0 +1,2 @@ +File Override +Other Name diff --git a/tests/resources/reftable/merge-recursive/.gitted/HEAD b/tests/resources/reftable/merge-recursive/.gitted/HEAD new file mode 100644 index 000000000..fe6d7e5fa --- /dev/null +++ b/tests/resources/reftable/merge-recursive/.gitted/HEAD @@ -0,0 +1 @@ +ref: refs/heads/.invalid diff --git a/tests/resources/reftable/merge-recursive/.gitted/config b/tests/resources/reftable/merge-recursive/.gitted/config new file mode 100644 index 000000000..622302e60 --- /dev/null +++ b/tests/resources/reftable/merge-recursive/.gitted/config @@ -0,0 +1,9 @@ +[core] + repositoryformatversion = 1 + filemode = true + bare = false + logallrefupdates = true + ignorecase = true + precomposeunicode = true +[extensions] + refstorage = reftable diff --git a/tests/resources/reftable/merge-recursive/.gitted/index b/tests/resources/reftable/merge-recursive/.gitted/index new file mode 100644 index 000000000..571cfd02f Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/index differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/info/refs b/tests/resources/reftable/merge-recursive/.gitted/info/refs new file mode 100644 index 000000000..96482e6cb --- /dev/null +++ b/tests/resources/reftable/merge-recursive/.gitted/info/refs @@ -0,0 +1 @@ +7c7bf85e978f1d18c0566f702d2cb7766b9c8d4f refs/heads/master diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/00/6b298c5702b04c00370d0414959765b82fd722 b/tests/resources/reftable/merge-recursive/.gitted/objects/00/6b298c5702b04c00370d0414959765b82fd722 new file mode 100644 index 000000000..d3fb85fca Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/00/6b298c5702b04c00370d0414959765b82fd722 differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/00/7f1ee2af8e5d99906867c4237510e1790a89b8 b/tests/resources/reftable/merge-recursive/.gitted/objects/00/7f1ee2af8e5d99906867c4237510e1790a89b8 new file mode 100644 index 000000000..d9399d71c --- /dev/null +++ b/tests/resources/reftable/merge-recursive/.gitted/objects/00/7f1ee2af8e5d99906867c4237510e1790a89b8 @@ -0,0 +1,3 @@ +xNI +1<FtgA\vXɸPzIIM6iY],WzpBzPdF4V .xV!y~9ր0uhoU`$,_R:-a2%Sw^cJ>fFOv;+ \ No newline at end of file diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/07/10c3c796e0704361472ecb904413fca0107a25 b/tests/resources/reftable/merge-recursive/.gitted/objects/07/10c3c796e0704361472ecb904413fca0107a25 new file mode 100644 index 000000000..9f48594b5 Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/07/10c3c796e0704361472ecb904413fca0107a25 differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/07/2d89dcf3a7671ac34a8e875bb72fb39bcf14d7 b/tests/resources/reftable/merge-recursive/.gitted/objects/07/2d89dcf3a7671ac34a8e875bb72fb39bcf14d7 new file mode 100644 index 000000000..69104c948 Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/07/2d89dcf3a7671ac34a8e875bb72fb39bcf14d7 differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/08/f01e1bff7e442d574eb221913515b4bd27ccd6 b/tests/resources/reftable/merge-recursive/.gitted/objects/08/f01e1bff7e442d574eb221913515b4bd27ccd6 new file mode 100644 index 000000000..c2fbf5ba7 Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/08/f01e1bff7e442d574eb221913515b4bd27ccd6 differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/0b/b7ed583d7e9ad507e8b902594f5c9126ea456b b/tests/resources/reftable/merge-recursive/.gitted/objects/0b/b7ed583d7e9ad507e8b902594f5c9126ea456b new file mode 100644 index 000000000..e7b4ba10f Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/0b/b7ed583d7e9ad507e8b902594f5c9126ea456b differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/0b/beee1982b493330e375a85bbfddaba3d561556 b/tests/resources/reftable/merge-recursive/.gitted/objects/0b/beee1982b493330e375a85bbfddaba3d561556 new file mode 100644 index 000000000..66b927246 Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/0b/beee1982b493330e375a85bbfddaba3d561556 differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/0c/e202f64fa8356c1a32835fce4058ca76b0c7ed b/tests/resources/reftable/merge-recursive/.gitted/objects/0c/e202f64fa8356c1a32835fce4058ca76b0c7ed new file mode 100644 index 000000000..9a84b7149 Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/0c/e202f64fa8356c1a32835fce4058ca76b0c7ed differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/0e/8126647ec607f0a14122cec4b15315d790c8ff b/tests/resources/reftable/merge-recursive/.gitted/objects/0e/8126647ec607f0a14122cec4b15315d790c8ff new file mode 100644 index 000000000..c99a6865c Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/0e/8126647ec607f0a14122cec4b15315d790c8ff differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/0e/c39d71c1b074905350ce20ce3f0629f737a2a9 b/tests/resources/reftable/merge-recursive/.gitted/objects/0e/c39d71c1b074905350ce20ce3f0629f737a2a9 new file mode 100644 index 000000000..68808d2f3 Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/0e/c39d71c1b074905350ce20ce3f0629f737a2a9 differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/0f/a6ead2731b9d138afe38c336c9727ea05027a7 b/tests/resources/reftable/merge-recursive/.gitted/objects/0f/a6ead2731b9d138afe38c336c9727ea05027a7 new file mode 100644 index 000000000..b06362dd8 --- /dev/null +++ b/tests/resources/reftable/merge-recursive/.gitted/objects/0f/a6ead2731b9d138afe38c336c9727ea05027a7 @@ -0,0 +1 @@ +xJAE+*hk"bhTw8̴-\0/2<݌nKI\9D`5Tdϩ4Jm I)ꈼ"-鄱晴O'„3YG JAXSd#(NPxzmpg{q>e9ѱsӞ3=Y1pFe2oz \ No newline at end of file diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/12/4d4fe29d3433fdaa2f0f455d226f2c79d89cf3 b/tests/resources/reftable/merge-recursive/.gitted/objects/12/4d4fe29d3433fdaa2f0f455d226f2c79d89cf3 new file mode 100644 index 000000000..f0ea020fb Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/12/4d4fe29d3433fdaa2f0f455d226f2c79d89cf3 differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/15/311229e70fa62653f73dde1d4deef1a8e47a11 b/tests/resources/reftable/merge-recursive/.gitted/objects/15/311229e70fa62653f73dde1d4deef1a8e47a11 new file mode 100644 index 000000000..8c21bb357 Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/15/311229e70fa62653f73dde1d4deef1a8e47a11 differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/15/faa0c9991f2d65686e844651faa2ff9827887b b/tests/resources/reftable/merge-recursive/.gitted/objects/15/faa0c9991f2d65686e844651faa2ff9827887b new file mode 100644 index 000000000..54cd6f26e Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/15/faa0c9991f2d65686e844651faa2ff9827887b differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/16/895aa5e13f8907d4adab81285557d938fad342 b/tests/resources/reftable/merge-recursive/.gitted/objects/16/895aa5e13f8907d4adab81285557d938fad342 new file mode 100644 index 000000000..4d3319bc7 Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/16/895aa5e13f8907d4adab81285557d938fad342 differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/17/946ad3088f931102e5d81f94cf2825fc188953 b/tests/resources/reftable/merge-recursive/.gitted/objects/17/946ad3088f931102e5d81f94cf2825fc188953 new file mode 100644 index 000000000..9cc133e94 Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/17/946ad3088f931102e5d81f94cf2825fc188953 differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/18/2d0d250d1d7adcc60c178be5be98358b3a2fd1 b/tests/resources/reftable/merge-recursive/.gitted/objects/18/2d0d250d1d7adcc60c178be5be98358b3a2fd1 new file mode 100644 index 000000000..96674c89b --- /dev/null +++ b/tests/resources/reftable/merge-recursive/.gitted/objects/18/2d0d250d1d7adcc60c178be5be98358b3a2fd1 @@ -0,0 +1,5 @@ +xK +1]_>@H +^N"1[!#v_+\>uVo,ӭȼZ@2l1 N{`?Ts6_?B* \ No newline at end of file diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/2c/ba583804a4a6fad1baf97c959be447238d1489 b/tests/resources/reftable/merge-recursive/.gitted/objects/2c/ba583804a4a6fad1baf97c959be447238d1489 new file mode 100644 index 000000000..c0a60a172 Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/2c/ba583804a4a6fad1baf97c959be447238d1489 differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/2e/7ae0d42fb7b6126f6a08ac6314ac07833a52f6 b/tests/resources/reftable/merge-recursive/.gitted/objects/2e/7ae0d42fb7b6126f6a08ac6314ac07833a52f6 new file mode 100644 index 000000000..6a9651c76 Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/2e/7ae0d42fb7b6126f6a08ac6314ac07833a52f6 differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/30/39c07db695c8c99d0a7c7e32f0afe40eae0be0 b/tests/resources/reftable/merge-recursive/.gitted/objects/30/39c07db695c8c99d0a7c7e32f0afe40eae0be0 new file mode 100644 index 000000000..cc21b5c31 --- /dev/null +++ b/tests/resources/reftable/merge-recursive/.gitted/objects/30/39c07db695c8c99d0a7c7e32f0afe40eae0be0 @@ -0,0 +1,3 @@ +xQ +!@sB"茵mݾ +}^^Z"(J8iŌI]98Xd)QNX"[2^t|,pZ }5./[V]B \ No newline at end of file diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/34/8f16ffaeb73f319a75cec5b16a0a47d2d5e27c b/tests/resources/reftable/merge-recursive/.gitted/objects/34/8f16ffaeb73f319a75cec5b16a0a47d2d5e27c new file mode 100644 index 000000000..bd1b1f69a Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/34/8f16ffaeb73f319a75cec5b16a0a47d2d5e27c differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/35/8efd6f589384fa8baf92234db9c7899a53916e b/tests/resources/reftable/merge-recursive/.gitted/objects/35/8efd6f589384fa8baf92234db9c7899a53916e new file mode 100644 index 000000000..aefc81ad5 Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/35/8efd6f589384fa8baf92234db9c7899a53916e differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/35/dda4f3f9b3794d92a46d908790e550ed100eae b/tests/resources/reftable/merge-recursive/.gitted/objects/35/dda4f3f9b3794d92a46d908790e550ed100eae new file mode 100644 index 000000000..d6cabb419 Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/35/dda4f3f9b3794d92a46d908790e550ed100eae differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/36/71e42c8c8302d1a71c0ed7bf2b0a938e9e20f9 b/tests/resources/reftable/merge-recursive/.gitted/objects/36/71e42c8c8302d1a71c0ed7bf2b0a938e9e20f9 new file mode 100644 index 000000000..4f70ad6d4 Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/36/71e42c8c8302d1a71c0ed7bf2b0a938e9e20f9 differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/37/185b25a204309bf74817da1a607518f13ca3ed b/tests/resources/reftable/merge-recursive/.gitted/objects/37/185b25a204309bf74817da1a607518f13ca3ed new file mode 100644 index 000000000..a8cf005bc Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/37/185b25a204309bf74817da1a607518f13ca3ed differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/37/a5054a9f9b4628e3924c5cb8f2147c6e2a3efc b/tests/resources/reftable/merge-recursive/.gitted/objects/37/a5054a9f9b4628e3924c5cb8f2147c6e2a3efc new file mode 100644 index 000000000..4591f0e04 Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/37/a5054a9f9b4628e3924c5cb8f2147c6e2a3efc differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/38/55170cef875708da06ab9ad7fc6a73b531cda1 b/tests/resources/reftable/merge-recursive/.gitted/objects/38/55170cef875708da06ab9ad7fc6a73b531cda1 new file mode 100644 index 000000000..7da945e6f Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/38/55170cef875708da06ab9ad7fc6a73b531cda1 differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/39/78944e4cd53edcc10a170ab2ff142f7295b958 b/tests/resources/reftable/merge-recursive/.gitted/objects/39/78944e4cd53edcc10a170ab2ff142f7295b958 new file mode 100644 index 000000000..b18fd4836 Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/39/78944e4cd53edcc10a170ab2ff142f7295b958 differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/3a/0dc89a8bd20e74fae69d2e038b47360fafb02e b/tests/resources/reftable/merge-recursive/.gitted/objects/3a/0dc89a8bd20e74fae69d2e038b47360fafb02e new file mode 100644 index 000000000..fdff502d1 Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/3a/0dc89a8bd20e74fae69d2e038b47360fafb02e differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/3a/3f5a6ec1c968d1d2d5d20dee0d161a4351f279 b/tests/resources/reftable/merge-recursive/.gitted/objects/3a/3f5a6ec1c968d1d2d5d20dee0d161a4351f279 new file mode 100644 index 000000000..f39a1271f --- /dev/null +++ b/tests/resources/reftable/merge-recursive/.gitted/objects/3a/3f5a6ec1c968d1d2d5d20dee0d161a4351f279 @@ -0,0 +1 @@ +xO !*h@Bb?ׁ Xr&a}؁LfR]KqQ{ `Ozɚtɤk(gؓ+*+X[F8>EGkS~y˽CۥB4ƀNnPֈ)OWN: \ No newline at end of file diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/3a/8c70144d0334721154b1e0529716b368483d6f b/tests/resources/reftable/merge-recursive/.gitted/objects/3a/8c70144d0334721154b1e0529716b368483d6f new file mode 100644 index 000000000..958d17d35 Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/3a/8c70144d0334721154b1e0529716b368483d6f differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/3b/919b6e8a575b4779c8243ebea3e3beb436e88f b/tests/resources/reftable/merge-recursive/.gitted/objects/3b/919b6e8a575b4779c8243ebea3e3beb436e88f new file mode 100644 index 000000000..c85731d6b Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/3b/919b6e8a575b4779c8243ebea3e3beb436e88f differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/3e/eff81b57a0ac15a5ab6bb3a8e92511a01a429c b/tests/resources/reftable/merge-recursive/.gitted/objects/3e/eff81b57a0ac15a5ab6bb3a8e92511a01a429c new file mode 100644 index 000000000..6a6c65460 Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/3e/eff81b57a0ac15a5ab6bb3a8e92511a01a429c differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/3f/d41804a7906db846af5e868444782e546af46a b/tests/resources/reftable/merge-recursive/.gitted/objects/3f/d41804a7906db846af5e868444782e546af46a new file mode 100644 index 000000000..4915b864f Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/3f/d41804a7906db846af5e868444782e546af46a differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/40/9f5d072decec684331672f2d6c0a9bc3640adb b/tests/resources/reftable/merge-recursive/.gitted/objects/40/9f5d072decec684331672f2d6c0a9bc3640adb new file mode 100644 index 000000000..b4c9005e1 Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/40/9f5d072decec684331672f2d6c0a9bc3640adb differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/41/71bb8d40e9fc830d79b757dc06ec6c14548b78 b/tests/resources/reftable/merge-recursive/.gitted/objects/41/71bb8d40e9fc830d79b757dc06ec6c14548b78 new file mode 100644 index 000000000..5dc102d35 Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/41/71bb8d40e9fc830d79b757dc06ec6c14548b78 differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/42/1b392106e079df6d412babd5636697938269ec b/tests/resources/reftable/merge-recursive/.gitted/objects/42/1b392106e079df6d412babd5636697938269ec new file mode 100644 index 000000000..3a8324c1b --- /dev/null +++ b/tests/resources/reftable/merge-recursive/.gitted/objects/42/1b392106e079df6d412babd5636697938269ec @@ -0,0 +1,2 @@ +xQ +0D)re7D @ݥmFU3o`)u.zM[Dӽ,PH^w*)c&6,27JJADQ&KN)bT3~WENYZGj +RSj2I^'y51i0599`e5a z%潎U^XV Vtٙo]2Y~P1($bz7g\QdLɔ3Rsj/]3VLlg{W[ \ No newline at end of file diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/43/5424798e5e1b21dd4588d1c291ba4eb179a838 b/tests/resources/reftable/merge-recursive/.gitted/objects/43/5424798e5e1b21dd4588d1c291ba4eb179a838 new file mode 100644 index 000000000..58ab23917 Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/43/5424798e5e1b21dd4588d1c291ba4eb179a838 differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/43/6ea75c99f527e4b42fddb46abedf7726eb719d b/tests/resources/reftable/merge-recursive/.gitted/objects/43/6ea75c99f527e4b42fddb46abedf7726eb719d new file mode 100644 index 000000000..e8825d867 --- /dev/null +++ b/tests/resources/reftable/merge-recursive/.gitted/objects/43/6ea75c99f527e4b42fddb46abedf7726eb719d @@ -0,0 +1,2 @@ +xKj1D)tncev@bFf,G U(i۶v}CՂft1RRf`$tNTcy6>t]Rǐ!=@̱T\ +ǔW_aGm϶۳WOi"Q%  :v}s|Ϋp_Dž7QA \ No newline at end of file diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/44/faf5fba1af850dae54f8b2345938d3c7ae479f b/tests/resources/reftable/merge-recursive/.gitted/objects/44/faf5fba1af850dae54f8b2345938d3c7ae479f new file mode 100644 index 000000000..d0bc09902 Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/44/faf5fba1af850dae54f8b2345938d3c7ae479f differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/48/3065df53c0f4a02cdc6b2910b05d388fc17ffb b/tests/resources/reftable/merge-recursive/.gitted/objects/48/3065df53c0f4a02cdc6b2910b05d388fc17ffb new file mode 100644 index 000000000..298251b3c Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/48/3065df53c0f4a02cdc6b2910b05d388fc17ffb differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/4a/06b258fed8a4d15967ec4253ae7366b70f727d b/tests/resources/reftable/merge-recursive/.gitted/objects/4a/06b258fed8a4d15967ec4253ae7366b70f727d new file mode 100644 index 000000000..d3e181501 Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/4a/06b258fed8a4d15967ec4253ae7366b70f727d differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/4b/7c5650008b2e747fe1809eeb5a1dde0e80850a b/tests/resources/reftable/merge-recursive/.gitted/objects/4b/7c5650008b2e747fe1809eeb5a1dde0e80850a new file mode 100644 index 000000000..016398531 Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/4b/7c5650008b2e747fe1809eeb5a1dde0e80850a differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/4b/825dc642cb6eb9a060e54bf8d69288fbee4904 b/tests/resources/reftable/merge-recursive/.gitted/objects/4b/825dc642cb6eb9a060e54bf8d69288fbee4904 new file mode 100644 index 000000000..adf64119a Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/4b/825dc642cb6eb9a060e54bf8d69288fbee4904 differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/4c/49317a0912ca559d2048bc329994eb7d10474f b/tests/resources/reftable/merge-recursive/.gitted/objects/4c/49317a0912ca559d2048bc329994eb7d10474f new file mode 100644 index 000000000..d7bb4d37c Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/4c/49317a0912ca559d2048bc329994eb7d10474f differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/4c/62e9482ed42c1a6d08891906b26126daa4a8f5 b/tests/resources/reftable/merge-recursive/.gitted/objects/4c/62e9482ed42c1a6d08891906b26126daa4a8f5 new file mode 100644 index 000000000..f3cee9a2d Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/4c/62e9482ed42c1a6d08891906b26126daa4a8f5 differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/4d/fc1be85a9d6c9898152444d32b238b4aecf8cc b/tests/resources/reftable/merge-recursive/.gitted/objects/4d/fc1be85a9d6c9898152444d32b238b4aecf8cc new file mode 100644 index 000000000..9db684d40 Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/4d/fc1be85a9d6c9898152444d32b238b4aecf8cc differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/4e/21d2d63357bde5027d1625f5ec6b430cdeb143 b/tests/resources/reftable/merge-recursive/.gitted/objects/4e/21d2d63357bde5027d1625f5ec6b430cdeb143 new file mode 100644 index 000000000..34f183dd1 Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/4e/21d2d63357bde5027d1625f5ec6b430cdeb143 differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/4e/70a6b06fc62481f80fbb74327849e7170eebff b/tests/resources/reftable/merge-recursive/.gitted/objects/4e/70a6b06fc62481f80fbb74327849e7170eebff new file mode 100644 index 000000000..1dfcec50b Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/4e/70a6b06fc62481f80fbb74327849e7170eebff differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/4f/4e85a0ab8515e34302721fbcec06fa9d9c1a9a b/tests/resources/reftable/merge-recursive/.gitted/objects/4f/4e85a0ab8515e34302721fbcec06fa9d9c1a9a new file mode 100644 index 000000000..4752ea07a Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/4f/4e85a0ab8515e34302721fbcec06fa9d9c1a9a differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/50/4dd93fb5b9c2a28c094c6e84ef0606de1e9b5c b/tests/resources/reftable/merge-recursive/.gitted/objects/50/4dd93fb5b9c2a28c094c6e84ef0606de1e9b5c new file mode 100644 index 000000000..214d3076d Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/50/4dd93fb5b9c2a28c094c6e84ef0606de1e9b5c differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/50/dfa64a56b488fe8082371b182c8a3e3c942332 b/tests/resources/reftable/merge-recursive/.gitted/objects/50/dfa64a56b488fe8082371b182c8a3e3c942332 new file mode 100644 index 000000000..7c90c99af Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/50/dfa64a56b488fe8082371b182c8a3e3c942332 differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/50/e4facaafb746cfed89287206274193c1417288 b/tests/resources/reftable/merge-recursive/.gitted/objects/50/e4facaafb746cfed89287206274193c1417288 new file mode 100644 index 000000000..b1eaee557 --- /dev/null +++ b/tests/resources/reftable/merge-recursive/.gitted/objects/50/e4facaafb746cfed89287206274193c1417288 @@ -0,0 +1,2 @@ +x+)JMU022g040031QH,.H,JL/-+(a9/>~WENYZGj +RSj2I^'y51i0599`e5a z%潎U^XV Vtٙo]2Y~P1($bz7g\QdLɔ3RsjD-89S^75#-ע3;\ \ No newline at end of file diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/51/135c5884d7dd132fef3b432cca5826bab98f37 b/tests/resources/reftable/merge-recursive/.gitted/objects/51/135c5884d7dd132fef3b432cca5826bab98f37 new file mode 100644 index 000000000..95818f144 Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/51/135c5884d7dd132fef3b432cca5826bab98f37 differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/51/60ab78c1973dcd7cdebe2345dc8fcfc755e76d b/tests/resources/reftable/merge-recursive/.gitted/objects/51/60ab78c1973dcd7cdebe2345dc8fcfc755e76d new file mode 100644 index 000000000..f3f99d7fe Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/51/60ab78c1973dcd7cdebe2345dc8fcfc755e76d differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/53/9bd011c4822c560c1d17cab095006b7a10f707 b/tests/resources/reftable/merge-recursive/.gitted/objects/53/9bd011c4822c560c1d17cab095006b7a10f707 new file mode 100644 index 000000000..3fa1e1f94 Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/53/9bd011c4822c560c1d17cab095006b7a10f707 differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/56/07a8c4601a737daadd1f470bde3142aff57026 b/tests/resources/reftable/merge-recursive/.gitted/objects/56/07a8c4601a737daadd1f470bde3142aff57026 new file mode 100644 index 000000000..bf3639d05 --- /dev/null +++ b/tests/resources/reftable/merge-recursive/.gitted/objects/56/07a8c4601a737daadd1f470bde3142aff57026 @@ -0,0 +1 @@ +xMJ1])#?<čp:3w=Ԧ((~`MxCrBYMSP-}tjzL`JRvR jBV8Ze&6zsTr͵̍2.9>~I~Gs1G!j1IcS1xW(܎u#rbV \ No newline at end of file diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/56/fcbad344aafe519bafcc33c87b8e64849d82ab b/tests/resources/reftable/merge-recursive/.gitted/objects/56/fcbad344aafe519bafcc33c87b8e64849d82ab new file mode 100644 index 000000000..06bea32e6 Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/56/fcbad344aafe519bafcc33c87b8e64849d82ab differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/5a/47615db824433f816ba62217dda6d46c5a7640 b/tests/resources/reftable/merge-recursive/.gitted/objects/5a/47615db824433f816ba62217dda6d46c5a7640 new file mode 100644 index 000000000..c1e30ce54 Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/5a/47615db824433f816ba62217dda6d46c5a7640 differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/5a/ba269b3be41fc8db38068d3948c8af543fe609 b/tests/resources/reftable/merge-recursive/.gitted/objects/5a/ba269b3be41fc8db38068d3948c8af543fe609 new file mode 100644 index 000000000..85bc8f569 Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/5a/ba269b3be41fc8db38068d3948c8af543fe609 differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/5b/8e1e56cb99e8b99ac22eec8aebf6422ecd08c0 b/tests/resources/reftable/merge-recursive/.gitted/objects/5b/8e1e56cb99e8b99ac22eec8aebf6422ecd08c0 new file mode 100644 index 000000000..c3e6d31ca Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/5b/8e1e56cb99e8b99ac22eec8aebf6422ecd08c0 differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/5c/27b5f7c6f6dd4e5b4d64976741d56c2df8f48a b/tests/resources/reftable/merge-recursive/.gitted/objects/5c/27b5f7c6f6dd4e5b4d64976741d56c2df8f48a new file mode 100644 index 000000000..783d085a7 Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/5c/27b5f7c6f6dd4e5b4d64976741d56c2df8f48a differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/5d/998d5f278aff5693711bc48f6852aac4b603ad b/tests/resources/reftable/merge-recursive/.gitted/objects/5d/998d5f278aff5693711bc48f6852aac4b603ad new file mode 100644 index 000000000..a7795f59b Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/5d/998d5f278aff5693711bc48f6852aac4b603ad differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/5e/8747f5200fac0f945a07daf6163ca9cb1a8da9 b/tests/resources/reftable/merge-recursive/.gitted/objects/5e/8747f5200fac0f945a07daf6163ca9cb1a8da9 new file mode 100644 index 000000000..fa1c9e5dc Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/5e/8747f5200fac0f945a07daf6163ca9cb1a8da9 differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/5f/18576d464946eb2338daeb8b4030019961f505 b/tests/resources/reftable/merge-recursive/.gitted/objects/5f/18576d464946eb2338daeb8b4030019961f505 new file mode 100644 index 000000000..d03742b92 Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/5f/18576d464946eb2338daeb8b4030019961f505 differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/61/6d1209afac499b005f68309e1593b44899b054 b/tests/resources/reftable/merge-recursive/.gitted/objects/61/6d1209afac499b005f68309e1593b44899b054 new file mode 100644 index 000000000..6a06214d7 Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/61/6d1209afac499b005f68309e1593b44899b054 differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/63/e8773becdea9c3699c95a5740be5baa8be8d69 b/tests/resources/reftable/merge-recursive/.gitted/objects/63/e8773becdea9c3699c95a5740be5baa8be8d69 new file mode 100644 index 000000000..6d5c320fe Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/63/e8773becdea9c3699c95a5740be5baa8be8d69 differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/65/bea8448ca5b3104628ffbca553c54bde54b0fc b/tests/resources/reftable/merge-recursive/.gitted/objects/65/bea8448ca5b3104628ffbca553c54bde54b0fc new file mode 100644 index 000000000..031c91359 --- /dev/null +++ b/tests/resources/reftable/merge-recursive/.gitted/objects/65/bea8448ca5b3104628ffbca553c54bde54b0fc @@ -0,0 +1,3 @@ +x !D +а,3 jyL^\6h9qDLɒ~ + F'Qk$< !!2eְazlH}MEy^~Qïr- n`[Q+]eyBWyM \ No newline at end of file diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/66/6ffdfcf1eaa5641fa31064bf2607327e843c09 b/tests/resources/reftable/merge-recursive/.gitted/objects/66/6ffdfcf1eaa5641fa31064bf2607327e843c09 new file mode 100644 index 000000000..8d6be4216 Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/66/6ffdfcf1eaa5641fa31064bf2607327e843c09 differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/68/a2e1ee61a23a4728fe6b35580fbbbf729df370 b/tests/resources/reftable/merge-recursive/.gitted/objects/68/a2e1ee61a23a4728fe6b35580fbbbf729df370 new file mode 100644 index 000000000..6d7c948c9 Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/68/a2e1ee61a23a4728fe6b35580fbbbf729df370 differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/68/af1fc7407fd9addf1701a87eb1c95c7494c598 b/tests/resources/reftable/merge-recursive/.gitted/objects/68/af1fc7407fd9addf1701a87eb1c95c7494c598 new file mode 100644 index 000000000..6aaf79fcb Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/68/af1fc7407fd9addf1701a87eb1c95c7494c598 differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/68/f6182f4c85d39e1309d97c7e456156dc9c0096 b/tests/resources/reftable/merge-recursive/.gitted/objects/68/f6182f4c85d39e1309d97c7e456156dc9c0096 new file mode 100644 index 000000000..ed1de3ada Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/68/f6182f4c85d39e1309d97c7e456156dc9c0096 differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/6c/778edd0e4cf394f5a3df8b96db516024cc1bb8 b/tests/resources/reftable/merge-recursive/.gitted/objects/6c/778edd0e4cf394f5a3df8b96db516024cc1bb8 new file mode 100644 index 000000000..ec1db19e6 Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/6c/778edd0e4cf394f5a3df8b96db516024cc1bb8 differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/6e/f31d35a3f5abc1e24f4f9afa5cb2016f03fa2d b/tests/resources/reftable/merge-recursive/.gitted/objects/6e/f31d35a3f5abc1e24f4f9afa5cb2016f03fa2d new file mode 100644 index 000000000..e95a5e2db --- /dev/null +++ b/tests/resources/reftable/merge-recursive/.gitted/objects/6e/f31d35a3f5abc1e24f4f9afa5cb2016f03fa2d @@ -0,0 +1 @@ +xAN!]sahcx$2gpWE:z8‡5UA-YG zAl+&LLd>cW.-&͊)BI5o&p<gq/`n,<"!^C#anr]]Bɧ_*PV \ No newline at end of file diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/71/3e438567b28543235faf265c4c5b02b437c7fd b/tests/resources/reftable/merge-recursive/.gitted/objects/71/3e438567b28543235faf265c4c5b02b437c7fd new file mode 100644 index 000000000..8b1f688ca Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/71/3e438567b28543235faf265c4c5b02b437c7fd differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/71/c50785d8d512293bd3af838b131f3da5829ebc b/tests/resources/reftable/merge-recursive/.gitted/objects/71/c50785d8d512293bd3af838b131f3da5829ebc new file mode 100644 index 000000000..23c40332e Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/71/c50785d8d512293bd3af838b131f3da5829ebc differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/72/3181f1bfd30e47a6d1d36a4d874e31e7a0a1a4 b/tests/resources/reftable/merge-recursive/.gitted/objects/72/3181f1bfd30e47a6d1d36a4d874e31e7a0a1a4 new file mode 100644 index 000000000..01d113eec --- /dev/null +++ b/tests/resources/reftable/merge-recursive/.gitted/objects/72/3181f1bfd30e47a6d1d36a4d874e31e7a0a1a4 @@ -0,0 +1,2 @@ +x[ +1 E*Ağفȴ)#8SUowDž.˥E 8Bt6'<`bvh=I_ԍD)Bq}D )z6Z\{]B?Չ_Ku9Atl5jQcOznO6 \ No newline at end of file diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/73/b20c8e09fa2726d69ff66969186014165da3c3 b/tests/resources/reftable/merge-recursive/.gitted/objects/73/b20c8e09fa2726d69ff66969186014165da3c3 new file mode 100644 index 000000000..6559958c5 Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/73/b20c8e09fa2726d69ff66969186014165da3c3 differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/74/4df1bdf0f7bca20deb23e5a5eb8255fc237901 b/tests/resources/reftable/merge-recursive/.gitted/objects/74/4df1bdf0f7bca20deb23e5a5eb8255fc237901 new file mode 100644 index 000000000..c05cdad8f Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/74/4df1bdf0f7bca20deb23e5a5eb8255fc237901 differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/75/afa96db00c26c6ebf3b377615b4e2a20563ee4 b/tests/resources/reftable/merge-recursive/.gitted/objects/75/afa96db00c26c6ebf3b377615b4e2a20563ee4 new file mode 100644 index 000000000..11d7f94a9 Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/75/afa96db00c26c6ebf3b377615b4e2a20563ee4 differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/75/c653822173a8e5795153ec3773dfe44bb9bb63 b/tests/resources/reftable/merge-recursive/.gitted/objects/75/c653822173a8e5795153ec3773dfe44bb9bb63 new file mode 100644 index 000000000..1495f70f4 --- /dev/null +++ b/tests/resources/reftable/merge-recursive/.gitted/objects/75/c653822173a8e5795153ec3773dfe44bb9bb63 @@ -0,0 +1 @@ +xJ1);ՑLfrYdfSFbwヿm @WcRyh5V1nLܸ0ނc nڦiSӠwsP!gwaZB,CiB@HT ԰P(g@(*h7+,N*ĕd.5P6{|(mOaOo{8"Pbrױ^uɃO_.`s?o0Xa \ No newline at end of file diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/7c/61830f8b8632665bb44ae5d219f520f5aa5bb4 b/tests/resources/reftable/merge-recursive/.gitted/objects/7c/61830f8b8632665bb44ae5d219f520f5aa5bb4 new file mode 100644 index 000000000..04b10f7ee Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/7c/61830f8b8632665bb44ae5d219f520f5aa5bb4 differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/7c/7bf85e978f1d18c0566f702d2cb7766b9c8d4f b/tests/resources/reftable/merge-recursive/.gitted/objects/7c/7bf85e978f1d18c0566f702d2cb7766b9c8d4f new file mode 100644 index 000000000..fe8b15777 --- /dev/null +++ b/tests/resources/reftable/merge-recursive/.gitted/objects/7c/7bf85e978f1d18c0566f702d2cb7766b9c8d4f @@ -0,0 +1 @@ +xN0Dd' \V\~/1rw5m|0 tntƺ%kcnu a:K,^W550j-+k}'⤒#(,HmK 2 ZNǝ=%!QEa^p޹% $Y||N'~[[}hvoSGl̥1I!pNΰkK%  \ No newline at end of file diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/8f/1b918542a5fe9b3bb7a8770a7525ad5b3b5864 b/tests/resources/reftable/merge-recursive/.gitted/objects/8f/1b918542a5fe9b3bb7a8770a7525ad5b3b5864 new file mode 100644 index 000000000..5ecb3e57b Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/8f/1b918542a5fe9b3bb7a8770a7525ad5b3b5864 differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/8f/35f30bfe09513f96cf8aa4df0834ae34e93bae b/tests/resources/reftable/merge-recursive/.gitted/objects/8f/35f30bfe09513f96cf8aa4df0834ae34e93bae new file mode 100644 index 000000000..1011a885d --- /dev/null +++ b/tests/resources/reftable/merge-recursive/.gitted/objects/8f/35f30bfe09513f96cf8aa4df0834ae34e93bae @@ -0,0 +1 @@ +xO 1*ҀfAv`̄\#1jFo뺞4mzcl&toQ *p:9qK])BѤ!+Bʐc8e WDz69+5z{k. sgV9Pƈ'xxO \ No newline at end of file diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/94/d2c01087f48213bd157222d54edfefd77c9bba b/tests/resources/reftable/merge-recursive/.gitted/objects/94/d2c01087f48213bd157222d54edfefd77c9bba new file mode 100644 index 000000000..76ffe4ea7 Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/94/d2c01087f48213bd157222d54edfefd77c9bba differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/95/78b04e2087976e382622322ba476aa40398dc7 b/tests/resources/reftable/merge-recursive/.gitted/objects/95/78b04e2087976e382622322ba476aa40398dc7 new file mode 100644 index 000000000..e3d15aac3 Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/95/78b04e2087976e382622322ba476aa40398dc7 differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/96/23368f0fc562d6d840372ae17dc4cc32d51a80 b/tests/resources/reftable/merge-recursive/.gitted/objects/96/23368f0fc562d6d840372ae17dc4cc32d51a80 new file mode 100644 index 000000000..70bf8fbb0 --- /dev/null +++ b/tests/resources/reftable/merge-recursive/.gitted/objects/96/23368f0fc562d6d840372ae17dc4cc32d51a80 @@ -0,0 +1,2 @@ +xK +1D]H>πYId1oo ԢuJ7"BthuՊ2ypH@bhܡ2IXPIat8OYx6Whֺ=O4][vH| t Tr˸0L#S; \ No newline at end of file diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/97/3b70322e758da87e1ce21d2195d86c5e4e9647 b/tests/resources/reftable/merge-recursive/.gitted/objects/97/3b70322e758da87e1ce21d2195d86c5e4e9647 new file mode 100644 index 000000000..a90a61cd7 --- /dev/null +++ b/tests/resources/reftable/merge-recursive/.gitted/objects/97/3b70322e758da87e1ce21d2195d86c5e4e9647 @@ -0,0 +1 @@ +xN1 )]u^!NDI 8^[z$&u7{7fBD{Rr(䓯2jmL9AHI .TT s T Y6۾]{祭׶Ɇns[(pD8 w5ӓ68u. up`p3 \ No newline at end of file diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/97/5dd228fd1b0cacf2988167088fd1190c9ac0f5 b/tests/resources/reftable/merge-recursive/.gitted/objects/97/5dd228fd1b0cacf2988167088fd1190c9ac0f5 new file mode 100644 index 000000000..96658c4fb Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/97/5dd228fd1b0cacf2988167088fd1190c9ac0f5 differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/98/1c79eb38518d3821e73bb159dc413bb42d6614 b/tests/resources/reftable/merge-recursive/.gitted/objects/98/1c79eb38518d3821e73bb159dc413bb42d6614 new file mode 100644 index 000000000..d5787b44d Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/98/1c79eb38518d3821e73bb159dc413bb42d6614 differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/98/5b725cf91c6861b5e7a419415d03cbcf5f16ca b/tests/resources/reftable/merge-recursive/.gitted/objects/98/5b725cf91c6861b5e7a419415d03cbcf5f16ca new file mode 100644 index 000000000..bc95c6fc5 Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/98/5b725cf91c6861b5e7a419415d03cbcf5f16ca differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/98/cacbdd1fac7bbab54a6c7c97aa2103219e08b8 b/tests/resources/reftable/merge-recursive/.gitted/objects/98/cacbdd1fac7bbab54a6c7c97aa2103219e08b8 new file mode 100644 index 000000000..13344d86c Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/98/cacbdd1fac7bbab54a6c7c97aa2103219e08b8 differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/99/754e36599906b81b917447280c4918269e14ff b/tests/resources/reftable/merge-recursive/.gitted/objects/99/754e36599906b81b917447280c4918269e14ff new file mode 100644 index 000000000..40455efab Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/99/754e36599906b81b917447280c4918269e14ff differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/9a/228c1ee87f286202ec9a25de837a18550013b5 b/tests/resources/reftable/merge-recursive/.gitted/objects/9a/228c1ee87f286202ec9a25de837a18550013b5 new file mode 100644 index 000000000..d6bcd5262 Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/9a/228c1ee87f286202ec9a25de837a18550013b5 differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/9a/e63b4a8ce0f181b2d1d098971733a103226917 b/tests/resources/reftable/merge-recursive/.gitted/objects/9a/e63b4a8ce0f181b2d1d098971733a103226917 new file mode 100644 index 000000000..0cbd00d53 Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/9a/e63b4a8ce0f181b2d1d098971733a103226917 differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/9b/258ad4c39f40c24f66bf1faf48eb6202d59c85 b/tests/resources/reftable/merge-recursive/.gitted/objects/9b/258ad4c39f40c24f66bf1faf48eb6202d59c85 new file mode 100644 index 000000000..305e1f3e9 Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/9b/258ad4c39f40c24f66bf1faf48eb6202d59c85 differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/9c/3f1c70db28c00ce74b22ba3edafe16d9cf03d4 b/tests/resources/reftable/merge-recursive/.gitted/objects/9c/3f1c70db28c00ce74b22ba3edafe16d9cf03d4 new file mode 100644 index 000000000..b0ef1af86 Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/9c/3f1c70db28c00ce74b22ba3edafe16d9cf03d4 differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/9c/dde216049c6a5ccddac0ad81f604419d8990ed b/tests/resources/reftable/merge-recursive/.gitted/objects/9c/dde216049c6a5ccddac0ad81f604419d8990ed new file mode 100644 index 000000000..9f2c92851 --- /dev/null +++ b/tests/resources/reftable/merge-recursive/.gitted/objects/9c/dde216049c6a5ccddac0ad81f604419d8990ed @@ -0,0 +1,2 @@ +xQ +B!EvnPDbA϶繜 Z箝Mo"7)Hvdq0!S,T( J𬞩ɣ8q`8>*}mi,K҇}4/;ZQѻzk1j#Wuv CN \ No newline at end of file diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/9e/12bce04446d097ae1782967a5888c2e2a0d35b b/tests/resources/reftable/merge-recursive/.gitted/objects/9e/12bce04446d097ae1782967a5888c2e2a0d35b new file mode 100644 index 000000000..0940d09c2 Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/9e/12bce04446d097ae1782967a5888c2e2a0d35b differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/a0/2d4fd126e0cc8fb46ee48cf38bad36d44f2dbc b/tests/resources/reftable/merge-recursive/.gitted/objects/a0/2d4fd126e0cc8fb46ee48cf38bad36d44f2dbc new file mode 100644 index 000000000..566976715 Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/a0/2d4fd126e0cc8fb46ee48cf38bad36d44f2dbc differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/a0/65d3022e99a1943177c10a53cce38bc2127042 b/tests/resources/reftable/merge-recursive/.gitted/objects/a0/65d3022e99a1943177c10a53cce38bc2127042 new file mode 100644 index 000000000..d14b7394c Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/a0/65d3022e99a1943177c10a53cce38bc2127042 differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/a0/ce8909834f389b4f8be6a6ec420868422d40a1 b/tests/resources/reftable/merge-recursive/.gitted/objects/a0/ce8909834f389b4f8be6a6ec420868422d40a1 new file mode 100644 index 000000000..5f6643c59 Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/a0/ce8909834f389b4f8be6a6ec420868422d40a1 differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/a2/817ed0e8ca6fe52bf0a20b2f50eb94b9ea5415 b/tests/resources/reftable/merge-recursive/.gitted/objects/a2/817ed0e8ca6fe52bf0a20b2f50eb94b9ea5415 new file mode 100644 index 000000000..a043a8e03 Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/a2/817ed0e8ca6fe52bf0a20b2f50eb94b9ea5415 differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/a2/8c21c90aa36580641b345011869d1a899a6783 b/tests/resources/reftable/merge-recursive/.gitted/objects/a2/8c21c90aa36580641b345011869d1a899a6783 new file mode 100644 index 000000000..91ffb4b88 --- /dev/null +++ b/tests/resources/reftable/merge-recursive/.gitted/objects/a2/8c21c90aa36580641b345011869d1a899a6783 @@ -0,0 +1,2 @@ +xN@ ۥ:\I x^dQ WDg3i\<7le*MbB0 Ji%XTUV[6CԠՔQR0ZjB/TD OmDr% bxR> +jra,hWwY=wo;[nk1'D1Ó/~xmrrmѝROa \ No newline at end of file diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/a2/fa36ffc4a565a223e225d15b18774f87d0c4f0 b/tests/resources/reftable/merge-recursive/.gitted/objects/a2/fa36ffc4a565a223e225d15b18774f87d0c4f0 new file mode 100644 index 000000000..347139464 --- /dev/null +++ b/tests/resources/reftable/merge-recursive/.gitted/objects/a2/fa36ffc4a565a223e225d15b18774f87d0c4f0 @@ -0,0 +1,3 @@ +xA D]s +.Cb c]LfRG¡P9Ѣ%@ k0L bӡ/W^ĄT倾 yIY +*u"Dd("m+Yަ:ougG] ~|@)>5brx7Q \ No newline at end of file diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/a3/4e5a16feabbd0335a633aadb8217c9f3dba58d b/tests/resources/reftable/merge-recursive/.gitted/objects/a3/4e5a16feabbd0335a633aadb8217c9f3dba58d new file mode 100644 index 000000000..00f9c2ddd Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/a3/4e5a16feabbd0335a633aadb8217c9f3dba58d differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/a3/5aa65d86215fce909fc0bcce8949d12becba44 b/tests/resources/reftable/merge-recursive/.gitted/objects/a3/5aa65d86215fce909fc0bcce8949d12becba44 new file mode 100644 index 000000000..e71e9ec44 Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/a3/5aa65d86215fce909fc0bcce8949d12becba44 differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/a3/ca4c462e93fee824c8ad500917ae34b800dea4 b/tests/resources/reftable/merge-recursive/.gitted/objects/a3/ca4c462e93fee824c8ad500917ae34b800dea4 new file mode 100644 index 000000000..dff9e9750 Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/a3/ca4c462e93fee824c8ad500917ae34b800dea4 differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/a6/64873b1c0b9a1ed300f8644dde536fdaa3a34f b/tests/resources/reftable/merge-recursive/.gitted/objects/a6/64873b1c0b9a1ed300f8644dde536fdaa3a34f new file mode 100644 index 000000000..f6b66dada Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/a6/64873b1c0b9a1ed300f8644dde536fdaa3a34f differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/a7/b066537e6be7109abfe4ff97b675d4e077da20 b/tests/resources/reftable/merge-recursive/.gitted/objects/a7/b066537e6be7109abfe4ff97b675d4e077da20 new file mode 100644 index 000000000..54f9b6617 Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/a7/b066537e6be7109abfe4ff97b675d4e077da20 differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/a8/2a121ea36b115548d6dad2cd86ec27f06f7b30 b/tests/resources/reftable/merge-recursive/.gitted/objects/a8/2a121ea36b115548d6dad2cd86ec27f06f7b30 new file mode 100644 index 000000000..e740872fa Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/a8/2a121ea36b115548d6dad2cd86ec27f06f7b30 differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/a9/9bf55117ab1958171fccfeb19885f707bd08fd b/tests/resources/reftable/merge-recursive/.gitted/objects/a9/9bf55117ab1958171fccfeb19885f707bd08fd new file mode 100644 index 000000000..9c3a3ec28 Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/a9/9bf55117ab1958171fccfeb19885f707bd08fd differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/aa/9e263294fd2f6f6fd9ceab23ca8ce3ea2ce707 b/tests/resources/reftable/merge-recursive/.gitted/objects/aa/9e263294fd2f6f6fd9ceab23ca8ce3ea2ce707 new file mode 100644 index 000000000..0ec6cd891 Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/aa/9e263294fd2f6f6fd9ceab23ca8ce3ea2ce707 differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/ad/1ea02c2cc4f55c1dff87b80a086206a73885eb b/tests/resources/reftable/merge-recursive/.gitted/objects/ad/1ea02c2cc4f55c1dff87b80a086206a73885eb new file mode 100644 index 000000000..99207a9dd --- /dev/null +++ b/tests/resources/reftable/merge-recursive/.gitted/objects/ad/1ea02c2cc4f55c1dff87b80a086206a73885eb @@ -0,0 +1,2 @@ +x+)JMU022g040031QH,.H,JL/-+(a9/>~WENYZGj +RSj2I^'y51i0599`e5a z%潎U^XV Vtٙo]2Y~P1($bz7g\QdLɔ3Rsjݿ*~뛘R+<[{ \ No newline at end of file diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/ad/2ace9e15f66b3d1138922e6ffdc3ea3f967fa6 b/tests/resources/reftable/merge-recursive/.gitted/objects/ad/2ace9e15f66b3d1138922e6ffdc3ea3f967fa6 new file mode 100644 index 000000000..8ae3ba5a7 Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/ad/2ace9e15f66b3d1138922e6ffdc3ea3f967fa6 differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/ad/98bfa4679fb00b89207a0a11b8bbf91a3e4de9 b/tests/resources/reftable/merge-recursive/.gitted/objects/ad/98bfa4679fb00b89207a0a11b8bbf91a3e4de9 new file mode 100644 index 000000000..457f9da1f Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/ad/98bfa4679fb00b89207a0a11b8bbf91a3e4de9 differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/b0/1de62cf11945685c98ec671edabdff3e90ddc5 b/tests/resources/reftable/merge-recursive/.gitted/objects/b0/1de62cf11945685c98ec671edabdff3e90ddc5 new file mode 100644 index 000000000..786c9a510 Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/b0/1de62cf11945685c98ec671edabdff3e90ddc5 differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/b0/4823b75c8220b89c2f8da54709cda262304cd3 b/tests/resources/reftable/merge-recursive/.gitted/objects/b0/4823b75c8220b89c2f8da54709cda262304cd3 new file mode 100644 index 000000000..81714b06d Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/b0/4823b75c8220b89c2f8da54709cda262304cd3 differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/b1/71224a4f604b6091072007765419b14c232c1d b/tests/resources/reftable/merge-recursive/.gitted/objects/b1/71224a4f604b6091072007765419b14c232c1d new file mode 100644 index 000000000..987d5fec1 Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/b1/71224a4f604b6091072007765419b14c232c1d differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/b2/908343e3c16249d0036dd444fc0d4662cd8c0e b/tests/resources/reftable/merge-recursive/.gitted/objects/b2/908343e3c16249d0036dd444fc0d4662cd8c0e new file mode 100644 index 000000000..7f0e0aba6 Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/b2/908343e3c16249d0036dd444fc0d4662cd8c0e differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/b2/a81ead9e722af0099fccfb478cea88eea749a2 b/tests/resources/reftable/merge-recursive/.gitted/objects/b2/a81ead9e722af0099fccfb478cea88eea749a2 new file mode 100644 index 000000000..7a8ffe58a Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/b2/a81ead9e722af0099fccfb478cea88eea749a2 differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/b4/cefb3c75770e57bb8bb44e4a50d9578009e847 b/tests/resources/reftable/merge-recursive/.gitted/objects/b4/cefb3c75770e57bb8bb44e4a50d9578009e847 new file mode 100644 index 000000000..836bb4edc Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/b4/cefb3c75770e57bb8bb44e4a50d9578009e847 differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/b6/bd0f9952f396e757d3f91e08c59a7e91707201 b/tests/resources/reftable/merge-recursive/.gitted/objects/b6/bd0f9952f396e757d3f91e08c59a7e91707201 new file mode 100644 index 000000000..87cb8fa04 Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/b6/bd0f9952f396e757d3f91e08c59a7e91707201 differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/b7/de2b52ba055688061355fad1599a5d214ce8f8 b/tests/resources/reftable/merge-recursive/.gitted/objects/b7/de2b52ba055688061355fad1599a5d214ce8f8 new file mode 100644 index 000000000..6fbf58187 Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/b7/de2b52ba055688061355fad1599a5d214ce8f8 differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/b8/a3b657edcf31e6365a2f1c45d45e6c9ebe8f02 b/tests/resources/reftable/merge-recursive/.gitted/objects/b8/a3b657edcf31e6365a2f1c45d45e6c9ebe8f02 new file mode 100644 index 000000000..0b8404bf3 Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/b8/a3b657edcf31e6365a2f1c45d45e6c9ebe8f02 differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/b9/1ef5ffa8612616c8e76051901caafd723f0e2c b/tests/resources/reftable/merge-recursive/.gitted/objects/b9/1ef5ffa8612616c8e76051901caafd723f0e2c new file mode 100644 index 000000000..e19652394 Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/b9/1ef5ffa8612616c8e76051901caafd723f0e2c differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/ba/9dcfe079848e8e5c1b53bc3b6e47ff57f6e481 b/tests/resources/reftable/merge-recursive/.gitted/objects/ba/9dcfe079848e8e5c1b53bc3b6e47ff57f6e481 new file mode 100644 index 000000000..c43b79da3 Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/ba/9dcfe079848e8e5c1b53bc3b6e47ff57f6e481 differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/bb/4e0014fb09d24312f0af37c7a45e5488f19510 b/tests/resources/reftable/merge-recursive/.gitted/objects/bb/4e0014fb09d24312f0af37c7a45e5488f19510 new file mode 100644 index 000000000..ca45760cd --- /dev/null +++ b/tests/resources/reftable/merge-recursive/.gitted/objects/bb/4e0014fb09d24312f0af37c7a45e5488f19510 @@ -0,0 +1,4 @@ +xKj1)tVs}ղf2f' _WT-2 cSK v&8)`# +*ssMI (J%5BUx +!R JbI ࢏nMju~1 OQd]t 1  +~h2OP# \ No newline at end of file diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/bd/97980c22d122509cdd915fd9788d56c8d3ae20 b/tests/resources/reftable/merge-recursive/.gitted/objects/bd/97980c22d122509cdd915fd9788d56c8d3ae20 new file mode 100644 index 000000000..71295e071 Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/bd/97980c22d122509cdd915fd9788d56c8d3ae20 differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/c0/bd078a61d2cc22c52ca5ce04abdcdc5cc1829e b/tests/resources/reftable/merge-recursive/.gitted/objects/c0/bd078a61d2cc22c52ca5ce04abdcdc5cc1829e new file mode 100644 index 000000000..3dde6c243 Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/c0/bd078a61d2cc22c52ca5ce04abdcdc5cc1829e differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/c0/dcb4bfcd86e65a822090aa7a0455413828886b b/tests/resources/reftable/merge-recursive/.gitted/objects/c0/dcb4bfcd86e65a822090aa7a0455413828886b new file mode 100644 index 000000000..f8fe20180 Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/c0/dcb4bfcd86e65a822090aa7a0455413828886b differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/c4/44758b02d4af6e3145ac2fc0e3ed02199cf7ec b/tests/resources/reftable/merge-recursive/.gitted/objects/c4/44758b02d4af6e3145ac2fc0e3ed02199cf7ec new file mode 100644 index 000000000..b2f6662a0 Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/c4/44758b02d4af6e3145ac2fc0e3ed02199cf7ec differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/c4/83ca4bb087174af5cb51d7caa9c09fe4a28ccb b/tests/resources/reftable/merge-recursive/.gitted/objects/c4/83ca4bb087174af5cb51d7caa9c09fe4a28ccb new file mode 100644 index 000000000..643a98280 --- /dev/null +++ b/tests/resources/reftable/merge-recursive/.gitted/objects/c4/83ca4bb087174af5cb51d7caa9c09fe4a28ccb @@ -0,0 +1 @@ +xPKN@ cS̮d#!+v\ d[E}E\`۱lɼ-0.cW5熱5Қ\sX(V#$V;g1H y±ڂP!HmzXb-X \^)\+15WP!g`JHw~Uy㘷<'b^m9oӮ~y\-o˽AdC2}C3g3 GCq;zl<{ \ No newline at end of file diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/c4/e6cca3ec6ae0148ed231f97257df8c311e015f b/tests/resources/reftable/merge-recursive/.gitted/objects/c4/e6cca3ec6ae0148ed231f97257df8c311e015f new file mode 100644 index 000000000..2bbf28f57 --- /dev/null +++ b/tests/resources/reftable/merge-recursive/.gitted/objects/c4/e6cca3ec6ae0148ed231f97257df8c311e015f @@ -0,0 +1 @@ +x%P1n0 WCNEN7:*pԒ/WmI$=^^._?~|C6yTȄA(#1e鴓.(Hto@̸K-as1r6)&)8ŷTa<0ׇJ٢[K5IJcq͓쌫r_ۇ"u^@7~X)2 G,fR`B43vQH֩uab SwcJq)fƔOv; \ No newline at end of file diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/c7/f3257db72e885d6612080c003e0f2ef480e0c4 b/tests/resources/reftable/merge-recursive/.gitted/objects/c7/f3257db72e885d6612080c003e0f2ef480e0c4 new file mode 100644 index 000000000..255624e93 Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/c7/f3257db72e885d6612080c003e0f2ef480e0c4 differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/ca/224bba0a8a24f1768804fe5f565b1014af7ef2 b/tests/resources/reftable/merge-recursive/.gitted/objects/ca/224bba0a8a24f1768804fe5f565b1014af7ef2 new file mode 100644 index 000000000..0dd861f2c Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/ca/224bba0a8a24f1768804fe5f565b1014af7ef2 differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/ca/49d1a8b6116ffeba22667bba265fa5261df7ab b/tests/resources/reftable/merge-recursive/.gitted/objects/ca/49d1a8b6116ffeba22667bba265fa5261df7ab new file mode 100644 index 000000000..1ea596763 --- /dev/null +++ b/tests/resources/reftable/merge-recursive/.gitted/objects/ca/49d1a8b6116ffeba22667bba265fa5261df7ab @@ -0,0 +1,2 @@ +xN1 D+8q^BH:{ݠ^=gFھ_8FWo* s]#ZR)Zl$N0ڔz bY4+ +VCE9>_=$#)hDf#fN-őYmlCy^ikk;F'Twel[@"2Yp6d2,71ˣg48 .hv>d?;No \ No newline at end of file diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/ca/7d316d6d9af99d2481e980d68b77e572d80fe7 b/tests/resources/reftable/merge-recursive/.gitted/objects/ca/7d316d6d9af99d2481e980d68b77e572d80fe7 new file mode 100644 index 000000000..0733fa232 Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/ca/7d316d6d9af99d2481e980d68b77e572d80fe7 differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/ca/fa936d25f0b397432a27201f6b3284c47df8be b/tests/resources/reftable/merge-recursive/.gitted/objects/ca/fa936d25f0b397432a27201f6b3284c47df8be new file mode 100644 index 000000000..fb012eea3 Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/ca/fa936d25f0b397432a27201f6b3284c47df8be differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/cb/49ad76147f5f9439cbd6133708b76142660660 b/tests/resources/reftable/merge-recursive/.gitted/objects/cb/49ad76147f5f9439cbd6133708b76142660660 new file mode 100644 index 000000000..849668c8b Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/cb/49ad76147f5f9439cbd6133708b76142660660 differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/ce/0d744cd2e18eacf883d43471636f231c0995e3 b/tests/resources/reftable/merge-recursive/.gitted/objects/ce/0d744cd2e18eacf883d43471636f231c0995e3 new file mode 100644 index 000000000..63c457a2c Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/ce/0d744cd2e18eacf883d43471636f231c0995e3 differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/d0/97bcf99adb1022a6b7d2e94fed2031ebd9d89c b/tests/resources/reftable/merge-recursive/.gitted/objects/d0/97bcf99adb1022a6b7d2e94fed2031ebd9d89c new file mode 100644 index 000000000..51ffec090 Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/d0/97bcf99adb1022a6b7d2e94fed2031ebd9d89c differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/d0/c9bd6e2a3e327d81a32de51201d3bd58909f7c b/tests/resources/reftable/merge-recursive/.gitted/objects/d0/c9bd6e2a3e327d81a32de51201d3bd58909f7c new file mode 100644 index 000000000..5a0508c5d Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/d0/c9bd6e2a3e327d81a32de51201d3bd58909f7c differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/d0/dd5d9083bda65ec99aa8b9b64a5a278771b70a b/tests/resources/reftable/merge-recursive/.gitted/objects/d0/dd5d9083bda65ec99aa8b9b64a5a278771b70a new file mode 100644 index 000000000..b0d951c9e Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/d0/dd5d9083bda65ec99aa8b9b64a5a278771b70a differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/d2/682aaf9594080ce877b5eeee110850fd6e3480 b/tests/resources/reftable/merge-recursive/.gitted/objects/d2/682aaf9594080ce877b5eeee110850fd6e3480 new file mode 100644 index 000000000..c79a3bb0f --- /dev/null +++ b/tests/resources/reftable/merge-recursive/.gitted/objects/d2/682aaf9594080ce877b5eeee110850fd6e3480 @@ -0,0 +1 @@ +x%Pn@ |_IPS)SХ$2ʶp>'9F:gH$it]p:?p``dΝBzBE)aۅt@4+FC{b]& yl`(p9[*mx`?t2.Ԩ^ReMEZVE ƕd;z@>+r^[fFOvۅЋ \ No newline at end of file diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/d3/482dbdca5bb83aaf3e3768359855d55aef84d7 b/tests/resources/reftable/merge-recursive/.gitted/objects/d3/482dbdca5bb83aaf3e3768359855d55aef84d7 new file mode 100644 index 000000000..8442948fa Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/d3/482dbdca5bb83aaf3e3768359855d55aef84d7 differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/d5/015f9436b2d8c842bf6616e7cf5bc54eb79ced b/tests/resources/reftable/merge-recursive/.gitted/objects/d5/015f9436b2d8c842bf6616e7cf5bc54eb79ced new file mode 100644 index 000000000..6d4446ec4 Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/d5/015f9436b2d8c842bf6616e7cf5bc54eb79ced differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/d6/04c75019c282144bdbbf3fd3462ba74b240efc b/tests/resources/reftable/merge-recursive/.gitted/objects/d6/04c75019c282144bdbbf3fd3462ba74b240efc new file mode 100644 index 000000000..059fcfe72 Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/d6/04c75019c282144bdbbf3fd3462ba74b240efc differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/d7/1c24b3b113fd1d1909998c5bfe33b86a65ee03 b/tests/resources/reftable/merge-recursive/.gitted/objects/d7/1c24b3b113fd1d1909998c5bfe33b86a65ee03 new file mode 100644 index 000000000..66720086c Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/d7/1c24b3b113fd1d1909998c5bfe33b86a65ee03 differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/d8/dd349b78f19a4ebe3357bacb8138f00bf5ed41 b/tests/resources/reftable/merge-recursive/.gitted/objects/d8/dd349b78f19a4ebe3357bacb8138f00bf5ed41 new file mode 100644 index 000000000..ade33f7f5 Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/d8/dd349b78f19a4ebe3357bacb8138f00bf5ed41 differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/d8/e05a90b3c2240d71a20c2502c937d9b7d22777 b/tests/resources/reftable/merge-recursive/.gitted/objects/d8/e05a90b3c2240d71a20c2502c937d9b7d22777 new file mode 100644 index 000000000..b157ba17c --- /dev/null +++ b/tests/resources/reftable/merge-recursive/.gitted/objects/d8/e05a90b3c2240d71a20c2502c937d9b7d22777 @@ -0,0 +1,2 @@ +x%Pn@ |_IQS)SХ$2ʶp>'9F:gH$it]p:oB8u0L2N!=ZĔ0B: !ѽ1.s Ӽ60FvZMA^ +Vn-yb6<0ׇq -jT/)ɲʦ"-[UOgz@>+r^[fFOvۄ𶋅 \ No newline at end of file diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/da/b7b53383a1fec46632e60a1d847ce4f9ae14f2 b/tests/resources/reftable/merge-recursive/.gitted/objects/da/b7b53383a1fec46632e60a1d847ce4f9ae14f2 new file mode 100644 index 000000000..cc4f24369 Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/da/b7b53383a1fec46632e60a1d847ce4f9ae14f2 differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/db/203155a789fb749aa3c14e93eea2c744a9c6c7 b/tests/resources/reftable/merge-recursive/.gitted/objects/db/203155a789fb749aa3c14e93eea2c744a9c6c7 new file mode 100644 index 000000000..e9f7fd8fd --- /dev/null +++ b/tests/resources/reftable/merge-recursive/.gitted/objects/db/203155a789fb749aa3c14e93eea2c744a9c6c7 @@ -0,0 +1 @@ +xMJ1]$_q;/t;D Ԧ((K k2S A,J*b[,'KG dyRP0PuF1 o$jL 81}l}6'q/}9nC#$mQ'=-DŽzNܶ{nD2ZQk5Yn0hn,UV8e N;G>>MpM \ No newline at end of file diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/e2/93bfdddb81a853bbb16b8b58e68626f30841a4 b/tests/resources/reftable/merge-recursive/.gitted/objects/e2/93bfdddb81a853bbb16b8b58e68626f30841a4 new file mode 100644 index 000000000..fab55fea6 Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/e2/93bfdddb81a853bbb16b8b58e68626f30841a4 differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/e2/c84bb33992a455b1a7a5019f0e38d883d3f475 b/tests/resources/reftable/merge-recursive/.gitted/objects/e2/c84bb33992a455b1a7a5019f0e38d883d3f475 new file mode 100644 index 000000000..8c6686706 Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/e2/c84bb33992a455b1a7a5019f0e38d883d3f475 differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/e2/d185fa827d58134cea20b9e1df893833c6560e b/tests/resources/reftable/merge-recursive/.gitted/objects/e2/d185fa827d58134cea20b9e1df893833c6560e new file mode 100644 index 000000000..fc80c0851 Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/e2/d185fa827d58134cea20b9e1df893833c6560e differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/e5/0fbbd701458757bdfe9815f58ed717c588d1b5 b/tests/resources/reftable/merge-recursive/.gitted/objects/e5/0fbbd701458757bdfe9815f58ed717c588d1b5 new file mode 100644 index 000000000..96467c106 --- /dev/null +++ b/tests/resources/reftable/merge-recursive/.gitted/objects/e5/0fbbd701458757bdfe9815f58ed717c588d1b5 @@ -0,0 +1,3 @@ +x%P1n0 Wݡ@SKCCG%QXr}&IKi*ݡRKl8͆Uj2*HLx>3?03RKXNXPZɩ9[-=\߷_밓q9El-ҳ*X7n\$ +C: hVe^[<ᨐżԄE +7LH[@Wvfw.0u:Ժ.U=Ld{L 4 0m$ox \ No newline at end of file diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/e5/20e6aaf8d1e68a433e29d4360c1e74aa4b24d1 b/tests/resources/reftable/merge-recursive/.gitted/objects/e5/20e6aaf8d1e68a433e29d4360c1e74aa4b24d1 new file mode 100644 index 000000000..bcf2dcfc5 Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/e5/20e6aaf8d1e68a433e29d4360c1e74aa4b24d1 differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/e6/269ce9017816d67c7189a58b6d0d22bf4b8a1a b/tests/resources/reftable/merge-recursive/.gitted/objects/e6/269ce9017816d67c7189a58b6d0d22bf4b8a1a new file mode 100644 index 000000000..f9a0a27cc Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/e6/269ce9017816d67c7189a58b6d0d22bf4b8a1a differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/e9/30c8c67848df4aa66319c5752fab6b8fdec765 b/tests/resources/reftable/merge-recursive/.gitted/objects/e9/30c8c67848df4aa66319c5752fab6b8fdec765 new file mode 100644 index 000000000..c0ba76deb Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/e9/30c8c67848df4aa66319c5752fab6b8fdec765 differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/ea/3521485adfa0b0373deaaa06db9218a22edae8 b/tests/resources/reftable/merge-recursive/.gitted/objects/ea/3521485adfa0b0373deaaa06db9218a22edae8 new file mode 100644 index 000000000..40d89843c Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/ea/3521485adfa0b0373deaaa06db9218a22edae8 differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/ef/1783444b61a8671beea4ce1f4d0202677dfbfb b/tests/resources/reftable/merge-recursive/.gitted/objects/ef/1783444b61a8671beea4ce1f4d0202677dfbfb new file mode 100644 index 000000000..67e6e8a5e --- /dev/null +++ b/tests/resources/reftable/merge-recursive/.gitted/objects/ef/1783444b61a8671beea4ce1f4d0202677dfbfb @@ -0,0 +1,3 @@ +xO[ +0; TI " l-Fj3Pr+(+7ue~0bxL4A;TpJDŽcZqd#FmD kdGg +5e*Qqs?৶=1Vmc+Y#eI9yv5 70U \ No newline at end of file diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/f0/856993e005c0d8ed2dc7cdc222cc1d89fb3c77 b/tests/resources/reftable/merge-recursive/.gitted/objects/f0/856993e005c0d8ed2dc7cdc222cc1d89fb3c77 new file mode 100644 index 000000000..22b1ad94c Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/f0/856993e005c0d8ed2dc7cdc222cc1d89fb3c77 differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/f1/3e1bc6ba935fce2efffa5be4c4832404034ef1 b/tests/resources/reftable/merge-recursive/.gitted/objects/f1/3e1bc6ba935fce2efffa5be4c4832404034ef1 new file mode 100644 index 000000000..e115747a2 Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/f1/3e1bc6ba935fce2efffa5be4c4832404034ef1 differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/f1/72517a8cf39e009ffff541ee52429b89e418f3 b/tests/resources/reftable/merge-recursive/.gitted/objects/f1/72517a8cf39e009ffff541ee52429b89e418f3 new file mode 100644 index 000000000..3d29a0fe8 Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/f1/72517a8cf39e009ffff541ee52429b89e418f3 differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/f1/b44c04989a3a1c14b036cfadfa328d53a7bc5e b/tests/resources/reftable/merge-recursive/.gitted/objects/f1/b44c04989a3a1c14b036cfadfa328d53a7bc5e new file mode 100644 index 000000000..7cbaaeecf Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/f1/b44c04989a3a1c14b036cfadfa328d53a7bc5e differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/f2/9ccca75754d8476e5dad8cf250e03d43fe9e6c b/tests/resources/reftable/merge-recursive/.gitted/objects/f2/9ccca75754d8476e5dad8cf250e03d43fe9e6c new file mode 100644 index 000000000..b91872905 Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/f2/9ccca75754d8476e5dad8cf250e03d43fe9e6c differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/f3/2c284f537ff1a55d3cbfe9a37d431b6edfadc2 b/tests/resources/reftable/merge-recursive/.gitted/objects/f3/2c284f537ff1a55d3cbfe9a37d431b6edfadc2 new file mode 100644 index 000000000..be3ceccdc Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/f3/2c284f537ff1a55d3cbfe9a37d431b6edfadc2 differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/f3/5f159ff5d44dfd9f52d63dd5b659f0521ff569 b/tests/resources/reftable/merge-recursive/.gitted/objects/f3/5f159ff5d44dfd9f52d63dd5b659f0521ff569 new file mode 100644 index 000000000..5179f2ccf Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/f3/5f159ff5d44dfd9f52d63dd5b659f0521ff569 differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/f4/c149e7d0983e90e9ee802ff57ae3c905ba63da b/tests/resources/reftable/merge-recursive/.gitted/objects/f4/c149e7d0983e90e9ee802ff57ae3c905ba63da new file mode 100644 index 000000000..e9c675b6d Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/f4/c149e7d0983e90e9ee802ff57ae3c905ba63da differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/f5/1658077d85f2264fa179b4d0848268cb3475c3 b/tests/resources/reftable/merge-recursive/.gitted/objects/f5/1658077d85f2264fa179b4d0848268cb3475c3 new file mode 100644 index 000000000..3b4eb97e9 --- /dev/null +++ b/tests/resources/reftable/merge-recursive/.gitted/objects/f5/1658077d85f2264fa179b4d0848268cb3475c3 @@ -0,0 +1,2 @@ +xERN1W,}D@Jsl^'3Ǯz}{@٘o^X3y';K8ęOlI)g7d3Q FABFtc9*~)@a1L. ݜĔXiV1a2tP*$%ɝ׭q$ET<< UP;uKu*T⤛ +&U-q̱*nѥ fgg:ע4!AASmĹiQށm E 43FgFғaD5 Y)G8@*g1NN;_ jw3*Fzv~y|s \ No newline at end of file diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/f6/5de1834f57708e76d8dc25502b7f1ecbcce162 b/tests/resources/reftable/merge-recursive/.gitted/objects/f6/5de1834f57708e76d8dc25502b7f1ecbcce162 new file mode 100644 index 000000000..3d238fd8c Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/f6/5de1834f57708e76d8dc25502b7f1ecbcce162 differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/f7/929c5a67a4bdc98247fb4b5098675723932a64 b/tests/resources/reftable/merge-recursive/.gitted/objects/f7/929c5a67a4bdc98247fb4b5098675723932a64 new file mode 100644 index 000000000..2861579e8 Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/f7/929c5a67a4bdc98247fb4b5098675723932a64 differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/f9/c04e4e9d4aaf1e6fe7478a7cc0756554974c2b b/tests/resources/reftable/merge-recursive/.gitted/objects/f9/c04e4e9d4aaf1e6fe7478a7cc0756554974c2b new file mode 100644 index 000000000..bc44fa73a Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/f9/c04e4e9d4aaf1e6fe7478a7cc0756554974c2b differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/fa/567f568ed72157c0c617438d077695b99d9aac b/tests/resources/reftable/merge-recursive/.gitted/objects/fa/567f568ed72157c0c617438d077695b99d9aac new file mode 100644 index 000000000..ad5a3cf4f Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/fa/567f568ed72157c0c617438d077695b99d9aac differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/fd/8b5fe88cda995e70a22ed98701e65b843e05ec b/tests/resources/reftable/merge-recursive/.gitted/objects/fd/8b5fe88cda995e70a22ed98701e65b843e05ec new file mode 100644 index 000000000..b6f14634e Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/fd/8b5fe88cda995e70a22ed98701e65b843e05ec differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/fe/f01f3104c8047d05e8572e521c454f8fd4b8db b/tests/resources/reftable/merge-recursive/.gitted/objects/fe/f01f3104c8047d05e8572e521c454f8fd4b8db new file mode 100644 index 000000000..715b6a865 Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/fe/f01f3104c8047d05e8572e521c454f8fd4b8db differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/ff/b36e513f5fdf8a6ba850a20142676a2ac4807d b/tests/resources/reftable/merge-recursive/.gitted/objects/ff/b36e513f5fdf8a6ba850a20142676a2ac4807d new file mode 100644 index 000000000..f655d12ea Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/ff/b36e513f5fdf8a6ba850a20142676a2ac4807d differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/objects/info/commit-graph b/tests/resources/reftable/merge-recursive/.gitted/objects/info/commit-graph new file mode 100644 index 000000000..da055f180 Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/objects/info/commit-graph differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/refs/heads b/tests/resources/reftable/merge-recursive/.gitted/refs/heads new file mode 100644 index 000000000..3e639a56a --- /dev/null +++ b/tests/resources/reftable/merge-recursive/.gitted/refs/heads @@ -0,0 +1 @@ +this repository uses the reftable format diff --git a/tests/resources/reftable/merge-recursive/.gitted/reftable/0x000000000001-0x000000000001-4a306a9f.ref b/tests/resources/reftable/merge-recursive/.gitted/reftable/0x000000000001-0x000000000001-4a306a9f.ref new file mode 100644 index 000000000..372635c68 Binary files /dev/null and b/tests/resources/reftable/merge-recursive/.gitted/reftable/0x000000000001-0x000000000001-4a306a9f.ref differ diff --git a/tests/resources/reftable/merge-recursive/.gitted/reftable/tables.list b/tests/resources/reftable/merge-recursive/.gitted/reftable/tables.list new file mode 100644 index 000000000..b94b05b14 --- /dev/null +++ b/tests/resources/reftable/merge-recursive/.gitted/reftable/tables.list @@ -0,0 +1 @@ +0x000000000001-0x000000000001-4a306a9f.ref diff --git a/tests/resources/reftable/merge-recursive/asparagus.txt b/tests/resources/reftable/merge-recursive/asparagus.txt new file mode 100644 index 000000000..ffb36e513 --- /dev/null +++ b/tests/resources/reftable/merge-recursive/asparagus.txt @@ -0,0 +1,10 @@ +ASPARAGUS SOUP. + +Take four large bunches of asparagus, scrape it nicely, cut off one inch +of the tops, and lay them in water, chop the stalks and put them on the +fire with a piece of bacon, a large onion cut up, and pepper and salt; +add two quarts of water, boil them till the stalks are quite soft, then +pulp them through a sieve, and strain the water to it, which must be put +back in the pot; put into it a chicken cut up, with the tops of +asparagus which had been laid by, boil it until these last articles are +sufficiently done, thicken with flour, butter and milk, and serve it up. diff --git a/tests/resources/reftable/merge-recursive/beef.txt b/tests/resources/reftable/merge-recursive/beef.txt new file mode 100644 index 000000000..68f6182f4 --- /dev/null +++ b/tests/resources/reftable/merge-recursive/beef.txt @@ -0,0 +1,22 @@ +BEEF SOUP. + +Take the hind shin of beef, cut off all the flesh off the leg-bone, +which must be taken away entirely, or the soup will be greasy. Wash the +meat clean and lay it in a pot, sprinkle over it one small +table-spoonful of pounded black pepper, and two of salt; three onions +the size of a hen's egg, cut small, six small carrots scraped and cut +up, two small turnips pared and cut into dice; pour on three quarts of +water, cover the pot close, and keep it gently and steadily boiling five +hours, which will leave about three pints of clear soup; do not let the +pot boil over, but take off the scum carefully, as it rises. When it has +boiled four hours, put in a small bundle of thyme and parsley, and a +pint of celery cut small, or a tea-spoonful of celery seed pounded. +These latter ingredients would lose their delicate flavour if boiled too +much. Just before you take it up, brown it in the following manner: put +a small table-spoonful of nice brown sugar into an iron skillet, set it +on the fire and stir it till it melts and looks very dark, pour into it +a ladle full of the soup, a little at a time; stirring it all the while. +Strain this browning and mix it well with the soup; take out the bundle +of thyme and parsley, put the nicest pieces of meat in your tureen, and +pour on the soup and vegetables; put in some toasted bread cut in dice, +and serve it up. diff --git a/tests/resources/reftable/merge-recursive/bouilli.txt b/tests/resources/reftable/merge-recursive/bouilli.txt new file mode 100644 index 000000000..4b7c56500 --- /dev/null +++ b/tests/resources/reftable/merge-recursive/bouilli.txt @@ -0,0 +1,18 @@ +SOUP WITH BOUILLI. + +Take the nicest part of the thick brisket of beef, about eight pounds, +put it into a pot with every thing directed for the other soup; make it +exactly in the same way, only put it on an hour sooner, that you may +have time to prepare the bouilli; after it has boiled five hours, take +out the beef, cover up the soup and set it near the fire that it may +keep hot. Take the skin off the beef, have the yelk of an egg well +beaten, dip a feather in it and wash the top of your beef, sprinkle over +it the crumb of stale bread finely grated, put it in a Dutch oven +previously heated, put the top on with coals enough to brown, but not +burn the beef; let it stand nearly an hour, and prepare your gravy +thus:--Take a sufficient quantity of soup and the vegetables boiled in +it; add to it a table-spoonful of red wine, and two of mushroom catsup, +thicken with a little bit of butter and a little brown flour; make it +very hot, pour it in your dish, and put the beef on it. Garnish it with +green pickle, cut in thin slices, serve up the soup in a tureen with +bits of toasted bread. diff --git a/tests/resources/reftable/merge-recursive/gravy.txt b/tests/resources/reftable/merge-recursive/gravy.txt new file mode 100644 index 000000000..c4e6cca3e --- /dev/null +++ b/tests/resources/reftable/merge-recursive/gravy.txt @@ -0,0 +1,8 @@ +GRAVY SOUP. + +Get eight pounds of coarse lean beef--wash it clean and lay it in your +pot, put in the same ingredients as for the shin soup, with the same +quantity of water, and follow the process directed for that. Strain the +soup through a sieve, and serve it up clear, with nothing more than +toasted bread in it; two table-spoonsful of mushroom catsup will add a +fine flavour to the soup. diff --git a/tests/resources/reftable/merge-recursive/oyster.txt b/tests/resources/reftable/merge-recursive/oyster.txt new file mode 100644 index 000000000..7c7e08f95 --- /dev/null +++ b/tests/resources/reftable/merge-recursive/oyster.txt @@ -0,0 +1,13 @@ +OYSTER SOUP! + +Wash and drain two quarts of oysters, put them on with three quarts of +water, three onions chopped up, two or three slices of lean ham, pepper +and salt; boil it till reduced one-half, strain it through a sieve, +return the liquid into the pot, put in one quart of fresh oysters, boil +it till they are sufficiently done, and thicken the soup with four +spoonsful of flour, two gills of rich cream, and the yelks of six new +laid eggs beaten well; boil it a few minutes after the thickening is put +in. Take care that it does not curdle, and that the flour is not in +lumps; serve it up with the last oysters that were put in. If the +flavour of thyme be agreeable, you may put in a little, but take care +that it does not boil in it long enough to discolour the soup. diff --git a/tests/resources/reftable/merge-recursive/veal.txt b/tests/resources/reftable/merge-recursive/veal.txt new file mode 100644 index 000000000..898d12687 --- /dev/null +++ b/tests/resources/reftable/merge-recursive/veal.txt @@ -0,0 +1,20 @@ +VEAL SOUP. + +PUT INTO A POT THREE QUARTS OF WATER, 3 onions cut small, ONE +spoonful of black pepper pounded, and two of salt, with two or three +slices of lean ham; let it boil steadily two hours; skim it +occasionally, then put into it a shin of veal, let it boil two hours +longer; take out the slices of ham, and skim off the grease if any +should rise, take a gill of good cream, mix with it two table-spoonsful +of flour very nicely, and the yelks of two eggs beaten well, strain this +mixture, and add some chopped parsley; pour some soup on by degrees, +stir it well, and pour it into the pot, continuing to stir until it has +boiled two or three minutes to take off the raw taste of the eggs. If +the cream be not perfectly sweet, and the eggs quite new, the thickening +will curdle in the soup. For a change you may put a dozen ripe tomatos +in, first taking off their skins, by letting them stand a few minutes in +hot water, when they may be easily peeled. When made in this way you +must thicken it with the flour only. Any part of the veal may be used, +but the shin or knuckle is the nicest. + +This is a mighty fine recipe! diff --git a/tests/resources/reftable/merge-resolve/.gitted/COMMIT_EDITMSG b/tests/resources/reftable/merge-resolve/.gitted/COMMIT_EDITMSG new file mode 100644 index 000000000..245b18a2c --- /dev/null +++ b/tests/resources/reftable/merge-resolve/.gitted/COMMIT_EDITMSG @@ -0,0 +1 @@ +rename conflict theirs diff --git a/tests/resources/reftable/merge-resolve/.gitted/HEAD b/tests/resources/reftable/merge-resolve/.gitted/HEAD new file mode 100644 index 000000000..fe6d7e5fa --- /dev/null +++ b/tests/resources/reftable/merge-resolve/.gitted/HEAD @@ -0,0 +1 @@ +ref: refs/heads/.invalid diff --git a/tests/resources/reftable/merge-resolve/.gitted/config b/tests/resources/reftable/merge-resolve/.gitted/config new file mode 100644 index 000000000..a2050209e --- /dev/null +++ b/tests/resources/reftable/merge-resolve/.gitted/config @@ -0,0 +1,10 @@ +[core] + repositoryformatversion = 1 + filemode = true + bare = false + logallrefupdates = true + ignorecase = true +[submodule "submodule"] + url = ../submodule +[extensions] + refstorage = reftable diff --git a/tests/resources/reftable/merge-resolve/.gitted/description b/tests/resources/reftable/merge-resolve/.gitted/description new file mode 100644 index 000000000..498b267a8 --- /dev/null +++ b/tests/resources/reftable/merge-resolve/.gitted/description @@ -0,0 +1 @@ +Unnamed repository; edit this file 'description' to name the repository. diff --git a/tests/resources/reftable/merge-resolve/.gitted/index b/tests/resources/reftable/merge-resolve/.gitted/index new file mode 100644 index 000000000..230eba9eb Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/index differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/modules/submodule/HEAD b/tests/resources/reftable/merge-resolve/.gitted/modules/submodule/HEAD new file mode 100644 index 000000000..cb089cd89 --- /dev/null +++ b/tests/resources/reftable/merge-resolve/.gitted/modules/submodule/HEAD @@ -0,0 +1 @@ +ref: refs/heads/master diff --git a/tests/resources/reftable/merge-resolve/.gitted/modules/submodule/ORIG_HEAD b/tests/resources/reftable/merge-resolve/.gitted/modules/submodule/ORIG_HEAD new file mode 100644 index 000000000..d1bfcf0f4 --- /dev/null +++ b/tests/resources/reftable/merge-resolve/.gitted/modules/submodule/ORIG_HEAD @@ -0,0 +1 @@ +ae39c77c70cb6bad18bb471912460c4e1ba0f586 diff --git a/tests/resources/reftable/merge-resolve/.gitted/modules/submodule/config b/tests/resources/reftable/merge-resolve/.gitted/modules/submodule/config new file mode 100644 index 000000000..575cc8599 --- /dev/null +++ b/tests/resources/reftable/merge-resolve/.gitted/modules/submodule/config @@ -0,0 +1,15 @@ +[core] + repositoryformatversion = 0 + filemode = false + bare = false + logallrefupdates = true + worktree = ../../../submodule + symlinks = false + ignorecase = true + hideDotFiles = dotGitOnly +[remote "origin"] + url = c:/Temp/TestRepos/submodule + fetch = +refs/heads/*:refs/remotes/origin/* +[branch "master"] + remote = origin + merge = refs/heads/master diff --git a/tests/resources/reftable/merge-resolve/.gitted/modules/submodule/index b/tests/resources/reftable/merge-resolve/.gitted/modules/submodule/index new file mode 100644 index 000000000..e948afb27 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/modules/submodule/index differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/modules/submodule/info/exclude b/tests/resources/reftable/merge-resolve/.gitted/modules/submodule/info/exclude new file mode 100644 index 000000000..a5196d1be --- /dev/null +++ b/tests/resources/reftable/merge-resolve/.gitted/modules/submodule/info/exclude @@ -0,0 +1,6 @@ +# git ls-files --others --exclude-from=.git/info/exclude +# Lines that start with '#' are comments. +# For a project mostly in C, the following would be a good set of +# exclude patterns (uncomment them if you want to use them): +# *.[oa] +# *~ diff --git a/tests/resources/reftable/merge-resolve/.gitted/modules/submodule/objects/18/fae1354bba0a5f1e6a531f9988369142c24a9e b/tests/resources/reftable/merge-resolve/.gitted/modules/submodule/objects/18/fae1354bba0a5f1e6a531f9988369142c24a9e new file mode 100644 index 000000000..fcf1c6381 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/modules/submodule/objects/18/fae1354bba0a5f1e6a531f9988369142c24a9e differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/modules/submodule/objects/29/7aa6cd028b3336c7802c7a6f49143da4e1602d b/tests/resources/reftable/merge-resolve/.gitted/modules/submodule/objects/29/7aa6cd028b3336c7802c7a6f49143da4e1602d new file mode 100644 index 000000000..aa9fc5006 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/modules/submodule/objects/29/7aa6cd028b3336c7802c7a6f49143da4e1602d differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/modules/submodule/objects/38/6c80dc813b89d719797668f40c1be0a6efa996 b/tests/resources/reftable/merge-resolve/.gitted/modules/submodule/objects/38/6c80dc813b89d719797668f40c1be0a6efa996 new file mode 100644 index 000000000..bc9a32ebc Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/modules/submodule/objects/38/6c80dc813b89d719797668f40c1be0a6efa996 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/modules/submodule/objects/ab/435a147bae6d5906ecfd0916a570c4ab3eeea8 b/tests/resources/reftable/merge-resolve/.gitted/modules/submodule/objects/ab/435a147bae6d5906ecfd0916a570c4ab3eeea8 new file mode 100644 index 000000000..65a8d759f Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/modules/submodule/objects/ab/435a147bae6d5906ecfd0916a570c4ab3eeea8 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/modules/submodule/objects/ad/16e0a7684ea95bf892980a2ee412293ae979cc b/tests/resources/reftable/merge-resolve/.gitted/modules/submodule/objects/ad/16e0a7684ea95bf892980a2ee412293ae979cc new file mode 100644 index 000000000..49e1aafeb Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/modules/submodule/objects/ad/16e0a7684ea95bf892980a2ee412293ae979cc differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/modules/submodule/objects/ae/39c77c70cb6bad18bb471912460c4e1ba0f586 b/tests/resources/reftable/merge-resolve/.gitted/modules/submodule/objects/ae/39c77c70cb6bad18bb471912460c4e1ba0f586 new file mode 100644 index 000000000..6ceffdd4e --- /dev/null +++ b/tests/resources/reftable/merge-resolve/.gitted/modules/submodule/objects/ae/39c77c70cb6bad18bb471912460c4e1ba0f586 @@ -0,0 +1,2 @@ +x !@=S hf%x! ]k/{k-a] xWs =,lP +#g0KIC ,51 9;alB=>|h}_{{Me?u6">:叄ʃ6^Kd \ No newline at end of file diff --git a/tests/resources/reftable/merge-resolve/.gitted/modules/submodule/objects/c2/0765f6e24e8bbb63a648d0d11d84da63170190 b/tests/resources/reftable/merge-resolve/.gitted/modules/submodule/objects/c2/0765f6e24e8bbb63a648d0d11d84da63170190 new file mode 100644 index 000000000..14781032f Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/modules/submodule/objects/c2/0765f6e24e8bbb63a648d0d11d84da63170190 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/modules/submodule/objects/d3/d806a4bef96889117fd7ebac0e3cb5ec152932 b/tests/resources/reftable/merge-resolve/.gitted/modules/submodule/objects/d3/d806a4bef96889117fd7ebac0e3cb5ec152932 new file mode 100644 index 000000000..8df72a45c --- /dev/null +++ b/tests/resources/reftable/merge-resolve/.gitted/modules/submodule/objects/d3/d806a4bef96889117fd7ebac0e3cb5ec152932 @@ -0,0 +1,3 @@ +xA +0E]semDx$҂@gpQs^+ZD[a +,cGsBO# vhGpIZ4U{^c]zo@ǎ\M-\ ZC'g$楧f&%%g5qYeZokM2ԐX\ZDPC~^ZNfrIf^:XZHي1O(_,' jvn~JfZ&5&ؽ +gz43^2 I{| 2mg˾15ӿ,\})TC)0Xvz֛9MՅ'6b# \ No newline at end of file diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/05/8541fc37114bfc1dddf6bd6bffc7fae5c2e6fe b/tests/resources/reftable/merge-resolve/.gitted/objects/05/8541fc37114bfc1dddf6bd6bffc7fae5c2e6fe new file mode 100644 index 000000000..d79dc30ba Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/05/8541fc37114bfc1dddf6bd6bffc7fae5c2e6fe differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/05/f3c1a2a56ca95c3d2ef28dc9ddf32b5cd6c91c b/tests/resources/reftable/merge-resolve/.gitted/objects/05/f3c1a2a56ca95c3d2ef28dc9ddf32b5cd6c91c new file mode 100644 index 000000000..7b4b152f3 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/05/f3c1a2a56ca95c3d2ef28dc9ddf32b5cd6c91c differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/07/a759da919f737221791d542f176ab49c88837f b/tests/resources/reftable/merge-resolve/.gitted/objects/07/a759da919f737221791d542f176ab49c88837f new file mode 100644 index 000000000..a34b6c235 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/07/a759da919f737221791d542f176ab49c88837f differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/07/c514b04698e068892b31c8d352b85813b99c6e b/tests/resources/reftable/merge-resolve/.gitted/objects/07/c514b04698e068892b31c8d352b85813b99c6e new file mode 100644 index 000000000..23ab92171 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/07/c514b04698e068892b31c8d352b85813b99c6e differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/09/055301463b7f2f8ee5d368f8ed5c0a40ad8515 b/tests/resources/reftable/merge-resolve/.gitted/objects/09/055301463b7f2f8ee5d368f8ed5c0a40ad8515 new file mode 100644 index 000000000..bf5b0fcc5 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/09/055301463b7f2f8ee5d368f8ed5c0a40ad8515 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/09/17bb159596aea4d295f4857da77e8f96b3c7dc b/tests/resources/reftable/merge-resolve/.gitted/objects/09/17bb159596aea4d295f4857da77e8f96b3c7dc new file mode 100644 index 000000000..9fb640dd5 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/09/17bb159596aea4d295f4857da77e8f96b3c7dc differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/09/2ce8682d7f3a2a3a769a6daca58950168ba5c4 b/tests/resources/reftable/merge-resolve/.gitted/objects/09/2ce8682d7f3a2a3a769a6daca58950168ba5c4 new file mode 100644 index 000000000..b709cf461 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/09/2ce8682d7f3a2a3a769a6daca58950168ba5c4 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/09/3bebf072dd4bbba88833667d6ffe454df199e1 b/tests/resources/reftable/merge-resolve/.gitted/objects/09/3bebf072dd4bbba88833667d6ffe454df199e1 new file mode 100644 index 000000000..ae13207d7 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/09/3bebf072dd4bbba88833667d6ffe454df199e1 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/09/768bed22680cdb0859683fa9677ccc8d5a25c1 b/tests/resources/reftable/merge-resolve/.gitted/objects/09/768bed22680cdb0859683fa9677ccc8d5a25c1 new file mode 100644 index 000000000..5f4b4dab1 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/09/768bed22680cdb0859683fa9677ccc8d5a25c1 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/0a/75d9aac1dc84fb5aa51f7325c0ab53242ddef7 b/tests/resources/reftable/merge-resolve/.gitted/objects/0a/75d9aac1dc84fb5aa51f7325c0ab53242ddef7 new file mode 100644 index 000000000..d5377341a Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/0a/75d9aac1dc84fb5aa51f7325c0ab53242ddef7 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/0c/fd6c54ef6532d862408f562309dc9c74a401e8 b/tests/resources/reftable/merge-resolve/.gitted/objects/0c/fd6c54ef6532d862408f562309dc9c74a401e8 new file mode 100644 index 000000000..40f628f89 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/0c/fd6c54ef6532d862408f562309dc9c74a401e8 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/0d/52e3a556e189ba0948ae56780918011c1b167d b/tests/resources/reftable/merge-resolve/.gitted/objects/0d/52e3a556e189ba0948ae56780918011c1b167d new file mode 100644 index 000000000..4b633e504 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/0d/52e3a556e189ba0948ae56780918011c1b167d differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/0d/872f8e871a30208305978ecbf9e66d864f1638 b/tests/resources/reftable/merge-resolve/.gitted/objects/0d/872f8e871a30208305978ecbf9e66d864f1638 new file mode 100644 index 000000000..4cbc18e84 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/0d/872f8e871a30208305978ecbf9e66d864f1638 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/0e/c5f433959cd46177f745903353efb5be08d151 b/tests/resources/reftable/merge-resolve/.gitted/objects/0e/c5f433959cd46177f745903353efb5be08d151 new file mode 100644 index 000000000..1bee56c14 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/0e/c5f433959cd46177f745903353efb5be08d151 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/0f/3fc5dddc8964b9ac1040d0e957f9eb02d9efb3 b/tests/resources/reftable/merge-resolve/.gitted/objects/0f/3fc5dddc8964b9ac1040d0e957f9eb02d9efb3 new file mode 100644 index 000000000..d0ca42dad Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/0f/3fc5dddc8964b9ac1040d0e957f9eb02d9efb3 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/11/aeee27ac45a8402c2fd5b875d66dd844e5df00 b/tests/resources/reftable/merge-resolve/.gitted/objects/11/aeee27ac45a8402c2fd5b875d66dd844e5df00 new file mode 100644 index 000000000..90e729f6d Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/11/aeee27ac45a8402c2fd5b875d66dd844e5df00 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/11/deab00b2d3a6f5a3073988ac050c2d7b6655e2 b/tests/resources/reftable/merge-resolve/.gitted/objects/11/deab00b2d3a6f5a3073988ac050c2d7b6655e2 new file mode 100644 index 000000000..857b23686 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/11/deab00b2d3a6f5a3073988ac050c2d7b6655e2 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/11/f4f3c08b737f5fd896cbefa1425ee63b21b2fa b/tests/resources/reftable/merge-resolve/.gitted/objects/11/f4f3c08b737f5fd896cbefa1425ee63b21b2fa new file mode 100644 index 000000000..6555194cb --- /dev/null +++ b/tests/resources/reftable/merge-resolve/.gitted/objects/11/f4f3c08b737f5fd896cbefa1425ee63b21b2fa @@ -0,0 +1 @@ +xQ D\fw)c^` ۴-Q/ơdb^ץjEDC$u> , z@8qjk<٩G>z2Lva2)Veŏ:%˜{A|Ǽ5K@mg9jY _;n,YyP \ No newline at end of file diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/13/d1be4ea52a6ced1d7a1d832f0ee3c399348e5e b/tests/resources/reftable/merge-resolve/.gitted/objects/13/d1be4ea52a6ced1d7a1d832f0ee3c399348e5e new file mode 100644 index 000000000..4e4e175e8 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/13/d1be4ea52a6ced1d7a1d832f0ee3c399348e5e differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/14/39088f509b79b1535b64193137d3ce4b240734 b/tests/resources/reftable/merge-resolve/.gitted/objects/14/39088f509b79b1535b64193137d3ce4b240734 new file mode 100644 index 000000000..51ddf6dcb Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/14/39088f509b79b1535b64193137d3ce4b240734 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/15/8dc7bedb202f5b26502bf3574faa7f4238d56c b/tests/resources/reftable/merge-resolve/.gitted/objects/15/8dc7bedb202f5b26502bf3574faa7f4238d56c new file mode 100644 index 000000000..064423d0c --- /dev/null +++ b/tests/resources/reftable/merge-resolve/.gitted/objects/15/8dc7bedb202f5b26502bf3574faa7f4238d56c @@ -0,0 +1,2 @@ +xK!D]sCboi2. bK*Eep73UӾ*NYYIԔ)jL:8<{NޓH6iDC"mqH!9Tm9>R^i.= +G'+~@@j+7أENsFt]7bN) \ No newline at end of file diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/16/f825815cfd20a07a75c71554e82d8eede0b061 b/tests/resources/reftable/merge-resolve/.gitted/objects/16/f825815cfd20a07a75c71554e82d8eede0b061 new file mode 100644 index 000000000..82d65253b --- /dev/null +++ b/tests/resources/reftable/merge-resolve/.gitted/objects/16/f825815cfd20a07a75c71554e82d8eede0b061 @@ -0,0 +1 @@ +xK!D]sObo hJqo6AJـT1h3'Lՠ.{ec,a`ZJT1#e+هJUi">\+ ץG_X6IvN;^bYgGMM \ No newline at end of file diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/17/8940b450f238a56c0d75b7955cb57b38191982 b/tests/resources/reftable/merge-resolve/.gitted/objects/17/8940b450f238a56c0d75b7955cb57b38191982 new file mode 100644 index 000000000..94e571e65 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/17/8940b450f238a56c0d75b7955cb57b38191982 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/18/3310e30fb1499af8c619108ffea4d300b5e778 b/tests/resources/reftable/merge-resolve/.gitted/objects/18/3310e30fb1499af8c619108ffea4d300b5e778 new file mode 100644 index 000000000..1c4010d04 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/18/3310e30fb1499af8c619108ffea4d300b5e778 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/18/cb316b1cefa0f8a6946f0e201a8e1a6f845ab9 b/tests/resources/reftable/merge-resolve/.gitted/objects/18/cb316b1cefa0f8a6946f0e201a8e1a6f845ab9 new file mode 100644 index 000000000..30f3110f1 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/18/cb316b1cefa0f8a6946f0e201a8e1a6f845ab9 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/19/b7ac485269b672a101060894de3ba9c2a24dd1 b/tests/resources/reftable/merge-resolve/.gitted/objects/19/b7ac485269b672a101060894de3ba9c2a24dd1 new file mode 100644 index 000000000..e34ccb855 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/19/b7ac485269b672a101060894de3ba9c2a24dd1 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/1a/010b1c0f081b2e8901d55307a15c29ff30af0e b/tests/resources/reftable/merge-resolve/.gitted/objects/1a/010b1c0f081b2e8901d55307a15c29ff30af0e new file mode 100644 index 000000000..6039df00e Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/1a/010b1c0f081b2e8901d55307a15c29ff30af0e differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/1c/51d885170f57a0c4e8c69ff6363d91a5b51f85 b/tests/resources/reftable/merge-resolve/.gitted/objects/1c/51d885170f57a0c4e8c69ff6363d91a5b51f85 new file mode 100644 index 000000000..9a21e26c0 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/1c/51d885170f57a0c4e8c69ff6363d91a5b51f85 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/1c/ff9ec6a47a537380dedfdd17c9e76d74259a2b b/tests/resources/reftable/merge-resolve/.gitted/objects/1c/ff9ec6a47a537380dedfdd17c9e76d74259a2b new file mode 100644 index 000000000..30802bcec Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/1c/ff9ec6a47a537380dedfdd17c9e76d74259a2b differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/1e/4ff029aee68d0d69ef9eb6efa6cbf1ec732f99 b/tests/resources/reftable/merge-resolve/.gitted/objects/1e/4ff029aee68d0d69ef9eb6efa6cbf1ec732f99 new file mode 100644 index 000000000..5183b8360 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/1e/4ff029aee68d0d69ef9eb6efa6cbf1ec732f99 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/1f/81433e3161efbf250576c58fede7f6b836f3d3 b/tests/resources/reftable/merge-resolve/.gitted/objects/1f/81433e3161efbf250576c58fede7f6b836f3d3 new file mode 100644 index 000000000..970855675 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/1f/81433e3161efbf250576c58fede7f6b836f3d3 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/20/91d94c8bd3eb0835dc5220de5e8bb310fa1513 b/tests/resources/reftable/merge-resolve/.gitted/objects/20/91d94c8bd3eb0835dc5220de5e8bb310fa1513 new file mode 100644 index 000000000..a843890c0 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/20/91d94c8bd3eb0835dc5220de5e8bb310fa1513 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/21/671e290278286fb2ce4c63d01699b67adce331 b/tests/resources/reftable/merge-resolve/.gitted/objects/21/671e290278286fb2ce4c63d01699b67adce331 new file mode 100644 index 000000000..b656d0001 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/21/671e290278286fb2ce4c63d01699b67adce331 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/22/7792b52aaa0b238bea00ec7e509b02623f168c b/tests/resources/reftable/merge-resolve/.gitted/objects/22/7792b52aaa0b238bea00ec7e509b02623f168c new file mode 100644 index 000000000..3bb19bb77 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/22/7792b52aaa0b238bea00ec7e509b02623f168c differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/23/3c0919c998ed110a4b6ff36f353aec8b713487 b/tests/resources/reftable/merge-resolve/.gitted/objects/23/3c0919c998ed110a4b6ff36f353aec8b713487 new file mode 100644 index 000000000..d0c8c9e1d Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/23/3c0919c998ed110a4b6ff36f353aec8b713487 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/23/92a2dacc9efb562b8635d6579fb458751c7c5b b/tests/resources/reftable/merge-resolve/.gitted/objects/23/92a2dacc9efb562b8635d6579fb458751c7c5b new file mode 100644 index 000000000..86127a344 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/23/92a2dacc9efb562b8635d6579fb458751c7c5b differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/23/ed141a6ae1e798b2f721afedbe947c119111ba b/tests/resources/reftable/merge-resolve/.gitted/objects/23/ed141a6ae1e798b2f721afedbe947c119111ba new file mode 100644 index 000000000..06dee3b23 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/23/ed141a6ae1e798b2f721afedbe947c119111ba differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/24/1a1005cd9b980732741b74385b891142bcba28 b/tests/resources/reftable/merge-resolve/.gitted/objects/24/1a1005cd9b980732741b74385b891142bcba28 new file mode 100644 index 000000000..9b65f666f Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/24/1a1005cd9b980732741b74385b891142bcba28 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/24/2591eb280ee9eeb2ce63524b9a8b9bc4cb515d b/tests/resources/reftable/merge-resolve/.gitted/objects/24/2591eb280ee9eeb2ce63524b9a8b9bc4cb515d new file mode 100644 index 000000000..74a01373f Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/24/2591eb280ee9eeb2ce63524b9a8b9bc4cb515d differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/24/90b9f1a079420870027deefb49f51d6656cf74 b/tests/resources/reftable/merge-resolve/.gitted/objects/24/90b9f1a079420870027deefb49f51d6656cf74 new file mode 100644 index 000000000..60497caa5 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/24/90b9f1a079420870027deefb49f51d6656cf74 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/25/9d08ca43af9200e9ea9a098e44a5a350ebd9b3 b/tests/resources/reftable/merge-resolve/.gitted/objects/25/9d08ca43af9200e9ea9a098e44a5a350ebd9b3 new file mode 100644 index 000000000..2bae66998 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/25/9d08ca43af9200e9ea9a098e44a5a350ebd9b3 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/25/c40b7660c08c8fb581f770312f41b9b03119d1 b/tests/resources/reftable/merge-resolve/.gitted/objects/25/c40b7660c08c8fb581f770312f41b9b03119d1 new file mode 100644 index 000000000..185214727 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/25/c40b7660c08c8fb581f770312f41b9b03119d1 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/26/153a3ff3649b6c2bb652d3f06878c6e0a172f9 b/tests/resources/reftable/merge-resolve/.gitted/objects/26/153a3ff3649b6c2bb652d3f06878c6e0a172f9 new file mode 100644 index 000000000..4fcaa07e2 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/26/153a3ff3649b6c2bb652d3f06878c6e0a172f9 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/27/133da702ba3c60af2a01e96c2555ff4045d692 b/tests/resources/reftable/merge-resolve/.gitted/objects/27/133da702ba3c60af2a01e96c2555ff4045d692 new file mode 100644 index 000000000..08e61f844 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/27/133da702ba3c60af2a01e96c2555ff4045d692 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/27/4bbe983022fb4c02f8a2bf2ebe8da4fe130054 b/tests/resources/reftable/merge-resolve/.gitted/objects/27/4bbe983022fb4c02f8a2bf2ebe8da4fe130054 new file mode 100644 index 000000000..c7afad2a8 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/27/4bbe983022fb4c02f8a2bf2ebe8da4fe130054 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/29 b/tests/resources/reftable/merge-resolve/.gitted/objects/29 new file mode 100644 index 000000000..966150707 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/29 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/2a/f2d9bcbc73723ac988bb202d4397f72a6ca7a0 b/tests/resources/reftable/merge-resolve/.gitted/objects/2a/f2d9bcbc73723ac988bb202d4397f72a6ca7a0 new file mode 100644 index 000000000..0d658237b Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/2a/f2d9bcbc73723ac988bb202d4397f72a6ca7a0 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/2b/0de5dc27505dcdd83a75c8bf1fcd9462cd7add b/tests/resources/reftable/merge-resolve/.gitted/objects/2b/0de5dc27505dcdd83a75c8bf1fcd9462cd7add new file mode 100644 index 000000000..a95f926f8 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/2b/0de5dc27505dcdd83a75c8bf1fcd9462cd7add differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/2b/5f1f181ee3b58ea751f5dd5d8f9b445520a136 b/tests/resources/reftable/merge-resolve/.gitted/objects/2b/5f1f181ee3b58ea751f5dd5d8f9b445520a136 new file mode 100644 index 000000000..d24231eda Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/2b/5f1f181ee3b58ea751f5dd5d8f9b445520a136 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/2b/d0a343aeef7a2cf0d158478966a6e587ff3863 b/tests/resources/reftable/merge-resolve/.gitted/objects/2b/d0a343aeef7a2cf0d158478966a6e587ff3863 new file mode 100644 index 000000000..d10ca636b Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/2b/d0a343aeef7a2cf0d158478966a6e587ff3863 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/2b/fdd7e1b6c6ae993f23dfe8e84a8e06a772fa2a b/tests/resources/reftable/merge-resolve/.gitted/objects/2b/fdd7e1b6c6ae993f23dfe8e84a8e06a772fa2a new file mode 100644 index 000000000..c86edfb68 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/2b/fdd7e1b6c6ae993f23dfe8e84a8e06a772fa2a differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/2d/a538570bc1e5b2c3e855bf702f35248ad0735f b/tests/resources/reftable/merge-resolve/.gitted/objects/2d/a538570bc1e5b2c3e855bf702f35248ad0735f new file mode 100644 index 000000000..83253f81c --- /dev/null +++ b/tests/resources/reftable/merge-resolve/.gitted/objects/2d/a538570bc1e5b2c3e855bf702f35248ad0735f @@ -0,0 +1,2 @@ +xK +1D]N"n{t:L$ UEQ>~7:L D [5ɇ,y2eT@z*.([žunum_|Št@ +apg%haJYծA8թ훠fN4;h[%cOuJWyΏ \ No newline at end of file diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/2f/598248eeccfc27e5ca44d9d96383f6dfea7b16 b/tests/resources/reftable/merge-resolve/.gitted/objects/2f/598248eeccfc27e5ca44d9d96383f6dfea7b16 new file mode 100644 index 000000000..1d9f226e2 --- /dev/null +++ b/tests/resources/reftable/merge-resolve/.gitted/objects/2f/598248eeccfc27e5ca44d9d96383f6dfea7b16 @@ -0,0 +1 @@ +x+)JMU067c040031QH,-M-JOMLI+(aH:,:C: o>ZC'g$楧f&%%g5qYeZokM2ԐX\ZDPC~^ZNfrIf^:XZHي1O(_,' jvQjn~13zדm9Wu]:$I{| 2mg˾15ӿ,\})TC)0Pavz֛9MՅ'6b \ No newline at end of file diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/31/68dca1a561889b045a6441909f4c56145e666d b/tests/resources/reftable/merge-resolve/.gitted/objects/31/68dca1a561889b045a6441909f4c56145e666d new file mode 100644 index 000000000..2de1c5a79 --- /dev/null +++ b/tests/resources/reftable/merge-resolve/.gitted/objects/31/68dca1a561889b045a6441909f4c56145e666d @@ -0,0 +1,2 @@ +xQ +0D)rJMxMHz}xfރaRYipkUD $1fQ2q-=Y3R76ġg9e7 bw GJe*˽ |ůSY"5&Нƨng9Z3_;kdO \ No newline at end of file diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/31/d5472536041a83d986829240bbbdc897c6f8a6 b/tests/resources/reftable/merge-resolve/.gitted/objects/31/d5472536041a83d986829240bbbdc897c6f8a6 new file mode 100644 index 000000000..5ec5acb59 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/31/d5472536041a83d986829240bbbdc897c6f8a6 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/32/21dd512b7e2dc4b5bd03046df6c81b2ab2070b b/tests/resources/reftable/merge-resolve/.gitted/objects/32/21dd512b7e2dc4b5bd03046df6c81b2ab2070b new file mode 100644 index 000000000..d36138d79 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/32/21dd512b7e2dc4b5bd03046df6c81b2ab2070b differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/33/46d64325b39e5323733492cd55f808994a2475 b/tests/resources/reftable/merge-resolve/.gitted/objects/33/46d64325b39e5323733492cd55f808994a2475 new file mode 100644 index 000000000..11546cea4 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/33/46d64325b39e5323733492cd55f808994a2475 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/33/d500f588fbbe65901d82b4e6b008e549064be0 b/tests/resources/reftable/merge-resolve/.gitted/objects/33/d500f588fbbe65901d82b4e6b008e549064be0 new file mode 100644 index 000000000..061a031b6 --- /dev/null +++ b/tests/resources/reftable/merge-resolve/.gitted/objects/33/d500f588fbbe65901d82b4e6b008e549064be0 @@ -0,0 +1,2 @@ +xA E]s +.hbo.Z x}[ ~kCA<:km`d̑d,!:𦐳P1P qHccHEO[zsK>y>隿ïm6*Rn>O \ No newline at end of file diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/34/8dcd41e2b467991578e92bedd16971b877ef1e b/tests/resources/reftable/merge-resolve/.gitted/objects/34/8dcd41e2b467991578e92bedd16971b877ef1e new file mode 100644 index 000000000..fd61b6ce5 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/34/8dcd41e2b467991578e92bedd16971b877ef1e differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/34/bfafff88eaf118402b44e6f3e2dbbf1a582b05 b/tests/resources/reftable/merge-resolve/.gitted/objects/34/bfafff88eaf118402b44e6f3e2dbbf1a582b05 new file mode 100644 index 000000000..c653cec50 --- /dev/null +++ b/tests/resources/reftable/merge-resolve/.gitted/objects/34/bfafff88eaf118402b44e6f3e2dbbf1a582b05 @@ -0,0 +1 @@ +xKj1D) >`7A. $<`Morlm4G&dVd[j2JCъgu_Gu%2:3XزQ'";?wpkm׾&Pf! %QJ%:Cez=6q;iO \ No newline at end of file diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/35/0c6eb3010efc403a6bed682332635314e9ed58 b/tests/resources/reftable/merge-resolve/.gitted/objects/35/0c6eb3010efc403a6bed682332635314e9ed58 new file mode 100644 index 000000000..2eee60233 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/35/0c6eb3010efc403a6bed682332635314e9ed58 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/35/411bfb77cd2cc431f3a03a2b4976ed94b5d241 b/tests/resources/reftable/merge-resolve/.gitted/objects/35/411bfb77cd2cc431f3a03a2b4976ed94b5d241 new file mode 100644 index 000000000..ea024ccd9 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/35/411bfb77cd2cc431f3a03a2b4976ed94b5d241 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/35/4704d3613ad4228e4786fc76656b11e98236c4 b/tests/resources/reftable/merge-resolve/.gitted/objects/35/4704d3613ad4228e4786fc76656b11e98236c4 new file mode 100644 index 000000000..1dd13c44a Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/35/4704d3613ad4228e4786fc76656b11e98236c4 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/35/632e43612c06a3ea924bfbacd48333da874c29 b/tests/resources/reftable/merge-resolve/.gitted/objects/35/632e43612c06a3ea924bfbacd48333da874c29 new file mode 100644 index 000000000..be7684f19 --- /dev/null +++ b/tests/resources/reftable/merge-resolve/.gitted/objects/35/632e43612c06a3ea924bfbacd48333da874c29 @@ -0,0 +1 @@ +xN !LdMb60^,40;iUFf+)1vB939fG(DIݸʵA$sk]l|L{Ig$m.N5y.\a/]|Ʋ@[g4< Hl?gTsˠzCP \ No newline at end of file diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/35/75826c96a975031d2c14368529cc5c4353a8fd b/tests/resources/reftable/merge-resolve/.gitted/objects/35/75826c96a975031d2c14368529cc5c4353a8fd new file mode 100644 index 000000000..24e33bc41 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/35/75826c96a975031d2c14368529cc5c4353a8fd differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/36/219b49367146cb2e6a1555b5a9ebd4d0328495 b/tests/resources/reftable/merge-resolve/.gitted/objects/36/219b49367146cb2e6a1555b5a9ebd4d0328495 new file mode 100644 index 000000000..7f8044372 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/36/219b49367146cb2e6a1555b5a9ebd4d0328495 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/36/4bbe4ce80c7bd31e6307dce77d46e3e1759fb3 b/tests/resources/reftable/merge-resolve/.gitted/objects/36/4bbe4ce80c7bd31e6307dce77d46e3e1759fb3 new file mode 100644 index 000000000..90fd9651f Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/36/4bbe4ce80c7bd31e6307dce77d46e3e1759fb3 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/37/48859b001c6e627e712a07951aee40afd19b41 b/tests/resources/reftable/merge-resolve/.gitted/objects/37/48859b001c6e627e712a07951aee40afd19b41 new file mode 100644 index 000000000..6a0c389e4 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/37/48859b001c6e627e712a07951aee40afd19b41 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/37/f53a5a14f64e91089a39ea58e71c87d81df765 b/tests/resources/reftable/merge-resolve/.gitted/objects/37/f53a5a14f64e91089a39ea58e71c87d81df765 new file mode 100644 index 000000000..95327ed64 --- /dev/null +++ b/tests/resources/reftable/merge-resolve/.gitted/objects/37/f53a5a14f64e91089a39ea58e71c87d81df765 @@ -0,0 +1 @@ +xAjC1 D)ّe}%z^ߖ,wpr: tVԶ6RBBLh,9+%rǮh1%p"=Iue{ڶ߶Igrm-23/'|R~Uk{dJ \ No newline at end of file diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/38/5c8a0f26ddf79e9041e15e17dc352ed2c4cced b/tests/resources/reftable/merge-resolve/.gitted/objects/38/5c8a0f26ddf79e9041e15e17dc352ed2c4cced new file mode 100644 index 000000000..e95ff3a88 --- /dev/null +++ b/tests/resources/reftable/merge-resolve/.gitted/objects/38/5c8a0f26ddf79e9041e15e17dc352ed2c4cced @@ -0,0 +1,2 @@ +x-MK +1 uSYRą6C6뛪oknYt Ep iDCddLB+8%qk +e6fHB1J4F1l \ No newline at end of file diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/3b/47b031b3e55ae11e14a05260b1c3ffd6838d55 b/tests/resources/reftable/merge-resolve/.gitted/objects/3b/47b031b3e55ae11e14a05260b1c3ffd6838d55 new file mode 100644 index 000000000..82086466f Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/3b/47b031b3e55ae11e14a05260b1c3ffd6838d55 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/3b/bf0bf59b20df5d5fc58b9fc1dc07be637c301f b/tests/resources/reftable/merge-resolve/.gitted/objects/3b/bf0bf59b20df5d5fc58b9fc1dc07be637c301f new file mode 100644 index 000000000..723a9ae4c Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/3b/bf0bf59b20df5d5fc58b9fc1dc07be637c301f differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/3e/f4d30382ca33fdeba9fda895a99e0891ba37aa b/tests/resources/reftable/merge-resolve/.gitted/objects/3e/f4d30382ca33fdeba9fda895a99e0891ba37aa new file mode 100644 index 000000000..49ee15239 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/3e/f4d30382ca33fdeba9fda895a99e0891ba37aa differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/3e/f9bfe82f9635518ae89152322f3b46fd4ba25b b/tests/resources/reftable/merge-resolve/.gitted/objects/3e/f9bfe82f9635518ae89152322f3b46fd4ba25b new file mode 100644 index 000000000..3b5998ca6 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/3e/f9bfe82f9635518ae89152322f3b46fd4ba25b differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/40/2784a46a4a3982294231594cbeb431f506d22c b/tests/resources/reftable/merge-resolve/.gitted/objects/40/2784a46a4a3982294231594cbeb431f506d22c new file mode 100644 index 000000000..a17e05d0f Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/40/2784a46a4a3982294231594cbeb431f506d22c differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/41/2b32fb66137366147f1801ecc962452757d48a b/tests/resources/reftable/merge-resolve/.gitted/objects/41/2b32fb66137366147f1801ecc962452757d48a new file mode 100644 index 000000000..b183dd782 --- /dev/null +++ b/tests/resources/reftable/merge-resolve/.gitted/objects/41/2b32fb66137366147f1801ecc962452757d48a @@ -0,0 +1,2 @@ +xK +1D]IO>"nt:x}xwUxjum'뫈.9=y 6$@T8&Lhf4Aܻf0B(.K>9S< +z_f}]Z]eO:wzރP.ިaNU6O \ No newline at end of file diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/42/18670ab81cc219a9f94befb5c5dad90ec52648 b/tests/resources/reftable/merge-resolve/.gitted/objects/42/18670ab81cc219a9f94befb5c5dad90ec52648 new file mode 100644 index 000000000..33ead6112 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/42/18670ab81cc219a9f94befb5c5dad90ec52648 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/43/aafd43bea779ec74317dc361f45ae3f532a505 b/tests/resources/reftable/merge-resolve/.gitted/objects/43/aafd43bea779ec74317dc361f45ae3f532a505 new file mode 100644 index 000000000..ac86823b6 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/43/aafd43bea779ec74317dc361f45ae3f532a505 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/43/c338656342227a3a3cd3aa85cbf784061f5425 b/tests/resources/reftable/merge-resolve/.gitted/objects/43/c338656342227a3a3cd3aa85cbf784061f5425 new file mode 100644 index 000000000..d9773118b Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/43/c338656342227a3a3cd3aa85cbf784061f5425 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/45/299c1ca5e07bba1fd90843056fb559f96b1f5a b/tests/resources/reftable/merge-resolve/.gitted/objects/45/299c1ca5e07bba1fd90843056fb559f96b1f5a new file mode 100644 index 000000000..2093b4410 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/45/299c1ca5e07bba1fd90843056fb559f96b1f5a differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/46/6daf8552b891e5c22bc58c9d7fc1a2eb8f0289 b/tests/resources/reftable/merge-resolve/.gitted/objects/46/6daf8552b891e5c22bc58c9d7fc1a2eb8f0289 new file mode 100644 index 000000000..c39b53aa8 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/46/6daf8552b891e5c22bc58c9d7fc1a2eb8f0289 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/47/6dbb3e207313d1d8aaa120c6ad204bf1295e53 b/tests/resources/reftable/merge-resolve/.gitted/objects/47/6dbb3e207313d1d8aaa120c6ad204bf1295e53 new file mode 100644 index 000000000..3e5f66e55 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/47/6dbb3e207313d1d8aaa120c6ad204bf1295e53 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/47/8172cb2f5ff9b514bc9d04d3bd5ef5840cb3b2 b/tests/resources/reftable/merge-resolve/.gitted/objects/47/8172cb2f5ff9b514bc9d04d3bd5ef5840cb3b2 new file mode 100644 index 000000000..d9e250e66 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/47/8172cb2f5ff9b514bc9d04d3bd5ef5840cb3b2 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/49/130a28ef567af9a6a6104c38773fedfa5f9742 b/tests/resources/reftable/merge-resolve/.gitted/objects/49/130a28ef567af9a6a6104c38773fedfa5f9742 new file mode 100644 index 000000000..e2c49f5c4 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/49/130a28ef567af9a6a6104c38773fedfa5f9742 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/49/9df817155e4bdd3c6ee192a72c52f481818230 b/tests/resources/reftable/merge-resolve/.gitted/objects/49/9df817155e4bdd3c6ee192a72c52f481818230 new file mode 100644 index 000000000..9c7e471dd Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/49/9df817155e4bdd3c6ee192a72c52f481818230 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/49/fd9edac79d15c8fbfca2d481cbb900beba22a6 b/tests/resources/reftable/merge-resolve/.gitted/objects/49/fd9edac79d15c8fbfca2d481cbb900beba22a6 new file mode 100644 index 000000000..d808d9fd9 --- /dev/null +++ b/tests/resources/reftable/merge-resolve/.gitted/objects/49/fd9edac79d15c8fbfca2d481cbb900beba22a6 @@ -0,0 +1,3 @@ +xU +0D=+ +f5dI~Ehe3x2?ذ$Ɂ%+"SRAWRm Kn\t XZ/hMƱߙg2j># \ No newline at end of file diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/4a/9550ebcc97ce22b22f45af7b829bb030d003f5 b/tests/resources/reftable/merge-resolve/.gitted/objects/4a/9550ebcc97ce22b22f45af7b829bb030d003f5 new file mode 100644 index 000000000..6ec674adc Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/4a/9550ebcc97ce22b22f45af7b829bb030d003f5 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/4b/253da36a0ae8bfce63aeabd8c5b58429925594 b/tests/resources/reftable/merge-resolve/.gitted/objects/4b/253da36a0ae8bfce63aeabd8c5b58429925594 new file mode 100644 index 000000000..1a4072794 --- /dev/null +++ b/tests/resources/reftable/merge-resolve/.gitted/objects/4b/253da36a0ae8bfce63aeabd8c5b58429925594 @@ -0,0 +1,2 @@ +x A +0 @AAILm l׹vGx#63tW B6%h \ No newline at end of file diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/4b/48deed3a433909bfd6b6ab3d4b91348b6af464 b/tests/resources/reftable/merge-resolve/.gitted/objects/4b/48deed3a433909bfd6b6ab3d4b91348b6af464 new file mode 100644 index 000000000..328c8506e Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/4b/48deed3a433909bfd6b6ab3d4b91348b6af464 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/4b/825dc642cb6eb9a060e54bf8d69288fbee4904 b/tests/resources/reftable/merge-resolve/.gitted/objects/4b/825dc642cb6eb9a060e54bf8d69288fbee4904 new file mode 100644 index 000000000..adf64119a Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/4b/825dc642cb6eb9a060e54bf8d69288fbee4904 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/4c/9fac0707f8d4195037ae5a681aa48626491541 b/tests/resources/reftable/merge-resolve/.gitted/objects/4c/9fac0707f8d4195037ae5a681aa48626491541 new file mode 100644 index 000000000..6b8c85e2b Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/4c/9fac0707f8d4195037ae5a681aa48626491541 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/4c/a408a8c88655f7586a1b580be6fad138121e98 b/tests/resources/reftable/merge-resolve/.gitted/objects/4c/a408a8c88655f7586a1b580be6fad138121e98 new file mode 100644 index 000000000..15cb7f29a Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/4c/a408a8c88655f7586a1b580be6fad138121e98 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/4d/d1ef7569b18d92d93c0a35bb6b93049137b355 b/tests/resources/reftable/merge-resolve/.gitted/objects/4d/d1ef7569b18d92d93c0a35bb6b93049137b355 new file mode 100644 index 000000000..86a21ad50 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/4d/d1ef7569b18d92d93c0a35bb6b93049137b355 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/4e/0d9401aee78eb345a8685a859d37c8c3c0bbed b/tests/resources/reftable/merge-resolve/.gitted/objects/4e/0d9401aee78eb345a8685a859d37c8c3c0bbed new file mode 100644 index 000000000..57f7eb68c Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/4e/0d9401aee78eb345a8685a859d37c8c3c0bbed differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/4e/886e602529caa9ab11d71f86634bd1b6e0de10 b/tests/resources/reftable/merge-resolve/.gitted/objects/4e/886e602529caa9ab11d71f86634bd1b6e0de10 new file mode 100644 index 000000000..53168a038 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/4e/886e602529caa9ab11d71f86634bd1b6e0de10 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/4e/b04c9e79e88f6640d01ff5b25ca2a60764f216 b/tests/resources/reftable/merge-resolve/.gitted/objects/4e/b04c9e79e88f6640d01ff5b25ca2a60764f216 new file mode 100644 index 000000000..f4ec0efec Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/4e/b04c9e79e88f6640d01ff5b25ca2a60764f216 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/4f/e93c0ec83eb6305cbace3dace88ecee1b63cb6 b/tests/resources/reftable/merge-resolve/.gitted/objects/4f/e93c0ec83eb6305cbace3dace88ecee1b63cb6 new file mode 100644 index 000000000..67dc6842f Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/4f/e93c0ec83eb6305cbace3dace88ecee1b63cb6 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/50/12fd565b1393bdfda1805d4ec38ce6619e1fd1 b/tests/resources/reftable/merge-resolve/.gitted/objects/50/12fd565b1393bdfda1805d4ec38ce6619e1fd1 new file mode 100644 index 000000000..d629a23a1 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/50/12fd565b1393bdfda1805d4ec38ce6619e1fd1 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/50/4f75ac95a71ef98051817618576a68505b92f9 b/tests/resources/reftable/merge-resolve/.gitted/objects/50/4f75ac95a71ef98051817618576a68505b92f9 new file mode 100644 index 000000000..1b24c721a Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/50/4f75ac95a71ef98051817618576a68505b92f9 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/50/84fc2a88b6bdba8db93bd3953a8f4fdb470238 b/tests/resources/reftable/merge-resolve/.gitted/objects/50/84fc2a88b6bdba8db93bd3953a8f4fdb470238 new file mode 100644 index 000000000..84c9987ce Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/50/84fc2a88b6bdba8db93bd3953a8f4fdb470238 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/50/c5dc8cdfe40c688eb0a0e23be54dd57cae2e78 b/tests/resources/reftable/merge-resolve/.gitted/objects/50/c5dc8cdfe40c688eb0a0e23be54dd57cae2e78 new file mode 100644 index 000000000..c04baa14b --- /dev/null +++ b/tests/resources/reftable/merge-resolve/.gitted/objects/50/c5dc8cdfe40c688eb0a0e23be54dd57cae2e78 @@ -0,0 +1,2 @@ +x] +0})Jv">x/I6ZhIӞ*aeZC`F6;KLO).y8N^ }a'Ѱ S*gpmHp_sh/O>.PiF?,kJZGoJT \ No newline at end of file diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/50/ce7d7d01217679e26c55939eef119e0c93e272 b/tests/resources/reftable/merge-resolve/.gitted/objects/50/ce7d7d01217679e26c55939eef119e0c93e272 new file mode 100644 index 000000000..e2f9f67fd Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/50/ce7d7d01217679e26c55939eef119e0c93e272 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/51/95a1b480f66691b667f10a9e41e70115a78351 b/tests/resources/reftable/merge-resolve/.gitted/objects/51/95a1b480f66691b667f10a9e41e70115a78351 new file mode 100644 index 000000000..088ee5498 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/51/95a1b480f66691b667f10a9e41e70115a78351 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/52/d8bc572af2b6d4ee0d5e62ed5d1fbad92210a9 b/tests/resources/reftable/merge-resolve/.gitted/objects/52/d8bc572af2b6d4ee0d5e62ed5d1fbad92210a9 new file mode 100644 index 000000000..6522209bd --- /dev/null +++ b/tests/resources/reftable/merge-resolve/.gitted/objects/52/d8bc572af2b6d4ee0d5e62ed5d1fbad92210a9 @@ -0,0 +1,3 @@ +x] +0})rnD|^`Ђm$FUo3ä,sӽ]" #b"1 9cThS//SYe'+~mrh\cQwFMQϙ]b5M R \ No newline at end of file diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/53/825f41ac8d640612f9423a2f03a69f3d96809a b/tests/resources/reftable/merge-resolve/.gitted/objects/53/825f41ac8d640612f9423a2f03a69f3d96809a new file mode 100644 index 000000000..08cb0b66f Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/53/825f41ac8d640612f9423a2f03a69f3d96809a differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/54/269b3f6ec3d7d4ede24dd350dd5d605495c3ae b/tests/resources/reftable/merge-resolve/.gitted/objects/54/269b3f6ec3d7d4ede24dd350dd5d605495c3ae new file mode 100644 index 000000000..4a2415339 --- /dev/null +++ b/tests/resources/reftable/merge-resolve/.gitted/objects/54/269b3f6ec3d7d4ede24dd350dd5d605495c3ae @@ -0,0 +1,2 @@ +xK +1D]I7 LӌL$FxwUAQj m'؍^v9 d- Ɯ \ ϽC'&`"Ĺ(֡9_sg}]Z}UF?\I&@mt;;ʟ3hzN \ No newline at end of file diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/54/59c89aa0026d543ce8343bd89871bce543f9c2 b/tests/resources/reftable/merge-resolve/.gitted/objects/54/59c89aa0026d543ce8343bd89871bce543f9c2 new file mode 100644 index 000000000..178b833e8 --- /dev/null +++ b/tests/resources/reftable/merge-resolve/.gitted/objects/54/59c89aa0026d543ce8343bd89871bce543f9c2 @@ -0,0 +1,3 @@ +x !D +,,,,9O bl؁3%mY.C[LEtd`\ %aBH%TvB G%Qphq]nCgP3B(H14yS)W;IVsT^܋>myJ?(_kܖ6-$#-Zzvȟ3 +:NqMB \ No newline at end of file diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/54/7607c690372fe81fab8e3bb44c530e129118fd b/tests/resources/reftable/merge-resolve/.gitted/objects/54/7607c690372fe81fab8e3bb44c530e129118fd new file mode 100644 index 000000000..dccd22006 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/54/7607c690372fe81fab8e3bb44c530e129118fd differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/54/c9d15687fb4f56e08252662962d6d1dbc09d9d b/tests/resources/reftable/merge-resolve/.gitted/objects/54/c9d15687fb4f56e08252662962d6d1dbc09d9d new file mode 100644 index 000000000..7e0555b3f --- /dev/null +++ b/tests/resources/reftable/merge-resolve/.gitted/objects/54/c9d15687fb4f56e08252662962d6d1dbc09d9d @@ -0,0 +1,3 @@ +xNI +1W]/a&#~(:FQ\A۸Mtr8K0YK&Xkwə"$pPwjv\RhgI=ŘK*SDaM*z68 .^aG?` +q6Y83W^BMiQ \ No newline at end of file diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/55/b4e4687e7a0d9ca367016ed930f385d4022e6f b/tests/resources/reftable/merge-resolve/.gitted/objects/55/b4e4687e7a0d9ca367016ed930f385d4022e6f new file mode 100644 index 000000000..fb157a214 --- /dev/null +++ b/tests/resources/reftable/merge-resolve/.gitted/objects/55/b4e4687e7a0d9ca367016ed930f385d4022e6f @@ -0,0 +1 @@ +xQj0DSZvJ \N 7㷱d-{LX' vm*{Z`$U9-TN{,}Kyuۣ78A_Sv.EQgSsxZZX MNRi \ No newline at end of file diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/56/6ab53c220a2eafc1212af1a024513230280ab9 b/tests/resources/reftable/merge-resolve/.gitted/objects/56/6ab53c220a2eafc1212af1a024513230280ab9 new file mode 100644 index 000000000..a8855ae67 --- /dev/null +++ b/tests/resources/reftable/merge-resolve/.gitted/objects/56/6ab53c220a2eafc1212af1a024513230280ab9 @@ -0,0 +1,3 @@ +x !D +,˱1؁ ,LD bl؁3%Ihft ١XvY`L2М՝܆NsIbRЧL3Ra$Is,S~qh7~QvՃ6!-Zzvȟ3 +:9M& \ No newline at end of file diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/56/a638b76b75e068590ac999c2f8621e7f3e264c b/tests/resources/reftable/merge-resolve/.gitted/objects/56/a638b76b75e068590ac999c2f8621e7f3e264c new file mode 100644 index 000000000..36289bf7a --- /dev/null +++ b/tests/resources/reftable/merge-resolve/.gitted/objects/56/a638b76b75e068590ac999c2f8621e7f3e264c @@ -0,0 +1 @@ +xAj!Eu vuWB6s%6qΐ$^Rb[{=coj'|褯UjeKLnn5СPY|2`zzQ{ \ No newline at end of file diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/57/079a46233ae2b6df62e9ade71c4948512abefb b/tests/resources/reftable/merge-resolve/.gitted/objects/57/079a46233ae2b6df62e9ade71c4948512abefb new file mode 100644 index 000000000..c7eabc46b Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/57/079a46233ae2b6df62e9ade71c4948512abefb differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/57/16ca5987cbf97d6bb54920bea6adde242d87e6 b/tests/resources/reftable/merge-resolve/.gitted/objects/57/16ca5987cbf97d6bb54920bea6adde242d87e6 new file mode 100644 index 000000000..cfc3920fb Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/57/16ca5987cbf97d6bb54920bea6adde242d87e6 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/58/43febcb23480df0b5edb22a21c59c772bb8e29 b/tests/resources/reftable/merge-resolve/.gitted/objects/58/43febcb23480df0b5edb22a21c59c772bb8e29 new file mode 100644 index 000000000..f6b2a2bfe Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/58/43febcb23480df0b5edb22a21c59c772bb8e29 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/58/87a5e516c53bd58efb0f02ec6aa031b6fe9ad7 b/tests/resources/reftable/merge-resolve/.gitted/objects/58/87a5e516c53bd58efb0f02ec6aa031b6fe9ad7 new file mode 100644 index 000000000..550d288d4 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/58/87a5e516c53bd58efb0f02ec6aa031b6fe9ad7 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/58/e853f66699fd02629fd50bde08082bc005933a b/tests/resources/reftable/merge-resolve/.gitted/objects/58/e853f66699fd02629fd50bde08082bc005933a new file mode 100644 index 000000000..cf6db633c Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/58/e853f66699fd02629fd50bde08082bc005933a differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/59/6803b523203a4851c824c07366906f8353f4ad b/tests/resources/reftable/merge-resolve/.gitted/objects/59/6803b523203a4851c824c07366906f8353f4ad new file mode 100644 index 000000000..cbc8cbef3 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/59/6803b523203a4851c824c07366906f8353f4ad differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/5c/2411f8075f48a6b2fdb85ebc0d371747c4df15 b/tests/resources/reftable/merge-resolve/.gitted/objects/5c/2411f8075f48a6b2fdb85ebc0d371747c4df15 new file mode 100644 index 000000000..7b41413da Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/5c/2411f8075f48a6b2fdb85ebc0d371747c4df15 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/5c/341ead2ba6f2af98ce5ec3fe84f6b6d2899c0d b/tests/resources/reftable/merge-resolve/.gitted/objects/5c/341ead2ba6f2af98ce5ec3fe84f6b6d2899c0d new file mode 100644 index 000000000..63c86bd33 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/5c/341ead2ba6f2af98ce5ec3fe84f6b6d2899c0d differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/5c/3b68a71fc4fa5d362fd3875e53137c6a5ab7a5 b/tests/resources/reftable/merge-resolve/.gitted/objects/5c/3b68a71fc4fa5d362fd3875e53137c6a5ab7a5 new file mode 100644 index 000000000..541001456 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/5c/3b68a71fc4fa5d362fd3875e53137c6a5ab7a5 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/5d/c1018e90b19654bee986b7a0c268804d39659d b/tests/resources/reftable/merge-resolve/.gitted/objects/5d/c1018e90b19654bee986b7a0c268804d39659d new file mode 100644 index 000000000..7500b9914 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/5d/c1018e90b19654bee986b7a0c268804d39659d differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/5d/dd0fe66f990dc0e5cf9fec6d9b465240e9537f b/tests/resources/reftable/merge-resolve/.gitted/objects/5d/dd0fe66f990dc0e5cf9fec6d9b465240e9537f new file mode 100644 index 000000000..9d8691eb2 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/5d/dd0fe66f990dc0e5cf9fec6d9b465240e9537f differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/5e/b7bb6a146eb3c7fd3990b240a2308eceb1cf8d b/tests/resources/reftable/merge-resolve/.gitted/objects/5e/b7bb6a146eb3c7fd3990b240a2308eceb1cf8d new file mode 100644 index 000000000..aca2666cf Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/5e/b7bb6a146eb3c7fd3990b240a2308eceb1cf8d differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/5f/bfbdc04b4eca46f54f4853a3c5a1dce28f5165 b/tests/resources/reftable/merge-resolve/.gitted/objects/5f/bfbdc04b4eca46f54f4853a3c5a1dce28f5165 new file mode 100644 index 000000000..aec3867c8 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/5f/bfbdc04b4eca46f54f4853a3c5a1dce28f5165 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/60/61fe116ecba0800c26113ea1a7dfac2e16eeaf b/tests/resources/reftable/merge-resolve/.gitted/objects/60/61fe116ecba0800c26113ea1a7dfac2e16eeaf new file mode 100644 index 000000000..3f266f6df Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/60/61fe116ecba0800c26113ea1a7dfac2e16eeaf differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/60/91fc2c036a382a69489e3f518ee5aae9a4e567 b/tests/resources/reftable/merge-resolve/.gitted/objects/60/91fc2c036a382a69489e3f518ee5aae9a4e567 new file mode 100644 index 000000000..fa63afba1 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/60/91fc2c036a382a69489e3f518ee5aae9a4e567 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/60/b12be2d2f57977ce83d8dfd32e2394ac1ba1a2 b/tests/resources/reftable/merge-resolve/.gitted/objects/60/b12be2d2f57977ce83d8dfd32e2394ac1ba1a2 new file mode 100644 index 000000000..f53f75e0a Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/60/b12be2d2f57977ce83d8dfd32e2394ac1ba1a2 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/61/340eeed7340fa6a8792def9a5938bb5d4434bb b/tests/resources/reftable/merge-resolve/.gitted/objects/61/340eeed7340fa6a8792def9a5938bb5d4434bb new file mode 100644 index 000000000..e830cafe5 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/61/340eeed7340fa6a8792def9a5938bb5d4434bb differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/61/78885b38fe96e825ac0f492c0a941f288b37f6 b/tests/resources/reftable/merge-resolve/.gitted/objects/61/78885b38fe96e825ac0f492c0a941f288b37f6 new file mode 100644 index 000000000..bedc5f27e Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/61/78885b38fe96e825ac0f492c0a941f288b37f6 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/62/12c31dab5e482247d7977e4f0dd3601decf13b b/tests/resources/reftable/merge-resolve/.gitted/objects/62/12c31dab5e482247d7977e4f0dd3601decf13b new file mode 100644 index 000000000..b6f0607bb Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/62/12c31dab5e482247d7977e4f0dd3601decf13b differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/62/269111c3b02a9355badcb9da8678b1bf41787b b/tests/resources/reftable/merge-resolve/.gitted/objects/62/269111c3b02a9355badcb9da8678b1bf41787b new file mode 100644 index 000000000..0edf65994 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/62/269111c3b02a9355badcb9da8678b1bf41787b differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/62/33c6a0670228627f93c01cef32485a30403670 b/tests/resources/reftable/merge-resolve/.gitted/objects/62/33c6a0670228627f93c01cef32485a30403670 new file mode 100644 index 000000000..81428dd62 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/62/33c6a0670228627f93c01cef32485a30403670 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/62/c4f6533c9a3894191fdcb96a3be935ade63f1a b/tests/resources/reftable/merge-resolve/.gitted/objects/62/c4f6533c9a3894191fdcb96a3be935ade63f1a new file mode 100644 index 000000000..c0f822d2c Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/62/c4f6533c9a3894191fdcb96a3be935ade63f1a differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/63/247125386de9ec90a27ad36169307bf8a11a38 b/tests/resources/reftable/merge-resolve/.gitted/objects/63/247125386de9ec90a27ad36169307bf8a11a38 new file mode 100644 index 000000000..bc2d7384d --- /dev/null +++ b/tests/resources/reftable/merge-resolve/.gitted/objects/63/247125386de9ec90a27ad36169307bf8a11a38 @@ -0,0 +1 @@ +xݏ;1 D}AV\8HIVp|?LyOuN7C] ͥlt:iA(xip,O;o7 UYZ Bý]dUmyk[cͥ)!X{Z \ No newline at end of file diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/63/ec604d491161ddafdae4179843c26d54bd999a b/tests/resources/reftable/merge-resolve/.gitted/objects/63/ec604d491161ddafdae4179843c26d54bd999a new file mode 100644 index 000000000..bc74da5ba Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/63/ec604d491161ddafdae4179843c26d54bd999a differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/67/110d77886b2af6309b9212961e72b8583e5fa9 b/tests/resources/reftable/merge-resolve/.gitted/objects/67/110d77886b2af6309b9212961e72b8583e5fa9 new file mode 100644 index 000000000..877bad703 --- /dev/null +++ b/tests/resources/reftable/merge-resolve/.gitted/objects/67/110d77886b2af6309b9212961e72b8583e5fa9 @@ -0,0 +1 @@ +x=N1 ^r !J:.`'lP^gT343Ҕup*Z %l4irHz,곥[M]aJҐb5l8OX$XճEa")U$d2zODŽų>m'qZ渍O`lFO1!n'=-]A&e˯^o^ \ No newline at end of file diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/67/18a45909532d1fcf5600d0877f7fe7e78f0b86 b/tests/resources/reftable/merge-resolve/.gitted/objects/67/18a45909532d1fcf5600d0877f7fe7e78f0b86 new file mode 100644 index 000000000..ffda698f0 --- /dev/null +++ b/tests/resources/reftable/merge-resolve/.gitted/objects/67/18a45909532d1fcf5600d0877f7fe7e78f0b86 @@ -0,0 +1 @@ +xM1 DNi`ǹDB~ǧ]ݠY74M8J?$_k[Q,"Zz˟39 LO \ No newline at end of file diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/76/63fce0130db092936b137cabd693ec234eb060 b/tests/resources/reftable/merge-resolve/.gitted/objects/76/63fce0130db092936b137cabd693ec234eb060 new file mode 100644 index 000000000..f578a4a68 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/76/63fce0130db092936b137cabd693ec234eb060 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/76/ab0e2868197ec158ddd6c78d8a0d2fd73d38f9 b/tests/resources/reftable/merge-resolve/.gitted/objects/76/ab0e2868197ec158ddd6c78d8a0d2fd73d38f9 new file mode 100644 index 000000000..4d41ad8cd Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/76/ab0e2868197ec158ddd6c78d8a0d2fd73d38f9 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/7a/a3edf2bcfee22398e6b55295aa56366b7aaf76 b/tests/resources/reftable/merge-resolve/.gitted/objects/7a/a3edf2bcfee22398e6b55295aa56366b7aaf76 new file mode 100644 index 000000000..09f1e4d3a Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/7a/a3edf2bcfee22398e6b55295aa56366b7aaf76 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/7a/a825857f87aea74ddf13d954568aa30dfcdeb4 b/tests/resources/reftable/merge-resolve/.gitted/objects/7a/a825857f87aea74ddf13d954568aa30dfcdeb4 new file mode 100644 index 000000000..b9c06303b Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/7a/a825857f87aea74ddf13d954568aa30dfcdeb4 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/7a/f14d9c679baaef35555095f4f5d33e9a569ab9 b/tests/resources/reftable/merge-resolve/.gitted/objects/7a/f14d9c679baaef35555095f4f5d33e9a569ab9 new file mode 100644 index 000000000..b4c4ef734 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/7a/f14d9c679baaef35555095f4f5d33e9a569ab9 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/7c/04ca611203ed320c5f495b9813054dd23be3be b/tests/resources/reftable/merge-resolve/.gitted/objects/7c/04ca611203ed320c5f495b9813054dd23be3be new file mode 100644 index 000000000..e3ba6056d --- /dev/null +++ b/tests/resources/reftable/merge-resolve/.gitted/objects/7c/04ca611203ed320c5f495b9813054dd23be3be @@ -0,0 +1,2 @@ +xQ D{ -,tc^`%b(K|ͼd&k)Dsl<f4a1B8zsCvŘEQdO>E񧯵#}%xu z{yV%rɐdžp֨tDŽ +UrL \ No newline at end of file diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/7c/2c5228c9e90170d4a35e6558e47163daf092e5 b/tests/resources/reftable/merge-resolve/.gitted/objects/7c/2c5228c9e90170d4a35e6558e47163daf092e5 new file mode 100644 index 000000000..52fde92a1 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/7c/2c5228c9e90170d4a35e6558e47163daf092e5 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/7c/b63eed597130ba4abb87b3e544b85021905520 b/tests/resources/reftable/merge-resolve/.gitted/objects/7c/b63eed597130ba4abb87b3e544b85021905520 new file mode 100644 index 000000000..769f29c6e --- /dev/null +++ b/tests/resources/reftable/merge-resolve/.gitted/objects/7c/b63eed597130ba4abb87b3e544b85021905520 @@ -0,0 +1,3 @@ +xK +1D]t'"nH:L$FxwUAQܖ6f7IT*zJ +1#;@rX]ꞺC3A F'aj#Tf acn]_+s[mG'+~m9i PFCQge"N \ No newline at end of file diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/7e/2d058d5fedf8329db44db4fac610d6b1a89159 b/tests/resources/reftable/merge-resolve/.gitted/objects/7e/2d058d5fedf8329db44db4fac610d6b1a89159 new file mode 100644 index 000000000..d12d7b4a7 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/7e/2d058d5fedf8329db44db4fac610d6b1a89159 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/7f/7a2da58126226986d71c6ddfab4afba693280d b/tests/resources/reftable/merge-resolve/.gitted/objects/7f/7a2da58126226986d71c6ddfab4afba693280d new file mode 100644 index 000000000..2f833c292 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/7f/7a2da58126226986d71c6ddfab4afba693280d differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/80/a8fbb3abb1ba423d554e9630b8fc2e5698f86b b/tests/resources/reftable/merge-resolve/.gitted/objects/80/a8fbb3abb1ba423d554e9630b8fc2e5698f86b new file mode 100644 index 000000000..3daf6c3e0 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/80/a8fbb3abb1ba423d554e9630b8fc2e5698f86b differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/81/1c70fcb6d5bbd022d04cc31836d30b436f9551 b/tests/resources/reftable/merge-resolve/.gitted/objects/81/1c70fcb6d5bbd022d04cc31836d30b436f9551 new file mode 100644 index 000000000..6d8702404 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/81/1c70fcb6d5bbd022d04cc31836d30b436f9551 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/81/87117062b750eed4f93fd7e899f17b52ce554d b/tests/resources/reftable/merge-resolve/.gitted/objects/81/87117062b750eed4f93fd7e899f17b52ce554d new file mode 100644 index 000000000..19cac9faf Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/81/87117062b750eed4f93fd7e899f17b52ce554d differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/83/07d93a155903a5c49576583f0ce1f6ff897c0e b/tests/resources/reftable/merge-resolve/.gitted/objects/83/07d93a155903a5c49576583f0ce1f6ff897c0e new file mode 100644 index 000000000..5a96a4e4e Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/83/07d93a155903a5c49576583f0ce1f6ff897c0e differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/83/6b8b82b26cab22eaaed8820877c76d6c8bca19 b/tests/resources/reftable/merge-resolve/.gitted/objects/83/6b8b82b26cab22eaaed8820877c76d6c8bca19 new file mode 100644 index 000000000..99f828649 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/83/6b8b82b26cab22eaaed8820877c76d6c8bca19 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/83/824a8c6658768e2013905219cc8c64cc3d9a2e b/tests/resources/reftable/merge-resolve/.gitted/objects/83/824a8c6658768e2013905219cc8c64cc3d9a2e new file mode 100644 index 000000000..066190fb8 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/83/824a8c6658768e2013905219cc8c64cc3d9a2e differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/84/9619b03ae540acee4d1edec96b86993da6b497 b/tests/resources/reftable/merge-resolve/.gitted/objects/84/9619b03ae540acee4d1edec96b86993da6b497 new file mode 100644 index 000000000..67271ac50 --- /dev/null +++ b/tests/resources/reftable/merge-resolve/.gitted/objects/84/9619b03ae540acee4d1edec96b86993da6b497 @@ -0,0 +1,3 @@ +xK +1D]v7t3L$ UEVZC'g$楧f&%%g5qYeZokM2ԐX\ZDPC~^ZNfrIf^:XZHي1O(_,' jv^j9!Ɖ9%`<sBާHrS3d Ң2 wI{| 2mg˾15ӿ,\})TC)00avʉz֛9MՅ'6bG \ No newline at end of file diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/8b/095d8fd01594f4d14454d073e3ac57b9ce485f b/tests/resources/reftable/merge-resolve/.gitted/objects/8b/095d8fd01594f4d14454d073e3ac57b9ce485f new file mode 100644 index 000000000..4ec013881 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/8b/095d8fd01594f4d14454d073e3ac57b9ce485f differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/8b/5b53cb2aa9ceb1139f5312fcfa3cc3c5a47c9a b/tests/resources/reftable/merge-resolve/.gitted/objects/8b/5b53cb2aa9ceb1139f5312fcfa3cc3c5a47c9a new file mode 100644 index 000000000..f4249c23d --- /dev/null +++ b/tests/resources/reftable/merge-resolve/.gitted/objects/8b/5b53cb2aa9ceb1139f5312fcfa3cc3c5a47c9a @@ -0,0 +1 @@ +x퐱 0 S{"2d,0^?&SH[8눪E`фrZ*drl, cbF/'gв \ No newline at end of file diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/8b/7cd60d49ce3a1a770ece43b7d29b5cf462a33a b/tests/resources/reftable/merge-resolve/.gitted/objects/8b/7cd60d49ce3a1a770ece43b7d29b5cf462a33a new file mode 100644 index 000000000..790750c0f Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/8b/7cd60d49ce3a1a770ece43b7d29b5cf462a33a differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/8b/fb012a6d809e499bd8d3e194a3929bc8995b93 b/tests/resources/reftable/merge-resolve/.gitted/objects/8b/fb012a6d809e499bd8d3e194a3929bc8995b93 new file mode 100644 index 000000000..a90ee08ce Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/8b/fb012a6d809e499bd8d3e194a3929bc8995b93 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/8c/749d9968d4b10dcfb06c9f97d0e5d92d337071 b/tests/resources/reftable/merge-resolve/.gitted/objects/8c/749d9968d4b10dcfb06c9f97d0e5d92d337071 new file mode 100644 index 000000000..e42393cf7 --- /dev/null +++ b/tests/resources/reftable/merge-resolve/.gitted/objects/8c/749d9968d4b10dcfb06c9f97d0e5d92d337071 @@ -0,0 +1,2 @@ +xAB!C]s +.acxf`|_ bh5m^mzL`}$26#"8`s.`ԝܺ.!bH\< i",K8ٗ_X>MeЏ:7]AC40뭙Q]Q\.,VO \ No newline at end of file diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/8f/4433f8593ddd65b7dd43dd4564d841f4d9c8aa b/tests/resources/reftable/merge-resolve/.gitted/objects/8f/4433f8593ddd65b7dd43dd4564d841f4d9c8aa new file mode 100644 index 000000000..d2de777cc Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/8f/4433f8593ddd65b7dd43dd4564d841f4d9c8aa differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/90/a336c7dacbe295159413559b0043b8bdc60d57 b/tests/resources/reftable/merge-resolve/.gitted/objects/90/a336c7dacbe295159413559b0043b8bdc60d57 new file mode 100644 index 000000000..35453ebfd Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/90/a336c7dacbe295159413559b0043b8bdc60d57 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/91/2b2d7819cf9c1029e414883857ed61d597a1a5 b/tests/resources/reftable/merge-resolve/.gitted/objects/91/2b2d7819cf9c1029e414883857ed61d597a1a5 new file mode 100644 index 000000000..d5df393e9 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/91/2b2d7819cf9c1029e414883857ed61d597a1a5 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/91/8bb3e09090a9995d48af9a2a6296d7e6088d1c b/tests/resources/reftable/merge-resolve/.gitted/objects/91/8bb3e09090a9995d48af9a2a6296d7e6088d1c new file mode 100644 index 000000000..c214ab206 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/91/8bb3e09090a9995d48af9a2a6296d7e6088d1c differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/91/f44111cb1cb1358ac6944ad356ca1738813ea1 b/tests/resources/reftable/merge-resolve/.gitted/objects/91/f44111cb1cb1358ac6944ad356ca1738813ea1 new file mode 100644 index 000000000..51a456f42 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/91/f44111cb1cb1358ac6944ad356ca1738813ea1 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/92/7d4943cdbdc9a667db8e62cfd0a41870235c51 b/tests/resources/reftable/merge-resolve/.gitted/objects/92/7d4943cdbdc9a667db8e62cfd0a41870235c51 new file mode 100644 index 000000000..b6b92c842 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/92/7d4943cdbdc9a667db8e62cfd0a41870235c51 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/93/77fccdb210540b8c0520cc6e80eb632c20bd25 b/tests/resources/reftable/merge-resolve/.gitted/objects/93/77fccdb210540b8c0520cc6e80eb632c20bd25 new file mode 100644 index 000000000..4b2d93b07 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/93/77fccdb210540b8c0520cc6e80eb632c20bd25 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/94/29c05dd6f6f39fc567b4ce923b16df5d3d7a7a b/tests/resources/reftable/merge-resolve/.gitted/objects/94/29c05dd6f6f39fc567b4ce923b16df5d3d7a7a new file mode 100644 index 000000000..d4d93f508 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/94/29c05dd6f6f39fc567b4ce923b16df5d3d7a7a differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/94/4f5dd1a867cab4c2bbcb896493435cae1dcc1a b/tests/resources/reftable/merge-resolve/.gitted/objects/94/4f5dd1a867cab4c2bbcb896493435cae1dcc1a new file mode 100644 index 000000000..143093831 --- /dev/null +++ b/tests/resources/reftable/merge-resolve/.gitted/objects/94/4f5dd1a867cab4c2bbcb896493435cae1dcc1a @@ -0,0 +1,2 @@ +xK!D]s +.z7 |2. bhWKVmH0~7z"P9`:Qi)QLEyq=oC*P6-"4l0StAHZC'g$楧f&%%g5qYeZokM2ԐX\ZDPC~^ZNfrIf^:XZHي1O(_,' jv^jnb^nJfZZjQj^ X#3|>^U:'A2R2 I{| 2mg˾15ӿ,\})TC)0H!vʉz֛9MՅ'6bGx \ No newline at end of file diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/a9/0bc3fb6f15181972a2959a921429efbd81a473 b/tests/resources/reftable/merge-resolve/.gitted/objects/a9/0bc3fb6f15181972a2959a921429efbd81a473 new file mode 100644 index 000000000..91113ee8e --- /dev/null +++ b/tests/resources/reftable/merge-resolve/.gitted/objects/a9/0bc3fb6f15181972a2959a921429efbd81a473 @@ -0,0 +1,2 @@ +xK +1D]};7d=oo^UQT\;hk6@g 5rѓ]uOMndgz&c圈'} NJ7p?(G\8CآGTg9x$faxN" \ No newline at end of file diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/ab/347abd8cda4a0e3b8bb42bb620c0c72c7df779 b/tests/resources/reftable/merge-resolve/.gitted/objects/ab/347abd8cda4a0e3b8bb42bb620c0c72c7df779 new file mode 100644 index 000000000..d743a385c Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/ab/347abd8cda4a0e3b8bb42bb620c0c72c7df779 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/ab/40af3cb8a3ed2e2843e96d9aa7871336b94573 b/tests/resources/reftable/merge-resolve/.gitted/objects/ab/40af3cb8a3ed2e2843e96d9aa7871336b94573 new file mode 100644 index 000000000..7da1da656 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/ab/40af3cb8a3ed2e2843e96d9aa7871336b94573 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/ab/6c44a2e84492ad4b41bb6bac87353e9d02ac8b b/tests/resources/reftable/merge-resolve/.gitted/objects/ab/6c44a2e84492ad4b41bb6bac87353e9d02ac8b new file mode 100644 index 000000000..d840c1a57 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/ab/6c44a2e84492ad4b41bb6bac87353e9d02ac8b differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/ab/929391ac42572f92110f3deeb4f0844a951e22 b/tests/resources/reftable/merge-resolve/.gitted/objects/ab/929391ac42572f92110f3deeb4f0844a951e22 new file mode 100644 index 000000000..8840d00c5 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/ab/929391ac42572f92110f3deeb4f0844a951e22 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/ac/4045f965119e6998f4340ed0f411decfb3ec05 b/tests/resources/reftable/merge-resolve/.gitted/objects/ac/4045f965119e6998f4340ed0f411decfb3ec05 new file mode 100644 index 000000000..4c32d63f8 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/ac/4045f965119e6998f4340ed0f411decfb3ec05 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/ad/01aebfdf2ac13145efafe3f9fcf798882f1730 b/tests/resources/reftable/merge-resolve/.gitted/objects/ad/01aebfdf2ac13145efafe3f9fcf798882f1730 new file mode 100644 index 000000000..ae3ef8ce3 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/ad/01aebfdf2ac13145efafe3f9fcf798882f1730 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/ad/26b598134264fd284292cb233fc0b2f25851da b/tests/resources/reftable/merge-resolve/.gitted/objects/ad/26b598134264fd284292cb233fc0b2f25851da new file mode 100644 index 000000000..5819a2e25 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/ad/26b598134264fd284292cb233fc0b2f25851da differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/ad/a14492498136771f69dd451866cabcb0e9ef9a b/tests/resources/reftable/merge-resolve/.gitted/objects/ad/a14492498136771f69dd451866cabcb0e9ef9a new file mode 100644 index 000000000..71023de39 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/ad/a14492498136771f69dd451866cabcb0e9ef9a differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/ad/a55a45d14527dc3dfc714ea1c65d2e1e6fbe87 b/tests/resources/reftable/merge-resolve/.gitted/objects/ad/a55a45d14527dc3dfc714ea1c65d2e1e6fbe87 new file mode 100644 index 000000000..3091b8f3d --- /dev/null +++ b/tests/resources/reftable/merge-resolve/.gitted/objects/ad/a55a45d14527dc3dfc714ea1c65d2e1e6fbe87 @@ -0,0 +1 @@ +x+)JMU067d040031QH,-M-JOMLI+(aH:,:C: o>ZC'g$楧f&%%g5qYeZokM2ԐX\ZDPC~^ZNfrIf^:XZHي1O(_,' jvn~JfZ&5`nלU7 V.6t6L/R2 I{| 2mg˾15ӿ,\})TC)0<vʉz֛9MՅ'6bN* \ No newline at end of file diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/b2/d399ae15224e1d58066e3c8df70ce37de7a656 b/tests/resources/reftable/merge-resolve/.gitted/objects/b2/d399ae15224e1d58066e3c8df70ce37de7a656 new file mode 100644 index 000000000..20fa838f2 --- /dev/null +++ b/tests/resources/reftable/merge-resolve/.gitted/objects/b2/d399ae15224e1d58066e3c8df70ce37de7a656 @@ -0,0 +1,2 @@ +xQA1+xċϡ-kI*5f/z af!^/WJcܤ5Lƛ;+B6HZP|`h>\($sX@75}57K ++= ;g @!4!,\$\ \b/Hs#aQ \ No newline at end of file diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/b4/2712cfe99a1a500b2a51fe984e0b8a7702ba11 b/tests/resources/reftable/merge-resolve/.gitted/objects/b4/2712cfe99a1a500b2a51fe984e0b8a7702ba11 new file mode 100644 index 000000000..2820b46cc --- /dev/null +++ b/tests/resources/reftable/merge-resolve/.gitted/objects/b4/2712cfe99a1a500b2a51fe984e0b8a7702ba11 @@ -0,0 +1,5 @@ +xA + {B{M1 ߯>P3F֎7E02 X0̒,)$;:ܷ(: \ No newline at end of file diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/b6/f610aef53bd343e6c96227de874c66f00ee8e8 b/tests/resources/reftable/merge-resolve/.gitted/objects/b6/f610aef53bd343e6c96227de874c66f00ee8e8 new file mode 100644 index 000000000..fb102f15d Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/b6/f610aef53bd343e6c96227de874c66f00ee8e8 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/b7/a2576f9fc20024ac9ef17cb134acbd1ac73127 b/tests/resources/reftable/merge-resolve/.gitted/objects/b7/a2576f9fc20024ac9ef17cb134acbd1ac73127 new file mode 100644 index 000000000..22f2d137d Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/b7/a2576f9fc20024ac9ef17cb134acbd1ac73127 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/b8/a3a806d3950e8c0a03a34f234a92eff0e2c68d b/tests/resources/reftable/merge-resolve/.gitted/objects/b8/a3a806d3950e8c0a03a34f234a92eff0e2c68d new file mode 100644 index 000000000..24f029900 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/b8/a3a806d3950e8c0a03a34f234a92eff0e2c68d differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/ba/cac9b3493509aa15e1730e1545fc0919d1dae0 b/tests/resources/reftable/merge-resolve/.gitted/objects/ba/cac9b3493509aa15e1730e1545fc0919d1dae0 new file mode 100644 index 000000000..f35586f7f Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/ba/cac9b3493509aa15e1730e1545fc0919d1dae0 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/bc/114411903fd2afaa4bb9b85ed13f27e37ac375 b/tests/resources/reftable/merge-resolve/.gitted/objects/bc/114411903fd2afaa4bb9b85ed13f27e37ac375 new file mode 100644 index 000000000..08941ff95 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/bc/114411903fd2afaa4bb9b85ed13f27e37ac375 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/bc/744705e1d8a019993cf88f62bc4020f1b80919 b/tests/resources/reftable/merge-resolve/.gitted/objects/bc/744705e1d8a019993cf88f62bc4020f1b80919 new file mode 100644 index 000000000..0d4bdb323 --- /dev/null +++ b/tests/resources/reftable/merge-resolve/.gitted/objects/bc/744705e1d8a019993cf88f62bc4020f1b80919 @@ -0,0 +1,2 @@ +xK +1D]}%%tYH& UJuj7:P(#F̄ģ1+k#vΚS8W|٨%Kpɯ3\Vv#MQg?wH@(c s9t 嶭{kO \ No newline at end of file diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/bc/85d1aad435ff3705a8c30ace85f7542c5736cb b/tests/resources/reftable/merge-resolve/.gitted/objects/bc/85d1aad435ff3705a8c30ace85f7542c5736cb new file mode 100644 index 000000000..ae529fe87 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/bc/85d1aad435ff3705a8c30ace85f7542c5736cb differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/bc/95c75d59386147d1e79a87c33068d8dbfd71f2 b/tests/resources/reftable/merge-resolve/.gitted/objects/bc/95c75d59386147d1e79a87c33068d8dbfd71f2 new file mode 100644 index 000000000..436d5a076 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/bc/95c75d59386147d1e79a87c33068d8dbfd71f2 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/bd/593285fc7fe4ca18ccdbabf027f5d689101452 b/tests/resources/reftable/merge-resolve/.gitted/objects/bd/593285fc7fe4ca18ccdbabf027f5d689101452 new file mode 100644 index 000000000..75ab1f0f3 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/bd/593285fc7fe4ca18ccdbabf027f5d689101452 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/bd/867fbae2faa80b920b002b80b1c91bcade7784 b/tests/resources/reftable/merge-resolve/.gitted/objects/bd/867fbae2faa80b920b002b80b1c91bcade7784 new file mode 100644 index 000000000..0f7421963 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/bd/867fbae2faa80b920b002b80b1c91bcade7784 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/bd/9cb4cd0a770cb9adcb5fce212142ef40ea1c35 b/tests/resources/reftable/merge-resolve/.gitted/objects/bd/9cb4cd0a770cb9adcb5fce212142ef40ea1c35 new file mode 100644 index 000000000..2aafdc64f Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/bd/9cb4cd0a770cb9adcb5fce212142ef40ea1c35 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/be/f6e37b3ee632ba74159168836f382fed21d77d b/tests/resources/reftable/merge-resolve/.gitted/objects/be/f6e37b3ee632ba74159168836f382fed21d77d new file mode 100644 index 000000000..6c243150d --- /dev/null +++ b/tests/resources/reftable/merge-resolve/.gitted/objects/be/f6e37b3ee632ba74159168836f382fed21d77d @@ -0,0 +1,2 @@ +xK +1D]}3?Ač7p?$=`Ґx}Gރ`)+0ѮUh.NWޓ!Idlj-f 9UV61:̸ !>Z.P0x hhQ+t`1NZe,X[ =vyI_vJ^2$?I7o4{K>V!~|U= \ No newline at end of file diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/c5/bbe550b9f09444bdddd3ecf3d97c0b42aa786c b/tests/resources/reftable/merge-resolve/.gitted/objects/c5/bbe550b9f09444bdddd3ecf3d97c0b42aa786c new file mode 100644 index 000000000..2f2ada732 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/c5/bbe550b9f09444bdddd3ecf3d97c0b42aa786c differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/c6/07fc30883e335def28cd686b51f6cfa02b06ec b/tests/resources/reftable/merge-resolve/.gitted/objects/c6/07fc30883e335def28cd686b51f6cfa02b06ec new file mode 100644 index 000000000..475b87ef9 --- /dev/null +++ b/tests/resources/reftable/merge-resolve/.gitted/objects/c6/07fc30883e335def28cd686b51f6cfa02b06ec @@ -0,0 +1,2 @@ +xQ +1 D)r%n "x/m[[oo{0k)iכ*`ZavJ>,af<EZȳ5%<'.v,;]=2tws-,w8@ \ No newline at end of file diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/c6/92ecf62007c0ac9fb26e2aa884de2933de15ed b/tests/resources/reftable/merge-resolve/.gitted/objects/c6/92ecf62007c0ac9fb26e2aa884de2933de15ed new file mode 100644 index 000000000..ae430bd4a Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/c6/92ecf62007c0ac9fb26e2aa884de2933de15ed differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/c8/26ef8b17b5cd2c4a0023f265f3a423b3aa0388 b/tests/resources/reftable/merge-resolve/.gitted/objects/c8/26ef8b17b5cd2c4a0023f265f3a423b3aa0388 new file mode 100644 index 000000000..b655d7c40 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/c8/26ef8b17b5cd2c4a0023f265f3a423b3aa0388 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/c8/f06f2e3bb2964174677e91f0abead0e43c9e5d b/tests/resources/reftable/merge-resolve/.gitted/objects/c8/f06f2e3bb2964174677e91f0abead0e43c9e5d new file mode 100644 index 000000000..5dae4c3ac Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/c8/f06f2e3bb2964174677e91f0abead0e43c9e5d differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/c9/174cef549ec94ecbc43ef03cdc775b4950becb b/tests/resources/reftable/merge-resolve/.gitted/objects/c9/174cef549ec94ecbc43ef03cdc775b4950becb new file mode 100644 index 000000000..da8dba244 --- /dev/null +++ b/tests/resources/reftable/merge-resolve/.gitted/objects/c9/174cef549ec94ecbc43ef03cdc775b4950becb @@ -0,0 +1,2 @@ +xQ +0D)rfnSxfCHx}xfc,˵Y kUb8pu`%|@r3GtB;W]!z'%QiӐdT ?\=d/sYe';^r#l`6m Z7U^e6oVO \ No newline at end of file diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/c9/4b27e41064c521120627e07e2035cca1d24ffa b/tests/resources/reftable/merge-resolve/.gitted/objects/c9/4b27e41064c521120627e07e2035cca1d24ffa new file mode 100644 index 000000000..fd1ec9fab Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/c9/4b27e41064c521120627e07e2035cca1d24ffa differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/ca/b2cf23998b40f1af2d9d9a756dc9e285a8df4b b/tests/resources/reftable/merge-resolve/.gitted/objects/ca/b2cf23998b40f1af2d9d9a756dc9e285a8df4b new file mode 100644 index 000000000..32ba2aa53 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/ca/b2cf23998b40f1af2d9d9a756dc9e285a8df4b differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/ca/ff6b7d44973f53e3e0cf31d0d695188b19aec6 b/tests/resources/reftable/merge-resolve/.gitted/objects/ca/ff6b7d44973f53e3e0cf31d0d695188b19aec6 new file mode 100644 index 000000000..6d0f60077 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/ca/ff6b7d44973f53e3e0cf31d0d695188b19aec6 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/cb/491780d82e46dc88a065b965ab307a038f2bc2 b/tests/resources/reftable/merge-resolve/.gitted/objects/cb/491780d82e46dc88a065b965ab307a038f2bc2 new file mode 100644 index 000000000..cf9cd7d39 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/cb/491780d82e46dc88a065b965ab307a038f2bc2 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/cb/6693a788715b82440a54e0eacd19ba9f6ec559 b/tests/resources/reftable/merge-resolve/.gitted/objects/cb/6693a788715b82440a54e0eacd19ba9f6ec559 new file mode 100644 index 000000000..e11181a96 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/cb/6693a788715b82440a54e0eacd19ba9f6ec559 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/cc/338e4710c9b257106b8d16d82f86458d5beaf1 b/tests/resources/reftable/merge-resolve/.gitted/objects/cc/338e4710c9b257106b8d16d82f86458d5beaf1 new file mode 100644 index 000000000..85b3b8112 --- /dev/null +++ b/tests/resources/reftable/merge-resolve/.gitted/objects/cc/338e4710c9b257106b8d16d82f86458d5beaf1 @@ -0,0 +1,2 @@ +xK!]s3`bo1 gpWEGmx]6d +eaΉ碵z.Dv [hD[JﱶwX[.2nuVƉZڳF!x88GPP_?KN \ No newline at end of file diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/cc/3e3009134cb88014129fc8858d1101359e5e2f b/tests/resources/reftable/merge-resolve/.gitted/objects/cc/3e3009134cb88014129fc8858d1101359e5e2f new file mode 100644 index 000000000..9a0cb7a0c --- /dev/null +++ b/tests/resources/reftable/merge-resolve/.gitted/objects/cc/3e3009134cb88014129fc8858d1101359e5e2f @@ -0,0 +1,2 @@ +x] +0})&_H -Fb[6}0L2wPzc*sXb Rt#G$[lvH$kf.ʧLF+ QHD|68Wl.S]uoNOu9Va0^ZF9^# Od \ No newline at end of file diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/cd/3e8d4aa06bdc781f264171030bc28f2b370fee b/tests/resources/reftable/merge-resolve/.gitted/objects/cd/3e8d4aa06bdc781f264171030bc28f2b370fee new file mode 100644 index 000000000..144225df1 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/cd/3e8d4aa06bdc781f264171030bc28f2b370fee differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/cd/edf9760406dc79e0c6a8899ce9f180ec2a23a0 b/tests/resources/reftable/merge-resolve/.gitted/objects/cd/edf9760406dc79e0c6a8899ce9f180ec2a23a0 new file mode 100644 index 000000000..011b5b3e5 --- /dev/null +++ b/tests/resources/reftable/merge-resolve/.gitted/objects/cd/edf9760406dc79e0c6a8899ce9f180ec2a23a0 @@ -0,0 +1,2 @@ +xA +B1C] "n)B[U R^Mo3c:d chCi2FGkKzŖ:ײ<ǝ[Ҏj9 zB0X!58猒E;4~*uQo$D \ No newline at end of file diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/ce/8860d49e3bea6fd745874a01b7c3e46da8cbc3 b/tests/resources/reftable/merge-resolve/.gitted/objects/ce/8860d49e3bea6fd745874a01b7c3e46da8cbc3 new file mode 100644 index 000000000..860f9952f Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/ce/8860d49e3bea6fd745874a01b7c3e46da8cbc3 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/ce/e656c392ad0557b3aae0fb411475c206e2926f b/tests/resources/reftable/merge-resolve/.gitted/objects/ce/e656c392ad0557b3aae0fb411475c206e2926f new file mode 100644 index 000000000..ff0624ccb Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/ce/e656c392ad0557b3aae0fb411475c206e2926f differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/cf/8c5cc8a85a1ff5a4ba51e0bc7cf5665669924d b/tests/resources/reftable/merge-resolve/.gitted/objects/cf/8c5cc8a85a1ff5a4ba51e0bc7cf5665669924d new file mode 100644 index 000000000..36b0289e6 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/cf/8c5cc8a85a1ff5a4ba51e0bc7cf5665669924d differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/d0/7ec190c306ec690bac349e87d01c4358e49bb2 b/tests/resources/reftable/merge-resolve/.gitted/objects/d0/7ec190c306ec690bac349e87d01c4358e49bb2 new file mode 100644 index 000000000..d52a56ffe --- /dev/null +++ b/tests/resources/reftable/merge-resolve/.gitted/objects/d0/7ec190c306ec690bac349e87d01c4358e49bb2 @@ -0,0 +1,2 @@ +xՏ 0 3aOb%ǑS=HT@u:]uYG%LE;u`_?g~0Ҕ. +׋PӜxvXi ӭf! \ No newline at end of file diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/d0/d4594e16f2e19107e3fa7ea63e7aaaff305ffb b/tests/resources/reftable/merge-resolve/.gitted/objects/d0/d4594e16f2e19107e3fa7ea63e7aaaff305ffb new file mode 100644 index 000000000..5f7e286ff Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/d0/d4594e16f2e19107e3fa7ea63e7aaaff305ffb differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/d2/f8637f2eab2507a1e13cbc9df4729ec386627e b/tests/resources/reftable/merge-resolve/.gitted/objects/d2/f8637f2eab2507a1e13cbc9df4729ec386627e new file mode 100644 index 000000000..558a8513f Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/d2/f8637f2eab2507a1e13cbc9df4729ec386627e differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/d3/3cedf513c059e0515653fa2c2e386631387a05 b/tests/resources/reftable/merge-resolve/.gitted/objects/d3/3cedf513c059e0515653fa2c2e386631387a05 new file mode 100644 index 000000000..d6d4c2b45 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/d3/3cedf513c059e0515653fa2c2e386631387a05 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/d3/719a5ae8e4d92276b5313ce976f6ee5af2b436 b/tests/resources/reftable/merge-resolve/.gitted/objects/d3/719a5ae8e4d92276b5313ce976f6ee5af2b436 new file mode 100644 index 000000000..930bf5a5e --- /dev/null +++ b/tests/resources/reftable/merge-resolve/.gitted/objects/d3/719a5ae8e4d92276b5313ce976f6ee5af2b436 @@ -0,0 +1,2 @@ +x=10 E}uAHب zRHPT Brh/]?a 48,_MdkуTPF!TZQ? +R֧FN_J͆ h{(kLKV1p+Q A \ No newline at end of file diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/d3/7aa3bbfe1c0c49b909781251b956dbabe85f96 b/tests/resources/reftable/merge-resolve/.gitted/objects/d3/7aa3bbfe1c0c49b909781251b956dbabe85f96 new file mode 100644 index 000000000..5902e0f32 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/d3/7aa3bbfe1c0c49b909781251b956dbabe85f96 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/d3/7ad72a2052685fc6201c2af90103ad42d2079b b/tests/resources/reftable/merge-resolve/.gitted/objects/d3/7ad72a2052685fc6201c2af90103ad42d2079b new file mode 100644 index 000000000..b2f39bff4 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/d3/7ad72a2052685fc6201c2af90103ad42d2079b differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/d4/207f77243500bec335ab477f9227fcdb1e271a b/tests/resources/reftable/merge-resolve/.gitted/objects/d4/207f77243500bec335ab477f9227fcdb1e271a new file mode 100644 index 000000000..862e4e5bc --- /dev/null +++ b/tests/resources/reftable/merge-resolve/.gitted/objects/d4/207f77243500bec335ab477f9227fcdb1e271a @@ -0,0 +1,2 @@ +xK +1D]O'7t:݌H&z:]oZBBXl(昭+d<"6^% A( J,% %5SSmR^؊Nu^뢏O:Wځ| DcFQEn6#Q \ No newline at end of file diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/d4/27e0b2e138501a3d15cc376077a3631e15bd46 b/tests/resources/reftable/merge-resolve/.gitted/objects/d4/27e0b2e138501a3d15cc376077a3631e15bd46 new file mode 100644 index 000000000..0b3611ae4 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/d4/27e0b2e138501a3d15cc376077a3631e15bd46 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/d5/093787ef302b941b6aab081b99fb4880038bd8 b/tests/resources/reftable/merge-resolve/.gitted/objects/d5/093787ef302b941b6aab081b99fb4880038bd8 new file mode 100644 index 000000000..7d73449eb Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/d5/093787ef302b941b6aab081b99fb4880038bd8 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/d5/a61b0b4992a4f0caa887fa08b52431e727bb6f b/tests/resources/reftable/merge-resolve/.gitted/objects/d5/a61b0b4992a4f0caa887fa08b52431e727bb6f new file mode 100644 index 000000000..a7921de43 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/d5/a61b0b4992a4f0caa887fa08b52431e727bb6f differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/d5/b6fc965c926a1bfc9ee456042b94088b5c5d21 b/tests/resources/reftable/merge-resolve/.gitted/objects/d5/b6fc965c926a1bfc9ee456042b94088b5c5d21 new file mode 100644 index 000000000..924bdbbb5 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/d5/b6fc965c926a1bfc9ee456042b94088b5c5d21 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/d5/ec1152fe25e9fec00189eb00b3db71db24c218 b/tests/resources/reftable/merge-resolve/.gitted/objects/d5/ec1152fe25e9fec00189eb00b3db71db24c218 new file mode 100644 index 000000000..0d2534bc9 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/d5/ec1152fe25e9fec00189eb00b3db71db24c218 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/d6/42b9770c66bba94a08df09b5efb095001f76d7 b/tests/resources/reftable/merge-resolve/.gitted/objects/d6/42b9770c66bba94a08df09b5efb095001f76d7 new file mode 100644 index 000000000..1671f9f2c Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/d6/42b9770c66bba94a08df09b5efb095001f76d7 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/d6/462fa3f5292857db599c54aea2bf91616230c5 b/tests/resources/reftable/merge-resolve/.gitted/objects/d6/462fa3f5292857db599c54aea2bf91616230c5 new file mode 100644 index 000000000..baae3f0e0 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/d6/462fa3f5292857db599c54aea2bf91616230c5 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/d6/cf6c7741b3316826af1314042550c97ded1d50 b/tests/resources/reftable/merge-resolve/.gitted/objects/d6/cf6c7741b3316826af1314042550c97ded1d50 new file mode 100644 index 000000000..8f9ae1fc6 --- /dev/null +++ b/tests/resources/reftable/merge-resolve/.gitted/objects/d6/cf6c7741b3316826af1314042550c97ded1d50 @@ -0,0 +1,2 @@ +xQ +1 D)r%i@oje[7̤ZʽMSLBNlm B~>-uY8ꠟt֯]Qa͠3f]>bl(A] \ No newline at end of file diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/d7/308cc367b2cc23f710834ec1fd8ffbacf1b460 b/tests/resources/reftable/merge-resolve/.gitted/objects/d7/308cc367b2cc23f710834ec1fd8ffbacf1b460 new file mode 100644 index 000000000..b02cda4fa --- /dev/null +++ b/tests/resources/reftable/merge-resolve/.gitted/objects/d7/308cc367b2cc23f710834ec1fd8ffbacf1b460 @@ -0,0 +1 @@ +xK @]s)Ё7 ]I(x{ ^,nлSo`/X)ٙB@GÔaD 4xwlCv?-79d,hF4Z ;ƝH}= \ No newline at end of file diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/d8/74671ef5b20184836cb983bb273e5280384d0b b/tests/resources/reftable/merge-resolve/.gitted/objects/d8/74671ef5b20184836cb983bb273e5280384d0b new file mode 100644 index 000000000..1d8037895 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/d8/74671ef5b20184836cb983bb273e5280384d0b differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/d8/dec75ff2f8b41d1c5bfef0cd57b7300c834f66 b/tests/resources/reftable/merge-resolve/.gitted/objects/d8/dec75ff2f8b41d1c5bfef0cd57b7300c834f66 new file mode 100644 index 000000000..74f807e68 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/d8/dec75ff2f8b41d1c5bfef0cd57b7300c834f66 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/d8/fa77b6833082c1ea36b7828a582d4c43882450 b/tests/resources/reftable/merge-resolve/.gitted/objects/d8/fa77b6833082c1ea36b7828a582d4c43882450 new file mode 100644 index 000000000..988145322 --- /dev/null +++ b/tests/resources/reftable/merge-resolve/.gitted/objects/d8/fa77b6833082c1ea36b7828a582d4c43882450 @@ -0,0 +1 @@ +x1 DQkN1&6%lBknaa1kdI(Ur'7LA,+Wm9 I'U͹_ܰN \ No newline at end of file diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/d9/63979c237d08b6ba39062ee7bf64c7d34a27f8 b/tests/resources/reftable/merge-resolve/.gitted/objects/d9/63979c237d08b6ba39062ee7bf64c7d34a27f8 new file mode 100644 index 000000000..5fa10405c Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/d9/63979c237d08b6ba39062ee7bf64c7d34a27f8 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/da/178208145ef585a1bd5ca5f4c9785d738df2cf b/tests/resources/reftable/merge-resolve/.gitted/objects/da/178208145ef585a1bd5ca5f4c9785d738df2cf new file mode 100644 index 000000000..6292118e0 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/da/178208145ef585a1bd5ca5f4c9785d738df2cf differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/db/6261a7c65c7fd678520c9bb6f2c47582ab9ed5 b/tests/resources/reftable/merge-resolve/.gitted/objects/db/6261a7c65c7fd678520c9bb6f2c47582ab9ed5 new file mode 100644 index 000000000..b82e7fcaf Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/db/6261a7c65c7fd678520c9bb6f2c47582ab9ed5 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/dd/2ae5ab264e5592aa754235d5ad5eac8f0ecdfd b/tests/resources/reftable/merge-resolve/.gitted/objects/dd/2ae5ab264e5592aa754235d5ad5eac8f0ecdfd new file mode 100644 index 000000000..55626a57b Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/dd/2ae5ab264e5592aa754235d5ad5eac8f0ecdfd differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/dd/9a570c3400e6e07bc4d7651d6e20b08926b3d9 b/tests/resources/reftable/merge-resolve/.gitted/objects/dd/9a570c3400e6e07bc4d7651d6e20b08926b3d9 new file mode 100644 index 000000000..8fd60cbe8 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/dd/9a570c3400e6e07bc4d7651d6e20b08926b3d9 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/de/06afe070b65f94d7d791c39a6d389c58dda60d b/tests/resources/reftable/merge-resolve/.gitted/objects/de/06afe070b65f94d7d791c39a6d389c58dda60d new file mode 100644 index 000000000..28567b624 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/de/06afe070b65f94d7d791c39a6d389c58dda60d differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/de/872ee3618b894992e9d1e18ba2ebe256a112f9 b/tests/resources/reftable/merge-resolve/.gitted/objects/de/872ee3618b894992e9d1e18ba2ebe256a112f9 new file mode 100644 index 000000000..04dda4a75 --- /dev/null +++ b/tests/resources/reftable/merge-resolve/.gitted/objects/de/872ee3618b894992e9d1e18ba2ebe256a112f9 @@ -0,0 +1 @@ +x퐱 S3ŏlKAB4Wb T5:8Sc ԻP`KIˆO3Z&ؐ \ No newline at end of file diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/df/e3f22baa1f6fce5447901c3086bae368de6bdd b/tests/resources/reftable/merge-resolve/.gitted/objects/df/e3f22baa1f6fce5447901c3086bae368de6bdd new file mode 100644 index 000000000..e13569440 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/df/e3f22baa1f6fce5447901c3086bae368de6bdd differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/e0/67f9361140f19391472df8a82d6610813c73b7 b/tests/resources/reftable/merge-resolve/.gitted/objects/e0/67f9361140f19391472df8a82d6610813c73b7 new file mode 100644 index 000000000..955431dd7 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/e0/67f9361140f19391472df8a82d6610813c73b7 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/e1/129b3cfb5898e0fbd606e0cb80b2755e50d161 b/tests/resources/reftable/merge-resolve/.gitted/objects/e1/129b3cfb5898e0fbd606e0cb80b2755e50d161 new file mode 100644 index 000000000..751f1dd33 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/e1/129b3cfb5898e0fbd606e0cb80b2755e50d161 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/e1/7ace1492648c9dc5701bad5c47af9d1b60c4e9 b/tests/resources/reftable/merge-resolve/.gitted/objects/e1/7ace1492648c9dc5701bad5c47af9d1b60c4e9 new file mode 100644 index 000000000..4a812e5df Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/e1/7ace1492648c9dc5701bad5c47af9d1b60c4e9 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/e2/6b8888956137218d8589368a3e606cf50fbb56 b/tests/resources/reftable/merge-resolve/.gitted/objects/e2/6b8888956137218d8589368a3e606cf50fbb56 new file mode 100644 index 000000000..d4ec2b972 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/e2/6b8888956137218d8589368a3e606cf50fbb56 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/e2/c6abbd55fed5ac71a5f2751e29b4a34726a595 b/tests/resources/reftable/merge-resolve/.gitted/objects/e2/c6abbd55fed5ac71a5f2751e29b4a34726a595 new file mode 100644 index 000000000..7b84ce966 --- /dev/null +++ b/tests/resources/reftable/merge-resolve/.gitted/objects/e2/c6abbd55fed5ac71a5f2751e29b4a34726a595 @@ -0,0 +1 @@ +x+)JMU067f040031QH,-M-JOMLI+(aH:,:C: o>ZC'g$楧f&%%g5qYeZokM2ԐX\ZDPC~^ZNfrIf^:XZHي1O(_,' jvn~JfZ&5%\N,5[e2 I{| 2mg˾15ӿ,\})TC)0Dvz֛9MՅ'6b \ No newline at end of file diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/e3/1e7ad3ed298f24e383c4950f4671993ec078e4 b/tests/resources/reftable/merge-resolve/.gitted/objects/e3/1e7ad3ed298f24e383c4950f4671993ec078e4 new file mode 100644 index 000000000..a28ded3fb Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/e3/1e7ad3ed298f24e383c4950f4671993ec078e4 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/e3/76fbdd06ebf021c92724da9f26f44212734e3e b/tests/resources/reftable/merge-resolve/.gitted/objects/e3/76fbdd06ebf021c92724da9f26f44212734e3e new file mode 100644 index 000000000..8da234114 --- /dev/null +++ b/tests/resources/reftable/merge-resolve/.gitted/objects/e3/76fbdd06ebf021c92724da9f26f44212734e3e @@ -0,0 +1,3 @@ +xA@E]s +`@ uH)M=Scz:ʊ(N+6ޛDFe𭭘Yg$+G&F +pG 4mQ\85#FC~QERu);c6'j \ No newline at end of file diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/e4/9f917b448d1340b31d76e54ba388268fd4c922 b/tests/resources/reftable/merge-resolve/.gitted/objects/e4/9f917b448d1340b31d76e54ba388268fd4c922 new file mode 100644 index 000000000..870c3e732 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/e4/9f917b448d1340b31d76e54ba388268fd4c922 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/e4/f618a2c3ed0669308735727df5ebf2447f022f b/tests/resources/reftable/merge-resolve/.gitted/objects/e4/f618a2c3ed0669308735727df5ebf2447f022f new file mode 100644 index 000000000..c7e1ee9d7 --- /dev/null +++ b/tests/resources/reftable/merge-resolve/.gitted/objects/e4/f618a2c3ed0669308735727df5ebf2447f022f @@ -0,0 +1,2 @@ +xK!D]s +.iOboi2. bhJQ6b`7:DN.%4uIQYcm`Q¨ aQYa@>ɗEc9%bhZ;uB[JrN9z)Vb!.Rj +: +$ŘK:!c \˃Fｷ[?Kby{; pA-wS[_i{WOGR \ No newline at end of file diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/eb/c09d0137cfb0c26697aed0109fb943ad906f3f b/tests/resources/reftable/merge-resolve/.gitted/objects/eb/c09d0137cfb0c26697aed0109fb943ad906f3f new file mode 100644 index 000000000..83b489d3a Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/eb/c09d0137cfb0c26697aed0109fb943ad906f3f differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/ec/67e5a86adff465359f1c8f995e12dbdfa08d8a b/tests/resources/reftable/merge-resolve/.gitted/objects/ec/67e5a86adff465359f1c8f995e12dbdfa08d8a new file mode 100644 index 000000000..8490346e1 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/ec/67e5a86adff465359f1c8f995e12dbdfa08d8a differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/ed/9523e62e453e50dd9be1606af19399b96e397a b/tests/resources/reftable/merge-resolve/.gitted/objects/ed/9523e62e453e50dd9be1606af19399b96e397a new file mode 100644 index 000000000..7853e235c Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/ed/9523e62e453e50dd9be1606af19399b96e397a differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/ee/1d6f164893c1866a323f072eeed36b855656be b/tests/resources/reftable/merge-resolve/.gitted/objects/ee/1d6f164893c1866a323f072eeed36b855656be new file mode 100644 index 000000000..87d808007 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/ee/1d6f164893c1866a323f072eeed36b855656be differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/ee/3fa1b8c00aff7fe02065fdb50864bb0d932ccf b/tests/resources/reftable/merge-resolve/.gitted/objects/ee/3fa1b8c00aff7fe02065fdb50864bb0d932ccf new file mode 100644 index 000000000..974b72dfd Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/ee/3fa1b8c00aff7fe02065fdb50864bb0d932ccf differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/ee/a9286df54245fea72c5b557291470eb825f38f b/tests/resources/reftable/merge-resolve/.gitted/objects/ee/a9286df54245fea72c5b557291470eb825f38f new file mode 100644 index 000000000..ead0b2cda Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/ee/a9286df54245fea72c5b557291470eb825f38f differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/ef/58fdd8086c243bdc81f99e379acacfd21d32d6 b/tests/resources/reftable/merge-resolve/.gitted/objects/ef/58fdd8086c243bdc81f99e379acacfd21d32d6 new file mode 100644 index 000000000..55f79e066 --- /dev/null +++ b/tests/resources/reftable/merge-resolve/.gitted/objects/ef/58fdd8086c243bdc81f99e379acacfd21d32d6 @@ -0,0 +1,2 @@ +x 0О:JBݟOV +y55jq!4{:p; \ No newline at end of file diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/ef/c499524cf105d5264ac7fc54e07e95764e8075 b/tests/resources/reftable/merge-resolve/.gitted/objects/ef/c499524cf105d5264ac7fc54e07e95764e8075 new file mode 100644 index 000000000..bc9350bc0 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/ef/c499524cf105d5264ac7fc54e07e95764e8075 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/ef/c9121fdedaf08ba180b53ebfbcf71bd488ed09 b/tests/resources/reftable/merge-resolve/.gitted/objects/ef/c9121fdedaf08ba180b53ebfbcf71bd488ed09 new file mode 100644 index 000000000..5f9cd3012 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/ef/c9121fdedaf08ba180b53ebfbcf71bd488ed09 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/f0/053b8060bb3f0be5cbcc3147a07ece26bf097e b/tests/resources/reftable/merge-resolve/.gitted/objects/f0/053b8060bb3f0be5cbcc3147a07ece26bf097e new file mode 100644 index 000000000..c63d37fb0 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/f0/053b8060bb3f0be5cbcc3147a07ece26bf097e differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/f0/ce2b8e4986084d9b308fb72709e414c23eb5e6 b/tests/resources/reftable/merge-resolve/.gitted/objects/f0/ce2b8e4986084d9b308fb72709e414c23eb5e6 new file mode 100644 index 000000000..e78c19f1a Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/f0/ce2b8e4986084d9b308fb72709e414c23eb5e6 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/f2/0c9063fa0bda9a397c96947a7b687305c49753 b/tests/resources/reftable/merge-resolve/.gitted/objects/f2/0c9063fa0bda9a397c96947a7b687305c49753 new file mode 100644 index 000000000..34d9aed20 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/f2/0c9063fa0bda9a397c96947a7b687305c49753 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/f2/9e7fb590551095230c6149cbe72f2e9104a796 b/tests/resources/reftable/merge-resolve/.gitted/objects/f2/9e7fb590551095230c6149cbe72f2e9104a796 new file mode 100644 index 000000000..663f6aeb7 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/f2/9e7fb590551095230c6149cbe72f2e9104a796 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/f2/e1550a0c9e53d5811175864a29536642ae3821 b/tests/resources/reftable/merge-resolve/.gitted/objects/f2/e1550a0c9e53d5811175864a29536642ae3821 new file mode 100644 index 000000000..1fdcbe22a Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/f2/e1550a0c9e53d5811175864a29536642ae3821 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/f3/293571dcd708b6a3faf03818cd2844d000e198 b/tests/resources/reftable/merge-resolve/.gitted/objects/f3/293571dcd708b6a3faf03818cd2844d000e198 new file mode 100644 index 000000000..f748743b8 --- /dev/null +++ b/tests/resources/reftable/merge-resolve/.gitted/objects/f3/293571dcd708b6a3faf03818cd2844d000e198 @@ -0,0 +1 @@ +xKj0)dZ!\@nI,3{XZ?F/\E12zc"#X1][_G&c+9XWKžiUtgS*O۹)u|oXp*" pӤtũ`9zKO\ \ No newline at end of file diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/f3/f1164b68b57b1995b658a828320e6df3081fae b/tests/resources/reftable/merge-resolve/.gitted/objects/f3/f1164b68b57b1995b658a828320e6df3081fae new file mode 100644 index 000000000..5f0b4e424 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/f3/f1164b68b57b1995b658a828320e6df3081fae differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/f4/15caf3fcad16304cb424b67f0ee6b12dc03aae b/tests/resources/reftable/merge-resolve/.gitted/objects/f4/15caf3fcad16304cb424b67f0ee6b12dc03aae new file mode 100644 index 000000000..21ce1a0fc Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/f4/15caf3fcad16304cb424b67f0ee6b12dc03aae differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/f4/8097eb340dc5a7cae55aabcf1faf4548aa821f b/tests/resources/reftable/merge-resolve/.gitted/objects/f4/8097eb340dc5a7cae55aabcf1faf4548aa821f new file mode 100644 index 000000000..5a4a9a54f Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/f4/8097eb340dc5a7cae55aabcf1faf4548aa821f differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/f5/504f36e6f4eb797a56fc5bac6c6c7f32969bf2 b/tests/resources/reftable/merge-resolve/.gitted/objects/f5/504f36e6f4eb797a56fc5bac6c6c7f32969bf2 new file mode 100644 index 000000000..2aa0c3b9a Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/f5/504f36e6f4eb797a56fc5bac6c6c7f32969bf2 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/f5/b50c85a87cac64d7eb3254cdd1aec9564c0293 b/tests/resources/reftable/merge-resolve/.gitted/objects/f5/b50c85a87cac64d7eb3254cdd1aec9564c0293 new file mode 100644 index 000000000..c1885cbe7 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/f5/b50c85a87cac64d7eb3254cdd1aec9564c0293 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/f5/f9dd5886a6ee20272be0aafc790cba43b31931 b/tests/resources/reftable/merge-resolve/.gitted/objects/f5/f9dd5886a6ee20272be0aafc790cba43b31931 new file mode 100644 index 000000000..17ad5063d Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/f5/f9dd5886a6ee20272be0aafc790cba43b31931 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/f6/65b45cde9b568009c6e6b7b568e89cfe717df8 b/tests/resources/reftable/merge-resolve/.gitted/objects/f6/65b45cde9b568009c6e6b7b568e89cfe717df8 new file mode 100644 index 000000000..7af50d7df Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/f6/65b45cde9b568009c6e6b7b568e89cfe717df8 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/f6/be049e284c0f9dcbbc745543885be3502ea521 b/tests/resources/reftable/merge-resolve/.gitted/objects/f6/be049e284c0f9dcbbc745543885be3502ea521 new file mode 100644 index 000000000..12d3c25c2 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/f6/be049e284c0f9dcbbc745543885be3502ea521 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/f7/c332bd4d4d4b777366cae4d24d1687477576bf b/tests/resources/reftable/merge-resolve/.gitted/objects/f7/c332bd4d4d4b777366cae4d24d1687477576bf new file mode 100644 index 000000000..b36bceabf Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/f7/c332bd4d4d4b777366cae4d24d1687477576bf differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/f8/958bdf4d365a84a9a178b1f5f35ff1dacbd884 b/tests/resources/reftable/merge-resolve/.gitted/objects/f8/958bdf4d365a84a9a178b1f5f35ff1dacbd884 new file mode 100644 index 000000000..5dbbef276 --- /dev/null +++ b/tests/resources/reftable/merge-resolve/.gitted/objects/f8/958bdf4d365a84a9a178b1f5f35ff1dacbd884 @@ -0,0 +1,2 @@ +xK +1D]}Iq K>f1x}xwUQv kv@`O;$Kșybh2癈sLA ?R\˷ץ(~Yïb-'Yǎp=Njq˟m[zO+ \ No newline at end of file diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/f9/7da95f156121bea8f978623628f4cbdbf30b36 b/tests/resources/reftable/merge-resolve/.gitted/objects/f9/7da95f156121bea8f978623628f4cbdbf30b36 new file mode 100644 index 000000000..d785511fb --- /dev/null +++ b/tests/resources/reftable/merge-resolve/.gitted/objects/f9/7da95f156121bea8f978623628f4cbdbf30b36 @@ -0,0 +1 @@ +x1!E9)0[^^u])zщ%A). dgDCtzSWdMXcb3g/ϵ[P1u/}at}.}Ӊzcơ>15x^iH \ No newline at end of file diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/fa/c03f2c5139618d87d53614c153823bf1f31396 b/tests/resources/reftable/merge-resolve/.gitted/objects/fa/c03f2c5139618d87d53614c153823bf1f31396 new file mode 100644 index 000000000..30e07e5b7 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/fa/c03f2c5139618d87d53614c153823bf1f31396 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/fa/da9356aa3f74622327a3038ae9c6f92e1c5c1d b/tests/resources/reftable/merge-resolve/.gitted/objects/fa/da9356aa3f74622327a3038ae9c6f92e1c5c1d new file mode 100644 index 000000000..16ce49a1b Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/fa/da9356aa3f74622327a3038ae9c6f92e1c5c1d differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/fb/738a106cfd097a4acb96ce132ecb1ad6c46b03 b/tests/resources/reftable/merge-resolve/.gitted/objects/fb/738a106cfd097a4acb96ce132ecb1ad6c46b03 new file mode 100644 index 000000000..4f1e72688 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/fb/738a106cfd097a4acb96ce132ecb1ad6c46b03 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/fc/4c636d6515e9e261f9260dbcf3cc6eca97ea08 b/tests/resources/reftable/merge-resolve/.gitted/objects/fc/4c636d6515e9e261f9260dbcf3cc6eca97ea08 new file mode 100644 index 000000000..be8a810cd Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/fc/4c636d6515e9e261f9260dbcf3cc6eca97ea08 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/fc/7d7b805f7a9428574f4f802b2e34cd20ab9d99 b/tests/resources/reftable/merge-resolve/.gitted/objects/fc/7d7b805f7a9428574f4f802b2e34cd20ab9d99 new file mode 100644 index 000000000..20493e68c Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/fc/7d7b805f7a9428574f4f802b2e34cd20ab9d99 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/fc/90237dc4891fa6c69827fc465632225e391618 b/tests/resources/reftable/merge-resolve/.gitted/objects/fc/90237dc4891fa6c69827fc465632225e391618 new file mode 100644 index 000000000..961814bae Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/fc/90237dc4891fa6c69827fc465632225e391618 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/fd/57d2d6770fad8e9959124793a17f441b571e66 b/tests/resources/reftable/merge-resolve/.gitted/objects/fd/57d2d6770fad8e9959124793a17f441b571e66 new file mode 100644 index 000000000..21e6b2c55 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/fd/57d2d6770fad8e9959124793a17f441b571e66 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/fd/89f8cffb663ac89095a0f9764902e93ceaca6a b/tests/resources/reftable/merge-resolve/.gitted/objects/fd/89f8cffb663ac89095a0f9764902e93ceaca6a new file mode 100644 index 000000000..2f9d83b26 --- /dev/null +++ b/tests/resources/reftable/merge-resolve/.gitted/objects/fd/89f8cffb663ac89095a0f9764902e93ceaca6a @@ -0,0 +1,2 @@ +xK!D]s +.{`cx/ɸ`0 oURy|Y`dPA!4C2d=x#e`BgrubLffG@՗-}KԲUy=];)r0 R$(%o=׶OPw \ No newline at end of file diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/fe/5407fc50a53aecb41d1a6e9ea7b612e581af87 b/tests/resources/reftable/merge-resolve/.gitted/objects/fe/5407fc50a53aecb41d1a6e9ea7b612e581af87 new file mode 100644 index 000000000..4ce7d2297 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/fe/5407fc50a53aecb41d1a6e9ea7b612e581af87 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/ff/49d07869831ad761bbdaea026086f8789bcb00 b/tests/resources/reftable/merge-resolve/.gitted/objects/ff/49d07869831ad761bbdaea026086f8789bcb00 new file mode 100644 index 000000000..eada39b77 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/ff/49d07869831ad761bbdaea026086f8789bcb00 differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/objects/ff/b312248d607284c290023f9502eea010d34efd b/tests/resources/reftable/merge-resolve/.gitted/objects/ff/b312248d607284c290023f9502eea010d34efd new file mode 100644 index 000000000..7e46c4fe3 Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/objects/ff/b312248d607284c290023f9502eea010d34efd differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/refs/heads b/tests/resources/reftable/merge-resolve/.gitted/refs/heads new file mode 100644 index 000000000..3e639a56a --- /dev/null +++ b/tests/resources/reftable/merge-resolve/.gitted/refs/heads @@ -0,0 +1 @@ +this repository uses the reftable format diff --git a/tests/resources/reftable/merge-resolve/.gitted/reftable/0x000000000001-0x0000000000ec-c00ecd56.ref b/tests/resources/reftable/merge-resolve/.gitted/reftable/0x000000000001-0x0000000000ec-c00ecd56.ref new file mode 100644 index 000000000..40de13c6f Binary files /dev/null and b/tests/resources/reftable/merge-resolve/.gitted/reftable/0x000000000001-0x0000000000ec-c00ecd56.ref differ diff --git a/tests/resources/reftable/merge-resolve/.gitted/reftable/tables.list b/tests/resources/reftable/merge-resolve/.gitted/reftable/tables.list new file mode 100644 index 000000000..8f199b0c7 --- /dev/null +++ b/tests/resources/reftable/merge-resolve/.gitted/reftable/tables.list @@ -0,0 +1 @@ +0x000000000001-0x0000000000ec-c00ecd56.ref diff --git a/tests/resources/reftable/merge-resolve/added-in-master.txt b/tests/resources/reftable/merge-resolve/added-in-master.txt new file mode 100644 index 000000000..233c0919c --- /dev/null +++ b/tests/resources/reftable/merge-resolve/added-in-master.txt @@ -0,0 +1 @@ +this file is added in master diff --git a/tests/resources/reftable/merge-resolve/automergeable.txt b/tests/resources/reftable/merge-resolve/automergeable.txt new file mode 100644 index 000000000..ee3fa1b8c --- /dev/null +++ b/tests/resources/reftable/merge-resolve/automergeable.txt @@ -0,0 +1,9 @@ +this file is changed in master +this file is automergeable +this file is automergeable +this file is automergeable +this file is automergeable +this file is automergeable +this file is automergeable +this file is automergeable +this file is automergeable diff --git a/tests/resources/reftable/merge-resolve/changed-in-branch.txt b/tests/resources/reftable/merge-resolve/changed-in-branch.txt new file mode 100644 index 000000000..ab6c44a2e --- /dev/null +++ b/tests/resources/reftable/merge-resolve/changed-in-branch.txt @@ -0,0 +1 @@ +initial revision diff --git a/tests/resources/reftable/merge-resolve/changed-in-master.txt b/tests/resources/reftable/merge-resolve/changed-in-master.txt new file mode 100644 index 000000000..11deab00b --- /dev/null +++ b/tests/resources/reftable/merge-resolve/changed-in-master.txt @@ -0,0 +1 @@ +changed in master diff --git a/tests/resources/reftable/merge-resolve/conflicting.txt b/tests/resources/reftable/merge-resolve/conflicting.txt new file mode 100644 index 000000000..4e886e602 --- /dev/null +++ b/tests/resources/reftable/merge-resolve/conflicting.txt @@ -0,0 +1 @@ +this file is changed in master and branch diff --git a/tests/resources/reftable/merge-resolve/removed-in-branch.txt b/tests/resources/reftable/merge-resolve/removed-in-branch.txt new file mode 100644 index 000000000..dfe3f22ba --- /dev/null +++ b/tests/resources/reftable/merge-resolve/removed-in-branch.txt @@ -0,0 +1 @@ +this is removed in branch diff --git a/tests/resources/reftable/merge-resolve/unchanged.txt b/tests/resources/reftable/merge-resolve/unchanged.txt new file mode 100644 index 000000000..c8f06f2e3 --- /dev/null +++ b/tests/resources/reftable/merge-resolve/unchanged.txt @@ -0,0 +1 @@ +this file is unchanged in both diff --git a/tests/resources/reftable/merge-whitespace/.gitted/HEAD b/tests/resources/reftable/merge-whitespace/.gitted/HEAD new file mode 100644 index 000000000..fe6d7e5fa --- /dev/null +++ b/tests/resources/reftable/merge-whitespace/.gitted/HEAD @@ -0,0 +1 @@ +ref: refs/heads/.invalid diff --git a/tests/resources/reftable/merge-whitespace/.gitted/config b/tests/resources/reftable/merge-whitespace/.gitted/config new file mode 100644 index 000000000..622302e60 --- /dev/null +++ b/tests/resources/reftable/merge-whitespace/.gitted/config @@ -0,0 +1,9 @@ +[core] + repositoryformatversion = 1 + filemode = true + bare = false + logallrefupdates = true + ignorecase = true + precomposeunicode = true +[extensions] + refstorage = reftable diff --git a/tests/resources/reftable/merge-whitespace/.gitted/index b/tests/resources/reftable/merge-whitespace/.gitted/index new file mode 100644 index 000000000..534804af2 Binary files /dev/null and b/tests/resources/reftable/merge-whitespace/.gitted/index differ diff --git a/tests/resources/reftable/merge-whitespace/.gitted/objects/01/bd650462136a4f0a266dfc91ab93b3fef0f7cb b/tests/resources/reftable/merge-whitespace/.gitted/objects/01/bd650462136a4f0a266dfc91ab93b3fef0f7cb new file mode 100644 index 000000000..074a77abf Binary files /dev/null and b/tests/resources/reftable/merge-whitespace/.gitted/objects/01/bd650462136a4f0a266dfc91ab93b3fef0f7cb differ diff --git a/tests/resources/reftable/merge-whitespace/.gitted/objects/08/3f868fb4324e32a4999173b2437b31d7a1ef25 b/tests/resources/reftable/merge-whitespace/.gitted/objects/08/3f868fb4324e32a4999173b2437b31d7a1ef25 new file mode 100644 index 000000000..ec6ed4d4c Binary files /dev/null and b/tests/resources/reftable/merge-whitespace/.gitted/objects/08/3f868fb4324e32a4999173b2437b31d7a1ef25 differ diff --git a/tests/resources/reftable/merge-whitespace/.gitted/objects/0a/a2acaa63cacc7a99fab0c2ce3d56572911df19 b/tests/resources/reftable/merge-whitespace/.gitted/objects/0a/a2acaa63cacc7a99fab0c2ce3d56572911df19 new file mode 100644 index 000000000..a2178ceab --- /dev/null +++ b/tests/resources/reftable/merge-whitespace/.gitted/objects/0a/a2acaa63cacc7a99fab0c2ce3d56572911df19 @@ -0,0 +1 @@ +xA @Qלb&fR!1Ɲ[Lqb#L&z~K:F*3g
)qJZ&B{;xk-2_ 78s-˻mSIhr Zq{C%Ӥ>4? \ No newline at end of file diff --git a/tests/resources/reftable/merge-whitespace/.gitted/objects/11/89e10a62aadf2fea8cd018afb52c1980f40b4f b/tests/resources/reftable/merge-whitespace/.gitted/objects/11/89e10a62aadf2fea8cd018afb52c1980f40b4f new file mode 100644 index 000000000..f9f59840e Binary files /dev/null and b/tests/resources/reftable/merge-whitespace/.gitted/objects/11/89e10a62aadf2fea8cd018afb52c1980f40b4f differ diff --git a/tests/resources/reftable/merge-whitespace/.gitted/objects/24/2c8f6cf388e96e2c12b6e49cb7ae60167cba1e b/tests/resources/reftable/merge-whitespace/.gitted/objects/24/2c8f6cf388e96e2c12b6e49cb7ae60167cba1e new file mode 100644 index 000000000..7cfc318ed Binary files /dev/null and b/tests/resources/reftable/merge-whitespace/.gitted/objects/24/2c8f6cf388e96e2c12b6e49cb7ae60167cba1e differ diff --git a/tests/resources/reftable/merge-whitespace/.gitted/objects/25/246acb001858ffeffb03ea399fd2c0a163b832 b/tests/resources/reftable/merge-whitespace/.gitted/objects/25/246acb001858ffeffb03ea399fd2c0a163b832 new file mode 100644 index 000000000..f7160ce44 Binary files /dev/null and b/tests/resources/reftable/merge-whitespace/.gitted/objects/25/246acb001858ffeffb03ea399fd2c0a163b832 differ diff --git a/tests/resources/reftable/merge-whitespace/.gitted/objects/26/2f67de0de2e535a59ae1bc3c739601e98c354d b/tests/resources/reftable/merge-whitespace/.gitted/objects/26/2f67de0de2e535a59ae1bc3c739601e98c354d new file mode 100644 index 000000000..c5a33b4b4 Binary files /dev/null and b/tests/resources/reftable/merge-whitespace/.gitted/objects/26/2f67de0de2e535a59ae1bc3c739601e98c354d differ diff --git a/tests/resources/reftable/merge-whitespace/.gitted/objects/2f/6727d2e570bf962d9dd926423cf6fe5072071a b/tests/resources/reftable/merge-whitespace/.gitted/objects/2f/6727d2e570bf962d9dd926423cf6fe5072071a new file mode 100644 index 000000000..02bb788e5 Binary files /dev/null and b/tests/resources/reftable/merge-whitespace/.gitted/objects/2f/6727d2e570bf962d9dd926423cf6fe5072071a differ diff --git a/tests/resources/reftable/merge-whitespace/.gitted/objects/3c/43e7fc2a56fc825c31dfee65abd6dda8d16dca b/tests/resources/reftable/merge-whitespace/.gitted/objects/3c/43e7fc2a56fc825c31dfee65abd6dda8d16dca new file mode 100644 index 000000000..0ec95b5c2 Binary files /dev/null and b/tests/resources/reftable/merge-whitespace/.gitted/objects/3c/43e7fc2a56fc825c31dfee65abd6dda8d16dca differ diff --git a/tests/resources/reftable/merge-whitespace/.gitted/objects/40/26a6c83f39c56881c9ac62e7582db9e3d33a4f b/tests/resources/reftable/merge-whitespace/.gitted/objects/40/26a6c83f39c56881c9ac62e7582db9e3d33a4f new file mode 100644 index 000000000..50bdfc543 Binary files /dev/null and b/tests/resources/reftable/merge-whitespace/.gitted/objects/40/26a6c83f39c56881c9ac62e7582db9e3d33a4f differ diff --git a/tests/resources/reftable/merge-whitespace/.gitted/objects/42/dabb8d5dba2de103815a77e4369bb3966e64ef b/tests/resources/reftable/merge-whitespace/.gitted/objects/42/dabb8d5dba2de103815a77e4369bb3966e64ef new file mode 100644 index 000000000..ae6dab79a Binary files /dev/null and b/tests/resources/reftable/merge-whitespace/.gitted/objects/42/dabb8d5dba2de103815a77e4369bb3966e64ef differ diff --git a/tests/resources/reftable/merge-whitespace/.gitted/objects/43/9230587f2eb38e9540a5c99e9831f65641eab9 b/tests/resources/reftable/merge-whitespace/.gitted/objects/43/9230587f2eb38e9540a5c99e9831f65641eab9 new file mode 100644 index 000000000..1b6354db8 Binary files /dev/null and b/tests/resources/reftable/merge-whitespace/.gitted/objects/43/9230587f2eb38e9540a5c99e9831f65641eab9 differ diff --git a/tests/resources/reftable/merge-whitespace/.gitted/objects/43/ad73e75e15f03bb0b4398a48a57ecfc20788e2 b/tests/resources/reftable/merge-whitespace/.gitted/objects/43/ad73e75e15f03bb0b4398a48a57ecfc20788e2 new file mode 100644 index 000000000..1936bc34a Binary files /dev/null and b/tests/resources/reftable/merge-whitespace/.gitted/objects/43/ad73e75e15f03bb0b4398a48a57ecfc20788e2 differ diff --git a/tests/resources/reftable/merge-whitespace/.gitted/objects/4b/825dc642cb6eb9a060e54bf8d69288fbee4904 b/tests/resources/reftable/merge-whitespace/.gitted/objects/4b/825dc642cb6eb9a060e54bf8d69288fbee4904 new file mode 100644 index 000000000..adf64119a Binary files /dev/null and b/tests/resources/reftable/merge-whitespace/.gitted/objects/4b/825dc642cb6eb9a060e54bf8d69288fbee4904 differ diff --git a/tests/resources/reftable/merge-whitespace/.gitted/objects/54/74989173042512ab630191ad71cdcedb646b9a b/tests/resources/reftable/merge-whitespace/.gitted/objects/54/74989173042512ab630191ad71cdcedb646b9a new file mode 100644 index 000000000..cf12d4d96 Binary files /dev/null and b/tests/resources/reftable/merge-whitespace/.gitted/objects/54/74989173042512ab630191ad71cdcedb646b9a differ diff --git a/tests/resources/reftable/merge-whitespace/.gitted/objects/5e/fb9bc29c482e023e40e0a2b3b7e49cec842034 b/tests/resources/reftable/merge-whitespace/.gitted/objects/5e/fb9bc29c482e023e40e0a2b3b7e49cec842034 new file mode 100644 index 000000000..d615c02a6 Binary files /dev/null and b/tests/resources/reftable/merge-whitespace/.gitted/objects/5e/fb9bc29c482e023e40e0a2b3b7e49cec842034 differ diff --git a/tests/resources/reftable/merge-whitespace/.gitted/objects/70/d3d2e7d51a18fcc6f035a67e5c3f33069be04d b/tests/resources/reftable/merge-whitespace/.gitted/objects/70/d3d2e7d51a18fcc6f035a67e5c3f33069be04d new file mode 100644 index 000000000..1718878a7 Binary files /dev/null and b/tests/resources/reftable/merge-whitespace/.gitted/objects/70/d3d2e7d51a18fcc6f035a67e5c3f33069be04d differ diff --git a/tests/resources/reftable/merge-whitespace/.gitted/objects/74/e83b6c5df14f1fba7c4ea1f99c6d007b591002 b/tests/resources/reftable/merge-whitespace/.gitted/objects/74/e83b6c5df14f1fba7c4ea1f99c6d007b591002 new file mode 100644 index 000000000..779e1bcb3 Binary files /dev/null and b/tests/resources/reftable/merge-whitespace/.gitted/objects/74/e83b6c5df14f1fba7c4ea1f99c6d007b591002 differ diff --git a/tests/resources/reftable/merge-whitespace/.gitted/objects/77/f40c621ceae77ad8d756ef507bdbafe2713aa7 b/tests/resources/reftable/merge-whitespace/.gitted/objects/77/f40c621ceae77ad8d756ef507bdbafe2713aa7 new file mode 100644 index 000000000..f2efa93be Binary files /dev/null and b/tests/resources/reftable/merge-whitespace/.gitted/objects/77/f40c621ceae77ad8d756ef507bdbafe2713aa7 differ diff --git a/tests/resources/reftable/merge-whitespace/.gitted/objects/9c/5362069759fb37ae036cef6e4b2f95c6c5eaab b/tests/resources/reftable/merge-whitespace/.gitted/objects/9c/5362069759fb37ae036cef6e4b2f95c6c5eaab new file mode 100644 index 000000000..cc6ad103d Binary files /dev/null and b/tests/resources/reftable/merge-whitespace/.gitted/objects/9c/5362069759fb37ae036cef6e4b2f95c6c5eaab differ diff --git a/tests/resources/reftable/merge-whitespace/.gitted/objects/a2/9e7dabd68dfb38a717e6b1648713cd5c7adee2 b/tests/resources/reftable/merge-whitespace/.gitted/objects/a2/9e7dabd68dfb38a717e6b1648713cd5c7adee2 new file mode 100644 index 000000000..6e034377f Binary files /dev/null and b/tests/resources/reftable/merge-whitespace/.gitted/objects/a2/9e7dabd68dfb38a717e6b1648713cd5c7adee2 differ diff --git a/tests/resources/reftable/merge-whitespace/.gitted/objects/a4/e6a86e07ef5afe036e26602fbbaa27496d00a9 b/tests/resources/reftable/merge-whitespace/.gitted/objects/a4/e6a86e07ef5afe036e26602fbbaa27496d00a9 new file mode 100644 index 000000000..95e0d7163 --- /dev/null +++ b/tests/resources/reftable/merge-whitespace/.gitted/objects/a4/e6a86e07ef5afe036e26602fbbaa27496d00a9 @@ -0,0 +1,2 @@ +xMJ@])j7 A:]"3 U5ՓIYx{#'pZEk(DA EPk!Xs }\|yk>oMA ϱL_t3`ZdAe \ No newline at end of file diff --git a/tests/resources/reftable/merge-whitespace/.gitted/objects/a8/27eab4fd66ab37a6ebcfaa7b7e341abfd55947 b/tests/resources/reftable/merge-whitespace/.gitted/objects/a8/27eab4fd66ab37a6ebcfaa7b7e341abfd55947 new file mode 100644 index 000000000..fe2bdf492 Binary files /dev/null and b/tests/resources/reftable/merge-whitespace/.gitted/objects/a8/27eab4fd66ab37a6ebcfaa7b7e341abfd55947 differ diff --git a/tests/resources/reftable/merge-whitespace/.gitted/objects/a9/66acc271e50b5d4595911752a77def0a5e5d40 b/tests/resources/reftable/merge-whitespace/.gitted/objects/a9/66acc271e50b5d4595911752a77def0a5e5d40 new file mode 100644 index 000000000..cd6f64d6f Binary files /dev/null and b/tests/resources/reftable/merge-whitespace/.gitted/objects/a9/66acc271e50b5d4595911752a77def0a5e5d40 differ diff --git a/tests/resources/reftable/merge-whitespace/.gitted/objects/b2/a69114f4897109fedf1aafea363cb2d2557029 b/tests/resources/reftable/merge-whitespace/.gitted/objects/b2/a69114f4897109fedf1aafea363cb2d2557029 new file mode 100644 index 000000000..b95a7be74 Binary files /dev/null and b/tests/resources/reftable/merge-whitespace/.gitted/objects/b2/a69114f4897109fedf1aafea363cb2d2557029 differ diff --git a/tests/resources/reftable/merge-whitespace/.gitted/objects/bc/83ac0422ba1082c80e406234910377984cfbb6 b/tests/resources/reftable/merge-whitespace/.gitted/objects/bc/83ac0422ba1082c80e406234910377984cfbb6 new file mode 100644 index 000000000..0ea77e816 Binary files /dev/null and b/tests/resources/reftable/merge-whitespace/.gitted/objects/bc/83ac0422ba1082c80e406234910377984cfbb6 differ diff --git a/tests/resources/reftable/merge-whitespace/.gitted/objects/bf/e4ea5805af22a5b194259bda6f5f634486f891 b/tests/resources/reftable/merge-whitespace/.gitted/objects/bf/e4ea5805af22a5b194259bda6f5f634486f891 new file mode 100644 index 000000000..a27169e8f --- /dev/null +++ b/tests/resources/reftable/merge-whitespace/.gitted/objects/bf/e4ea5805af22a5b194259bda6f5f634486f891 @@ -0,0 +1 @@ +xMj0F)flA)%B/x4Jcho_!}T׵X?HcC)iL`??`ʎffnxЈ tf4Y!;M$,'>/_}wiT70u)FF8i:*ԈZp!1(-MozX \ No newline at end of file diff --git a/tests/resources/reftable/merge-whitespace/.gitted/objects/c3/b1fb31424c98072542cc8e42b48c92e52f494a b/tests/resources/reftable/merge-whitespace/.gitted/objects/c3/b1fb31424c98072542cc8e42b48c92e52f494a new file mode 100644 index 000000000..4006460e8 Binary files /dev/null and b/tests/resources/reftable/merge-whitespace/.gitted/objects/c3/b1fb31424c98072542cc8e42b48c92e52f494a differ diff --git a/tests/resources/reftable/merge-whitespace/.gitted/objects/c7/e2f386736445936f5ba181269a0e0967e280e8 b/tests/resources/reftable/merge-whitespace/.gitted/objects/c7/e2f386736445936f5ba181269a0e0967e280e8 new file mode 100644 index 000000000..821336f20 --- /dev/null +++ b/tests/resources/reftable/merge-whitespace/.gitted/objects/c7/e2f386736445936f5ba181269a0e0967e280e8 @@ -0,0 +1,2 @@ +xAj0E)fEȒFA) +=CQF Y^MI{><>^YyЛ*5X|&Ęl"Rg>!٘*>Z֨A\XbAeT H:(C9Vч@R }\qyk;&TG57zK/yvQKpߓ`ZOl$e \ No newline at end of file diff --git a/tests/resources/reftable/merge-whitespace/.gitted/objects/d9/5182053c31f8aa09df4fa225f4e668c5320b59 b/tests/resources/reftable/merge-whitespace/.gitted/objects/d9/5182053c31f8aa09df4fa225f4e668c5320b59 new file mode 100644 index 000000000..6b9483a5c --- /dev/null +++ b/tests/resources/reftable/merge-whitespace/.gitted/objects/d9/5182053c31f8aa09df4fa225f4e668c5320b59 @@ -0,0 +1,5 @@ +xM +0@a9$M/z: +1I^#4Eh.:M'6uv&k `JY +Z 5D1$9zgXI:,nįM +\%OcwgsyJ^ƸC, ~WQaRVbh~,3\gR \ No newline at end of file diff --git a/tests/resources/reftable/merge-whitespace/.gitted/objects/e6/9de29bb2d1d6434b8b29ae775ad8c2e48c5391 b/tests/resources/reftable/merge-whitespace/.gitted/objects/e6/9de29bb2d1d6434b8b29ae775ad8c2e48c5391 new file mode 100644 index 000000000..711223894 Binary files /dev/null and b/tests/resources/reftable/merge-whitespace/.gitted/objects/e6/9de29bb2d1d6434b8b29ae775ad8c2e48c5391 differ diff --git a/tests/resources/reftable/merge-whitespace/.gitted/objects/ec/5a35c75b8d3ee29bed37996b14e909d04fdcee b/tests/resources/reftable/merge-whitespace/.gitted/objects/ec/5a35c75b8d3ee29bed37996b14e909d04fdcee new file mode 100644 index 000000000..d7fc301d8 Binary files /dev/null and b/tests/resources/reftable/merge-whitespace/.gitted/objects/ec/5a35c75b8d3ee29bed37996b14e909d04fdcee differ diff --git a/tests/resources/reftable/merge-whitespace/.gitted/objects/ee/3c2aac8e03224c323b58ecb1f9eef616745467 b/tests/resources/reftable/merge-whitespace/.gitted/objects/ee/3c2aac8e03224c323b58ecb1f9eef616745467 new file mode 100644 index 000000000..1acec06a6 Binary files /dev/null and b/tests/resources/reftable/merge-whitespace/.gitted/objects/ee/3c2aac8e03224c323b58ecb1f9eef616745467 differ diff --git a/tests/resources/reftable/merge-whitespace/.gitted/objects/ef/e94a4bf4e697f7f0270f0d1b8a93af784a19d0 b/tests/resources/reftable/merge-whitespace/.gitted/objects/ef/e94a4bf4e697f7f0270f0d1b8a93af784a19d0 new file mode 100644 index 000000000..ca5af406b Binary files /dev/null and b/tests/resources/reftable/merge-whitespace/.gitted/objects/ef/e94a4bf4e697f7f0270f0d1b8a93af784a19d0 differ diff --git a/tests/resources/reftable/merge-whitespace/.gitted/objects/f0/0c965d8307308469e537302baa73048488f162 b/tests/resources/reftable/merge-whitespace/.gitted/objects/f0/0c965d8307308469e537302baa73048488f162 new file mode 100644 index 000000000..343037e77 Binary files /dev/null and b/tests/resources/reftable/merge-whitespace/.gitted/objects/f0/0c965d8307308469e537302baa73048488f162 differ diff --git a/tests/resources/reftable/merge-whitespace/.gitted/objects/f1/90a0d111ca1688778657798743ddfb4ed4bd64 b/tests/resources/reftable/merge-whitespace/.gitted/objects/f1/90a0d111ca1688778657798743ddfb4ed4bd64 new file mode 100644 index 000000000..4e2291208 --- /dev/null +++ b/tests/resources/reftable/merge-whitespace/.gitted/objects/f1/90a0d111ca1688778657798743ddfb4ed4bd64 @@ -0,0 +1,2 @@ +xM +0@a9Eo .o1IZ![nZԥad!y![fCԎQaVn̉Y%0PJk!;@@=>xS%h{E^iyE?&tHv0g+t[WD\ܷqM \ No newline at end of file diff --git a/tests/resources/reftable/merge-whitespace/.gitted/objects/f4/9b2c244e9d3b0647fdfb95954c38fbfeecf3ad b/tests/resources/reftable/merge-whitespace/.gitted/objects/f4/9b2c244e9d3b0647fdfb95954c38fbfeecf3ad new file mode 100644 index 000000000..437f667f5 --- /dev/null +++ b/tests/resources/reftable/merge-whitespace/.gitted/objects/f4/9b2c244e9d3b0647fdfb95954c38fbfeecf3ad @@ -0,0 +1,2 @@ +x= +1@abzAfI-!,.xۯx/mСWU(dRt}@j9.2;O"KTelV{h֒:> .=oz8\ab^ĞHf}R< \ No newline at end of file diff --git a/tests/resources/reftable/merge-whitespace/.gitted/objects/f8/7905f99f0e66d179a8379d8ca4d8cbbd32c231 b/tests/resources/reftable/merge-whitespace/.gitted/objects/f8/7905f99f0e66d179a8379d8ca4d8cbbd32c231 new file mode 100644 index 000000000..d568dc1e9 --- /dev/null +++ b/tests/resources/reftable/merge-whitespace/.gitted/objects/f8/7905f99f0e66d179a8379d8ca4d8cbbd32c231 @@ -0,0 +1 @@ +xKj0D)E tg50@ g0-e;`;#ˋ> WEQe2ZQaoj7{L9IH}sLgrvŊ!9!:G͞mz* 2aM:kzѦNCv.uם׽ՙmySx=3h&*>b5Mr!iu׶=܁i \ No newline at end of file diff --git a/tests/resources/reftable/merge-whitespace/.gitted/refs/heads b/tests/resources/reftable/merge-whitespace/.gitted/refs/heads new file mode 100644 index 000000000..3e639a56a --- /dev/null +++ b/tests/resources/reftable/merge-whitespace/.gitted/refs/heads @@ -0,0 +1 @@ +this repository uses the reftable format diff --git a/tests/resources/reftable/merge-whitespace/.gitted/reftable/0x000000000001-0x000000000001-c364d45f.ref b/tests/resources/reftable/merge-whitespace/.gitted/reftable/0x000000000001-0x000000000001-c364d45f.ref new file mode 100644 index 000000000..4f963ce8e Binary files /dev/null and b/tests/resources/reftable/merge-whitespace/.gitted/reftable/0x000000000001-0x000000000001-c364d45f.ref differ diff --git a/tests/resources/reftable/merge-whitespace/.gitted/reftable/tables.list b/tests/resources/reftable/merge-whitespace/.gitted/reftable/tables.list new file mode 100644 index 000000000..723dc7df4 --- /dev/null +++ b/tests/resources/reftable/merge-whitespace/.gitted/reftable/tables.list @@ -0,0 +1 @@ +0x000000000001-0x000000000001-c364d45f.ref diff --git a/tests/resources/reftable/merge-whitespace/test.txt b/tests/resources/reftable/merge-whitespace/test.txt new file mode 100644 index 000000000..74e83b6c5 --- /dev/null +++ b/tests/resources/reftable/merge-whitespace/test.txt @@ -0,0 +1,11 @@ +0 +1 +2 +3 +4 +5 XXX +6 +7 +8 +9 +10 diff --git a/tests/resources/reftable/mergedrepo/.gitted/COMMIT_EDITMSG b/tests/resources/reftable/mergedrepo/.gitted/COMMIT_EDITMSG new file mode 100644 index 000000000..1f7391f92 --- /dev/null +++ b/tests/resources/reftable/mergedrepo/.gitted/COMMIT_EDITMSG @@ -0,0 +1 @@ +master diff --git a/tests/resources/reftable/mergedrepo/.gitted/HEAD b/tests/resources/reftable/mergedrepo/.gitted/HEAD new file mode 100644 index 000000000..fe6d7e5fa --- /dev/null +++ b/tests/resources/reftable/mergedrepo/.gitted/HEAD @@ -0,0 +1 @@ +ref: refs/heads/.invalid diff --git a/tests/resources/reftable/mergedrepo/.gitted/MERGE_HEAD b/tests/resources/reftable/mergedrepo/.gitted/MERGE_HEAD new file mode 100644 index 000000000..a5bdf6e40 --- /dev/null +++ b/tests/resources/reftable/mergedrepo/.gitted/MERGE_HEAD @@ -0,0 +1 @@ +e2809157a7766f272e4cfe26e61ef2678a5357ff diff --git a/tests/resources/reftable/mergedrepo/.gitted/MERGE_MODE b/tests/resources/reftable/mergedrepo/.gitted/MERGE_MODE new file mode 100644 index 000000000..e69de29bb diff --git a/tests/resources/reftable/mergedrepo/.gitted/MERGE_MSG b/tests/resources/reftable/mergedrepo/.gitted/MERGE_MSG new file mode 100644 index 000000000..7c4d1f5a9 --- /dev/null +++ b/tests/resources/reftable/mergedrepo/.gitted/MERGE_MSG @@ -0,0 +1,5 @@ +Merge branch 'branch' + +Conflicts: + conflicts-one.txt + conflicts-two.txt diff --git a/tests/resources/reftable/mergedrepo/.gitted/config b/tests/resources/reftable/mergedrepo/.gitted/config new file mode 100644 index 000000000..0694d84cb --- /dev/null +++ b/tests/resources/reftable/mergedrepo/.gitted/config @@ -0,0 +1,8 @@ +[core] + repositoryformatversion = 1 + filemode = true + bare = false + logallrefupdates = true + ignorecase = true +[extensions] + refstorage = reftable diff --git a/tests/resources/reftable/mergedrepo/.gitted/description b/tests/resources/reftable/mergedrepo/.gitted/description new file mode 100644 index 000000000..498b267a8 --- /dev/null +++ b/tests/resources/reftable/mergedrepo/.gitted/description @@ -0,0 +1 @@ +Unnamed repository; edit this file 'description' to name the repository. diff --git a/tests/resources/reftable/mergedrepo/.gitted/index b/tests/resources/reftable/mergedrepo/.gitted/index new file mode 100644 index 000000000..3d29f78e7 Binary files /dev/null and b/tests/resources/reftable/mergedrepo/.gitted/index differ diff --git a/tests/resources/reftable/mergedrepo/.gitted/info/exclude b/tests/resources/reftable/mergedrepo/.gitted/info/exclude new file mode 100644 index 000000000..a5196d1be --- /dev/null +++ b/tests/resources/reftable/mergedrepo/.gitted/info/exclude @@ -0,0 +1,6 @@ +# git ls-files --others --exclude-from=.git/info/exclude +# Lines that start with '#' are comments. +# For a project mostly in C, the following would be a good set of +# exclude patterns (uncomment them if you want to use them): +# *.[oa] +# *~ diff --git a/tests/resources/reftable/mergedrepo/.gitted/objects/03/db1d37504ca0c4f7c26d7776b0e28bdea08712 b/tests/resources/reftable/mergedrepo/.gitted/objects/03/db1d37504ca0c4f7c26d7776b0e28bdea08712 new file mode 100644 index 000000000..9232f79d9 Binary files /dev/null and b/tests/resources/reftable/mergedrepo/.gitted/objects/03/db1d37504ca0c4f7c26d7776b0e28bdea08712 differ diff --git a/tests/resources/reftable/mergedrepo/.gitted/objects/17/0efc1023e0ed2390150bb4469c8456b63e8f91 b/tests/resources/reftable/mergedrepo/.gitted/objects/17/0efc1023e0ed2390150bb4469c8456b63e8f91 new file mode 100644 index 000000000..3e124d9a4 Binary files /dev/null and b/tests/resources/reftable/mergedrepo/.gitted/objects/17/0efc1023e0ed2390150bb4469c8456b63e8f91 differ diff --git a/tests/resources/reftable/mergedrepo/.gitted/objects/1f/85ca51b8e0aac893a621b61a9c2661d6aa6d81 b/tests/resources/reftable/mergedrepo/.gitted/objects/1f/85ca51b8e0aac893a621b61a9c2661d6aa6d81 new file mode 100644 index 000000000..7bb19c873 Binary files /dev/null and b/tests/resources/reftable/mergedrepo/.gitted/objects/1f/85ca51b8e0aac893a621b61a9c2661d6aa6d81 differ diff --git a/tests/resources/reftable/mergedrepo/.gitted/objects/22/0bd62631c8cf7a83ef39c6b94595f00517211e b/tests/resources/reftable/mergedrepo/.gitted/objects/22/0bd62631c8cf7a83ef39c6b94595f00517211e new file mode 100644 index 000000000..487bcffb1 Binary files /dev/null and b/tests/resources/reftable/mergedrepo/.gitted/objects/22/0bd62631c8cf7a83ef39c6b94595f00517211e differ diff --git a/tests/resources/reftable/mergedrepo/.gitted/objects/32/d55d59265db86dd690f0a7fc563db43e2bc6a6 b/tests/resources/reftable/mergedrepo/.gitted/objects/32/d55d59265db86dd690f0a7fc563db43e2bc6a6 new file mode 100644 index 000000000..2eb3954fc Binary files /dev/null and b/tests/resources/reftable/mergedrepo/.gitted/objects/32/d55d59265db86dd690f0a7fc563db43e2bc6a6 differ diff --git a/tests/resources/reftable/mergedrepo/.gitted/objects/38/e2d82b9065a237904af4b780b4d68da6950534 b/tests/resources/reftable/mergedrepo/.gitted/objects/38/e2d82b9065a237904af4b780b4d68da6950534 new file mode 100644 index 000000000..ebe83ccb2 Binary files /dev/null and b/tests/resources/reftable/mergedrepo/.gitted/objects/38/e2d82b9065a237904af4b780b4d68da6950534 differ diff --git a/tests/resources/reftable/mergedrepo/.gitted/objects/3a/34580a35add43a4cf361e8e9a30060a905c876 b/tests/resources/reftable/mergedrepo/.gitted/objects/3a/34580a35add43a4cf361e8e9a30060a905c876 new file mode 100644 index 000000000..0d4095ffc --- /dev/null +++ b/tests/resources/reftable/mergedrepo/.gitted/objects/3a/34580a35add43a4cf361e8e9a30060a905c876 @@ -0,0 +1,2 @@ +xK +1D]}Dx/O"F2oo<*ZoљuIhhrl"r YT8'#vm0.¨.:.#+9R^nG~[=VjR"IjD۔7|N` \ No newline at end of file diff --git a/tests/resources/reftable/mergedrepo/.gitted/objects/44/58b8bc9e72b6c8755ae456f60e9844d0538d8c b/tests/resources/reftable/mergedrepo/.gitted/objects/44/58b8bc9e72b6c8755ae456f60e9844d0538d8c new file mode 100644 index 000000000..33389c302 Binary files /dev/null and b/tests/resources/reftable/mergedrepo/.gitted/objects/44/58b8bc9e72b6c8755ae456f60e9844d0538d8c differ diff --git a/tests/resources/reftable/mergedrepo/.gitted/objects/47/8871385b9cd03908c5383acfd568bef023c6b3 b/tests/resources/reftable/mergedrepo/.gitted/objects/47/8871385b9cd03908c5383acfd568bef023c6b3 new file mode 100644 index 000000000..5361ea685 Binary files /dev/null and b/tests/resources/reftable/mergedrepo/.gitted/objects/47/8871385b9cd03908c5383acfd568bef023c6b3 differ diff --git a/tests/resources/reftable/mergedrepo/.gitted/objects/51/6bd85f78061e09ccc714561d7b504672cb52da b/tests/resources/reftable/mergedrepo/.gitted/objects/51/6bd85f78061e09ccc714561d7b504672cb52da new file mode 100644 index 000000000..a60da877c Binary files /dev/null and b/tests/resources/reftable/mergedrepo/.gitted/objects/51/6bd85f78061e09ccc714561d7b504672cb52da differ diff --git a/tests/resources/reftable/mergedrepo/.gitted/objects/53/c1d95a01f4514b162066fc98564500c96c46ad b/tests/resources/reftable/mergedrepo/.gitted/objects/53/c1d95a01f4514b162066fc98564500c96c46ad new file mode 100644 index 000000000..85e84d71e Binary files /dev/null and b/tests/resources/reftable/mergedrepo/.gitted/objects/53/c1d95a01f4514b162066fc98564500c96c46ad differ diff --git a/tests/resources/reftable/mergedrepo/.gitted/objects/6a/ea5f295304c36144ad6e9247a291b7f8112399 b/tests/resources/reftable/mergedrepo/.gitted/objects/6a/ea5f295304c36144ad6e9247a291b7f8112399 new file mode 100644 index 000000000..b16b521e6 Binary files /dev/null and b/tests/resources/reftable/mergedrepo/.gitted/objects/6a/ea5f295304c36144ad6e9247a291b7f8112399 differ diff --git a/tests/resources/reftable/mergedrepo/.gitted/objects/70/68e30a7f0090ae32db35dfa1e4189d8780fcb8 b/tests/resources/reftable/mergedrepo/.gitted/objects/70/68e30a7f0090ae32db35dfa1e4189d8780fcb8 new file mode 100644 index 000000000..7c4e85ffb Binary files /dev/null and b/tests/resources/reftable/mergedrepo/.gitted/objects/70/68e30a7f0090ae32db35dfa1e4189d8780fcb8 differ diff --git a/tests/resources/reftable/mergedrepo/.gitted/objects/75/938de1e367098b3e9a7b1ec3c4ac4548afffe4 b/tests/resources/reftable/mergedrepo/.gitted/objects/75/938de1e367098b3e9a7b1ec3c4ac4548afffe4 new file mode 100644 index 000000000..65173fc4d Binary files /dev/null and b/tests/resources/reftable/mergedrepo/.gitted/objects/75/938de1e367098b3e9a7b1ec3c4ac4548afffe4 differ diff --git a/tests/resources/reftable/mergedrepo/.gitted/objects/7b/26923aaf452b1977eb08617c59475fb3f74b71 b/tests/resources/reftable/mergedrepo/.gitted/objects/7b/26923aaf452b1977eb08617c59475fb3f74b71 new file mode 100644 index 000000000..162fa4455 Binary files /dev/null and b/tests/resources/reftable/mergedrepo/.gitted/objects/7b/26923aaf452b1977eb08617c59475fb3f74b71 differ diff --git a/tests/resources/reftable/mergedrepo/.gitted/objects/84/af62840be1b1c47b778a8a249f3ff45155038c b/tests/resources/reftable/mergedrepo/.gitted/objects/84/af62840be1b1c47b778a8a249f3ff45155038c new file mode 100644 index 000000000..77a519f55 Binary files /dev/null and b/tests/resources/reftable/mergedrepo/.gitted/objects/84/af62840be1b1c47b778a8a249f3ff45155038c differ diff --git a/tests/resources/reftable/mergedrepo/.gitted/objects/88/71f7a2ee3addfc4ba39fbd0783c8e738d04cda b/tests/resources/reftable/mergedrepo/.gitted/objects/88/71f7a2ee3addfc4ba39fbd0783c8e738d04cda new file mode 100644 index 000000000..f624cd4f1 Binary files /dev/null and b/tests/resources/reftable/mergedrepo/.gitted/objects/88/71f7a2ee3addfc4ba39fbd0783c8e738d04cda differ diff --git a/tests/resources/reftable/mergedrepo/.gitted/objects/88/7b153b165d32409c70163e0f734c090f12f673 b/tests/resources/reftable/mergedrepo/.gitted/objects/88/7b153b165d32409c70163e0f734c090f12f673 new file mode 100644 index 000000000..096474c03 Binary files /dev/null and b/tests/resources/reftable/mergedrepo/.gitted/objects/88/7b153b165d32409c70163e0f734c090f12f673 differ diff --git a/tests/resources/reftable/mergedrepo/.gitted/objects/8a/ad34cc83733590e74b93d0f7cf00375e2a735a b/tests/resources/reftable/mergedrepo/.gitted/objects/8a/ad34cc83733590e74b93d0f7cf00375e2a735a new file mode 100644 index 000000000..a413bc6b0 Binary files /dev/null and b/tests/resources/reftable/mergedrepo/.gitted/objects/8a/ad34cc83733590e74b93d0f7cf00375e2a735a differ diff --git a/tests/resources/reftable/mergedrepo/.gitted/objects/8b/3f43d2402825c200f835ca1762413e386fd0b2 b/tests/resources/reftable/mergedrepo/.gitted/objects/8b/3f43d2402825c200f835ca1762413e386fd0b2 new file mode 100644 index 000000000..3ac8f6018 Binary files /dev/null and b/tests/resources/reftable/mergedrepo/.gitted/objects/8b/3f43d2402825c200f835ca1762413e386fd0b2 differ diff --git a/tests/resources/reftable/mergedrepo/.gitted/objects/8b/72416545c7e761b64cecad4f1686eae4078aa8 b/tests/resources/reftable/mergedrepo/.gitted/objects/8b/72416545c7e761b64cecad4f1686eae4078aa8 new file mode 100644 index 000000000..589a5ae9b Binary files /dev/null and b/tests/resources/reftable/mergedrepo/.gitted/objects/8b/72416545c7e761b64cecad4f1686eae4078aa8 differ diff --git a/tests/resources/reftable/mergedrepo/.gitted/objects/8f/3c06cff9a83757cec40c80bc9bf31a2582bde9 b/tests/resources/reftable/mergedrepo/.gitted/objects/8f/3c06cff9a83757cec40c80bc9bf31a2582bde9 new file mode 100644 index 000000000..6503985e3 Binary files /dev/null and b/tests/resources/reftable/mergedrepo/.gitted/objects/8f/3c06cff9a83757cec40c80bc9bf31a2582bde9 differ diff --git a/tests/resources/reftable/mergedrepo/.gitted/objects/8f/fcc405925511824a2240a6d3686aa7f8c7ac50 b/tests/resources/reftable/mergedrepo/.gitted/objects/8f/fcc405925511824a2240a6d3686aa7f8c7ac50 new file mode 100644 index 000000000..2eaa80838 Binary files /dev/null and b/tests/resources/reftable/mergedrepo/.gitted/objects/8f/fcc405925511824a2240a6d3686aa7f8c7ac50 differ diff --git a/tests/resources/reftable/mergedrepo/.gitted/objects/9a/05ccb4e0f948de03128e095f39dae6976751c5 b/tests/resources/reftable/mergedrepo/.gitted/objects/9a/05ccb4e0f948de03128e095f39dae6976751c5 new file mode 100644 index 000000000..7373a80d8 --- /dev/null +++ b/tests/resources/reftable/mergedrepo/.gitted/objects/9a/05ccb4e0f948de03128e095f39dae6976751c5 @@ -0,0 +1 @@ +x !Dm@ c6q##Ay/ ܁:#$ltH:闄*DXhV} ˷n[-K_;Z@J GԈbq3"go@I \ No newline at end of file diff --git a/tests/resources/reftable/mergedrepo/.gitted/objects/9d/81f82fccc7dcd7de7a1ffead1815294c2e092c b/tests/resources/reftable/mergedrepo/.gitted/objects/9d/81f82fccc7dcd7de7a1ffead1815294c2e092c new file mode 100644 index 000000000..c5a651f97 Binary files /dev/null and b/tests/resources/reftable/mergedrepo/.gitted/objects/9d/81f82fccc7dcd7de7a1ffead1815294c2e092c differ diff --git a/tests/resources/reftable/mergedrepo/.gitted/objects/b7/cedb8ad4cbb22b6363f9578cbd749797f7ef0d b/tests/resources/reftable/mergedrepo/.gitted/objects/b7/cedb8ad4cbb22b6363f9578cbd749797f7ef0d new file mode 100644 index 000000000..3e14b5dc8 Binary files /dev/null and b/tests/resources/reftable/mergedrepo/.gitted/objects/b7/cedb8ad4cbb22b6363f9578cbd749797f7ef0d differ diff --git a/tests/resources/reftable/mergedrepo/.gitted/objects/d0/1885ea594926eae9ba5b54ad76692af5969f51 b/tests/resources/reftable/mergedrepo/.gitted/objects/d0/1885ea594926eae9ba5b54ad76692af5969f51 new file mode 100644 index 000000000..a641adc2e Binary files /dev/null and b/tests/resources/reftable/mergedrepo/.gitted/objects/d0/1885ea594926eae9ba5b54ad76692af5969f51 differ diff --git a/tests/resources/reftable/mergedrepo/.gitted/objects/e2/809157a7766f272e4cfe26e61ef2678a5357ff b/tests/resources/reftable/mergedrepo/.gitted/objects/e2/809157a7766f272e4cfe26e61ef2678a5357ff new file mode 100644 index 000000000..fa86662e0 --- /dev/null +++ b/tests/resources/reftable/mergedrepo/.gitted/objects/e2/809157a7766f272e4cfe26e61ef2678a5357ff @@ -0,0 +1,3 @@ +xK +1D]t> xNq1(]{Pe mٍ.S0[Dcd +ŅbMԝCgd@>glX].$!0*zu})/E_<ڪO:WځrơqѤh@mt;;5uZyVo\M \ No newline at end of file diff --git a/tests/resources/reftable/mergedrepo/.gitted/objects/e6/2cac5c88b9928f2695b934c70efa4285324478 b/tests/resources/reftable/mergedrepo/.gitted/objects/e6/2cac5c88b9928f2695b934c70efa4285324478 new file mode 100644 index 000000000..c9841c698 Binary files /dev/null and b/tests/resources/reftable/mergedrepo/.gitted/objects/e6/2cac5c88b9928f2695b934c70efa4285324478 differ diff --git a/tests/resources/reftable/mergedrepo/.gitted/objects/f7/2784290c151092abf04ce6b875068547f70406 b/tests/resources/reftable/mergedrepo/.gitted/objects/f7/2784290c151092abf04ce6b875068547f70406 new file mode 100644 index 000000000..cd587dbec Binary files /dev/null and b/tests/resources/reftable/mergedrepo/.gitted/objects/f7/2784290c151092abf04ce6b875068547f70406 differ diff --git a/tests/resources/reftable/mergedrepo/.gitted/refs/heads b/tests/resources/reftable/mergedrepo/.gitted/refs/heads new file mode 100644 index 000000000..3e639a56a --- /dev/null +++ b/tests/resources/reftable/mergedrepo/.gitted/refs/heads @@ -0,0 +1 @@ +this repository uses the reftable format diff --git a/tests/resources/reftable/mergedrepo/.gitted/reftable/0x000000000001-0x000000000005-156bbfe6.ref b/tests/resources/reftable/mergedrepo/.gitted/reftable/0x000000000001-0x000000000005-156bbfe6.ref new file mode 100644 index 000000000..63ccaeb46 Binary files /dev/null and b/tests/resources/reftable/mergedrepo/.gitted/reftable/0x000000000001-0x000000000005-156bbfe6.ref differ diff --git a/tests/resources/reftable/mergedrepo/.gitted/reftable/tables.list b/tests/resources/reftable/mergedrepo/.gitted/reftable/tables.list new file mode 100644 index 000000000..e3e17f36f --- /dev/null +++ b/tests/resources/reftable/mergedrepo/.gitted/reftable/tables.list @@ -0,0 +1 @@ +0x000000000001-0x000000000005-156bbfe6.ref diff --git a/tests/resources/reftable/mergedrepo/conflicts-one.txt b/tests/resources/reftable/mergedrepo/conflicts-one.txt new file mode 100644 index 000000000..8aad34cc8 --- /dev/null +++ b/tests/resources/reftable/mergedrepo/conflicts-one.txt @@ -0,0 +1,5 @@ +<<<<<<< HEAD +This is most certainly a conflict! +======= +This is a conflict!!! +>>>>>>> branch diff --git a/tests/resources/reftable/mergedrepo/conflicts-two.txt b/tests/resources/reftable/mergedrepo/conflicts-two.txt new file mode 100644 index 000000000..e62cac5c8 --- /dev/null +++ b/tests/resources/reftable/mergedrepo/conflicts-two.txt @@ -0,0 +1,5 @@ +<<<<<<< HEAD +This is without question another conflict! +======= +This is another conflict!!! +>>>>>>> branch diff --git a/tests/resources/reftable/mergedrepo/one.txt b/tests/resources/reftable/mergedrepo/one.txt new file mode 100644 index 000000000..75938de1e --- /dev/null +++ b/tests/resources/reftable/mergedrepo/one.txt @@ -0,0 +1,10 @@ +This is file one! +This is file one. +This is file one. +This is file one. +This is file one. +This is file one. +This is file one. +This is file one. +This is file one. +This is file one! diff --git a/tests/resources/reftable/mergedrepo/two.txt b/tests/resources/reftable/mergedrepo/two.txt new file mode 100644 index 000000000..7b26923aa --- /dev/null +++ b/tests/resources/reftable/mergedrepo/two.txt @@ -0,0 +1,12 @@ +This is file two! +This is file two. +This is file two. +This is file two. +This is file two. +This is file two. +This is file two. +This is file two. +This is file two. +This is file two. +This is file two. +This is file two! diff --git a/tests/resources/reftable/nasty/.gitted/HEAD b/tests/resources/reftable/nasty/.gitted/HEAD new file mode 100644 index 000000000..fe6d7e5fa --- /dev/null +++ b/tests/resources/reftable/nasty/.gitted/HEAD @@ -0,0 +1 @@ +ref: refs/heads/.invalid diff --git a/tests/resources/reftable/nasty/.gitted/config b/tests/resources/reftable/nasty/.gitted/config new file mode 100644 index 000000000..b5d62785d --- /dev/null +++ b/tests/resources/reftable/nasty/.gitted/config @@ -0,0 +1,4 @@ +[extensions] + refstorage = reftable +[core] + repositoryformatversion = 1 diff --git a/tests/resources/reftable/nasty/.gitted/index b/tests/resources/reftable/nasty/.gitted/index new file mode 100644 index 000000000..782a50d0a Binary files /dev/null and b/tests/resources/reftable/nasty/.gitted/index differ diff --git a/tests/resources/reftable/nasty/.gitted/objects/02/28b21d477f67b9f7720565da9e760b84c8b85b b/tests/resources/reftable/nasty/.gitted/objects/02/28b21d477f67b9f7720565da9e760b84c8b85b new file mode 100644 index 000000000..e7cd63a28 --- /dev/null +++ b/tests/resources/reftable/nasty/.gitted/objects/02/28b21d477f67b9f7720565da9e760b84c8b85b @@ -0,0 +1,3 @@ +x] +!{vw ^Gb#8F,Ao|j)7"Aڠji&.(qIgvBY=-5ײ4'+~m +l :;9.w@ \ No newline at end of file diff --git a/tests/resources/reftable/nasty/.gitted/objects/04/18f28a75dc0c4951c01842e0d794843a88178a b/tests/resources/reftable/nasty/.gitted/objects/04/18f28a75dc0c4951c01842e0d794843a88178a new file mode 100644 index 000000000..7f8722e78 Binary files /dev/null and b/tests/resources/reftable/nasty/.gitted/objects/04/18f28a75dc0c4951c01842e0d794843a88178a differ diff --git a/tests/resources/reftable/nasty/.gitted/objects/04/fab819d8388295cbe3496310e4e53ef8f4a115 b/tests/resources/reftable/nasty/.gitted/objects/04/fab819d8388295cbe3496310e4e53ef8f4a115 new file mode 100644 index 000000000..688b970c2 Binary files /dev/null and b/tests/resources/reftable/nasty/.gitted/objects/04/fab819d8388295cbe3496310e4e53ef8f4a115 differ diff --git a/tests/resources/reftable/nasty/.gitted/objects/05/1229bf9d30ec923052ff42db8069ccdc17159d b/tests/resources/reftable/nasty/.gitted/objects/05/1229bf9d30ec923052ff42db8069ccdc17159d new file mode 100644 index 000000000..432160104 Binary files /dev/null and b/tests/resources/reftable/nasty/.gitted/objects/05/1229bf9d30ec923052ff42db8069ccdc17159d differ diff --git a/tests/resources/reftable/nasty/.gitted/objects/07/f9d4d85b75187e4db5b9cbcad3e6218582bd57 b/tests/resources/reftable/nasty/.gitted/objects/07/f9d4d85b75187e4db5b9cbcad3e6218582bd57 new file mode 100644 index 000000000..f040922a4 Binary files /dev/null and b/tests/resources/reftable/nasty/.gitted/objects/07/f9d4d85b75187e4db5b9cbcad3e6218582bd57 differ diff --git a/tests/resources/reftable/nasty/.gitted/objects/09/9ed86cb8501ae483b1855c351fe1a506ac9631 b/tests/resources/reftable/nasty/.gitted/objects/09/9ed86cb8501ae483b1855c351fe1a506ac9631 new file mode 100644 index 000000000..7738fc85d Binary files /dev/null and b/tests/resources/reftable/nasty/.gitted/objects/09/9ed86cb8501ae483b1855c351fe1a506ac9631 differ diff --git a/tests/resources/reftable/nasty/.gitted/objects/0a/78e40e54cc471c0415ca0680550f242e7843e2 b/tests/resources/reftable/nasty/.gitted/objects/0a/78e40e54cc471c0415ca0680550f242e7843e2 new file mode 100644 index 000000000..d59836e9c Binary files /dev/null and b/tests/resources/reftable/nasty/.gitted/objects/0a/78e40e54cc471c0415ca0680550f242e7843e2 differ diff --git a/tests/resources/reftable/nasty/.gitted/objects/0b/8206dd72a3b3b932fb562f92d29199b9398390 b/tests/resources/reftable/nasty/.gitted/objects/0b/8206dd72a3b3b932fb562f92d29199b9398390 new file mode 100644 index 000000000..b06361552 Binary files /dev/null and b/tests/resources/reftable/nasty/.gitted/objects/0b/8206dd72a3b3b932fb562f92d29199b9398390 differ diff --git a/tests/resources/reftable/nasty/.gitted/objects/0d/45fb57852c2229346a800bd3fc58e32527a21c b/tests/resources/reftable/nasty/.gitted/objects/0d/45fb57852c2229346a800bd3fc58e32527a21c new file mode 100644 index 000000000..d0433a0d5 Binary files /dev/null and b/tests/resources/reftable/nasty/.gitted/objects/0d/45fb57852c2229346a800bd3fc58e32527a21c differ diff --git a/tests/resources/reftable/nasty/.gitted/objects/10/cb44a89d1a9e8bf74de3f11a2a61ee833f13b1 b/tests/resources/reftable/nasty/.gitted/objects/10/cb44a89d1a9e8bf74de3f11a2a61ee833f13b1 new file mode 100644 index 000000000..9d14298d5 Binary files /dev/null and b/tests/resources/reftable/nasty/.gitted/objects/10/cb44a89d1a9e8bf74de3f11a2a61ee833f13b1 differ diff --git a/tests/resources/reftable/nasty/.gitted/objects/11/9f6cd3535de0e2a15654947a7b1a5affbf1406 b/tests/resources/reftable/nasty/.gitted/objects/11/9f6cd3535de0e2a15654947a7b1a5affbf1406 new file mode 100644 index 000000000..fb03b26b0 Binary files /dev/null and b/tests/resources/reftable/nasty/.gitted/objects/11/9f6cd3535de0e2a15654947a7b1a5affbf1406 differ diff --git a/tests/resources/reftable/nasty/.gitted/objects/12/12c12915820e1ad523b6305c0dcdefea8b7e97 b/tests/resources/reftable/nasty/.gitted/objects/12/12c12915820e1ad523b6305c0dcdefea8b7e97 new file mode 100644 index 000000000..95bc4c889 --- /dev/null +++ b/tests/resources/reftable/nasty/.gitted/objects/12/12c12915820e1ad523b6305c0dcdefea8b7e97 @@ -0,0 +1 @@ +xQ D{P1x`"%E y/ %[ծUfQrv-)oXMGK9>F;ů #F3+qΈ˝VA \ No newline at end of file diff --git a/tests/resources/reftable/nasty/.gitted/objects/13/e5f8be09e8b7db074fb39b96e08215cc4a36f1 b/tests/resources/reftable/nasty/.gitted/objects/13/e5f8be09e8b7db074fb39b96e08215cc4a36f1 new file mode 100644 index 000000000..ea54830c1 Binary files /dev/null and b/tests/resources/reftable/nasty/.gitted/objects/13/e5f8be09e8b7db074fb39b96e08215cc4a36f1 differ diff --git a/tests/resources/reftable/nasty/.gitted/objects/14/e70ab559b4c6a8a6fc9b6f538bd1f3934be725 b/tests/resources/reftable/nasty/.gitted/objects/14/e70ab559b4c6a8a6fc9b6f538bd1f3934be725 new file mode 100644 index 000000000..371951aac Binary files /dev/null and b/tests/resources/reftable/nasty/.gitted/objects/14/e70ab559b4c6a8a6fc9b6f538bd1f3934be725 differ diff --git a/tests/resources/reftable/nasty/.gitted/objects/15/f7d9f9514eeb65b9588c49b10b1da145a729a2 b/tests/resources/reftable/nasty/.gitted/objects/15/f7d9f9514eeb65b9588c49b10b1da145a729a2 new file mode 100644 index 000000000..a7f3683e4 --- /dev/null +++ b/tests/resources/reftable/nasty/.gitted/objects/15/f7d9f9514eeb65b9588c49b10b1da145a729a2 @@ -0,0 +1,2 @@ +x10 Es +H(iںbae&q(5BܞpԺ*`wژѓ3C”1epB> HKzSKp+R7ys]cMӌK.{WsM?P)“|? \ No newline at end of file diff --git a/tests/resources/reftable/nasty/.gitted/objects/16/35c47d80914f0abfa43dd4234a948db5bdb107 b/tests/resources/reftable/nasty/.gitted/objects/16/35c47d80914f0abfa43dd4234a948db5bdb107 new file mode 100644 index 000000000..f82b82be7 --- /dev/null +++ b/tests/resources/reftable/nasty/.gitted/objects/16/35c47d80914f0abfa43dd4234a948db5bdb107 @@ -0,0 +1,2 @@ +x=!9&[+/gckW|/Q + gDd?*kRҋ+5wl+NO8㠿u[jԩ)Q>Q/q?Pc=?q \ No newline at end of file diff --git a/tests/resources/reftable/nasty/.gitted/objects/16/a701796bc3670e5c2fdaeccb7f1280c60b373f b/tests/resources/reftable/nasty/.gitted/objects/16/a701796bc3670e5c2fdaeccb7f1280c60b373f new file mode 100644 index 000000000..46ed5c1e0 Binary files /dev/null and b/tests/resources/reftable/nasty/.gitted/objects/16/a701796bc3670e5c2fdaeccb7f1280c60b373f differ diff --git a/tests/resources/reftable/nasty/.gitted/objects/19/1381ee74dec49c89f99a62d055cb1058ba0de9 b/tests/resources/reftable/nasty/.gitted/objects/19/1381ee74dec49c89f99a62d055cb1058ba0de9 new file mode 100644 index 000000000..f1619a22e Binary files /dev/null and b/tests/resources/reftable/nasty/.gitted/objects/19/1381ee74dec49c89f99a62d055cb1058ba0de9 differ diff --git a/tests/resources/reftable/nasty/.gitted/objects/1e/3c845808fa5883aa4bcf2f882172edb72a7a32 b/tests/resources/reftable/nasty/.gitted/objects/1e/3c845808fa5883aa4bcf2f882172edb72a7a32 new file mode 100644 index 000000000..e25f153f4 --- /dev/null +++ b/tests/resources/reftable/nasty/.gitted/objects/1e/3c845808fa5883aa4bcf2f882172edb72a7a32 @@ -0,0 +1,2 @@ +xQ D{eaiI(`"%E y/%[iծeqbDd6nBZ%P~!Gq?PC=? \ No newline at end of file diff --git a/tests/resources/reftable/nasty/.gitted/objects/38/0b9e58872ccf1d858be4b0fc612514a080bc40 b/tests/resources/reftable/nasty/.gitted/objects/38/0b9e58872ccf1d858be4b0fc612514a080bc40 new file mode 100644 index 000000000..a911c3ca8 Binary files /dev/null and b/tests/resources/reftable/nasty/.gitted/objects/38/0b9e58872ccf1d858be4b0fc612514a080bc40 differ diff --git a/tests/resources/reftable/nasty/.gitted/objects/39/fb3af508440cf970b92767f6d081c811574d2a b/tests/resources/reftable/nasty/.gitted/objects/39/fb3af508440cf970b92767f6d081c811574d2a new file mode 100644 index 000000000..3854748c9 --- /dev/null +++ b/tests/resources/reftable/nasty/.gitted/objects/39/fb3af508440cf970b92767f6d081c811574d2a @@ -0,0 +1,2 @@ +x= +B1s& b#b.xq!FQS|3Ekup;\&甸p9X8bz &? NʍaZ>{-~iSKD֢2.dΤ? \ No newline at end of file diff --git a/tests/resources/reftable/nasty/.gitted/objects/3b/24e5c751ee9c7c89df32a0d959748aa3d0112c b/tests/resources/reftable/nasty/.gitted/objects/3b/24e5c751ee9c7c89df32a0d959748aa3d0112c new file mode 100644 index 000000000..5adcd1446 --- /dev/null +++ b/tests/resources/reftable/nasty/.gitted/objects/3b/24e5c751ee9c7c89df32a0d959748aa3d0112c @@ -0,0 +1,2 @@ +x10 Es +Hm&bae&(1Bܞp) !ٱ#t)Y;#z4U*\қj*4a=D)'F;هg쿚/+5@O c? \ No newline at end of file diff --git a/tests/resources/reftable/nasty/.gitted/objects/42/1376db9e8aee847e9d774891e73098a7415e94 b/tests/resources/reftable/nasty/.gitted/objects/42/1376db9e8aee847e9d774891e73098a7415e94 new file mode 100644 index 000000000..0666ba796 Binary files /dev/null and b/tests/resources/reftable/nasty/.gitted/objects/42/1376db9e8aee847e9d774891e73098a7415e94 differ diff --git a/tests/resources/reftable/nasty/.gitted/objects/44/14ac920acabc3eb00e3cf9375eeb0cb6859c15 b/tests/resources/reftable/nasty/.gitted/objects/44/14ac920acabc3eb00e3cf9375eeb0cb6859c15 new file mode 100644 index 000000000..4eaaa0cd7 Binary files /dev/null and b/tests/resources/reftable/nasty/.gitted/objects/44/14ac920acabc3eb00e3cf9375eeb0cb6859c15 differ diff --git a/tests/resources/reftable/nasty/.gitted/objects/44/2894787eddb1e84a952f17a027590e2c6c02cd b/tests/resources/reftable/nasty/.gitted/objects/44/2894787eddb1e84a952f17a027590e2c6c02cd new file mode 100644 index 000000000..c81b0e67a Binary files /dev/null and b/tests/resources/reftable/nasty/.gitted/objects/44/2894787eddb1e84a952f17a027590e2c6c02cd differ diff --git a/tests/resources/reftable/nasty/.gitted/objects/46/fe10fa23259b089ab050788b06df979cd7d054 b/tests/resources/reftable/nasty/.gitted/objects/46/fe10fa23259b089ab050788b06df979cd7d054 new file mode 100644 index 000000000..6d1f52df9 Binary files /dev/null and b/tests/resources/reftable/nasty/.gitted/objects/46/fe10fa23259b089ab050788b06df979cd7d054 differ diff --git a/tests/resources/reftable/nasty/.gitted/objects/4a/a347c8bb0456230f43f34833c97b9f52c40f62 b/tests/resources/reftable/nasty/.gitted/objects/4a/a347c8bb0456230f43f34833c97b9f52c40f62 new file mode 100644 index 000000000..2a54fe205 --- /dev/null +++ b/tests/resources/reftable/nasty/.gitted/objects/4a/a347c8bb0456230f43f34833c97b9f52c40f62 @@ -0,0 +1,3 @@ +x] +0})6? i!i 77m`Ɨo NVE#^ 8@ r\̬Fx- +t55'+~m%$i;i#Q!Ny?gފA \ No newline at end of file diff --git a/tests/resources/reftable/nasty/.gitted/objects/4d/83272d0d372e1232ddc4ff3260d76fdfa2015a b/tests/resources/reftable/nasty/.gitted/objects/4d/83272d0d372e1232ddc4ff3260d76fdfa2015a new file mode 100644 index 000000000..d362f1dce --- /dev/null +++ b/tests/resources/reftable/nasty/.gitted/objects/4d/83272d0d372e1232ddc4ff3260d76fdfa2015a @@ -0,0 +1,2 @@ +xK +1D]}Dx/O NH"2wo=5e@}L<%AD̄VI:%IrIDPs̵-|KpkvIW_;Ś/@-WGTl?gX}lзDX`oԙD \ No newline at end of file diff --git a/tests/resources/reftable/nasty/.gitted/objects/53/41a7b545d71198b076b8ba3374a75c9a290640 b/tests/resources/reftable/nasty/.gitted/objects/53/41a7b545d71198b076b8ba3374a75c9a290640 new file mode 100644 index 000000000..fdfe6eb37 --- /dev/null +++ b/tests/resources/reftable/nasty/.gitted/objects/53/41a7b545d71198b076b8ba3374a75c9a290640 @@ -0,0 +1,3 @@ +x] +0})ݤi%i 77m&o Ȫ]^ˌz"ѓ1bpJs|J +N~m%FFcWNy?5rw[z of@ \ No newline at end of file diff --git a/tests/resources/reftable/nasty/.gitted/objects/5d/1ee4f24f66dcd62a30248588d33804656b2073 b/tests/resources/reftable/nasty/.gitted/objects/5d/1ee4f24f66dcd62a30248588d33804656b2073 new file mode 100644 index 000000000..ffd9bfd36 Binary files /dev/null and b/tests/resources/reftable/nasty/.gitted/objects/5d/1ee4f24f66dcd62a30248588d33804656b2073 differ diff --git a/tests/resources/reftable/nasty/.gitted/objects/65/94bdbad86bbc8d3ed0806a23827203fbab56c6 b/tests/resources/reftable/nasty/.gitted/objects/65/94bdbad86bbc8d3ed0806a23827203fbab56c6 new file mode 100644 index 000000000..fa990d408 Binary files /dev/null and b/tests/resources/reftable/nasty/.gitted/objects/65/94bdbad86bbc8d3ed0806a23827203fbab56c6 differ diff --git a/tests/resources/reftable/nasty/.gitted/objects/68/e8bce48725490c376d57ebc60f0170605951a5 b/tests/resources/reftable/nasty/.gitted/objects/68/e8bce48725490c376d57ebc60f0170605951a5 new file mode 100644 index 000000000..c23f81597 Binary files /dev/null and b/tests/resources/reftable/nasty/.gitted/objects/68/e8bce48725490c376d57ebc60f0170605951a5 differ diff --git a/tests/resources/reftable/nasty/.gitted/objects/69/7dc3d723a018538eb819d5db2035c15109af73 b/tests/resources/reftable/nasty/.gitted/objects/69/7dc3d723a018538eb819d5db2035c15109af73 new file mode 100644 index 000000000..6d7d9f500 Binary files /dev/null and b/tests/resources/reftable/nasty/.gitted/objects/69/7dc3d723a018538eb819d5db2035c15109af73 differ diff --git a/tests/resources/reftable/nasty/.gitted/objects/6b/7d8a5a48a3c753b75a8fe5196f9c8704ac64ad b/tests/resources/reftable/nasty/.gitted/objects/6b/7d8a5a48a3c753b75a8fe5196f9c8704ac64ad new file mode 100644 index 000000000..121277fdf Binary files /dev/null and b/tests/resources/reftable/nasty/.gitted/objects/6b/7d8a5a48a3c753b75a8fe5196f9c8704ac64ad differ diff --git a/tests/resources/reftable/nasty/.gitted/objects/6c/1f5f6fec515d33036b44c596bfae28fc460cba b/tests/resources/reftable/nasty/.gitted/objects/6c/1f5f6fec515d33036b44c596bfae28fc460cba new file mode 100644 index 000000000..8172b7f0a Binary files /dev/null and b/tests/resources/reftable/nasty/.gitted/objects/6c/1f5f6fec515d33036b44c596bfae28fc460cba differ diff --git a/tests/resources/reftable/nasty/.gitted/objects/71/2ceb8eb3e57072447715bc4057c57aa50f629a b/tests/resources/reftable/nasty/.gitted/objects/71/2ceb8eb3e57072447715bc4057c57aa50f629a new file mode 100644 index 000000000..9ed35d78a Binary files /dev/null and b/tests/resources/reftable/nasty/.gitted/objects/71/2ceb8eb3e57072447715bc4057c57aa50f629a differ diff --git a/tests/resources/reftable/nasty/.gitted/objects/7a/0538bc4e20aecb36ef221f2077eb30ebe0bcb2 b/tests/resources/reftable/nasty/.gitted/objects/7a/0538bc4e20aecb36ef221f2077eb30ebe0bcb2 new file mode 100644 index 000000000..0c3ea2694 --- /dev/null +++ b/tests/resources/reftable/nasty/.gitted/objects/7a/0538bc4e20aecb36ef221f2077eb30ebe0bcb2 @@ -0,0 +1,2 @@ +x1!E9&X!1 +WMDF\9BMCc—2WpaRԸsCz3Yc5 +n}p͵lu I'_B-G@SR*{9gNΰo5A) \ No newline at end of file diff --git a/tests/resources/reftable/nasty/.gitted/objects/8c/e7a3ef59c3d602a0296321eb964218f3d52fae b/tests/resources/reftable/nasty/.gitted/objects/8c/e7a3ef59c3d602a0296321eb964218f3d52fae new file mode 100644 index 000000000..6f3484c1a Binary files /dev/null and b/tests/resources/reftable/nasty/.gitted/objects/8c/e7a3ef59c3d602a0296321eb964218f3d52fae differ diff --git a/tests/resources/reftable/nasty/.gitted/objects/8f/1dcd43aa0164eb6ec319c3ec8879ca5cf62c1e b/tests/resources/reftable/nasty/.gitted/objects/8f/1dcd43aa0164eb6ec319c3ec8879ca5cf62c1e new file mode 100644 index 000000000..f802e5af7 --- /dev/null +++ b/tests/resources/reftable/nasty/.gitted/objects/8f/1dcd43aa0164eb6ec319c3ec8879ca5cf62c1e @@ -0,0 +1,2 @@ +xK +1D]}|:c7zt` DzbE"ِ$h08ς"QK[aIp){6V`̌HV{ՠ˟3| kyMoA/ \ No newline at end of file diff --git a/tests/resources/reftable/nasty/.gitted/objects/91/602c85bb50dd834205edd30435b77d5bb9ccf0 b/tests/resources/reftable/nasty/.gitted/objects/91/602c85bb50dd834205edd30435b77d5bb9ccf0 new file mode 100644 index 000000000..d7147fb1c --- /dev/null +++ b/tests/resources/reftable/nasty/.gitted/objects/91/602c85bb50dd834205edd30435b77d5bb9ccf0 @@ -0,0 +1,3 @@ +xQ +1 D)rdZBЭ7o%k +vӪ*iԣ8kw`y(!~T*UJ^'[h%&H8#ny?gkz o!A2 \ No newline at end of file diff --git a/tests/resources/reftable/nasty/.gitted/objects/91/cd2c95af92883550b45fcc838013ae7e2954df b/tests/resources/reftable/nasty/.gitted/objects/91/cd2c95af92883550b45fcc838013ae7e2954df new file mode 100644 index 000000000..da9d5c467 Binary files /dev/null and b/tests/resources/reftable/nasty/.gitted/objects/91/cd2c95af92883550b45fcc838013ae7e2954df differ diff --git a/tests/resources/reftable/nasty/.gitted/objects/94/f37c29173c8fa45a232b17e745c82132b2fafd b/tests/resources/reftable/nasty/.gitted/objects/94/f37c29173c8fa45a232b17e745c82132b2fafd new file mode 100644 index 000000000..475d26b2f Binary files /dev/null and b/tests/resources/reftable/nasty/.gitted/objects/94/f37c29173c8fa45a232b17e745c82132b2fafd differ diff --git a/tests/resources/reftable/nasty/.gitted/objects/96/156716851c0afb4702b0d2c4ac8c496a730e29 b/tests/resources/reftable/nasty/.gitted/objects/96/156716851c0afb4702b0d2c4ac8c496a730e29 new file mode 100644 index 000000000..57419bc77 --- /dev/null +++ b/tests/resources/reftable/nasty/.gitted/objects/96/156716851c0afb4702b0d2c4ac8c496a730e29 @@ -0,0 +1 @@ +x;0sPKRqVRE"1W`)$uU0aich0lAWG1&,;deF襋47 E&8qukjICzc8؏UaѦI|\@o \ No newline at end of file diff --git a/tests/resources/reftable/nasty/.gitted/objects/96/3fdf003bf7261b9155c5748dc0945349b69e68 b/tests/resources/reftable/nasty/.gitted/objects/96/3fdf003bf7261b9155c5748dc0945349b69e68 new file mode 100644 index 000000000..ff1d33e5c Binary files /dev/null and b/tests/resources/reftable/nasty/.gitted/objects/96/3fdf003bf7261b9155c5748dc0945349b69e68 differ diff --git a/tests/resources/reftable/nasty/.gitted/objects/97/c14994866466aeb73e769a6f34e07c7f4b53f7 b/tests/resources/reftable/nasty/.gitted/objects/97/c14994866466aeb73e769a6f34e07c7f4b53f7 new file mode 100644 index 000000000..9f7679917 Binary files /dev/null and b/tests/resources/reftable/nasty/.gitted/objects/97/c14994866466aeb73e769a6f34e07c7f4b53f7 differ diff --git a/tests/resources/reftable/nasty/.gitted/objects/9a/b85e507899c19dca57778c9b6e5f1ec799b911 b/tests/resources/reftable/nasty/.gitted/objects/9a/b85e507899c19dca57778c9b6e5f1ec799b911 new file mode 100644 index 000000000..aa24a8fc7 --- /dev/null +++ b/tests/resources/reftable/nasty/.gitted/objects/9a/b85e507899c19dca57778c9b6e5f1ec799b911 @@ -0,0 +1,3 @@ +x= +1Fs5 bckf' EIF>^=Z79N;i9[| +h^P+ 3dƖrS.uƝ6a? Ԑ+u.HDY2@% \ No newline at end of file diff --git a/tests/resources/reftable/nasty/.gitted/objects/9d/5898503adc01d763e279ac8fcefbe865b19031 b/tests/resources/reftable/nasty/.gitted/objects/9d/5898503adc01d763e279ac8fcefbe865b19031 new file mode 100644 index 000000000..7cb310622 --- /dev/null +++ b/tests/resources/reftable/nasty/.gitted/objects/9d/5898503adc01d763e279ac8fcefbe865b19031 @@ -0,0 +1,4 @@ +xO[ S4 R +Icz +۴t bK7k^L&pJS%qS2T=51vo45tzuQFpO#\FNw^HvVQTFߩy +0Ouy$>F \ No newline at end of file diff --git a/tests/resources/reftable/nasty/.gitted/objects/9e/24726d64589ba02430da8cebb5712dad35593d b/tests/resources/reftable/nasty/.gitted/objects/9e/24726d64589ba02430da8cebb5712dad35593d new file mode 100644 index 000000000..2cf9535ae Binary files /dev/null and b/tests/resources/reftable/nasty/.gitted/objects/9e/24726d64589ba02430da8cebb5712dad35593d differ diff --git a/tests/resources/reftable/nasty/.gitted/objects/9e/683cdaf9ea2727c891b4cf8f7f11e9e28a67ca b/tests/resources/reftable/nasty/.gitted/objects/9e/683cdaf9ea2727c891b4cf8f7f11e9e28a67ca new file mode 100644 index 000000000..2e36dcae7 Binary files /dev/null and b/tests/resources/reftable/nasty/.gitted/objects/9e/683cdaf9ea2727c891b4cf8f7f11e9e28a67ca differ diff --git a/tests/resources/reftable/nasty/.gitted/objects/a0/d89aa95628fcd6b64fd5b23dd56b906b06bfe2 b/tests/resources/reftable/nasty/.gitted/objects/a0/d89aa95628fcd6b64fd5b23dd56b906b06bfe2 new file mode 100644 index 000000000..c1de43b2a Binary files /dev/null and b/tests/resources/reftable/nasty/.gitted/objects/a0/d89aa95628fcd6b64fd5b23dd56b906b06bfe2 differ diff --git a/tests/resources/reftable/nasty/.gitted/objects/a5/76a98d3279989226992610372035b76a01a3e9 b/tests/resources/reftable/nasty/.gitted/objects/a5/76a98d3279989226992610372035b76a01a3e9 new file mode 100644 index 000000000..75fa458e7 Binary files /dev/null and b/tests/resources/reftable/nasty/.gitted/objects/a5/76a98d3279989226992610372035b76a01a3e9 differ diff --git a/tests/resources/reftable/nasty/.gitted/objects/a7/8dde970cffbb71d67bef2a74aa72c6621d9819 b/tests/resources/reftable/nasty/.gitted/objects/a7/8dde970cffbb71d67bef2a74aa72c6621d9819 new file mode 100644 index 000000000..78c2fe4f8 Binary files /dev/null and b/tests/resources/reftable/nasty/.gitted/objects/a7/8dde970cffbb71d67bef2a74aa72c6621d9819 differ diff --git a/tests/resources/reftable/nasty/.gitted/objects/ac/84d85a425b2a21fd0ffccacac6c48823fc98c8 b/tests/resources/reftable/nasty/.gitted/objects/ac/84d85a425b2a21fd0ffccacac6c48823fc98c8 new file mode 100644 index 000000000..b08e24740 Binary files /dev/null and b/tests/resources/reftable/nasty/.gitted/objects/ac/84d85a425b2a21fd0ffccacac6c48823fc98c8 differ diff --git a/tests/resources/reftable/nasty/.gitted/objects/af/45aa1eb7edf804ed10f70efb96fd178527c17c b/tests/resources/reftable/nasty/.gitted/objects/af/45aa1eb7edf804ed10f70efb96fd178527c17c new file mode 100644 index 000000000..9e270bfbc Binary files /dev/null and b/tests/resources/reftable/nasty/.gitted/objects/af/45aa1eb7edf804ed10f70efb96fd178527c17c differ diff --git a/tests/resources/reftable/nasty/.gitted/objects/b1/1df9aee97a65817e8904a74f5e6a1c62c7a275 b/tests/resources/reftable/nasty/.gitted/objects/b1/1df9aee97a65817e8904a74f5e6a1c62c7a275 new file mode 100644 index 000000000..b2e0eda1a Binary files /dev/null and b/tests/resources/reftable/nasty/.gitted/objects/b1/1df9aee97a65817e8904a74f5e6a1c62c7a275 differ diff --git a/tests/resources/reftable/nasty/.gitted/objects/b8/3795b1e0eb54f22f7056119db132500d0cdc05 b/tests/resources/reftable/nasty/.gitted/objects/b8/3795b1e0eb54f22f7056119db132500d0cdc05 new file mode 100644 index 000000000..6cee4f9d8 Binary files /dev/null and b/tests/resources/reftable/nasty/.gitted/objects/b8/3795b1e0eb54f22f7056119db132500d0cdc05 differ diff --git a/tests/resources/reftable/nasty/.gitted/objects/b8/edf3ad62dbcbc983857a5bfee7b0181ee1a513 b/tests/resources/reftable/nasty/.gitted/objects/b8/edf3ad62dbcbc983857a5bfee7b0181ee1a513 new file mode 100644 index 000000000..bf446263c Binary files /dev/null and b/tests/resources/reftable/nasty/.gitted/objects/b8/edf3ad62dbcbc983857a5bfee7b0181ee1a513 differ diff --git a/tests/resources/reftable/nasty/.gitted/objects/bb/29ec85546d29b0bcc314242660d7772b0a3803 b/tests/resources/reftable/nasty/.gitted/objects/bb/29ec85546d29b0bcc314242660d7772b0a3803 new file mode 100644 index 000000000..00ab02c21 Binary files /dev/null and b/tests/resources/reftable/nasty/.gitted/objects/bb/29ec85546d29b0bcc314242660d7772b0a3803 differ diff --git a/tests/resources/reftable/nasty/.gitted/objects/bc/e2dabe5766838216d95f199d95aa4fd479a084 b/tests/resources/reftable/nasty/.gitted/objects/bc/e2dabe5766838216d95f199d95aa4fd479a084 new file mode 100644 index 000000000..b1eab1005 Binary files /dev/null and b/tests/resources/reftable/nasty/.gitted/objects/bc/e2dabe5766838216d95f199d95aa4fd479a084 differ diff --git a/tests/resources/reftable/nasty/.gitted/objects/bf/7ab4723fcc57ecc7fceccf591d6c4773491569 b/tests/resources/reftable/nasty/.gitted/objects/bf/7ab4723fcc57ecc7fceccf591d6c4773491569 new file mode 100644 index 000000000..af02c6b9b --- /dev/null +++ b/tests/resources/reftable/nasty/.gitted/objects/bf/7ab4723fcc57ecc7fceccf591d6c4773491569 @@ -0,0 +1,2 @@ +xK +1D]}|"n<^`;!@&"(]{P%[fjsb0j4GKYSײ!tI6pG K#괟猺ܧ57w@ \ No newline at end of file diff --git a/tests/resources/reftable/nasty/.gitted/objects/c2/a2ddd339574e5cbfd9228be840eb1bf496de4e b/tests/resources/reftable/nasty/.gitted/objects/c2/a2ddd339574e5cbfd9228be840eb1bf496de4e new file mode 100644 index 000000000..939cf5576 Binary files /dev/null and b/tests/resources/reftable/nasty/.gitted/objects/c2/a2ddd339574e5cbfd9228be840eb1bf496de4e differ diff --git a/tests/resources/reftable/nasty/.gitted/objects/c3/a70f8a376f17adccfb52b48e2831bfef2a2172 b/tests/resources/reftable/nasty/.gitted/objects/c3/a70f8a376f17adccfb52b48e2831bfef2a2172 new file mode 100644 index 000000000..b43d3f165 --- /dev/null +++ b/tests/resources/reftable/nasty/.gitted/objects/c3/a70f8a376f17adccfb52b48e2831bfef2a2172 @@ -0,0 +1,2 @@ +x= +1`=d'n6"6V^ d87^W=n3@yĸ^{Ҙb0FhYMjr/)߮EpJCRиsCzq1%ثits]>P]?1 \ No newline at end of file diff --git a/tests/resources/reftable/nasty/.gitted/objects/c4/89e70ed6d9f6331770eae21a77d15afd11cd99 b/tests/resources/reftable/nasty/.gitted/objects/c4/89e70ed6d9f6331770eae21a77d15afd11cd99 new file mode 100644 index 000000000..1d763482f Binary files /dev/null and b/tests/resources/reftable/nasty/.gitted/objects/c4/89e70ed6d9f6331770eae21a77d15afd11cd99 differ diff --git a/tests/resources/reftable/nasty/.gitted/objects/c6/72414d4d08111145ef8202f21c95fa7e688aee b/tests/resources/reftable/nasty/.gitted/objects/c6/72414d4d08111145ef8202f21c95fa7e688aee new file mode 100644 index 000000000..1b79b342c Binary files /dev/null and b/tests/resources/reftable/nasty/.gitted/objects/c6/72414d4d08111145ef8202f21c95fa7e688aee differ diff --git a/tests/resources/reftable/nasty/.gitted/objects/c8/f98a1762ec016c30f0d73512df399dedefc3fd b/tests/resources/reftable/nasty/.gitted/objects/c8/f98a1762ec016c30f0d73512df399dedefc3fd new file mode 100644 index 000000000..85ddc7f9b --- /dev/null +++ b/tests/resources/reftable/nasty/.gitted/objects/c8/f98a1762ec016c30f0d73512df399dedefc3fd @@ -0,0 +1,3 @@ +x= +1FsZy1%[Y+W|/qNޛE \ No newline at end of file diff --git a/tests/resources/reftable/nasty/.gitted/objects/cd/44b4ea1066b3fa1d4b3baad8dc1531aec287a6 b/tests/resources/reftable/nasty/.gitted/objects/cd/44b4ea1066b3fa1d4b3baad8dc1531aec287a6 new file mode 100644 index 000000000..51ad3880e Binary files /dev/null and b/tests/resources/reftable/nasty/.gitted/objects/cd/44b4ea1066b3fa1d4b3baad8dc1531aec287a6 differ diff --git a/tests/resources/reftable/nasty/.gitted/objects/ce/22b3cd9a01efafc370879c1938e0c32fb6f195 b/tests/resources/reftable/nasty/.gitted/objects/ce/22b3cd9a01efafc370879c1938e0c32fb6f195 new file mode 100644 index 000000000..eb5acc34b --- /dev/null +++ b/tests/resources/reftable/nasty/.gitted/objects/ce/22b3cd9a01efafc370879c1938e0c32fb6f195 @@ -0,0 +1,3 @@ +x; +B1E*$Zd+Hވ{< 2(v}p͵uI'_#ȝ4NYmŠ3rk~Mo"A< \ No newline at end of file diff --git a/tests/resources/reftable/nasty/.gitted/objects/dc/37c5f1521fb76fe1c1ac7b13187f9396a59247 b/tests/resources/reftable/nasty/.gitted/objects/dc/37c5f1521fb76fe1c1ac7b13187f9396a59247 new file mode 100644 index 000000000..57329de37 Binary files /dev/null and b/tests/resources/reftable/nasty/.gitted/objects/dc/37c5f1521fb76fe1c1ac7b13187f9396a59247 differ diff --git a/tests/resources/reftable/nasty/.gitted/objects/de/bdc4a004fda6141a17d9c297617be70d40248f b/tests/resources/reftable/nasty/.gitted/objects/de/bdc4a004fda6141a17d9c297617be70d40248f new file mode 100644 index 000000000..de34bd430 --- /dev/null +++ b/tests/resources/reftable/nasty/.gitted/objects/de/bdc4a004fda6141a17d9c297617be70d40248f @@ -0,0 +1,2 @@ +xK +1D]}tf&q m@&"(]{P%k UbȑR28/'\B ƓuLm)I5y)y-wItKN4zZuϛ9N7ZmA \ No newline at end of file diff --git a/tests/resources/reftable/nasty/.gitted/objects/e2/377bdbc93b30a34ed5deefedded89b947ff8f4 b/tests/resources/reftable/nasty/.gitted/objects/e2/377bdbc93b30a34ed5deefedded89b947ff8f4 new file mode 100644 index 000000000..f365908e0 --- /dev/null +++ b/tests/resources/reftable/nasty/.gitted/objects/e2/377bdbc93b30a34ed5deefedded89b947ff8f4 @@ -0,0 +1,2 @@ +xK +1D]}Dx@&i` d" UUr@^nzc-V&iK4xAhP{MA68gh ιaǃ~ҁצXH$aQ :;9#N@W \ No newline at end of file diff --git a/tests/resources/reftable/nasty/.gitted/objects/e3/0b60b120761f44ebd0f0a7b0e9445ce8e11d68 b/tests/resources/reftable/nasty/.gitted/objects/e3/0b60b120761f44ebd0f0a7b0e9445ce8e11d68 new file mode 100644 index 000000000..1c1be161d Binary files /dev/null and b/tests/resources/reftable/nasty/.gitted/objects/e3/0b60b120761f44ebd0f0a7b0e9445ce8e11d68 differ diff --git a/tests/resources/reftable/nasty/.gitted/objects/e3/99c4fc4c07cb7947d2f3d966bc374df6ccc691 b/tests/resources/reftable/nasty/.gitted/objects/e3/99c4fc4c07cb7947d2f3d966bc374df6ccc691 new file mode 100644 index 000000000..d8c237946 --- /dev/null +++ b/tests/resources/reftable/nasty/.gitted/objects/e3/99c4fc4c07cb7947d2f3d966bc374df6ccc691 @@ -0,0 +1,2 @@ +xQ +1 D)r.,' lЭ7o=MUU2c$$.sxl՚hT8.X8rY;~ů R# M3tkz o{@8 \ No newline at end of file diff --git a/tests/resources/reftable/nasty/.gitted/objects/e4/edb361e51932b5ccedbc7ee41b4d3a4289aece b/tests/resources/reftable/nasty/.gitted/objects/e4/edb361e51932b5ccedbc7ee41b4d3a4289aece new file mode 100644 index 000000000..a9b181815 Binary files /dev/null and b/tests/resources/reftable/nasty/.gitted/objects/e4/edb361e51932b5ccedbc7ee41b4d3a4289aece differ diff --git a/tests/resources/reftable/nasty/.gitted/objects/e5/1c3fa44fe981ec290c8f47fea736f3ff2af2a6 b/tests/resources/reftable/nasty/.gitted/objects/e5/1c3fa44fe981ec290c8f47fea736f3ff2af2a6 new file mode 100644 index 000000000..3d12f3a80 Binary files /dev/null and b/tests/resources/reftable/nasty/.gitted/objects/e5/1c3fa44fe981ec290c8f47fea736f3ff2af2a6 differ diff --git a/tests/resources/reftable/nasty/.gitted/objects/e7/3a04f71f11ab9d7dde72ff793882757a03f16e b/tests/resources/reftable/nasty/.gitted/objects/e7/3a04f71f11ab9d7dde72ff793882757a03f16e new file mode 100644 index 000000000..14144d736 Binary files /dev/null and b/tests/resources/reftable/nasty/.gitted/objects/e7/3a04f71f11ab9d7dde72ff793882757a03f16e differ diff --git a/tests/resources/reftable/nasty/.gitted/objects/e8/68b1d6833710021785581a9e11dba8468f3a55 b/tests/resources/reftable/nasty/.gitted/objects/e8/68b1d6833710021785581a9e11dba8468f3a55 new file mode 100644 index 000000000..8311ad31b Binary files /dev/null and b/tests/resources/reftable/nasty/.gitted/objects/e8/68b1d6833710021785581a9e11dba8468f3a55 differ diff --git a/tests/resources/reftable/nasty/.gitted/objects/e8/7caf56c91ab8d14e4ee8eb56308533503d1885 b/tests/resources/reftable/nasty/.gitted/objects/e8/7caf56c91ab8d14e4ee8eb56308533503d1885 new file mode 100644 index 000000000..6e61c0692 --- /dev/null +++ b/tests/resources/reftable/nasty/.gitted/objects/e8/7caf56c91ab8d14e4ee8eb56308533503d1885 @@ -0,0 +1,2 @@ +xK +1D]}n z|:D02FރPKv +71Ii?GJ^Zo #r$smpO"\r-kÞ#ůM"cAaQ :;9#7(AD \ No newline at end of file diff --git a/tests/resources/reftable/nasty/.gitted/objects/eb/82bf596b66f90e25f881ce9b92cb55bab4fdf5 b/tests/resources/reftable/nasty/.gitted/objects/eb/82bf596b66f90e25f881ce9b92cb55bab4fdf5 new file mode 100644 index 000000000..b886096ce Binary files /dev/null and b/tests/resources/reftable/nasty/.gitted/objects/eb/82bf596b66f90e25f881ce9b92cb55bab4fdf5 differ diff --git a/tests/resources/reftable/nasty/.gitted/objects/ed/4bc023f61dc345ff0084b922b229d24de206e7 b/tests/resources/reftable/nasty/.gitted/objects/ed/4bc023f61dc345ff0084b922b229d24de206e7 new file mode 100644 index 000000000..d128a9498 Binary files /dev/null and b/tests/resources/reftable/nasty/.gitted/objects/ed/4bc023f61dc345ff0084b922b229d24de206e7 differ diff --git a/tests/resources/reftable/nasty/.gitted/objects/ef/6ed8a2b15f95795aed82a974b995cace02dbfe b/tests/resources/reftable/nasty/.gitted/objects/ef/6ed8a2b15f95795aed82a974b995cace02dbfe new file mode 100644 index 000000000..7357306c6 Binary files /dev/null and b/tests/resources/reftable/nasty/.gitted/objects/ef/6ed8a2b15f95795aed82a974b995cace02dbfe differ diff --git a/tests/resources/reftable/nasty/.gitted/objects/f2/c059dab35f6534b3f16d90b2f1de308615320c b/tests/resources/reftable/nasty/.gitted/objects/f2/c059dab35f6534b3f16d90b2f1de308615320c new file mode 100644 index 000000000..c3580d334 Binary files /dev/null and b/tests/resources/reftable/nasty/.gitted/objects/f2/c059dab35f6534b3f16d90b2f1de308615320c differ diff --git a/tests/resources/reftable/nasty/.gitted/objects/fa/9cfdbeaaf3a91ff4b84d74412cd59d9b16a615 b/tests/resources/reftable/nasty/.gitted/objects/fa/9cfdbeaaf3a91ff4b84d74412cd59d9b16a615 new file mode 100644 index 000000000..890324e6c Binary files /dev/null and b/tests/resources/reftable/nasty/.gitted/objects/fa/9cfdbeaaf3a91ff4b84d74412cd59d9b16a615 differ diff --git a/tests/resources/reftable/nasty/.gitted/objects/fd/7a37d92197267e55e1fc0cc4f283a815bd79b8 b/tests/resources/reftable/nasty/.gitted/objects/fd/7a37d92197267e55e1fc0cc4f283a815bd79b8 new file mode 100644 index 000000000..c8d38ca46 Binary files /dev/null and b/tests/resources/reftable/nasty/.gitted/objects/fd/7a37d92197267e55e1fc0cc4f283a815bd79b8 differ diff --git a/tests/resources/reftable/nasty/.gitted/refs/heads b/tests/resources/reftable/nasty/.gitted/refs/heads new file mode 100644 index 000000000..3e639a56a --- /dev/null +++ b/tests/resources/reftable/nasty/.gitted/refs/heads @@ -0,0 +1 @@ +this repository uses the reftable format diff --git a/tests/resources/reftable/nasty/.gitted/reftable/0x000000000001-0x000000000001-b897f9f8.ref b/tests/resources/reftable/nasty/.gitted/reftable/0x000000000001-0x000000000001-b897f9f8.ref new file mode 100644 index 000000000..d3657b727 Binary files /dev/null and b/tests/resources/reftable/nasty/.gitted/reftable/0x000000000001-0x000000000001-b897f9f8.ref differ diff --git a/tests/resources/reftable/nasty/.gitted/reftable/tables.list b/tests/resources/reftable/nasty/.gitted/reftable/tables.list new file mode 100644 index 000000000..8ac1e830f --- /dev/null +++ b/tests/resources/reftable/nasty/.gitted/reftable/tables.list @@ -0,0 +1 @@ +0x000000000001-0x000000000001-b897f9f8.ref diff --git a/tests/resources/reftable/nsecs/.gitted/HEAD b/tests/resources/reftable/nsecs/.gitted/HEAD new file mode 100644 index 000000000..fe6d7e5fa --- /dev/null +++ b/tests/resources/reftable/nsecs/.gitted/HEAD @@ -0,0 +1 @@ +ref: refs/heads/.invalid diff --git a/tests/resources/reftable/nsecs/.gitted/config b/tests/resources/reftable/nsecs/.gitted/config new file mode 100644 index 000000000..15959e7b7 --- /dev/null +++ b/tests/resources/reftable/nsecs/.gitted/config @@ -0,0 +1,10 @@ +[core] + repositoryformatversion = 1 + filemode = false + bare = false + logallrefupdates = true + symlinks = false + ignorecase = true + hideDotFiles = dotGitOnly +[extensions] + refstorage = reftable diff --git a/tests/resources/reftable/nsecs/.gitted/index b/tests/resources/reftable/nsecs/.gitted/index new file mode 100644 index 000000000..9233f1b11 Binary files /dev/null and b/tests/resources/reftable/nsecs/.gitted/index differ diff --git a/tests/resources/reftable/nsecs/.gitted/objects/03/1986a8372d1442cfe9e3b54906a9aadc524a7e b/tests/resources/reftable/nsecs/.gitted/objects/03/1986a8372d1442cfe9e3b54906a9aadc524a7e new file mode 100644 index 000000000..a813b7424 --- /dev/null +++ b/tests/resources/reftable/nsecs/.gitted/objects/03/1986a8372d1442cfe9e3b54906a9aadc524a7e @@ -0,0 +1,2 @@ +xA +0D]J4DMu-/"FHFf P aʠZ rnX*4kUixK-#%y Z20;Џ; ŰJZ7FRBy?g?<^@]f˔GvܵNUOKv \ No newline at end of file diff --git a/tests/resources/reftable/nsecs/.gitted/objects/03/9afd91c98f82c14e425bb6796d8ca98e9c8cac b/tests/resources/reftable/nsecs/.gitted/objects/03/9afd91c98f82c14e425bb6796d8ca98e9c8cac new file mode 100644 index 000000000..74bb7d3fe Binary files /dev/null and b/tests/resources/reftable/nsecs/.gitted/objects/03/9afd91c98f82c14e425bb6796d8ca98e9c8cac differ diff --git a/tests/resources/reftable/nsecs/.gitted/objects/6d/8b18077cc99abd8dda05a6062c646406abb2d4 b/tests/resources/reftable/nsecs/.gitted/objects/6d/8b18077cc99abd8dda05a6062c646406abb2d4 new file mode 100644 index 000000000..7bf3a956c Binary files /dev/null and b/tests/resources/reftable/nsecs/.gitted/objects/6d/8b18077cc99abd8dda05a6062c646406abb2d4 differ diff --git a/tests/resources/reftable/nsecs/.gitted/objects/c5/12b6c64656b87ea8caf37a32bc5a562d797745 b/tests/resources/reftable/nsecs/.gitted/objects/c5/12b6c64656b87ea8caf37a32bc5a562d797745 new file mode 100644 index 000000000..dcf4c8ccb Binary files /dev/null and b/tests/resources/reftable/nsecs/.gitted/objects/c5/12b6c64656b87ea8caf37a32bc5a562d797745 differ diff --git a/tests/resources/reftable/nsecs/.gitted/objects/df/78d3d51c369e1d2f1eadb73464aadd931d56b4 b/tests/resources/reftable/nsecs/.gitted/objects/df/78d3d51c369e1d2f1eadb73464aadd931d56b4 new file mode 100644 index 000000000..df45d3314 Binary files /dev/null and b/tests/resources/reftable/nsecs/.gitted/objects/df/78d3d51c369e1d2f1eadb73464aadd931d56b4 differ diff --git a/tests/resources/reftable/nsecs/.gitted/refs/heads b/tests/resources/reftable/nsecs/.gitted/refs/heads new file mode 100644 index 000000000..3e639a56a --- /dev/null +++ b/tests/resources/reftable/nsecs/.gitted/refs/heads @@ -0,0 +1 @@ +this repository uses the reftable format diff --git a/tests/resources/reftable/nsecs/.gitted/reftable/0x000000000001-0x000000000001-7368b7d1.ref b/tests/resources/reftable/nsecs/.gitted/reftable/0x000000000001-0x000000000001-7368b7d1.ref new file mode 100644 index 000000000..98de2605b Binary files /dev/null and b/tests/resources/reftable/nsecs/.gitted/reftable/0x000000000001-0x000000000001-7368b7d1.ref differ diff --git a/tests/resources/reftable/nsecs/.gitted/reftable/tables.list b/tests/resources/reftable/nsecs/.gitted/reftable/tables.list new file mode 100644 index 000000000..999b1d25b --- /dev/null +++ b/tests/resources/reftable/nsecs/.gitted/reftable/tables.list @@ -0,0 +1 @@ +0x000000000001-0x000000000001-7368b7d1.ref diff --git a/tests/resources/reftable/nsecs/a.txt b/tests/resources/reftable/nsecs/a.txt new file mode 100644 index 000000000..be4c1ee68 --- /dev/null +++ b/tests/resources/reftable/nsecs/a.txt @@ -0,0 +1 @@ +File A diff --git a/tests/resources/reftable/nsecs/b.txt b/tests/resources/reftable/nsecs/b.txt new file mode 100644 index 000000000..19a0af40f --- /dev/null +++ b/tests/resources/reftable/nsecs/b.txt @@ -0,0 +1 @@ +File B diff --git a/tests/resources/reftable/nsecs/c.txt b/tests/resources/reftable/nsecs/c.txt new file mode 100644 index 000000000..31d776008 --- /dev/null +++ b/tests/resources/reftable/nsecs/c.txt @@ -0,0 +1 @@ +File C diff --git a/tests/resources/reftable/partial-testrepo/.gitted/HEAD b/tests/resources/reftable/partial-testrepo/.gitted/HEAD new file mode 100644 index 000000000..fe6d7e5fa --- /dev/null +++ b/tests/resources/reftable/partial-testrepo/.gitted/HEAD @@ -0,0 +1 @@ +ref: refs/heads/.invalid diff --git a/tests/resources/reftable/partial-testrepo/.gitted/config b/tests/resources/reftable/partial-testrepo/.gitted/config new file mode 100644 index 000000000..bfe184977 --- /dev/null +++ b/tests/resources/reftable/partial-testrepo/.gitted/config @@ -0,0 +1,9 @@ +[core] + repositoryformatversion = 1 + filemode = true + bare = false + logallrefupdates = true + ignorecase = true +[branch "dir"] +[extensions] + refstorage = reftable diff --git a/tests/resources/reftable/partial-testrepo/.gitted/index b/tests/resources/reftable/partial-testrepo/.gitted/index new file mode 100644 index 000000000..4f241f914 Binary files /dev/null and b/tests/resources/reftable/partial-testrepo/.gitted/index differ diff --git a/tests/resources/reftable/partial-testrepo/.gitted/objects/13/85f264afb75a56a5bec74243be9b367ba4ca08 b/tests/resources/reftable/partial-testrepo/.gitted/objects/13/85f264afb75a56a5bec74243be9b367ba4ca08 new file mode 100644 index 000000000..cedb2a22e Binary files /dev/null and b/tests/resources/reftable/partial-testrepo/.gitted/objects/13/85f264afb75a56a5bec74243be9b367ba4ca08 differ diff --git a/tests/resources/reftable/partial-testrepo/.gitted/objects/14/4344043ba4d4a405da03de3844aa829ae8be0e b/tests/resources/reftable/partial-testrepo/.gitted/objects/14/4344043ba4d4a405da03de3844aa829ae8be0e new file mode 100644 index 000000000..b7d944fa1 Binary files /dev/null and b/tests/resources/reftable/partial-testrepo/.gitted/objects/14/4344043ba4d4a405da03de3844aa829ae8be0e differ diff --git a/tests/resources/reftable/partial-testrepo/.gitted/objects/16/8e4ebd1c667499548ae12403b19b22a5c5e925 b/tests/resources/reftable/partial-testrepo/.gitted/objects/16/8e4ebd1c667499548ae12403b19b22a5c5e925 new file mode 100644 index 000000000..d37b93e4f Binary files /dev/null and b/tests/resources/reftable/partial-testrepo/.gitted/objects/16/8e4ebd1c667499548ae12403b19b22a5c5e925 differ diff --git a/tests/resources/reftable/partial-testrepo/.gitted/objects/18/1037049a54a1eb5fab404658a3a250b44335d7 b/tests/resources/reftable/partial-testrepo/.gitted/objects/18/1037049a54a1eb5fab404658a3a250b44335d7 new file mode 100644 index 000000000..93a16f146 Binary files /dev/null and b/tests/resources/reftable/partial-testrepo/.gitted/objects/18/1037049a54a1eb5fab404658a3a250b44335d7 differ diff --git a/tests/resources/reftable/partial-testrepo/.gitted/objects/18/10dff58d8a660512d4832e740f692884338ccd b/tests/resources/reftable/partial-testrepo/.gitted/objects/18/10dff58d8a660512d4832e740f692884338ccd new file mode 100644 index 000000000..ba0bfb30c Binary files /dev/null and b/tests/resources/reftable/partial-testrepo/.gitted/objects/18/10dff58d8a660512d4832e740f692884338ccd differ diff --git a/tests/resources/reftable/partial-testrepo/.gitted/objects/45/b983be36b73c0788dc9cbcb76cbb80fc7bb057 b/tests/resources/reftable/partial-testrepo/.gitted/objects/45/b983be36b73c0788dc9cbcb76cbb80fc7bb057 new file mode 100644 index 000000000..7ca4ceed5 Binary files /dev/null and b/tests/resources/reftable/partial-testrepo/.gitted/objects/45/b983be36b73c0788dc9cbcb76cbb80fc7bb057 differ diff --git a/tests/resources/reftable/partial-testrepo/.gitted/objects/4a/202b346bb0fb0db7eff3cffeb3c70babbd2045 b/tests/resources/reftable/partial-testrepo/.gitted/objects/4a/202b346bb0fb0db7eff3cffeb3c70babbd2045 new file mode 100644 index 000000000..8953b6cef --- /dev/null +++ b/tests/resources/reftable/partial-testrepo/.gitted/objects/4a/202b346bb0fb0db7eff3cffeb3c70babbd2045 @@ -0,0 +1,2 @@ +xQ +0D)6ͦ "xO-FbEo0 Ǥ,ske[Pn8R,EpD?g}^3 <GhYK8ЖDA);gݧjp4-r;sGA4ۺ=(in7IKFE \ No newline at end of file diff --git a/tests/resources/reftable/partial-testrepo/.gitted/objects/4e/0883eeeeebc1fb1735161cea82f7cb5fab7e63 b/tests/resources/reftable/partial-testrepo/.gitted/objects/4e/0883eeeeebc1fb1735161cea82f7cb5fab7e63 new file mode 100644 index 000000000..e9150214b Binary files /dev/null and b/tests/resources/reftable/partial-testrepo/.gitted/objects/4e/0883eeeeebc1fb1735161cea82f7cb5fab7e63 differ diff --git a/tests/resources/reftable/partial-testrepo/.gitted/objects/5b/5b025afb0b4c913b4c338a42934a3863bf3644 b/tests/resources/reftable/partial-testrepo/.gitted/objects/5b/5b025afb0b4c913b4c338a42934a3863bf3644 new file mode 100644 index 000000000..c1f22c54f --- /dev/null +++ b/tests/resources/reftable/partial-testrepo/.gitted/objects/5b/5b025afb0b4c913b4c338a42934a3863bf3644 @@ -0,0 +1,2 @@ +x 1ENi@k2 "X$YW0YcÅszMD08!s Xgd::@X0Pw"F/RUzmZZV}|/o5I!1z:vUim}/> +F- \ No newline at end of file diff --git a/tests/resources/reftable/partial-testrepo/.gitted/objects/62/eb56dabb4b9929bc15dd9263c2c733b13d2dcc b/tests/resources/reftable/partial-testrepo/.gitted/objects/62/eb56dabb4b9929bc15dd9263c2c733b13d2dcc new file mode 100644 index 000000000..b669961d8 Binary files /dev/null and b/tests/resources/reftable/partial-testrepo/.gitted/objects/62/eb56dabb4b9929bc15dd9263c2c733b13d2dcc differ diff --git a/tests/resources/reftable/partial-testrepo/.gitted/objects/66/3adb09143767984f7be83a91effa47e128c735 b/tests/resources/reftable/partial-testrepo/.gitted/objects/66/3adb09143767984f7be83a91effa47e128c735 new file mode 100644 index 000000000..9ff5eb2b5 Binary files /dev/null and b/tests/resources/reftable/partial-testrepo/.gitted/objects/66/3adb09143767984f7be83a91effa47e128c735 differ diff --git a/tests/resources/reftable/partial-testrepo/.gitted/objects/75/057dd4114e74cca1d750d0aee1647c903cb60a b/tests/resources/reftable/partial-testrepo/.gitted/objects/75/057dd4114e74cca1d750d0aee1647c903cb60a new file mode 100644 index 000000000..2ef4faa0f Binary files /dev/null and b/tests/resources/reftable/partial-testrepo/.gitted/objects/75/057dd4114e74cca1d750d0aee1647c903cb60a differ diff --git a/tests/resources/reftable/partial-testrepo/.gitted/objects/81/4889a078c031f61ed08ab5fa863aea9314344d b/tests/resources/reftable/partial-testrepo/.gitted/objects/81/4889a078c031f61ed08ab5fa863aea9314344d new file mode 100644 index 000000000..2f9b6b6e3 Binary files /dev/null and b/tests/resources/reftable/partial-testrepo/.gitted/objects/81/4889a078c031f61ed08ab5fa863aea9314344d differ diff --git a/tests/resources/reftable/partial-testrepo/.gitted/objects/84/96071c1b46c854b31185ea97743be6a8774479 b/tests/resources/reftable/partial-testrepo/.gitted/objects/84/96071c1b46c854b31185ea97743be6a8774479 new file mode 100644 index 000000000..5df58dda5 Binary files /dev/null and b/tests/resources/reftable/partial-testrepo/.gitted/objects/84/96071c1b46c854b31185ea97743be6a8774479 differ diff --git a/tests/resources/reftable/partial-testrepo/.gitted/objects/9f/d738e8f7967c078dceed8190330fc8648ee56a b/tests/resources/reftable/partial-testrepo/.gitted/objects/9f/d738e8f7967c078dceed8190330fc8648ee56a new file mode 100644 index 000000000..a79612435 --- /dev/null +++ b/tests/resources/reftable/partial-testrepo/.gitted/objects/9f/d738e8f7967c078dceed8190330fc8648ee56a @@ -0,0 +1,3 @@ +x[ +0E*fդ "W0-Ft݁pS[Yx^ +Db CLhut}8X*4ZsYUA X3RM) s6輢Mរ&Jm;}<\@ޏpĀv?jۺL?H \ No newline at end of file diff --git a/tests/resources/reftable/partial-testrepo/.gitted/objects/a4/a7dce85cf63874e984719f4fdd239f5145052f b/tests/resources/reftable/partial-testrepo/.gitted/objects/a4/a7dce85cf63874e984719f4fdd239f5145052f new file mode 100644 index 000000000..f8588696b --- /dev/null +++ b/tests/resources/reftable/partial-testrepo/.gitted/objects/a4/a7dce85cf63874e984719f4fdd239f5145052f @@ -0,0 +1,2 @@ +x;j1Dmdǎ|M3`V{ >QvL0I?!4Z=!צ8F!rsQy9]$D&l6A>jFWҵ IKNiZ%S + U~̽>' w [ DGڡQ-M>dO}\8g_ШoYr \ No newline at end of file diff --git a/tests/resources/reftable/partial-testrepo/.gitted/objects/a7/1586c1dfe8a71c6cbf6c129f404c5642ff31bd b/tests/resources/reftable/partial-testrepo/.gitted/objects/a7/1586c1dfe8a71c6cbf6c129f404c5642ff31bd new file mode 100644 index 000000000..d0d7e736e Binary files /dev/null and b/tests/resources/reftable/partial-testrepo/.gitted/objects/a7/1586c1dfe8a71c6cbf6c129f404c5642ff31bd differ diff --git a/tests/resources/reftable/partial-testrepo/.gitted/objects/a8/233120f6ad708f843d861ce2b7228ec4e3dec6 b/tests/resources/reftable/partial-testrepo/.gitted/objects/a8/233120f6ad708f843d861ce2b7228ec4e3dec6 new file mode 100644 index 000000000..18a7f61c2 Binary files /dev/null and b/tests/resources/reftable/partial-testrepo/.gitted/objects/a8/233120f6ad708f843d861ce2b7228ec4e3dec6 differ diff --git a/tests/resources/reftable/partial-testrepo/.gitted/objects/c4/7800c7266a2be04c571c04d5a6614691ea99bd b/tests/resources/reftable/partial-testrepo/.gitted/objects/c4/7800c7266a2be04c571c04d5a6614691ea99bd new file mode 100644 index 000000000..75f541f10 --- /dev/null +++ b/tests/resources/reftable/partial-testrepo/.gitted/objects/c4/7800c7266a2be04c571c04d5a6614691ea99bd @@ -0,0 +1,3 @@ +xQ +0D)ʦI<'lR+FjEo0 1352923205 -0500 clone: from m:/dd/libgit2/tests-clar/resources/testrepo.git diff --git a/tests/resources/reftable/push_src/.gitted/modules/submodule/logs/refs/heads/master b/tests/resources/reftable/push_src/.gitted/modules/submodule/logs/refs/heads/master new file mode 100644 index 000000000..aedcdf295 --- /dev/null +++ b/tests/resources/reftable/push_src/.gitted/modules/submodule/logs/refs/heads/master @@ -0,0 +1 @@ +0000000000000000000000000000000000000000 a65fedf39aefe402d3bb6e24df4d4f5fe4547750 Congyi Wu 1352923205 -0500 clone: from m:/dd/libgit2/tests-clar/resources/testrepo.git diff --git a/tests/resources/reftable/push_src/.gitted/modules/submodule/logs/refs/remotes/origin/HEAD b/tests/resources/reftable/push_src/.gitted/modules/submodule/logs/refs/remotes/origin/HEAD new file mode 100644 index 000000000..aedcdf295 --- /dev/null +++ b/tests/resources/reftable/push_src/.gitted/modules/submodule/logs/refs/remotes/origin/HEAD @@ -0,0 +1 @@ +0000000000000000000000000000000000000000 a65fedf39aefe402d3bb6e24df4d4f5fe4547750 Congyi Wu 1352923205 -0500 clone: from m:/dd/libgit2/tests-clar/resources/testrepo.git diff --git a/tests/resources/reftable/push_src/.gitted/modules/submodule/objects/08/b041783f40edfe12bb406c9c9a8a040177c125 b/tests/resources/reftable/push_src/.gitted/modules/submodule/objects/08/b041783f40edfe12bb406c9c9a8a040177c125 new file mode 100644 index 000000000..d1c032fce Binary files /dev/null and b/tests/resources/reftable/push_src/.gitted/modules/submodule/objects/08/b041783f40edfe12bb406c9c9a8a040177c125 differ diff --git a/tests/resources/reftable/push_src/.gitted/modules/submodule/objects/13/85f264afb75a56a5bec74243be9b367ba4ca08 b/tests/resources/reftable/push_src/.gitted/modules/submodule/objects/13/85f264afb75a56a5bec74243be9b367ba4ca08 new file mode 100644 index 000000000..cedb2a22e Binary files /dev/null and b/tests/resources/reftable/push_src/.gitted/modules/submodule/objects/13/85f264afb75a56a5bec74243be9b367ba4ca08 differ diff --git a/tests/resources/reftable/push_src/.gitted/modules/submodule/objects/18/1037049a54a1eb5fab404658a3a250b44335d7 b/tests/resources/reftable/push_src/.gitted/modules/submodule/objects/18/1037049a54a1eb5fab404658a3a250b44335d7 new file mode 100644 index 000000000..93a16f146 Binary files /dev/null and b/tests/resources/reftable/push_src/.gitted/modules/submodule/objects/18/1037049a54a1eb5fab404658a3a250b44335d7 differ diff --git a/tests/resources/reftable/push_src/.gitted/modules/submodule/objects/18/10dff58d8a660512d4832e740f692884338ccd b/tests/resources/reftable/push_src/.gitted/modules/submodule/objects/18/10dff58d8a660512d4832e740f692884338ccd new file mode 100644 index 000000000..ba0bfb30c Binary files /dev/null and b/tests/resources/reftable/push_src/.gitted/modules/submodule/objects/18/10dff58d8a660512d4832e740f692884338ccd differ diff --git a/tests/resources/reftable/push_src/.gitted/modules/submodule/objects/1a/443023183e3f2bfbef8ac923cd81c1018a18fd b/tests/resources/reftable/push_src/.gitted/modules/submodule/objects/1a/443023183e3f2bfbef8ac923cd81c1018a18fd new file mode 100644 index 000000000..3ec541288 Binary files /dev/null and b/tests/resources/reftable/push_src/.gitted/modules/submodule/objects/1a/443023183e3f2bfbef8ac923cd81c1018a18fd differ diff --git a/tests/resources/reftable/push_src/.gitted/modules/submodule/objects/1b/8cbad43e867676df601306689fe7c3def5e689 b/tests/resources/reftable/push_src/.gitted/modules/submodule/objects/1b/8cbad43e867676df601306689fe7c3def5e689 new file mode 100644 index 000000000..6048d4bad Binary files /dev/null and b/tests/resources/reftable/push_src/.gitted/modules/submodule/objects/1b/8cbad43e867676df601306689fe7c3def5e689 differ diff --git a/tests/resources/reftable/push_src/.gitted/modules/submodule/objects/1f/67fc4386b2d171e0d21be1c447e12660561f9b b/tests/resources/reftable/push_src/.gitted/modules/submodule/objects/1f/67fc4386b2d171e0d21be1c447e12660561f9b new file mode 100644 index 000000000..225c45734 Binary files /dev/null and b/tests/resources/reftable/push_src/.gitted/modules/submodule/objects/1f/67fc4386b2d171e0d21be1c447e12660561f9b differ diff --git a/tests/resources/reftable/push_src/.gitted/modules/submodule/objects/25/8f0e2a959a364e40ed6603d5d44fbb24765b10 b/tests/resources/reftable/push_src/.gitted/modules/submodule/objects/25/8f0e2a959a364e40ed6603d5d44fbb24765b10 new file mode 100644 index 000000000..cb1ed5712 Binary files /dev/null and b/tests/resources/reftable/push_src/.gitted/modules/submodule/objects/25/8f0e2a959a364e40ed6603d5d44fbb24765b10 differ diff --git a/tests/resources/reftable/push_src/.gitted/modules/submodule/objects/27/0b8ea76056d5cad83af921837702d3e3c2924d b/tests/resources/reftable/push_src/.gitted/modules/submodule/objects/27/0b8ea76056d5cad83af921837702d3e3c2924d new file mode 100644 index 000000000..df40d99af Binary files /dev/null and b/tests/resources/reftable/push_src/.gitted/modules/submodule/objects/27/0b8ea76056d5cad83af921837702d3e3c2924d differ diff --git a/tests/resources/reftable/push_src/.gitted/modules/submodule/objects/2d/59075e0681f540482d4f6223a68e0fef790bc7 b/tests/resources/reftable/push_src/.gitted/modules/submodule/objects/2d/59075e0681f540482d4f6223a68e0fef790bc7 new file mode 100644 index 000000000..0a1500a6f Binary files /dev/null and b/tests/resources/reftable/push_src/.gitted/modules/submodule/objects/2d/59075e0681f540482d4f6223a68e0fef790bc7 differ diff --git a/tests/resources/reftable/push_src/.gitted/modules/submodule/objects/32/59a6bd5b57fb9c1281bb7ed3167b50f224cb54 b/tests/resources/reftable/push_src/.gitted/modules/submodule/objects/32/59a6bd5b57fb9c1281bb7ed3167b50f224cb54 new file mode 100644 index 000000000..321eaa867 Binary files /dev/null and b/tests/resources/reftable/push_src/.gitted/modules/submodule/objects/32/59a6bd5b57fb9c1281bb7ed3167b50f224cb54 differ diff --git a/tests/resources/reftable/push_src/.gitted/modules/submodule/objects/36/97d64be941a53d4ae8f6a271e4e3fa56b022cc b/tests/resources/reftable/push_src/.gitted/modules/submodule/objects/36/97d64be941a53d4ae8f6a271e4e3fa56b022cc new file mode 100644 index 000000000..9bb5b623b Binary files /dev/null and b/tests/resources/reftable/push_src/.gitted/modules/submodule/objects/36/97d64be941a53d4ae8f6a271e4e3fa56b022cc differ diff --git a/tests/resources/reftable/push_src/.gitted/modules/submodule/objects/45/b983be36b73c0788dc9cbcb76cbb80fc7bb057 b/tests/resources/reftable/push_src/.gitted/modules/submodule/objects/45/b983be36b73c0788dc9cbcb76cbb80fc7bb057 new file mode 100644 index 000000000..7ca4ceed5 Binary files /dev/null and b/tests/resources/reftable/push_src/.gitted/modules/submodule/objects/45/b983be36b73c0788dc9cbcb76cbb80fc7bb057 differ diff --git a/tests/resources/reftable/push_src/.gitted/modules/submodule/objects/4a/202b346bb0fb0db7eff3cffeb3c70babbd2045 b/tests/resources/reftable/push_src/.gitted/modules/submodule/objects/4a/202b346bb0fb0db7eff3cffeb3c70babbd2045 new file mode 100644 index 000000000..8953b6cef --- /dev/null +++ b/tests/resources/reftable/push_src/.gitted/modules/submodule/objects/4a/202b346bb0fb0db7eff3cffeb3c70babbd2045 @@ -0,0 +1,2 @@ +xQ +0D)6ͦ "xO-FbEo0 Ǥ,ske[Pn8R,EpD?g}^3 <GhYK8ЖDA);gݧjp4-r;sGA4ۺ=(in7IKFE \ No newline at end of file diff --git a/tests/resources/reftable/push_src/.gitted/modules/submodule/objects/4b/22b35d44b5a4f589edf3dc89196399771796ea b/tests/resources/reftable/push_src/.gitted/modules/submodule/objects/4b/22b35d44b5a4f589edf3dc89196399771796ea new file mode 100644 index 000000000..b4e5aa186 Binary files /dev/null and b/tests/resources/reftable/push_src/.gitted/modules/submodule/objects/4b/22b35d44b5a4f589edf3dc89196399771796ea differ diff --git a/tests/resources/reftable/push_src/.gitted/modules/submodule/objects/52/1d87c1ec3aef9824daf6d96cc0ae3710766d91 b/tests/resources/reftable/push_src/.gitted/modules/submodule/objects/52/1d87c1ec3aef9824daf6d96cc0ae3710766d91 new file mode 100644 index 000000000..351cff823 Binary files /dev/null and b/tests/resources/reftable/push_src/.gitted/modules/submodule/objects/52/1d87c1ec3aef9824daf6d96cc0ae3710766d91 differ diff --git a/tests/resources/reftable/push_src/.gitted/modules/submodule/objects/5b/5b025afb0b4c913b4c338a42934a3863bf3644 b/tests/resources/reftable/push_src/.gitted/modules/submodule/objects/5b/5b025afb0b4c913b4c338a42934a3863bf3644 new file mode 100644 index 000000000..c1f22c54f --- /dev/null +++ b/tests/resources/reftable/push_src/.gitted/modules/submodule/objects/5b/5b025afb0b4c913b4c338a42934a3863bf3644 @@ -0,0 +1,2 @@ +x 1ENi@k2 "X$YW0YcÅszMD08!s Xgd::@X0Pw"F/RUzmZZV}|/o5I!1z:vUim}/> +F- \ No newline at end of file diff --git a/tests/resources/reftable/push_src/.gitted/modules/submodule/objects/75/057dd4114e74cca1d750d0aee1647c903cb60a b/tests/resources/reftable/push_src/.gitted/modules/submodule/objects/75/057dd4114e74cca1d750d0aee1647c903cb60a new file mode 100644 index 000000000..2ef4faa0f Binary files /dev/null and b/tests/resources/reftable/push_src/.gitted/modules/submodule/objects/75/057dd4114e74cca1d750d0aee1647c903cb60a differ diff --git a/tests/resources/reftable/push_src/.gitted/modules/submodule/objects/76/3d71aadf09a7951596c9746c024e7eece7c7af b/tests/resources/reftable/push_src/.gitted/modules/submodule/objects/76/3d71aadf09a7951596c9746c024e7eece7c7af new file mode 100644 index 000000000..716b0c64b --- /dev/null +++ b/tests/resources/reftable/push_src/.gitted/modules/submodule/objects/76/3d71aadf09a7951596c9746c024e7eece7c7af @@ -0,0 +1 @@ +xAj!?009o}H6}jUPPZ&Y AԛpFdpz[fYPqLJ.,Z`Ů.`v q $5+9Ot>/DE/龡W*eVdf1>覭ěʙFThk.i^0?PR, \ No newline at end of file diff --git a/tests/resources/reftable/push_src/.gitted/modules/submodule/objects/7b/4384978d2493e851f9cca7858815fac9b10980 b/tests/resources/reftable/push_src/.gitted/modules/submodule/objects/7b/4384978d2493e851f9cca7858815fac9b10980 new file mode 100644 index 000000000..23c462f34 Binary files /dev/null and b/tests/resources/reftable/push_src/.gitted/modules/submodule/objects/7b/4384978d2493e851f9cca7858815fac9b10980 differ diff --git a/tests/resources/reftable/push_src/.gitted/modules/submodule/objects/81/4889a078c031f61ed08ab5fa863aea9314344d b/tests/resources/reftable/push_src/.gitted/modules/submodule/objects/81/4889a078c031f61ed08ab5fa863aea9314344d new file mode 100644 index 000000000..2f9b6b6e3 Binary files /dev/null and b/tests/resources/reftable/push_src/.gitted/modules/submodule/objects/81/4889a078c031f61ed08ab5fa863aea9314344d differ diff --git a/tests/resources/reftable/push_src/.gitted/modules/submodule/objects/84/96071c1b46c854b31185ea97743be6a8774479 b/tests/resources/reftable/push_src/.gitted/modules/submodule/objects/84/96071c1b46c854b31185ea97743be6a8774479 new file mode 100644 index 000000000..5df58dda5 Binary files /dev/null and b/tests/resources/reftable/push_src/.gitted/modules/submodule/objects/84/96071c1b46c854b31185ea97743be6a8774479 differ diff --git a/tests/resources/reftable/push_src/.gitted/modules/submodule/objects/84/9a5e34a26815e821f865b8479f5815a47af0fe b/tests/resources/reftable/push_src/.gitted/modules/submodule/objects/84/9a5e34a26815e821f865b8479f5815a47af0fe new file mode 100644 index 000000000..71019a636 --- /dev/null +++ b/tests/resources/reftable/push_src/.gitted/modules/submodule/objects/84/9a5e34a26815e821f865b8479f5815a47af0fe @@ -0,0 +1,2 @@ +xM F]s41x(IKݽ/_P@!8)es + N&FGSƄh{+CZzvF7Z-kx\[P8GK/^ l>.4 \ No newline at end of file diff --git a/tests/resources/reftable/push_src/.gitted/modules/submodule/objects/94/4c0f6e4dfa41595e6eb3ceecdb14f50fe18162 b/tests/resources/reftable/push_src/.gitted/modules/submodule/objects/94/4c0f6e4dfa41595e6eb3ceecdb14f50fe18162 new file mode 100644 index 000000000..4cc3f4dff --- /dev/null +++ b/tests/resources/reftable/push_src/.gitted/modules/submodule/objects/94/4c0f6e4dfa41595e6eb3ceecdb14f50fe18162 @@ -0,0 +1 @@ +x+)JMU044b040031QrutueXlmmAṃJ}G;UTWRQ`6Kǥ^/-*|W3Py`%E\&g|0{Ӎ1X \ No newline at end of file diff --git a/tests/resources/reftable/push_src/.gitted/modules/submodule/objects/9a/03079b8a8ee85a0bee58bf9be3da8b62414ed4 b/tests/resources/reftable/push_src/.gitted/modules/submodule/objects/9a/03079b8a8ee85a0bee58bf9be3da8b62414ed4 new file mode 100644 index 000000000..bf7b2bb68 Binary files /dev/null and b/tests/resources/reftable/push_src/.gitted/modules/submodule/objects/9a/03079b8a8ee85a0bee58bf9be3da8b62414ed4 differ diff --git a/tests/resources/reftable/push_src/.gitted/modules/submodule/objects/9f/13f7d0a9402c681f91dc590cf7b5470e6a77d2 b/tests/resources/reftable/push_src/.gitted/modules/submodule/objects/9f/13f7d0a9402c681f91dc590cf7b5470e6a77d2 new file mode 100644 index 000000000..7f1cfb23c --- /dev/null +++ b/tests/resources/reftable/push_src/.gitted/modules/submodule/objects/9f/13f7d0a9402c681f91dc590cf7b5470e6a77d2 @@ -0,0 +1,2 @@ +xM +0F]d2;XEȎ5R AE &n}ZA \ No newline at end of file diff --git a/tests/resources/reftable/push_src/.gitted/modules/submodule/objects/9f/d738e8f7967c078dceed8190330fc8648ee56a b/tests/resources/reftable/push_src/.gitted/modules/submodule/objects/9f/d738e8f7967c078dceed8190330fc8648ee56a new file mode 100644 index 000000000..a79612435 --- /dev/null +++ b/tests/resources/reftable/push_src/.gitted/modules/submodule/objects/9f/d738e8f7967c078dceed8190330fc8648ee56a @@ -0,0 +1,3 @@ +x[ +0E*fդ "W0-Ft݁pS[Yx^ +Db CLhut}8X*4ZsYUA X3RM) s6輢Mរ&Jm;}<\@ޏpĀv?jۺL?H \ No newline at end of file diff --git a/tests/resources/reftable/push_src/.gitted/modules/submodule/objects/a4/a7dce85cf63874e984719f4fdd239f5145052f b/tests/resources/reftable/push_src/.gitted/modules/submodule/objects/a4/a7dce85cf63874e984719f4fdd239f5145052f new file mode 100644 index 000000000..f8588696b --- /dev/null +++ b/tests/resources/reftable/push_src/.gitted/modules/submodule/objects/a4/a7dce85cf63874e984719f4fdd239f5145052f @@ -0,0 +1,2 @@ +x;j1Dmdǎ|M3`V{ >QvL0I?!4Z=!צ8F!rsQy9]$D&l6A>jFWҵ IKNiZ%S + U~̽>' w [ DGڡQ-M>dO}\8g_ШoYr \ No newline at end of file diff --git a/tests/resources/reftable/push_src/.gitted/modules/submodule/objects/a6/5fedf39aefe402d3bb6e24df4d4f5fe4547750 b/tests/resources/reftable/push_src/.gitted/modules/submodule/objects/a6/5fedf39aefe402d3bb6e24df4d4f5fe4547750 new file mode 100644 index 000000000..29c8e824d --- /dev/null +++ b/tests/resources/reftable/push_src/.gitted/modules/submodule/objects/a6/5fedf39aefe402d3bb6e24df4d4f5fe4547750 @@ -0,0 +1,3 @@ +xQ +!@sBQ" ٱ r{RȞyE + mH&Er7S!*u΄2>#\V8|Gt-ybhFU/J-|M}W+GK \ No newline at end of file diff --git a/tests/resources/reftable/push_src/.gitted/objects/28/905c54ea45a4bed8d7b90f51bd8bd81eec8840 b/tests/resources/reftable/push_src/.gitted/objects/28/905c54ea45a4bed8d7b90f51bd8bd81eec8840 new file mode 100644 index 000000000..dc10f6831 Binary files /dev/null and b/tests/resources/reftable/push_src/.gitted/objects/28/905c54ea45a4bed8d7b90f51bd8bd81eec8840 differ diff --git a/tests/resources/reftable/push_src/.gitted/objects/36/6226fb970ac0caa9d3f55967ab01334a548f60 b/tests/resources/reftable/push_src/.gitted/objects/36/6226fb970ac0caa9d3f55967ab01334a548f60 new file mode 100644 index 000000000..45c4d9208 Binary files /dev/null and b/tests/resources/reftable/push_src/.gitted/objects/36/6226fb970ac0caa9d3f55967ab01334a548f60 differ diff --git a/tests/resources/reftable/push_src/.gitted/objects/36/f79b2846017d3761e0a02d0bccd573e0f90c57 b/tests/resources/reftable/push_src/.gitted/objects/36/f79b2846017d3761e0a02d0bccd573e0f90c57 new file mode 100644 index 000000000..0bc57f266 --- /dev/null +++ b/tests/resources/reftable/push_src/.gitted/objects/36/f79b2846017d3761e0a02d0bccd573e0f90c57 @@ -0,0 +1,2 @@ +x%] +0S͏B)} @bnf`f`>3(nibC0hQ6BMv2&-M0Q)+ tNsE*;}JϲN픹(th@#B˺C?TÅoyk7 \ No newline at end of file diff --git a/tests/resources/reftable/push_src/.gitted/objects/5c/0bb3d1b9449d1cc69d7519fd05166f01840915 b/tests/resources/reftable/push_src/.gitted/objects/5c/0bb3d1b9449d1cc69d7519fd05166f01840915 new file mode 100644 index 000000000..883182138 Binary files /dev/null and b/tests/resources/reftable/push_src/.gitted/objects/5c/0bb3d1b9449d1cc69d7519fd05166f01840915 differ diff --git a/tests/resources/reftable/push_src/.gitted/objects/61/780798228d17af2d34fce4cfbdf35556832472 b/tests/resources/reftable/push_src/.gitted/objects/61/780798228d17af2d34fce4cfbdf35556832472 new file mode 100644 index 000000000..586bf17a4 Binary files /dev/null and b/tests/resources/reftable/push_src/.gitted/objects/61/780798228d17af2d34fce4cfbdf35556832472 differ diff --git a/tests/resources/reftable/push_src/.gitted/objects/64/fd55f9b6390202db5e5666fd1fb339089fba4d b/tests/resources/reftable/push_src/.gitted/objects/64/fd55f9b6390202db5e5666fd1fb339089fba4d new file mode 100644 index 000000000..bcaaa91c2 Binary files /dev/null and b/tests/resources/reftable/push_src/.gitted/objects/64/fd55f9b6390202db5e5666fd1fb339089fba4d differ diff --git a/tests/resources/reftable/push_src/.gitted/objects/78/981922613b2afb6025042ff6bd878ac1994e85 b/tests/resources/reftable/push_src/.gitted/objects/78/981922613b2afb6025042ff6bd878ac1994e85 new file mode 100644 index 000000000..e814d07b0 Binary files /dev/null and b/tests/resources/reftable/push_src/.gitted/objects/78/981922613b2afb6025042ff6bd878ac1994e85 differ diff --git a/tests/resources/reftable/push_src/.gitted/objects/80/5c54522e614f29f70d2413a0470247d8b424ac b/tests/resources/reftable/push_src/.gitted/objects/80/5c54522e614f29f70d2413a0470247d8b424ac new file mode 100644 index 000000000..552670c06 Binary files /dev/null and b/tests/resources/reftable/push_src/.gitted/objects/80/5c54522e614f29f70d2413a0470247d8b424ac differ diff --git a/tests/resources/reftable/push_src/.gitted/objects/95/1bbbb90e2259a4c8950db78946784fb53fcbce b/tests/resources/reftable/push_src/.gitted/objects/95/1bbbb90e2259a4c8950db78946784fb53fcbce new file mode 100644 index 000000000..596cd43de --- /dev/null +++ b/tests/resources/reftable/push_src/.gitted/objects/95/1bbbb90e2259a4c8950db78946784fb53fcbce @@ -0,0 +1,2 @@ +x[J0}*f2$Eim +\8:DfZ &65^,%lm١~;KJRXT蕄(!{¯DZqPqsPӈB\;EEgs`IeoE(YMFC9uu>|#?i.׻qD90FEENzܶ<\,\a_a.gd \ No newline at end of file diff --git a/tests/resources/reftable/push_src/.gitted/objects/a7/8705c3b2725f931d3ee05348d83cc26700f247 b/tests/resources/reftable/push_src/.gitted/objects/a7/8705c3b2725f931d3ee05348d83cc26700f247 new file mode 100644 index 000000000..6ad835e86 Binary files /dev/null and b/tests/resources/reftable/push_src/.gitted/objects/a7/8705c3b2725f931d3ee05348d83cc26700f247 differ diff --git a/tests/resources/reftable/push_src/.gitted/objects/b4/83ae7ba66decee9aee971f501221dea84b1498 b/tests/resources/reftable/push_src/.gitted/objects/b4/83ae7ba66decee9aee971f501221dea84b1498 new file mode 100644 index 000000000..1e0bd3b05 --- /dev/null +++ b/tests/resources/reftable/push_src/.gitted/objects/b4/83ae7ba66decee9aee971f501221dea84b1498 @@ -0,0 +1,3 @@ +x5K +1D];1i"^'|d`d ooqQEͫ*Pݢ+ + 3$, }%Rw+s9y輨r`+ܦ2p/[mp~u8-Sr=,?Z+g \ No newline at end of file diff --git a/tests/resources/reftable/push_src/.gitted/objects/b4/e1f2b375a64c1ccd40c5ff6aa8bc96839ba4fd b/tests/resources/reftable/push_src/.gitted/objects/b4/e1f2b375a64c1ccd40c5ff6aa8bc96839ba4fd new file mode 100644 index 000000000..4e650aaa1 Binary files /dev/null and b/tests/resources/reftable/push_src/.gitted/objects/b4/e1f2b375a64c1ccd40c5ff6aa8bc96839ba4fd differ diff --git a/tests/resources/reftable/push_src/.gitted/objects/c1/0409136a7a75e025fa502a1b2fd7b62b77d279 b/tests/resources/reftable/push_src/.gitted/objects/c1/0409136a7a75e025fa502a1b2fd7b62b77d279 new file mode 100644 index 000000000..fcb2b32f3 Binary files /dev/null and b/tests/resources/reftable/push_src/.gitted/objects/c1/0409136a7a75e025fa502a1b2fd7b62b77d279 differ diff --git a/tests/resources/reftable/push_src/.gitted/objects/cd/881f90f2933db2e4cc26b8c71fe6037ac7fe4c b/tests/resources/reftable/push_src/.gitted/objects/cd/881f90f2933db2e4cc26b8c71fe6037ac7fe4c new file mode 100644 index 000000000..ad4272638 Binary files /dev/null and b/tests/resources/reftable/push_src/.gitted/objects/cd/881f90f2933db2e4cc26b8c71fe6037ac7fe4c differ diff --git a/tests/resources/reftable/push_src/.gitted/objects/d9/b63a88223d8367516f50bd131a5f7349b7f3e4 b/tests/resources/reftable/push_src/.gitted/objects/d9/b63a88223d8367516f50bd131a5f7349b7f3e4 new file mode 100644 index 000000000..b471e2155 --- /dev/null +++ b/tests/resources/reftable/push_src/.gitted/objects/d9/b63a88223d8367516f50bd131a5f7349b7f3e4 @@ -0,0 +1,2 @@ +xA +0E]sd$ "xi2ՂmzwSErgj ![͎%wbY(zC/G\tw({r$C`Y[=DCu&V8!s=]8ޛT#|;ltWhfM}UQDM \ No newline at end of file diff --git a/tests/resources/reftable/push_src/.gitted/objects/dc/ab83249f6f9d1ed735d651352a80519339b591 b/tests/resources/reftable/push_src/.gitted/objects/dc/ab83249f6f9d1ed735d651352a80519339b591 new file mode 100644 index 000000000..9f6b1502f Binary files /dev/null and b/tests/resources/reftable/push_src/.gitted/objects/dc/ab83249f6f9d1ed735d651352a80519339b591 differ diff --git a/tests/resources/reftable/push_src/.gitted/objects/ee/a4f2705eeec2db3813f2430829afce99cd00b5 b/tests/resources/reftable/push_src/.gitted/objects/ee/a4f2705eeec2db3813f2430829afce99cd00b5 new file mode 100644 index 000000000..b7b81d5e3 Binary files /dev/null and b/tests/resources/reftable/push_src/.gitted/objects/ee/a4f2705eeec2db3813f2430829afce99cd00b5 differ diff --git a/tests/resources/reftable/push_src/.gitted/objects/f7/8a3106c85fb549c65198b2a2086276c6174928 b/tests/resources/reftable/push_src/.gitted/objects/f7/8a3106c85fb549c65198b2a2086276c6174928 new file mode 100644 index 000000000..b9813576d Binary files /dev/null and b/tests/resources/reftable/push_src/.gitted/objects/f7/8a3106c85fb549c65198b2a2086276c6174928 differ diff --git a/tests/resources/reftable/push_src/.gitted/objects/f8/f7aefc2900a3d737cea9eee45729fd55761e1a b/tests/resources/reftable/push_src/.gitted/objects/f8/f7aefc2900a3d737cea9eee45729fd55761e1a new file mode 100644 index 000000000..888354fc2 Binary files /dev/null and b/tests/resources/reftable/push_src/.gitted/objects/f8/f7aefc2900a3d737cea9eee45729fd55761e1a differ diff --git a/tests/resources/reftable/push_src/.gitted/objects/fa/38b91f199934685819bea316186d8b008c52a2 b/tests/resources/reftable/push_src/.gitted/objects/fa/38b91f199934685819bea316186d8b008c52a2 new file mode 100644 index 000000000..13d9bca20 --- /dev/null +++ b/tests/resources/reftable/push_src/.gitted/objects/fa/38b91f199934685819bea316186d8b008c52a2 @@ -0,0 +1,2 @@ +xJ15>urrneo {f[)_DmIi7 +7Ĩ8ꔌ.n܃W)_T;x,(li[D\K墓XΓP?>W~|_Wؤxs6IcJNP}~ -מ/󄳭G X \ No newline at end of file diff --git a/tests/resources/reftable/push_src/.gitted/objects/ff/83aa4c5e5d28e3bcba2f5c6e2adc61286a4e5e b/tests/resources/reftable/push_src/.gitted/objects/ff/83aa4c5e5d28e3bcba2f5c6e2adc61286a4e5e new file mode 100644 index 000000000..10f25eb7c --- /dev/null +++ b/tests/resources/reftable/push_src/.gitted/objects/ff/83aa4c5e5d28e3bcba2f5c6e2adc61286a4e5e @@ -0,0 +1,4 @@ +x5M +1 `=E4NA H ooq{/G@5=$+SO) nx[@4y +h1ڄvmSyz' +Wk-ziQc<ޢfS~pv+ \ No newline at end of file diff --git a/tests/resources/reftable/push_src/.gitted/objects/ff/fe95c7fd0a37fa2ed702f8f93b56b2196b3925 b/tests/resources/reftable/push_src/.gitted/objects/ff/fe95c7fd0a37fa2ed702f8f93b56b2196b3925 new file mode 100644 index 000000000..1cdc048c0 Binary files /dev/null and b/tests/resources/reftable/push_src/.gitted/objects/ff/fe95c7fd0a37fa2ed702f8f93b56b2196b3925 differ diff --git a/tests/resources/reftable/push_src/.gitted/objects/pack/dummy b/tests/resources/reftable/push_src/.gitted/objects/pack/dummy new file mode 100644 index 000000000..e69de29bb diff --git a/tests/resources/reftable/push_src/.gitted/refs/heads b/tests/resources/reftable/push_src/.gitted/refs/heads new file mode 100644 index 000000000..3e639a56a --- /dev/null +++ b/tests/resources/reftable/push_src/.gitted/refs/heads @@ -0,0 +1 @@ +this repository uses the reftable format diff --git a/tests/resources/reftable/push_src/.gitted/reftable/0x000000000001-0x00000000000a-7855aa30.ref b/tests/resources/reftable/push_src/.gitted/reftable/0x000000000001-0x00000000000a-7855aa30.ref new file mode 100644 index 000000000..09bac04d6 Binary files /dev/null and b/tests/resources/reftable/push_src/.gitted/reftable/0x000000000001-0x00000000000a-7855aa30.ref differ diff --git a/tests/resources/reftable/push_src/.gitted/reftable/tables.list b/tests/resources/reftable/push_src/.gitted/reftable/tables.list new file mode 100644 index 000000000..25714bc8b --- /dev/null +++ b/tests/resources/reftable/push_src/.gitted/reftable/tables.list @@ -0,0 +1 @@ +0x000000000001-0x00000000000a-7855aa30.ref diff --git a/tests/resources/reftable/push_src/a.txt b/tests/resources/reftable/push_src/a.txt new file mode 100644 index 000000000..f7eac1c51 --- /dev/null +++ b/tests/resources/reftable/push_src/a.txt @@ -0,0 +1,2 @@ +a +edit diff --git a/tests/resources/reftable/push_src/fold/b.txt b/tests/resources/reftable/push_src/fold/b.txt new file mode 100644 index 000000000..617807982 --- /dev/null +++ b/tests/resources/reftable/push_src/fold/b.txt @@ -0,0 +1 @@ +b diff --git a/tests/resources/reftable/push_src/foldb.txt b/tests/resources/reftable/push_src/foldb.txt new file mode 100644 index 000000000..5b38718be --- /dev/null +++ b/tests/resources/reftable/push_src/foldb.txt @@ -0,0 +1 @@ +edit diff --git a/tests/resources/reftable/push_src/gitmodules b/tests/resources/reftable/push_src/gitmodules new file mode 100644 index 000000000..f1734dfc1 --- /dev/null +++ b/tests/resources/reftable/push_src/gitmodules @@ -0,0 +1,3 @@ +[submodule "submodule"] + path = submodule + url = ../testrepo.git diff --git a/tests/resources/reftable/push_src/submodule/.gitted b/tests/resources/reftable/push_src/submodule/.gitted new file mode 100644 index 000000000..3ffcf960a --- /dev/null +++ b/tests/resources/reftable/push_src/submodule/.gitted @@ -0,0 +1 @@ +gitdir: ../.git/modules/submodule diff --git a/tests/resources/reftable/push_src/submodule/README b/tests/resources/reftable/push_src/submodule/README new file mode 100644 index 000000000..ca8c64728 --- /dev/null +++ b/tests/resources/reftable/push_src/submodule/README @@ -0,0 +1 @@ +hey there diff --git a/tests/resources/reftable/push_src/submodule/branch_file.txt b/tests/resources/reftable/push_src/submodule/branch_file.txt new file mode 100644 index 000000000..a26902575 --- /dev/null +++ b/tests/resources/reftable/push_src/submodule/branch_file.txt @@ -0,0 +1,2 @@ +hi +bye! diff --git a/tests/resources/reftable/push_src/submodule/new.txt b/tests/resources/reftable/push_src/submodule/new.txt new file mode 100644 index 000000000..8e0884e36 --- /dev/null +++ b/tests/resources/reftable/push_src/submodule/new.txt @@ -0,0 +1 @@ +my new file diff --git a/tests/resources/reftable/rebase-submodule/.gitted/HEAD b/tests/resources/reftable/rebase-submodule/.gitted/HEAD new file mode 100644 index 000000000..fe6d7e5fa --- /dev/null +++ b/tests/resources/reftable/rebase-submodule/.gitted/HEAD @@ -0,0 +1 @@ +ref: refs/heads/.invalid diff --git a/tests/resources/reftable/rebase-submodule/.gitted/config b/tests/resources/reftable/rebase-submodule/.gitted/config new file mode 100644 index 000000000..14e28fdbb --- /dev/null +++ b/tests/resources/reftable/rebase-submodule/.gitted/config @@ -0,0 +1,11 @@ +[core] + repositoryformatversion = 1 + filemode = true + bare = false + logallrefupdates = true +[branch "asparagus"] + rebase = true +[branch "master"] + rebase = true +[extensions] + refstorage = reftable diff --git a/tests/resources/reftable/rebase-submodule/.gitted/description b/tests/resources/reftable/rebase-submodule/.gitted/description new file mode 100644 index 000000000..498b267a8 --- /dev/null +++ b/tests/resources/reftable/rebase-submodule/.gitted/description @@ -0,0 +1 @@ +Unnamed repository; edit this file 'description' to name the repository. diff --git a/tests/resources/reftable/rebase-submodule/.gitted/index b/tests/resources/reftable/rebase-submodule/.gitted/index new file mode 100644 index 000000000..b63efabdb Binary files /dev/null and b/tests/resources/reftable/rebase-submodule/.gitted/index differ diff --git a/tests/resources/reftable/rebase-submodule/.gitted/info/exclude b/tests/resources/reftable/rebase-submodule/.gitted/info/exclude new file mode 100644 index 000000000..a5196d1be --- /dev/null +++ b/tests/resources/reftable/rebase-submodule/.gitted/info/exclude @@ -0,0 +1,6 @@ +# git ls-files --others --exclude-from=.git/info/exclude +# Lines that start with '#' are comments. +# For a project mostly in C, the following would be a good set of +# exclude patterns (uncomment them if you want to use them): +# *.[oa] +# *~ diff --git a/tests/resources/reftable/rebase-submodule/.gitted/info/refs b/tests/resources/reftable/rebase-submodule/.gitted/info/refs new file mode 100644 index 000000000..230a6494b --- /dev/null +++ b/tests/resources/reftable/rebase-submodule/.gitted/info/refs @@ -0,0 +1,4 @@ +c64ea52df5b31efd7b73769418dc9e25b8803d25 refs/heads/asparagus +c64ea52df5b31efd7b73769418dc9e25b8803d25 refs/remotes/origin/HEAD +c64ea52df5b31efd7b73769418dc9e25b8803d25 refs/remotes/origin/asparagus +02a35db3f24db554b757b3009bc782784267c743 refs/remotes/origin/master diff --git a/tests/resources/reftable/rebase-submodule/.gitted/objects/01/971e2453a407e4b9f6c865e2c37f4db21da294 b/tests/resources/reftable/rebase-submodule/.gitted/objects/01/971e2453a407e4b9f6c865e2c37f4db21da294 new file mode 100644 index 000000000..308b38697 --- /dev/null +++ b/tests/resources/reftable/rebase-submodule/.gitted/objects/01/971e2453a407e4b9f6c865e2c37f4db21da294 @@ -0,0 +1 @@ +xUAj0Юu@Xfd%4Rj"t|>ZA[o)G2R1䠭 qbth&Bԗoi?M<"Z̨ELdY\cڒsu`dhO]K}_XO;E<[(U{R1J \ No newline at end of file diff --git a/tests/resources/reftable/rebase-submodule/.gitted/objects/17/f8ae8ebdd08a4bb272f61b897b308ad42b1b12 b/tests/resources/reftable/rebase-submodule/.gitted/objects/17/f8ae8ebdd08a4bb272f61b897b308ad42b1b12 new file mode 100644 index 000000000..79e4c484f --- /dev/null +++ b/tests/resources/reftable/rebase-submodule/.gitted/objects/17/f8ae8ebdd08a4bb272f61b897b308ad42b1b12 @@ -0,0 +1 @@ +x-Kn0 D)xMȢYv P'jqXt@=3p0qF eҤv&"[^;HHzb6Sq3*1zGmpK|=.yGw:Ǻ" *CNel:eO.Uϵ9mփ5De$+xo}RC \ No newline at end of file diff --git a/tests/resources/reftable/rebase-submodule/.gitted/objects/42/cdad903aef3e7b614675e6584a8be417941911 b/tests/resources/reftable/rebase-submodule/.gitted/objects/42/cdad903aef3e7b614675e6584a8be417941911 new file mode 100644 index 000000000..99b5e6d2c Binary files /dev/null and b/tests/resources/reftable/rebase-submodule/.gitted/objects/42/cdad903aef3e7b614675e6584a8be417941911 differ diff --git a/tests/resources/reftable/rebase-submodule/.gitted/objects/4b/7c5650008b2e747fe1809eeb5a1dde0e80850a b/tests/resources/reftable/rebase-submodule/.gitted/objects/4b/7c5650008b2e747fe1809eeb5a1dde0e80850a new file mode 100644 index 000000000..016398531 Binary files /dev/null and b/tests/resources/reftable/rebase-submodule/.gitted/objects/4b/7c5650008b2e747fe1809eeb5a1dde0e80850a differ diff --git a/tests/resources/reftable/rebase-submodule/.gitted/objects/5b/1e8bccf7787e942aecf61912f94a2c274f85a5 b/tests/resources/reftable/rebase-submodule/.gitted/objects/5b/1e8bccf7787e942aecf61912f94a2c274f85a5 new file mode 100644 index 000000000..d4776d883 Binary files /dev/null and b/tests/resources/reftable/rebase-submodule/.gitted/objects/5b/1e8bccf7787e942aecf61912f94a2c274f85a5 differ diff --git a/tests/resources/reftable/rebase-submodule/.gitted/objects/68/af1fc7407fd9addf1701a87eb1c95c7494c598 b/tests/resources/reftable/rebase-submodule/.gitted/objects/68/af1fc7407fd9addf1701a87eb1c95c7494c598 new file mode 100644 index 000000000..6aaf79fcb Binary files /dev/null and b/tests/resources/reftable/rebase-submodule/.gitted/objects/68/af1fc7407fd9addf1701a87eb1c95c7494c598 differ diff --git a/tests/resources/reftable/rebase-submodule/.gitted/objects/68/f6182f4c85d39e1309d97c7e456156dc9c0096 b/tests/resources/reftable/rebase-submodule/.gitted/objects/68/f6182f4c85d39e1309d97c7e456156dc9c0096 new file mode 100644 index 000000000..ed1de3ada Binary files /dev/null and b/tests/resources/reftable/rebase-submodule/.gitted/objects/68/f6182f4c85d39e1309d97c7e456156dc9c0096 differ diff --git a/tests/resources/reftable/rebase-submodule/.gitted/objects/7c/71f7606bd3bfb25d063c970804e7fc00b9605b b/tests/resources/reftable/rebase-submodule/.gitted/objects/7c/71f7606bd3bfb25d063c970804e7fc00b9605b new file mode 100644 index 000000000..ef923e714 Binary files /dev/null and b/tests/resources/reftable/rebase-submodule/.gitted/objects/7c/71f7606bd3bfb25d063c970804e7fc00b9605b differ diff --git a/tests/resources/reftable/rebase-submodule/.gitted/objects/7c/7bf85e978f1d18c0566f702d2cb7766b9c8d4f b/tests/resources/reftable/rebase-submodule/.gitted/objects/7c/7bf85e978f1d18c0566f702d2cb7766b9c8d4f new file mode 100644 index 000000000..fe8b15777 --- /dev/null +++ b/tests/resources/reftable/rebase-submodule/.gitted/objects/7c/7bf85e978f1d18c0566f702d2cb7766b9c8d4f @@ -0,0 +1 @@ +xN0Dd' \V\~/1rw5m|0 tntƺ%kcnu a:K,^W55K"Y+F̓y3YL8kfͮ3Z]I~K\>x]zm<~'1~ك:"GB4_yη|1_"fi \ No newline at end of file diff --git a/tests/resources/reftable/rebase/.gitted/objects/0f/5f6d3353be1a9966fa5767b7d604b051798224 b/tests/resources/reftable/rebase/.gitted/objects/0f/5f6d3353be1a9966fa5767b7d604b051798224 new file mode 100644 index 000000000..739aca383 Binary files /dev/null and b/tests/resources/reftable/rebase/.gitted/objects/0f/5f6d3353be1a9966fa5767b7d604b051798224 differ diff --git a/tests/resources/reftable/rebase/.gitted/objects/11/fac10ca1b9318ce361a0be0c3d889d777e299c b/tests/resources/reftable/rebase/.gitted/objects/11/fac10ca1b9318ce361a0be0c3d889d777e299c new file mode 100644 index 000000000..5af5474b5 Binary files /dev/null and b/tests/resources/reftable/rebase/.gitted/objects/11/fac10ca1b9318ce361a0be0c3d889d777e299c differ diff --git a/tests/resources/reftable/rebase/.gitted/objects/12/c084412b952396962eb420716df01022b847cc b/tests/resources/reftable/rebase/.gitted/objects/12/c084412b952396962eb420716df01022b847cc new file mode 100644 index 000000000..5244e469d --- /dev/null +++ b/tests/resources/reftable/rebase/.gitted/objects/12/c084412b952396962eb420716df01022b847cc @@ -0,0 +1,2 @@ +xKjC1)IB6^z YAQ0d Mm28 )!mJġ"MLye6.ggC8iUXIWC.g +8+ j҇<'澿AMZ4jVdFziem) ǗKU \ No newline at end of file diff --git a/tests/resources/reftable/rebase/.gitted/objects/12/f28ed978639d331269d9dc2b74e87db58e1057 b/tests/resources/reftable/rebase/.gitted/objects/12/f28ed978639d331269d9dc2b74e87db58e1057 new file mode 100644 index 000000000..b0dbc3e07 --- /dev/null +++ b/tests/resources/reftable/rebase/.gitted/objects/12/f28ed978639d331269d9dc2b74e87db58e1057 @@ -0,0 +1,3 @@ +xO9n0tWbp)KF&e:`\*$|?3,sݩmXX +c#ۤVBD.F1ڀR F +sBe'%>ڽnxpe+\ORO9vtmfy.pVonB#Vj \ No newline at end of file diff --git a/tests/resources/reftable/rebase/.gitted/objects/19/14d57ddf6c5c997664521cc94f190df46dc1c2 b/tests/resources/reftable/rebase/.gitted/objects/19/14d57ddf6c5c997664521cc94f190df46dc1c2 new file mode 100644 index 000000000..921f2cd88 Binary files /dev/null and b/tests/resources/reftable/rebase/.gitted/objects/19/14d57ddf6c5c997664521cc94f190df46dc1c2 differ diff --git a/tests/resources/reftable/rebase/.gitted/objects/1b/1d19799fcc89fa3cb821581fcf7f2e8fd2cc4d b/tests/resources/reftable/rebase/.gitted/objects/1b/1d19799fcc89fa3cb821581fcf7f2e8fd2cc4d new file mode 100644 index 000000000..3d206b0cc Binary files /dev/null and b/tests/resources/reftable/rebase/.gitted/objects/1b/1d19799fcc89fa3cb821581fcf7f2e8fd2cc4d differ diff --git a/tests/resources/reftable/rebase/.gitted/objects/1d/83f106355e4309a293e42ad2a2c4b8bdbe77ae b/tests/resources/reftable/rebase/.gitted/objects/1d/83f106355e4309a293e42ad2a2c4b8bdbe77ae new file mode 100644 index 000000000..6230fdf35 Binary files /dev/null and b/tests/resources/reftable/rebase/.gitted/objects/1d/83f106355e4309a293e42ad2a2c4b8bdbe77ae differ diff --git a/tests/resources/reftable/rebase/.gitted/objects/1f/2214c1b13b134d5508f41f6a3b77cc6a8f5182 b/tests/resources/reftable/rebase/.gitted/objects/1f/2214c1b13b134d5508f41f6a3b77cc6a8f5182 new file mode 100644 index 000000000..84b875c50 Binary files /dev/null and b/tests/resources/reftable/rebase/.gitted/objects/1f/2214c1b13b134d5508f41f6a3b77cc6a8f5182 differ diff --git a/tests/resources/reftable/rebase/.gitted/objects/20/db906c85e78c6dde82eb2ec6d3231c4b96fce8 b/tests/resources/reftable/rebase/.gitted/objects/20/db906c85e78c6dde82eb2ec6d3231c4b96fce8 new file mode 100644 index 000000000..2a908da61 Binary files /dev/null and b/tests/resources/reftable/rebase/.gitted/objects/20/db906c85e78c6dde82eb2ec6d3231c4b96fce8 differ diff --git a/tests/resources/reftable/rebase/.gitted/objects/22/adb22bef75a0371e85ff6d82e5e60e4b425501 b/tests/resources/reftable/rebase/.gitted/objects/22/adb22bef75a0371e85ff6d82e5e60e4b425501 new file mode 100644 index 000000000..7f17ef059 Binary files /dev/null and b/tests/resources/reftable/rebase/.gitted/objects/22/adb22bef75a0371e85ff6d82e5e60e4b425501 differ diff --git a/tests/resources/reftable/rebase/.gitted/objects/2a/a3ce842094e08ebac152b3d6d5b0fff39f9c6e b/tests/resources/reftable/rebase/.gitted/objects/2a/a3ce842094e08ebac152b3d6d5b0fff39f9c6e new file mode 100644 index 000000000..38eca43dc --- /dev/null +++ b/tests/resources/reftable/rebase/.gitted/objects/2a/a3ce842094e08ebac152b3d6d5b0fff39f9c6e @@ -0,0 +1 @@ +xMn! F@# 8RTeew!ńV}htHO/m[vg$H$bW >*jU̝{ R4d19sD\CbQ0M+mh78S=>0%:-‹ ֚NQ1M׺fTp0\:~'fUN \ No newline at end of file diff --git a/tests/resources/reftable/rebase/.gitted/objects/2b/4ebffd3111546d278bb5df62e5630930b605fb b/tests/resources/reftable/rebase/.gitted/objects/2b/4ebffd3111546d278bb5df62e5630930b605fb new file mode 100644 index 000000000..5bdfc1e29 Binary files /dev/null and b/tests/resources/reftable/rebase/.gitted/objects/2b/4ebffd3111546d278bb5df62e5630930b605fb differ diff --git a/tests/resources/reftable/rebase/.gitted/objects/30/69cc907e6294623e5917ef6de663928c1febfb b/tests/resources/reftable/rebase/.gitted/objects/30/69cc907e6294623e5917ef6de663928c1febfb new file mode 100644 index 000000000..edd86f721 --- /dev/null +++ b/tests/resources/reftable/rebase/.gitted/objects/30/69cc907e6294623e5917ef6de663928c1febfb @@ -0,0 +1 @@ +x;n1 DSR] 07.E[eldA7I_eOT!&Ɛ[U5RLPoz+Ab)iF8qۃ?+u餯>_@)n޸[Dz+' TG \ No newline at end of file diff --git a/tests/resources/reftable/rebase/.gitted/objects/32/52a0692ace4c4c709f22011227d9dc4845f289 b/tests/resources/reftable/rebase/.gitted/objects/32/52a0692ace4c4c709f22011227d9dc4845f289 new file mode 100644 index 000000000..2b2434f87 Binary files /dev/null and b/tests/resources/reftable/rebase/.gitted/objects/32/52a0692ace4c4c709f22011227d9dc4845f289 differ diff --git a/tests/resources/reftable/rebase/.gitted/objects/33/f915f9e4dbd9f4b24430e48731a59b45b15500 b/tests/resources/reftable/rebase/.gitted/objects/33/f915f9e4dbd9f4b24430e48731a59b45b15500 new file mode 100644 index 000000000..c33f179bf --- /dev/null +++ b/tests/resources/reftable/rebase/.gitted/objects/33/f915f9e4dbd9f4b24430e48731a59b45b15500 @@ -0,0 +1 @@ +xi1E*iVi@Hi@[®Lڏb܁.Z޾0YN"e18K}H!dG^H;I' ' WvD5{Px׾g{koG3W|/{{cFWmV3Q}G.zRsu1PHZ \ No newline at end of file diff --git a/tests/resources/reftable/rebase/.gitted/objects/34/86a9d4cdf0b7b4a702c199eed541dc3af13a03 b/tests/resources/reftable/rebase/.gitted/objects/34/86a9d4cdf0b7b4a702c199eed541dc3af13a03 new file mode 100644 index 000000000..fdbe16d10 --- /dev/null +++ b/tests/resources/reftable/rebase/.gitted/objects/34/86a9d4cdf0b7b4a702c199eed541dc3af13a03 @@ -0,0 +1 @@ +xMn0 ;),L-Э@ eҢ*Qu"##{'^>U!:g"\sL}fں?M_R0jMAb`5u+ '!` u&lÞA=Mk!Y,^#(.7*#QD1ɘ!Ic4~KRU%@/l4dH_:Ag$Jr#/n ex9)[t,^g11n;$w/ \ No newline at end of file diff --git a/tests/resources/reftable/rebase/.gitted/objects/3c/33b080bf75724c8899d8e703614cb59bfbd047 b/tests/resources/reftable/rebase/.gitted/objects/3c/33b080bf75724c8899d8e703614cb59bfbd047 new file mode 100644 index 000000000..8716898f8 Binary files /dev/null and b/tests/resources/reftable/rebase/.gitted/objects/3c/33b080bf75724c8899d8e703614cb59bfbd047 differ diff --git a/tests/resources/reftable/rebase/.gitted/objects/3d/a85aca38a95b44d77ef55a8deb445e49ba19b4 b/tests/resources/reftable/rebase/.gitted/objects/3d/a85aca38a95b44d77ef55a8deb445e49ba19b4 new file mode 100644 index 000000000..fa6d9468d Binary files /dev/null and b/tests/resources/reftable/rebase/.gitted/objects/3d/a85aca38a95b44d77ef55a8deb445e49ba19b4 differ diff --git a/tests/resources/reftable/rebase/.gitted/objects/3e/8989b5a16d5258c935d998ef0e6bb139cc4757 b/tests/resources/reftable/rebase/.gitted/objects/3e/8989b5a16d5258c935d998ef0e6bb139cc4757 new file mode 100644 index 000000000..1bbf138ef --- /dev/null +++ b/tests/resources/reftable/rebase/.gitted/objects/3e/8989b5a16d5258c935d998ef0e6bb139cc4757 @@ -0,0 +1,2 @@ +xKj1 )t1J&z%C'.\?n u[Pӊ"%C0+ozr +-&*V,e\b, fP spwstCdz涿 w\b̩I-5ShpU2w_T diff --git a/tests/resources/reftable/rebase/.gitted/objects/3f/05a038dd89f51ba2b3d7b14ba1f8c00f0e31ac b/tests/resources/reftable/rebase/.gitted/objects/3f/05a038dd89f51ba2b3d7b14ba1f8c00f0e31ac new file mode 100644 index 000000000..26bd353f7 Binary files /dev/null and b/tests/resources/reftable/rebase/.gitted/objects/3f/05a038dd89f51ba2b3d7b14ba1f8c00f0e31ac differ diff --git a/tests/resources/reftable/rebase/.gitted/objects/3f/d8d53cf02de539b9a25a5941030451f76a152f b/tests/resources/reftable/rebase/.gitted/objects/3f/d8d53cf02de539b9a25a5941030451f76a152f new file mode 100644 index 000000000..91c4d957e Binary files /dev/null and b/tests/resources/reftable/rebase/.gitted/objects/3f/d8d53cf02de539b9a25a5941030451f76a152f differ diff --git a/tests/resources/reftable/rebase/.gitted/objects/40/0d89e8ee6cd91b67b1f45de1ca190e1c580c6f b/tests/resources/reftable/rebase/.gitted/objects/40/0d89e8ee6cd91b67b1f45de1ca190e1c580c6f new file mode 100644 index 000000000..f67475370 --- /dev/null +++ b/tests/resources/reftable/rebase/.gitted/objects/40/0d89e8ee6cd91b67b1f45de1ca190e1c580c6f @@ -0,0 +1 @@ +xO;0 e)|PbadqC6  GzTio3XŲ !tܳ%bqsQA{O$>I1aPTbM|{Y,\eZ :cT#Ow!lm4s)2bZ O=W>{VT \ No newline at end of file diff --git a/tests/resources/reftable/rebase/.gitted/objects/41/4dfc71ead79c07acd4ea47fecf91f289afc4b9 b/tests/resources/reftable/rebase/.gitted/objects/41/4dfc71ead79c07acd4ea47fecf91f289afc4b9 new file mode 100644 index 000000000..546815ea8 Binary files /dev/null and b/tests/resources/reftable/rebase/.gitted/objects/41/4dfc71ead79c07acd4ea47fecf91f289afc4b9 differ diff --git a/tests/resources/reftable/rebase/.gitted/objects/41/c5a0a761bb4a7670924c1af0800b30fe9a21be b/tests/resources/reftable/rebase/.gitted/objects/41/c5a0a761bb4a7670924c1af0800b30fe9a21be new file mode 100644 index 000000000..ecb399264 Binary files /dev/null and b/tests/resources/reftable/rebase/.gitted/objects/41/c5a0a761bb4a7670924c1af0800b30fe9a21be differ diff --git a/tests/resources/reftable/rebase/.gitted/objects/42/cdad903aef3e7b614675e6584a8be417941911 b/tests/resources/reftable/rebase/.gitted/objects/42/cdad903aef3e7b614675e6584a8be417941911 new file mode 100644 index 000000000..99b5e6d2c Binary files /dev/null and b/tests/resources/reftable/rebase/.gitted/objects/42/cdad903aef3e7b614675e6584a8be417941911 differ diff --git a/tests/resources/reftable/rebase/.gitted/objects/44/c801fe026abbc141b52a4dec5df15fa98249c6 b/tests/resources/reftable/rebase/.gitted/objects/44/c801fe026abbc141b52a4dec5df15fa98249c6 new file mode 100644 index 000000000..eaf24ae46 Binary files /dev/null and b/tests/resources/reftable/rebase/.gitted/objects/44/c801fe026abbc141b52a4dec5df15fa98249c6 differ diff --git a/tests/resources/reftable/rebase/.gitted/objects/4b/21eb6eeeec7f8fc89a1d334faff9bd5f5f8c34 b/tests/resources/reftable/rebase/.gitted/objects/4b/21eb6eeeec7f8fc89a1d334faff9bd5f5f8c34 new file mode 100644 index 000000000..0c9f4b944 --- /dev/null +++ b/tests/resources/reftable/rebase/.gitted/objects/4b/21eb6eeeec7f8fc89a1d334faff9bd5f5f8c34 @@ -0,0 +1,2 @@ +x]J1})JOҙL`At:3,^(+68Ts 7L%`I-Ƽi@.$TRF +l8Q8iJ:g<"[?-wLԋIz{Яbphf:asƼ|TuB빖*-s!X\Utܨ9NԜrS57j \ No newline at end of file diff --git a/tests/resources/reftable/rebase/.gitted/objects/6d/fb87d20f3dbca02da4a39890114fd9ba6a51e7 b/tests/resources/reftable/rebase/.gitted/objects/6d/fb87d20f3dbca02da4a39890114fd9ba6a51e7 new file mode 100644 index 000000000..039c669aa Binary files /dev/null and b/tests/resources/reftable/rebase/.gitted/objects/6d/fb87d20f3dbca02da4a39890114fd9ba6a51e7 differ diff --git a/tests/resources/reftable/rebase/.gitted/objects/73/f346c88d965227a03c0af8d555870b8c5021d4 b/tests/resources/reftable/rebase/.gitted/objects/73/f346c88d965227a03c0af8d555870b8c5021d4 new file mode 100644 index 000000000..215df59d8 Binary files /dev/null and b/tests/resources/reftable/rebase/.gitted/objects/73/f346c88d965227a03c0af8d555870b8c5021d4 differ diff --git a/tests/resources/reftable/rebase/.gitted/objects/74/0a804e8963759c98e5b8cb912e15ae74a7a4a6 b/tests/resources/reftable/rebase/.gitted/objects/74/0a804e8963759c98e5b8cb912e15ae74a7a4a6 new file mode 100644 index 000000000..b81718279 Binary files /dev/null and b/tests/resources/reftable/rebase/.gitted/objects/74/0a804e8963759c98e5b8cb912e15ae74a7a4a6 differ diff --git a/tests/resources/reftable/rebase/.gitted/objects/77/0f14546ee2563a26c52afa5cc4139a96e5d360 b/tests/resources/reftable/rebase/.gitted/objects/77/0f14546ee2563a26c52afa5cc4139a96e5d360 new file mode 100644 index 000000000..6091d54a0 Binary files /dev/null and b/tests/resources/reftable/rebase/.gitted/objects/77/0f14546ee2563a26c52afa5cc4139a96e5d360 differ diff --git a/tests/resources/reftable/rebase/.gitted/objects/78/c320b06544e23d786a9ec84ee93861f2933094 b/tests/resources/reftable/rebase/.gitted/objects/78/c320b06544e23d786a9ec84ee93861f2933094 new file mode 100644 index 000000000..afa39fb97 Binary files /dev/null and b/tests/resources/reftable/rebase/.gitted/objects/78/c320b06544e23d786a9ec84ee93861f2933094 differ diff --git a/tests/resources/reftable/rebase/.gitted/objects/79/e28694aae0d3064b06f96a5207b943a2357f07 b/tests/resources/reftable/rebase/.gitted/objects/79/e28694aae0d3064b06f96a5207b943a2357f07 new file mode 100644 index 000000000..17ff306f1 Binary files /dev/null and b/tests/resources/reftable/rebase/.gitted/objects/79/e28694aae0d3064b06f96a5207b943a2357f07 differ diff --git a/tests/resources/reftable/rebase/.gitted/objects/7a/05900f340af0252aaa4e34941f040c5d2fe7f7 b/tests/resources/reftable/rebase/.gitted/objects/7a/05900f340af0252aaa4e34941f040c5d2fe7f7 new file mode 100644 index 000000000..43201f89b Binary files /dev/null and b/tests/resources/reftable/rebase/.gitted/objects/7a/05900f340af0252aaa4e34941f040c5d2fe7f7 differ diff --git a/tests/resources/reftable/rebase/.gitted/objects/7a/677f6201c8f9d46bdfe1f4b08cb504e360a34e b/tests/resources/reftable/rebase/.gitted/objects/7a/677f6201c8f9d46bdfe1f4b08cb504e360a34e new file mode 100644 index 000000000..dc2fd5a36 Binary files /dev/null and b/tests/resources/reftable/rebase/.gitted/objects/7a/677f6201c8f9d46bdfe1f4b08cb504e360a34e differ diff --git a/tests/resources/reftable/rebase/.gitted/objects/7c/7bf85e978f1d18c0566f702d2cb7766b9c8d4f b/tests/resources/reftable/rebase/.gitted/objects/7c/7bf85e978f1d18c0566f702d2cb7766b9c8d4f new file mode 100644 index 000000000..fe8b15777 --- /dev/null +++ b/tests/resources/reftable/rebase/.gitted/objects/7c/7bf85e978f1d18c0566f702d2cb7766b9c8d4f @@ -0,0 +1 @@ +xN0Dd' \V\~/1rw5m|0 tntƺ%kcnu a:K,^W55A\~km!? |]78/ww\30 0Mnq?ggbs/Bj |5_X$W \ No newline at end of file diff --git a/tests/resources/reftable/rebase/.gitted/objects/80/32d630f37266bace093e353f7b97d7f8b20950 b/tests/resources/reftable/rebase/.gitted/objects/80/32d630f37266bace093e353f7b97d7f8b20950 new file mode 100644 index 000000000..07050dfd4 Binary files /dev/null and b/tests/resources/reftable/rebase/.gitted/objects/80/32d630f37266bace093e353f7b97d7f8b20950 differ diff --git a/tests/resources/reftable/rebase/.gitted/objects/80/dce0e74f0534811db734a68c23b49f98584d7a b/tests/resources/reftable/rebase/.gitted/objects/80/dce0e74f0534811db734a68c23b49f98584d7a new file mode 100644 index 000000000..1b98b0a6f --- /dev/null +++ b/tests/resources/reftable/rebase/.gitted/objects/80/dce0e74f0534811db734a68c23b49f98584d7a @@ -0,0 +1,2 @@ +xERN0 朧TH* mj5KB0qv׵aUjgV#B0A>@2Qbpd^x:a +6Ok% <î}?*= g_YGv '{d ~W&FH~䦨٨m|JxM++8Od&8#J,%2IRuD8!tl/0x'FxᮜA2Keyq9ܪ \ No newline at end of file diff --git a/tests/resources/reftable/rebase/.gitted/objects/83/53b9f9deff7c707f280e0f656c80772cca7cd9 b/tests/resources/reftable/rebase/.gitted/objects/83/53b9f9deff7c707f280e0f656c80772cca7cd9 new file mode 100644 index 000000000..a4a7e3aa3 --- /dev/null +++ b/tests/resources/reftable/rebase/.gitted/objects/83/53b9f9deff7c707f280e0f656c80772cca7cd9 @@ -0,0 +1,2 @@ +xMAj0E)L6]Bh@q,*kTi\7Ji ۇ}y<|:]cΗwԯဗhlt+ C"d%P* CF; X<rl6tatB# PeJŕehߡaW +o1DQ^#pB~ЭZ1ɶ_('*g6kד* v,0;)FJy^v.=E9\MJ_mAͣΰc%]Do= .# \ No newline at end of file diff --git a/tests/resources/reftable/rebase/.gitted/objects/85/258e426a341cc1aa035ac7f6d18f84fed2ab38 b/tests/resources/reftable/rebase/.gitted/objects/85/258e426a341cc1aa035ac7f6d18f84fed2ab38 new file mode 100644 index 000000000..af1106d6a Binary files /dev/null and b/tests/resources/reftable/rebase/.gitted/objects/85/258e426a341cc1aa035ac7f6d18f84fed2ab38 differ diff --git a/tests/resources/reftable/rebase/.gitted/objects/85/f34ce9ca9e0f33d4146afec9cbe5a26757500a b/tests/resources/reftable/rebase/.gitted/objects/85/f34ce9ca9e0f33d4146afec9cbe5a26757500a new file mode 100644 index 000000000..03e75165a Binary files /dev/null and b/tests/resources/reftable/rebase/.gitted/objects/85/f34ce9ca9e0f33d4146afec9cbe5a26757500a differ diff --git a/tests/resources/reftable/rebase/.gitted/objects/86/a5415741ed3754ccb0cac1fc19fd82587840a4 b/tests/resources/reftable/rebase/.gitted/objects/86/a5415741ed3754ccb0cac1fc19fd82587840a4 new file mode 100644 index 000000000..fe00a22e3 Binary files /dev/null and b/tests/resources/reftable/rebase/.gitted/objects/86/a5415741ed3754ccb0cac1fc19fd82587840a4 differ diff --git a/tests/resources/reftable/rebase/.gitted/objects/8d/1f13f93c4995760ac07d129246ac1ff64c0be9 b/tests/resources/reftable/rebase/.gitted/objects/8d/1f13f93c4995760ac07d129246ac1ff64c0be9 new file mode 100644 index 000000000..a66cfccb2 --- /dev/null +++ b/tests/resources/reftable/rebase/.gitted/objects/8d/1f13f93c4995760ac07d129246ac1ff64c0be9 @@ -0,0 +1,2 @@ +xAn0 {+M[>@⃣Q-vgh[ץo0P"NX*H4Y1̩R.&_;MQh0$+Cc$`ҚA6lK[ +o:߾Gi1tMiE/Ao0S \ No newline at end of file diff --git a/tests/resources/reftable/rebase/.gitted/objects/8d/95ea62e621f1d38d230d9e7d206e41096d76af b/tests/resources/reftable/rebase/.gitted/objects/8d/95ea62e621f1d38d230d9e7d206e41096d76af new file mode 100644 index 000000000..464de7c1c Binary files /dev/null and b/tests/resources/reftable/rebase/.gitted/objects/8d/95ea62e621f1d38d230d9e7d206e41096d76af differ diff --git a/tests/resources/reftable/rebase/.gitted/objects/8f/4de6c781b9ff9cedfd7f9f9f224e744f97b259 b/tests/resources/reftable/rebase/.gitted/objects/8f/4de6c781b9ff9cedfd7f9f9f224e744f97b259 new file mode 100644 index 000000000..faa938958 --- /dev/null +++ b/tests/resources/reftable/rebase/.gitted/objects/8f/4de6c781b9ff9cedfd7f9f9f224e744f97b259 @@ -0,0 +1 @@ +x+)JMU0d040031QHJ,I+(a|6eՃll?w:/2gJ)LM/HM+tS5W^;?S#;a9$j \ No newline at end of file diff --git a/tests/resources/reftable/rebase/.gitted/objects/91/4f3c604d1098847b7fe275f659ee329878153f b/tests/resources/reftable/rebase/.gitted/objects/91/4f3c604d1098847b7fe275f659ee329878153f new file mode 100644 index 000000000..726bf9177 Binary files /dev/null and b/tests/resources/reftable/rebase/.gitted/objects/91/4f3c604d1098847b7fe275f659ee329878153f differ diff --git a/tests/resources/reftable/rebase/.gitted/objects/92/54a37fde7e97f9a28dee2967fdb2c5d1ed94e9 b/tests/resources/reftable/rebase/.gitted/objects/92/54a37fde7e97f9a28dee2967fdb2c5d1ed94e9 new file mode 100644 index 000000000..10d6c134f --- /dev/null +++ b/tests/resources/reftable/rebase/.gitted/objects/92/54a37fde7e97f9a28dee2967fdb2c5d1ed94e9 @@ -0,0 +1 @@ +xERn0 Y_0z+Z'5ue(VRdp8Av{A G!zQúZ#M oj[w&PѫN)VuP,FU1fpyѳhok}WZ` h ?Un59gsK aW50\5Lˤ,jGH.{ 0*KBCh ۾m3.HƖ4_2㹉 ZO|kp4u#*FpI`D`bTWk.SsM] KG޴I{VG 8#J ;˽'P(b& .dopѻvќK՘#+ {v?wǃ \ No newline at end of file diff --git a/tests/resources/reftable/rebase/.gitted/objects/95/39b2cc291d6a6b1b266df8474d31fdd344dd79 b/tests/resources/reftable/rebase/.gitted/objects/95/39b2cc291d6a6b1b266df8474d31fdd344dd79 new file mode 100644 index 000000000..964943473 Binary files /dev/null and b/tests/resources/reftable/rebase/.gitted/objects/95/39b2cc291d6a6b1b266df8474d31fdd344dd79 differ diff --git a/tests/resources/reftable/rebase/.gitted/objects/9a/8535dfcaf7554c728d874f047c5461fb2c71d1 b/tests/resources/reftable/rebase/.gitted/objects/9a/8535dfcaf7554c728d874f047c5461fb2c71d1 new file mode 100644 index 000000000..d997426b2 Binary files /dev/null and b/tests/resources/reftable/rebase/.gitted/objects/9a/8535dfcaf7554c728d874f047c5461fb2c71d1 differ diff --git a/tests/resources/reftable/rebase/.gitted/objects/9c/d483e7da23819d7f71d24e9843812337886753 b/tests/resources/reftable/rebase/.gitted/objects/9c/d483e7da23819d7f71d24e9843812337886753 new file mode 100644 index 000000000..d16845506 --- /dev/null +++ b/tests/resources/reftable/rebase/.gitted/objects/9c/d483e7da23819d7f71d24e9843812337886753 @@ -0,0 +1 @@ +xMAj0E)L6]ڀہv)XTѨҨo_JiZ-ۇ}U>Q.RK;p˱,kVKs|B@v]$_}U Sun0zQ#PمȼP%gR۾,whX21FN!.JV002WT2rnI]X6kRVdd')Q[٩H<ew7)6 i(cvdmt7C>&"r?v \ No newline at end of file diff --git a/tests/resources/reftable/rebase/.gitted/objects/a0/1a6ee390f65d834375e072952deaee0c5e92f7 b/tests/resources/reftable/rebase/.gitted/objects/a0/1a6ee390f65d834375e072952deaee0c5e92f7 new file mode 100644 index 000000000..eb98c9da5 Binary files /dev/null and b/tests/resources/reftable/rebase/.gitted/objects/a0/1a6ee390f65d834375e072952deaee0c5e92f7 differ diff --git a/tests/resources/reftable/rebase/.gitted/objects/a0/fa65f96c1e3bdc7287e334229279dcc1248fa4 b/tests/resources/reftable/rebase/.gitted/objects/a0/fa65f96c1e3bdc7287e334229279dcc1248fa4 new file mode 100644 index 000000000..fd43545ce --- /dev/null +++ b/tests/resources/reftable/rebase/.gitted/objects/a0/fa65f96c1e3bdc7287e334229279dcc1248fa4 @@ -0,0 +1,3 @@ +xERn ޙDMS6iqL S|~tuRPZh~%ı9>|m۴ )VUAX*P3\j }[=yqgX$a\HL<+M#Hf+T2-3Wft]̣ +aB=d9:])$Ml Te>bykpmEWF +L*XFFS$8SEzG\{3 C d,96ܣ왚;|╔dd9Y։ȏ'Aw@0hђAAEs0.D2Yõɯ9̃ \ No newline at end of file diff --git a/tests/resources/reftable/rebase/.gitted/objects/a1/25b9b655932711abceaf8962948e6b601d67b6 b/tests/resources/reftable/rebase/.gitted/objects/a1/25b9b655932711abceaf8962948e6b601d67b6 new file mode 100644 index 000000000..50bcee109 Binary files /dev/null and b/tests/resources/reftable/rebase/.gitted/objects/a1/25b9b655932711abceaf8962948e6b601d67b6 differ diff --git a/tests/resources/reftable/rebase/.gitted/objects/a7/00acc970eccccc73be53cd269462176544e6d1 b/tests/resources/reftable/rebase/.gitted/objects/a7/00acc970eccccc73be53cd269462176544e6d1 new file mode 100644 index 000000000..e5c62dba7 Binary files /dev/null and b/tests/resources/reftable/rebase/.gitted/objects/a7/00acc970eccccc73be53cd269462176544e6d1 differ diff --git a/tests/resources/reftable/rebase/.gitted/objects/a7/b066537e6be7109abfe4ff97b675d4e077da20 b/tests/resources/reftable/rebase/.gitted/objects/a7/b066537e6be7109abfe4ff97b675d4e077da20 new file mode 100644 index 000000000..54f9b6617 Binary files /dev/null and b/tests/resources/reftable/rebase/.gitted/objects/a7/b066537e6be7109abfe4ff97b675d4e077da20 differ diff --git a/tests/resources/reftable/rebase/.gitted/objects/aa/4c42aecdfc7cd989bbc3209934ea7cda3f4d88 b/tests/resources/reftable/rebase/.gitted/objects/aa/4c42aecdfc7cd989bbc3209934ea7cda3f4d88 new file mode 100644 index 000000000..628c2d3a1 --- /dev/null +++ b/tests/resources/reftable/rebase/.gitted/objects/aa/4c42aecdfc7cd989bbc3209934ea7cda3f4d88 @@ -0,0 +1 @@ +x B1D=m@=؁ l~#bFo3o`^ZK~՛dfL61G9)̘1568ezeO:wMzɡZ͠Csb. fԮ2o! Fw \ No newline at end of file diff --git a/tests/resources/reftable/rebase/.gitted/objects/ab/25a53ef5622d443ecb0492b7516725f0deac8f b/tests/resources/reftable/rebase/.gitted/objects/ab/25a53ef5622d443ecb0492b7516725f0deac8f new file mode 100644 index 000000000..83ef51e26 Binary files /dev/null and b/tests/resources/reftable/rebase/.gitted/objects/ab/25a53ef5622d443ecb0492b7516725f0deac8f differ diff --git a/tests/resources/reftable/rebase/.gitted/objects/ad/c97cfb874cdfb9d5ab17b54f3771dea6e02ccf b/tests/resources/reftable/rebase/.gitted/objects/ad/c97cfb874cdfb9d5ab17b54f3771dea6e02ccf new file mode 100644 index 000000000..cc7ccd086 Binary files /dev/null and b/tests/resources/reftable/rebase/.gitted/objects/ad/c97cfb874cdfb9d5ab17b54f3771dea6e02ccf differ diff --git a/tests/resources/reftable/rebase/.gitted/objects/ae/87cae12879a3c37d7cc994afc6395bcb0eaf99 b/tests/resources/reftable/rebase/.gitted/objects/ae/87cae12879a3c37d7cc994afc6395bcb0eaf99 new file mode 100644 index 000000000..5c8469eb9 Binary files /dev/null and b/tests/resources/reftable/rebase/.gitted/objects/ae/87cae12879a3c37d7cc994afc6395bcb0eaf99 differ diff --git a/tests/resources/reftable/rebase/.gitted/objects/b1/46bd7608eac53d9bf9e1a6963543588b555c64 b/tests/resources/reftable/rebase/.gitted/objects/b1/46bd7608eac53d9bf9e1a6963543588b555c64 new file mode 100644 index 000000000..3e4b975a9 --- /dev/null +++ b/tests/resources/reftable/rebase/.gitted/objects/b1/46bd7608eac53d9bf9e1a6963543588b555c64 @@ -0,0 +1 @@ +xj1 D{W,eB.=!_7syÔmk@婢Ƃ3NCyds.% !w]YƯi9bU)bY-eN}i;|ק~:;OҶ`2#|t挻ZAo0cJT/ \ No newline at end of file diff --git a/tests/resources/reftable/rebase/.gitted/objects/b1/b94ec02f8ed87d0efa4c65fb38d5d6da7e8b32 b/tests/resources/reftable/rebase/.gitted/objects/b1/b94ec02f8ed87d0efa4c65fb38d5d6da7e8b32 new file mode 100644 index 000000000..d15c02246 Binary files /dev/null and b/tests/resources/reftable/rebase/.gitted/objects/b1/b94ec02f8ed87d0efa4c65fb38d5d6da7e8b32 differ diff --git a/tests/resources/reftable/rebase/.gitted/objects/b6/72b141d48c369fee6c4deeb32a904387594365 b/tests/resources/reftable/rebase/.gitted/objects/b6/72b141d48c369fee6c4deeb32a904387594365 new file mode 100644 index 000000000..d8cdb71ae Binary files /dev/null and b/tests/resources/reftable/rebase/.gitted/objects/b6/72b141d48c369fee6c4deeb32a904387594365 differ diff --git a/tests/resources/reftable/rebase/.gitted/objects/b7/c536a5883c8adaeb34d5e198c5a3dbbdc608b5 b/tests/resources/reftable/rebase/.gitted/objects/b7/c536a5883c8adaeb34d5e198c5a3dbbdc608b5 new file mode 100644 index 000000000..b59498472 Binary files /dev/null and b/tests/resources/reftable/rebase/.gitted/objects/b7/c536a5883c8adaeb34d5e198c5a3dbbdc608b5 differ diff --git a/tests/resources/reftable/rebase/.gitted/objects/b9/f72b9158fa8c49fb4e4c10b26817ed867be803 b/tests/resources/reftable/rebase/.gitted/objects/b9/f72b9158fa8c49fb4e4c10b26817ed867be803 new file mode 100644 index 000000000..970166755 --- /dev/null +++ b/tests/resources/reftable/rebase/.gitted/objects/b9/f72b9158fa8c49fb4e4c10b26817ed867be803 @@ -0,0 +1,3 @@ +xO;N1 S +d;Nf"! %=aFb&'{_[/}:7)y֤}`Bb.2]BӣCt3Gʲ$|QuIj4D8]| lctׄDFVsFsN킁\RoV< \ No newline at end of file diff --git a/tests/resources/reftable/rebase/.gitted/objects/d6/b9ec0dfb972a6815ace42545cde5f2631cd776 b/tests/resources/reftable/rebase/.gitted/objects/d6/b9ec0dfb972a6815ace42545cde5f2631cd776 new file mode 100644 index 000000000..123970457 Binary files /dev/null and b/tests/resources/reftable/rebase/.gitted/objects/d6/b9ec0dfb972a6815ace42545cde5f2631cd776 differ diff --git a/tests/resources/reftable/rebase/.gitted/objects/d9/c5185186d95d233dc007c1927cb3bdd6cde35b b/tests/resources/reftable/rebase/.gitted/objects/d9/c5185186d95d233dc007c1927cb3bdd6cde35b new file mode 100644 index 000000000..3c340db84 Binary files /dev/null and b/tests/resources/reftable/rebase/.gitted/objects/d9/c5185186d95d233dc007c1927cb3bdd6cde35b differ diff --git a/tests/resources/reftable/rebase/.gitted/objects/da/82b3a60c50cf5ac524ec3000d743447329465d b/tests/resources/reftable/rebase/.gitted/objects/da/82b3a60c50cf5ac524ec3000d743447329465d new file mode 100644 index 000000000..352a13ad3 Binary files /dev/null and b/tests/resources/reftable/rebase/.gitted/objects/da/82b3a60c50cf5ac524ec3000d743447329465d differ diff --git a/tests/resources/reftable/rebase/.gitted/objects/da/9c51a23d02d931a486f45ad18cda05cf5d2b94 b/tests/resources/reftable/rebase/.gitted/objects/da/9c51a23d02d931a486f45ad18cda05cf5d2b94 new file mode 100644 index 000000000..85b78eed5 --- /dev/null +++ b/tests/resources/reftable/rebase/.gitted/objects/da/9c51a23d02d931a486f45ad18cda05cf5d2b94 @@ -0,0 +1,2 @@ +x;!9\@3@b1X1+WڲM_!5[K +clʑ*ICuO+:P,q Py/"P'QٯmS}ږGIG+m9h8!bԹY<4YS \ No newline at end of file diff --git a/tests/resources/reftable/rebase/.gitted/objects/dc/12ac1e10f2be70e8ecd52132a08da98a309c3a b/tests/resources/reftable/rebase/.gitted/objects/dc/12ac1e10f2be70e8ecd52132a08da98a309c3a new file mode 100644 index 000000000..9907248f8 --- /dev/null +++ b/tests/resources/reftable/rebase/.gitted/objects/dc/12ac1e10f2be70e8ecd52132a08da98a309c3a @@ -0,0 +1 @@ +xMJ1]ϤAd@\UICwLDQ/mUAI1eqU^ADbEP0 CFW%V&:1wFaC]F:Ti_28/RRpq2yвp+w Q@ԫ.`P 0_BR-&{YZ怩pP>{YiSɈH1RZɳ3ypRJ[gpM1ny_ ZNkb? \ No newline at end of file diff --git a/tests/resources/reftable/rebase/.gitted/objects/ec/725f5639730640f91cd0be5f2d6d7ac5d69c79 b/tests/resources/reftable/rebase/.gitted/objects/ec/725f5639730640f91cd0be5f2d6d7ac5d69c79 new file mode 100644 index 000000000..0fb3334db Binary files /dev/null and b/tests/resources/reftable/rebase/.gitted/objects/ec/725f5639730640f91cd0be5f2d6d7ac5d69c79 differ diff --git a/tests/resources/reftable/rebase/.gitted/objects/ed/f7b3ffde1624c60d2d6b1a2bb792d86de172e0 b/tests/resources/reftable/rebase/.gitted/objects/ed/f7b3ffde1624c60d2d6b1a2bb792d86de172e0 new file mode 100644 index 000000000..e2e98d6d8 --- /dev/null +++ b/tests/resources/reftable/rebase/.gitted/objects/ed/f7b3ffde1624c60d2d6b1a2bb792d86de172e0 @@ -0,0 +1,3 @@ +xOKN!u)h +ct f?8fb8{}o:`I0U…ZbH-PKўhE k=t@LrBق>!EnDph~K?C~!pSCoz3 +!D <轛;1]d~juZU \ No newline at end of file diff --git a/tests/resources/reftable/rebase/.gitted/objects/ee/23c5eeedadf8595c0ff60a366d970a165e373d b/tests/resources/reftable/rebase/.gitted/objects/ee/23c5eeedadf8595c0ff60a366d970a165e373d new file mode 100644 index 000000000..b32600f78 Binary files /dev/null and b/tests/resources/reftable/rebase/.gitted/objects/ee/23c5eeedadf8595c0ff60a366d970a165e373d differ diff --git a/tests/resources/reftable/rebase/.gitted/objects/ee/f0edde5daa94da5f297d4ddb5dfbc1980f0902 b/tests/resources/reftable/rebase/.gitted/objects/ee/f0edde5daa94da5f297d4ddb5dfbc1980f0902 new file mode 100644 index 000000000..e9b3f58c6 Binary files /dev/null and b/tests/resources/reftable/rebase/.gitted/objects/ee/f0edde5daa94da5f297d4ddb5dfbc1980f0902 differ diff --git a/tests/resources/reftable/rebase/.gitted/objects/ef/ad0b11c47cb2f0220cbd6f5b0f93bb99064b00 b/tests/resources/reftable/rebase/.gitted/objects/ef/ad0b11c47cb2f0220cbd6f5b0f93bb99064b00 new file mode 100644 index 000000000..285e14056 --- /dev/null +++ b/tests/resources/reftable/rebase/.gitted/objects/ef/ad0b11c47cb2f0220cbd6f5b0f93bb99064b00 @@ -0,0 +1 @@ +x=n0 3@ d.D&l^jt{?J[ץ%:]r)I`_Lϖٴ|a3F1H"xfoXb%&'~k;|o+\nm=gzg^K[3D> ^خq.@1qV \ No newline at end of file diff --git a/tests/resources/reftable/rebase/.gitted/objects/f5/56d5fef35003561dc0b64b37057d7541239105 b/tests/resources/reftable/rebase/.gitted/objects/f5/56d5fef35003561dc0b64b37057d7541239105 new file mode 100644 index 000000000..f4143e1f5 Binary files /dev/null and b/tests/resources/reftable/rebase/.gitted/objects/f5/56d5fef35003561dc0b64b37057d7541239105 differ diff --git a/tests/resources/reftable/rebase/.gitted/objects/f6/3fa37e285bd11b0a7b48fa584a4091814a3ada b/tests/resources/reftable/rebase/.gitted/objects/f6/3fa37e285bd11b0a7b48fa584a4091814a3ada new file mode 100644 index 000000000..e650383a2 Binary files /dev/null and b/tests/resources/reftable/rebase/.gitted/objects/f6/3fa37e285bd11b0a7b48fa584a4091814a3ada differ diff --git a/tests/resources/reftable/rebase/.gitted/objects/f7/5c193a1df47186727179f24867bc4d27a8991f b/tests/resources/reftable/rebase/.gitted/objects/f7/5c193a1df47186727179f24867bc4d27a8991f new file mode 100644 index 000000000..618cb6814 Binary files /dev/null and b/tests/resources/reftable/rebase/.gitted/objects/f7/5c193a1df47186727179f24867bc4d27a8991f differ diff --git a/tests/resources/reftable/rebase/.gitted/objects/f8/7d14a4a236582a0278a916340a793714256864 b/tests/resources/reftable/rebase/.gitted/objects/f8/7d14a4a236582a0278a916340a793714256864 new file mode 100644 index 000000000..1d29712c5 --- /dev/null +++ b/tests/resources/reftable/rebase/.gitted/objects/f8/7d14a4a236582a0278a916340a793714256864 @@ -0,0 +1,2 @@ +xKAD])Uqҝ6Жz}an0N1K~h[#Ub4cPLƼijGE|i[WIy!anl޸S&> +O{T \ No newline at end of file diff --git a/tests/resources/reftable/rebase/.gitted/objects/fc/e0584b379f535e50e036db587db71884ea6b36 b/tests/resources/reftable/rebase/.gitted/objects/fc/e0584b379f535e50e036db587db71884ea6b36 new file mode 100644 index 000000000..ce8b2fb54 Binary files /dev/null and b/tests/resources/reftable/rebase/.gitted/objects/fc/e0584b379f535e50e036db587db71884ea6b36 differ diff --git a/tests/resources/reftable/rebase/.gitted/objects/ff/b36e513f5fdf8a6ba850a20142676a2ac4807d b/tests/resources/reftable/rebase/.gitted/objects/ff/b36e513f5fdf8a6ba850a20142676a2ac4807d new file mode 100644 index 000000000..f655d12ea Binary files /dev/null and b/tests/resources/reftable/rebase/.gitted/objects/ff/b36e513f5fdf8a6ba850a20142676a2ac4807d differ diff --git a/tests/resources/reftable/rebase/.gitted/objects/ff/dfa89389040a87008c4ab1834120d3046daaea b/tests/resources/reftable/rebase/.gitted/objects/ff/dfa89389040a87008c4ab1834120d3046daaea new file mode 100644 index 000000000..54c938e2e Binary files /dev/null and b/tests/resources/reftable/rebase/.gitted/objects/ff/dfa89389040a87008c4ab1834120d3046daaea differ diff --git a/tests/resources/reftable/rebase/.gitted/refs/heads b/tests/resources/reftable/rebase/.gitted/refs/heads new file mode 100644 index 000000000..3e639a56a --- /dev/null +++ b/tests/resources/reftable/rebase/.gitted/refs/heads @@ -0,0 +1 @@ +this repository uses the reftable format diff --git a/tests/resources/reftable/rebase/.gitted/reftable/0x000000000001-0x000000000001-0a16f078.ref b/tests/resources/reftable/rebase/.gitted/reftable/0x000000000001-0x000000000001-0a16f078.ref new file mode 100644 index 000000000..e64f104b0 Binary files /dev/null and b/tests/resources/reftable/rebase/.gitted/reftable/0x000000000001-0x000000000001-0a16f078.ref differ diff --git a/tests/resources/reftable/rebase/.gitted/reftable/tables.list b/tests/resources/reftable/rebase/.gitted/reftable/tables.list new file mode 100644 index 000000000..ed986189e --- /dev/null +++ b/tests/resources/reftable/rebase/.gitted/reftable/tables.list @@ -0,0 +1 @@ +0x000000000001-0x000000000001-0a16f078.ref diff --git a/tests/resources/reftable/rebase/asparagus.txt b/tests/resources/reftable/rebase/asparagus.txt new file mode 100644 index 000000000..67ed7afb2 --- /dev/null +++ b/tests/resources/reftable/rebase/asparagus.txt @@ -0,0 +1,10 @@ +ASPARAGUS SOUP. + +TAKE FOUR LARGE BUNCHES of asparagus, scrape it nicely, cut off one inch +OF THE TOPS, and lay them in water, chop the stalks and put them on the +FIRE WITH A PIECE OF BACON, a large onion cut up, and pepper and salt; +ADD TWO QUARTS OF WATER, boil them till the stalks are quite soft, then +PULP THEM THROUGH A SIEVE, and strain the water to it, which must be put +back in the pot; put into it a chicken cut up, with the tops of +asparagus which had been laid by, boil it until these last articles are +sufficiently done, thicken with flour, butter and milk, and serve it up. diff --git a/tests/resources/reftable/rebase/beef.txt b/tests/resources/reftable/rebase/beef.txt new file mode 100644 index 000000000..68f6182f4 --- /dev/null +++ b/tests/resources/reftable/rebase/beef.txt @@ -0,0 +1,22 @@ +BEEF SOUP. + +Take the hind shin of beef, cut off all the flesh off the leg-bone, +which must be taken away entirely, or the soup will be greasy. Wash the +meat clean and lay it in a pot, sprinkle over it one small +table-spoonful of pounded black pepper, and two of salt; three onions +the size of a hen's egg, cut small, six small carrots scraped and cut +up, two small turnips pared and cut into dice; pour on three quarts of +water, cover the pot close, and keep it gently and steadily boiling five +hours, which will leave about three pints of clear soup; do not let the +pot boil over, but take off the scum carefully, as it rises. When it has +boiled four hours, put in a small bundle of thyme and parsley, and a +pint of celery cut small, or a tea-spoonful of celery seed pounded. +These latter ingredients would lose their delicate flavour if boiled too +much. Just before you take it up, brown it in the following manner: put +a small table-spoonful of nice brown sugar into an iron skillet, set it +on the fire and stir it till it melts and looks very dark, pour into it +a ladle full of the soup, a little at a time; stirring it all the while. +Strain this browning and mix it well with the soup; take out the bundle +of thyme and parsley, put the nicest pieces of meat in your tureen, and +pour on the soup and vegetables; put in some toasted bread cut in dice, +and serve it up. diff --git a/tests/resources/reftable/rebase/bouilli.txt b/tests/resources/reftable/rebase/bouilli.txt new file mode 100644 index 000000000..4b7c56500 --- /dev/null +++ b/tests/resources/reftable/rebase/bouilli.txt @@ -0,0 +1,18 @@ +SOUP WITH BOUILLI. + +Take the nicest part of the thick brisket of beef, about eight pounds, +put it into a pot with every thing directed for the other soup; make it +exactly in the same way, only put it on an hour sooner, that you may +have time to prepare the bouilli; after it has boiled five hours, take +out the beef, cover up the soup and set it near the fire that it may +keep hot. Take the skin off the beef, have the yelk of an egg well +beaten, dip a feather in it and wash the top of your beef, sprinkle over +it the crumb of stale bread finely grated, put it in a Dutch oven +previously heated, put the top on with coals enough to brown, but not +burn the beef; let it stand nearly an hour, and prepare your gravy +thus:--Take a sufficient quantity of soup and the vegetables boiled in +it; add to it a table-spoonful of red wine, and two of mushroom catsup, +thicken with a little bit of butter and a little brown flour; make it +very hot, pour it in your dish, and put the beef on it. Garnish it with +green pickle, cut in thin slices, serve up the soup in a tureen with +bits of toasted bread. diff --git a/tests/resources/reftable/rebase/gravy.txt b/tests/resources/reftable/rebase/gravy.txt new file mode 100644 index 000000000..c4e6cca3e --- /dev/null +++ b/tests/resources/reftable/rebase/gravy.txt @@ -0,0 +1,8 @@ +GRAVY SOUP. + +Get eight pounds of coarse lean beef--wash it clean and lay it in your +pot, put in the same ingredients as for the shin soup, with the same +quantity of water, and follow the process directed for that. Strain the +soup through a sieve, and serve it up clear, with nothing more than +toasted bread in it; two table-spoonsful of mushroom catsup will add a +fine flavour to the soup. diff --git a/tests/resources/reftable/rebase/oyster.txt b/tests/resources/reftable/rebase/oyster.txt new file mode 100644 index 000000000..68af1fc74 --- /dev/null +++ b/tests/resources/reftable/rebase/oyster.txt @@ -0,0 +1,13 @@ +OYSTER SOUP. + +Wash and drain two quarts of oysters, put them on with three quarts of +water, three onions chopped up, two or three slices of lean ham, pepper +and salt; boil it till reduced one-half, strain it through a sieve, +return the liquid into the pot, put in one quart of fresh oysters, boil +it till they are sufficiently done, and thicken the soup with four +spoonsful of flour, two gills of rich cream, and the yelks of six new +laid eggs beaten well; boil it a few minutes after the thickening is put +in. Take care that it does not curdle, and that the flour is not in +lumps; serve it up with the last oysters that were put in. If the +flavour of thyme be agreeable, you may put in a little, but take care +that it does not boil in it long enough to discolour the soup. diff --git a/tests/resources/reftable/rebase/veal.txt b/tests/resources/reftable/rebase/veal.txt new file mode 100644 index 000000000..a7b066537 --- /dev/null +++ b/tests/resources/reftable/rebase/veal.txt @@ -0,0 +1,18 @@ +VEAL SOUP. + +Put into a pot three quarts of water, three onions cut small, one +spoonful of black pepper pounded, and two of salt, with two or three +slices of lean ham; let it boil steadily two hours; skim it +occasionally, then put into it a shin of veal, let it boil two hours +longer; take out the slices of ham, and skim off the grease if any +should rise, take a gill of good cream, mix with it two table-spoonsful +of flour very nicely, and the yelks of two eggs beaten well, strain this +mixture, and add some chopped parsley; pour some soup on by degrees, +stir it well, and pour it into the pot, continuing to stir until it has +boiled two or three minutes to take off the raw taste of the eggs. If +the cream be not perfectly sweet, and the eggs quite new, the thickening +will curdle in the soup. For a change you may put a dozen ripe tomatos +in, first taking off their skins, by letting them stand a few minutes in +hot water, when they may be easily peeled. When made in this way you +must thicken it with the flour only. Any part of the veal may be used, +but the shin or knuckle is the nicest. diff --git a/tests/resources/reftable/redundant.git/HEAD b/tests/resources/reftable/redundant.git/HEAD new file mode 100644 index 000000000..fe6d7e5fa --- /dev/null +++ b/tests/resources/reftable/redundant.git/HEAD @@ -0,0 +1 @@ +ref: refs/heads/.invalid diff --git a/tests/resources/reftable/redundant.git/config b/tests/resources/reftable/redundant.git/config new file mode 100755 index 000000000..29db5cfc3 --- /dev/null +++ b/tests/resources/reftable/redundant.git/config @@ -0,0 +1,7 @@ +[core] + repositoryformatversion = 1 + filemode = true + bare = true + logallrefupdates = true +[extensions] + refstorage = reftable diff --git a/tests/resources/reftable/redundant.git/objects/info/packs b/tests/resources/reftable/redundant.git/objects/info/packs new file mode 100644 index 000000000..fbf960f10 --- /dev/null +++ b/tests/resources/reftable/redundant.git/objects/info/packs @@ -0,0 +1,2 @@ +P pack-3d944c0c5bcb6b16209af847052c6ff1a521529d.pack + diff --git a/tests/resources/reftable/redundant.git/objects/pack/pack-3d944c0c5bcb6b16209af847052c6ff1a521529d.idx b/tests/resources/reftable/redundant.git/objects/pack/pack-3d944c0c5bcb6b16209af847052c6ff1a521529d.idx new file mode 100644 index 000000000..d8e099a98 Binary files /dev/null and b/tests/resources/reftable/redundant.git/objects/pack/pack-3d944c0c5bcb6b16209af847052c6ff1a521529d.idx differ diff --git a/tests/resources/reftable/redundant.git/objects/pack/pack-3d944c0c5bcb6b16209af847052c6ff1a521529d.pack b/tests/resources/reftable/redundant.git/objects/pack/pack-3d944c0c5bcb6b16209af847052c6ff1a521529d.pack new file mode 100644 index 000000000..02ea49f4b Binary files /dev/null and b/tests/resources/reftable/redundant.git/objects/pack/pack-3d944c0c5bcb6b16209af847052c6ff1a521529d.pack differ diff --git a/tests/resources/reftable/redundant.git/refs/heads b/tests/resources/reftable/redundant.git/refs/heads new file mode 100644 index 000000000..3e639a56a --- /dev/null +++ b/tests/resources/reftable/redundant.git/refs/heads @@ -0,0 +1 @@ +this repository uses the reftable format diff --git a/tests/resources/reftable/redundant.git/reftable/0x000000000001-0x000000000001-76c6834d.ref b/tests/resources/reftable/redundant.git/reftable/0x000000000001-0x000000000001-76c6834d.ref new file mode 100644 index 000000000..39b911555 Binary files /dev/null and b/tests/resources/reftable/redundant.git/reftable/0x000000000001-0x000000000001-76c6834d.ref differ diff --git a/tests/resources/reftable/redundant.git/reftable/tables.list b/tests/resources/reftable/redundant.git/reftable/tables.list new file mode 100644 index 000000000..a3efbaa94 --- /dev/null +++ b/tests/resources/reftable/redundant.git/reftable/tables.list @@ -0,0 +1 @@ +0x000000000001-0x000000000001-76c6834d.ref diff --git a/tests/resources/reftable/renames/.gitted/HEAD b/tests/resources/reftable/renames/.gitted/HEAD new file mode 100644 index 000000000..fe6d7e5fa --- /dev/null +++ b/tests/resources/reftable/renames/.gitted/HEAD @@ -0,0 +1 @@ +ref: refs/heads/.invalid diff --git a/tests/resources/reftable/renames/.gitted/config b/tests/resources/reftable/renames/.gitted/config new file mode 100644 index 000000000..53ccf173f --- /dev/null +++ b/tests/resources/reftable/renames/.gitted/config @@ -0,0 +1,9 @@ +[core] + repositoryformatversion = 1 + filemode = true + bare = false + logallrefupdates = true + ignorecase = true + precomposeunicode = false +[extensions] + refstorage = reftable diff --git a/tests/resources/reftable/renames/.gitted/description b/tests/resources/reftable/renames/.gitted/description new file mode 100644 index 000000000..498b267a8 --- /dev/null +++ b/tests/resources/reftable/renames/.gitted/description @@ -0,0 +1 @@ +Unnamed repository; edit this file 'description' to name the repository. diff --git a/tests/resources/reftable/renames/.gitted/index b/tests/resources/reftable/renames/.gitted/index new file mode 100644 index 000000000..5882a8d60 Binary files /dev/null and b/tests/resources/reftable/renames/.gitted/index differ diff --git a/tests/resources/reftable/renames/.gitted/info/exclude b/tests/resources/reftable/renames/.gitted/info/exclude new file mode 100644 index 000000000..a5196d1be --- /dev/null +++ b/tests/resources/reftable/renames/.gitted/info/exclude @@ -0,0 +1,6 @@ +# git ls-files --others --exclude-from=.git/info/exclude +# Lines that start with '#' are comments. +# For a project mostly in C, the following would be a good set of +# exclude patterns (uncomment them if you want to use them): +# *.[oa] +# *~ diff --git a/tests/resources/reftable/renames/.gitted/objects/03/da7ad872536bd448da8d88eb7165338bf923a7 b/tests/resources/reftable/renames/.gitted/objects/03/da7ad872536bd448da8d88eb7165338bf923a7 new file mode 100644 index 000000000..2ee86444d Binary files /dev/null and b/tests/resources/reftable/renames/.gitted/objects/03/da7ad872536bd448da8d88eb7165338bf923a7 differ diff --git a/tests/resources/reftable/renames/.gitted/objects/17/58bdd7c16a72ff7c17d8de0c957ced3ccad645 b/tests/resources/reftable/renames/.gitted/objects/17/58bdd7c16a72ff7c17d8de0c957ced3ccad645 new file mode 100644 index 000000000..01801ed11 --- /dev/null +++ b/tests/resources/reftable/renames/.gitted/objects/17/58bdd7c16a72ff7c17d8de0c957ced3ccad645 @@ -0,0 +1,5 @@ +xEͱ @QbWq H_&{]yYX`='흶=ZohzF + + + +MhBЄ&4 MhB3ьf4hF3юKx \ No newline at end of file diff --git a/tests/resources/reftable/renames/.gitted/objects/19/dd32dfb1520a64e5bbaae8dce6ef423dfa2f13 b/tests/resources/reftable/renames/.gitted/objects/19/dd32dfb1520a64e5bbaae8dce6ef423dfa2f13 new file mode 100644 index 000000000..4be4c6952 --- /dev/null +++ b/tests/resources/reftable/renames/.gitted/objects/19/dd32dfb1520a64e5bbaae8dce6ef423dfa2f13 @@ -0,0 +1 @@ +xM!Ei@3ސc,\X K {Nrbo,xzYC<h[&?=fcvyCWm 䮔~*D \ No newline at end of file diff --git a/tests/resources/reftable/renames/.gitted/objects/5a/71babaaac78a758b52576a60cea3c218c8b546 b/tests/resources/reftable/renames/.gitted/objects/5a/71babaaac78a758b52576a60cea3c218c8b546 new file mode 100644 index 000000000..e685bfaff Binary files /dev/null and b/tests/resources/reftable/renames/.gitted/objects/5a/71babaaac78a758b52576a60cea3c218c8b546 differ diff --git a/tests/resources/reftable/renames/.gitted/objects/5e/26abc56a5a84d89790f45416648899cbe13109 b/tests/resources/reftable/renames/.gitted/objects/5e/26abc56a5a84d89790f45416648899cbe13109 new file mode 100644 index 000000000..2acd3d583 Binary files /dev/null and b/tests/resources/reftable/renames/.gitted/objects/5e/26abc56a5a84d89790f45416648899cbe13109 differ diff --git a/tests/resources/reftable/renames/.gitted/objects/61/8c6f2f8740bd6049b2fb9eb93fc15726462745 b/tests/resources/reftable/renames/.gitted/objects/61/8c6f2f8740bd6049b2fb9eb93fc15726462745 new file mode 100644 index 000000000..24eac54c5 Binary files /dev/null and b/tests/resources/reftable/renames/.gitted/objects/61/8c6f2f8740bd6049b2fb9eb93fc15726462745 differ diff --git a/tests/resources/reftable/renames/.gitted/objects/66/311f5cfbe7836c27510a3ba2f43e282e2c8bba b/tests/resources/reftable/renames/.gitted/objects/66/311f5cfbe7836c27510a3ba2f43e282e2c8bba new file mode 100644 index 000000000..5ee28a76a Binary files /dev/null and b/tests/resources/reftable/renames/.gitted/objects/66/311f5cfbe7836c27510a3ba2f43e282e2c8bba differ diff --git a/tests/resources/reftable/renames/.gitted/objects/7e/7bfb88ba9bc65fd700fee1819cf1c317aafa56 b/tests/resources/reftable/renames/.gitted/objects/7e/7bfb88ba9bc65fd700fee1819cf1c317aafa56 new file mode 100644 index 000000000..e53c843dd --- /dev/null +++ b/tests/resources/reftable/renames/.gitted/objects/7e/7bfb88ba9bc65fd700fee1819cf1c317aafa56 @@ -0,0 +1,2 @@ +xKn0))"e19Ec +b4 n0WR^2)؎>'VL ܀׎8y$[жt5:l'3a!,R!-EaI>yo*4戁Rf m&eIA*!;dݬ +Ho +OUDyTVHpwqH7Ʒ.ts6{Z+X\)C5Q9 +%t*&&v;|'4 Du[7he!NK*"C-=`#؎$Ee2T|@NBsslW|/0¬aȥJNv)-ڡiۤ3bbO:uWMNX7T \ No newline at end of file diff --git a/tests/resources/reftable/renames/.gitted/objects/eb/b3b7af1d25c8492d2f626826c92458b7cefd60 b/tests/resources/reftable/renames/.gitted/objects/eb/b3b7af1d25c8492d2f626826c92458b7cefd60 new file mode 100644 index 000000000..813e7ad90 Binary files /dev/null and b/tests/resources/reftable/renames/.gitted/objects/eb/b3b7af1d25c8492d2f626826c92458b7cefd60 differ diff --git a/tests/resources/reftable/renames/.gitted/objects/ed/2a95c4a6c295b9afcea50baff63ec544ccf600 b/tests/resources/reftable/renames/.gitted/objects/ed/2a95c4a6c295b9afcea50baff63ec544ccf600 new file mode 100644 index 000000000..4f439e293 Binary files /dev/null and b/tests/resources/reftable/renames/.gitted/objects/ed/2a95c4a6c295b9afcea50baff63ec544ccf600 differ diff --git a/tests/resources/reftable/renames/.gitted/objects/f6/7e2f70efe89665e829ea0d77c46965ad1307e4 b/tests/resources/reftable/renames/.gitted/objects/f6/7e2f70efe89665e829ea0d77c46965ad1307e4 new file mode 100644 index 000000000..1cad2134d Binary files /dev/null and b/tests/resources/reftable/renames/.gitted/objects/f6/7e2f70efe89665e829ea0d77c46965ad1307e4 differ diff --git a/tests/resources/reftable/renames/.gitted/objects/f9/0d4fc20ecddf21eebe6a37e9225d244339d2b5 b/tests/resources/reftable/renames/.gitted/objects/f9/0d4fc20ecddf21eebe6a37e9225d244339d2b5 new file mode 100644 index 000000000..f6d933be9 Binary files /dev/null and b/tests/resources/reftable/renames/.gitted/objects/f9/0d4fc20ecddf21eebe6a37e9225d244339d2b5 differ diff --git a/tests/resources/reftable/renames/.gitted/refs/heads b/tests/resources/reftable/renames/.gitted/refs/heads new file mode 100644 index 000000000..3e639a56a --- /dev/null +++ b/tests/resources/reftable/renames/.gitted/refs/heads @@ -0,0 +1 @@ +this repository uses the reftable format diff --git a/tests/resources/reftable/renames/.gitted/reftable/0x000000000001-0x000000000009-781fbe83.ref b/tests/resources/reftable/renames/.gitted/reftable/0x000000000001-0x000000000009-781fbe83.ref new file mode 100644 index 000000000..6a6989c2b Binary files /dev/null and b/tests/resources/reftable/renames/.gitted/reftable/0x000000000001-0x000000000009-781fbe83.ref differ diff --git a/tests/resources/reftable/renames/.gitted/reftable/tables.list b/tests/resources/reftable/renames/.gitted/reftable/tables.list new file mode 100644 index 000000000..0bd7828ec --- /dev/null +++ b/tests/resources/reftable/renames/.gitted/reftable/tables.list @@ -0,0 +1 @@ +0x000000000001-0x000000000009-781fbe83.ref diff --git a/tests/resources/reftable/renames/ikeepsix.txt b/tests/resources/reftable/renames/ikeepsix.txt new file mode 100644 index 000000000..eaf4a3e3b --- /dev/null +++ b/tests/resources/reftable/renames/ikeepsix.txt @@ -0,0 +1,27 @@ +I Keep Six Honest Serving-Men +============================= + +She sends'em abroad on her own affairs, + From the second she opens her eyes— +One million Hows, two million Wheres, +And seven million Whys! + +I let them rest from nine till five, + For I am busy then, +As well as breakfast, lunch, and tea, + For they are hungry men. +But different folk have different views; +I know a person small— +She keeps ten million serving-men, +Who get no rest at all! + + -- Rudyard Kipling + +I KEEP six honest serving-men + (They taught me all I knew); +Their names are What and Why and When + And How and Where and Who. +I send them over land and sea, + I send them east and west; +But after they have worked for me, + I give them all a rest. diff --git a/tests/resources/reftable/renames/sixserving.txt b/tests/resources/reftable/renames/sixserving.txt new file mode 100644 index 000000000..f90d4fc20 --- /dev/null +++ b/tests/resources/reftable/renames/sixserving.txt @@ -0,0 +1,25 @@ +I KEEP six honest serving-men + (They taught me all I knew); +Their names are What and Why and When + And How and Where and Who. +I send them over land and sea, + I send them east and west; +But after they have worked for me, + I give them all a rest. + +I let them rest from nine till five, + For I am busy then, +As well as breakfast, lunch, and tea, + For they are hungry men. +But different folk have different views; +I know a person small— +She keeps ten million serving-men, +Who get no rest at all! + +She sends'em abroad on her own affairs, + From the second she opens her eyes— +One million Hows, two million Wheres, +And seven million Whys! + + -- Rudyard Kipling + diff --git a/tests/resources/reftable/renames/songof7cities.txt b/tests/resources/reftable/renames/songof7cities.txt new file mode 100644 index 000000000..4210ffd5c --- /dev/null +++ b/tests/resources/reftable/renames/songof7cities.txt @@ -0,0 +1,49 @@ +The Song of Seven Cities +------------------------ + +I WAS Lord of Cities very sumptuously builded. +Seven roaring Cities paid me tribute from afar. +Ivory their outposts were--the guardrooms of them gilded, +And garrisoned with Amazons invincible in war. + +All the world went softly when it walked before my Cities-- +Neither King nor Army vexed my peoples at their toil, +Never horse nor chariot irked or overbore my Cities, +Never Mob nor Ruler questioned whence they drew their spoil. + +Banded, mailed and arrogant from sunrise unto sunset; +Singing while they sacked it, they possessed the land at large. +Yet when men would rob them, they resisted, they made onset +And pierced the smoke of battle with a thousand-sabred charge. + +So they warred and trafficked only yesterday, my Cities. +To-day there is no mark or mound of where my Cities stood. +For the River rose at midnight and it washed away my Cities. +They are evened with Atlantis and the towns before the Flood. + +Rain on rain-gorged channels raised the water-levels round them, +Freshet backed on freshet swelled and swept their world from sight, +Till the emboldened floods linked arms and, flashing forward, drowned them-- +Drowned my Seven Cities and their peoples in one night! + +Low among the alders lie their derelict foundations, +The beams wherein they trusted and the plinths whereon they built-- +My rulers and their treasure and their unborn populations, +Dead, destroyed, aborted, and defiled with mud and silt! + +The Daughters of the Palace whom they cherished in my Cities, +My silver-tongued Princesses, and the promise of their May-- +Their bridegrooms of the June-tide--all have perished in my Cities, +With the harsh envenomed virgins that can neither love nor play. + +I was Lord of Cities--I will build anew my Cities, +Seven, set on rocks, above the wrath of any flood. +Nor will I rest from search till I have filled anew my Cities +With peoples undefeated of the dark, enduring blood. + +To the sound of trumpets shall their seed restore my Cities +Wealthy and well-weaponed, that once more may I behold +All the world go softly when it walks before my Cities, +And the horses and the chariots fleeing from them as of old! + + -- Rudyard Kipling diff --git a/tests/resources/reftable/renames/untimely.txt b/tests/resources/reftable/renames/untimely.txt new file mode 100644 index 000000000..9a69d960a --- /dev/null +++ b/tests/resources/reftable/renames/untimely.txt @@ -0,0 +1,24 @@ +Untimely +======== + +Nothing in life has been made by man for man's using +But it was shown long since to man in ages +Lost as the name of the maker of it, +Who received oppression and shame for his wages-- +Hate, avoidance, and scorn in his daily dealings-- +Until he perished, wholly confounded + +More to be pitied than he are the wise +Souls which foresaw the evil of loosing +Knowledge or Art before time, and aborted +Noble devices and deep-wrought healings, +Lest offense should arise. + +Heaven delivers on earth the Hour that cannot be + thwarted, +Neither advanced, at the price of a world nor a soul, + and its Prophet +Comes through the blood of the vanguards who + dreamed--too soon--it had sounded. + + -- Rudyard Kipling diff --git a/tests/resources/reftable/revert-rename.git/HEAD b/tests/resources/reftable/revert-rename.git/HEAD new file mode 100644 index 000000000..fe6d7e5fa --- /dev/null +++ b/tests/resources/reftable/revert-rename.git/HEAD @@ -0,0 +1 @@ +ref: refs/heads/.invalid diff --git a/tests/resources/reftable/revert-rename.git/config b/tests/resources/reftable/revert-rename.git/config new file mode 100644 index 000000000..3a25695cf --- /dev/null +++ b/tests/resources/reftable/revert-rename.git/config @@ -0,0 +1,7 @@ +[core] + repositoryformatversion = 1 + filemode = true + bare = true + logallrefupdates = true +[extensions] + refstorage = reftable diff --git a/tests/resources/reftable/revert-rename.git/index b/tests/resources/reftable/revert-rename.git/index new file mode 100644 index 000000000..232325dfb Binary files /dev/null and b/tests/resources/reftable/revert-rename.git/index differ diff --git a/tests/resources/reftable/revert-rename.git/objects/info/packs b/tests/resources/reftable/revert-rename.git/objects/info/packs new file mode 100644 index 000000000..5d971426e --- /dev/null +++ b/tests/resources/reftable/revert-rename.git/objects/info/packs @@ -0,0 +1,2 @@ +P pack-4363774fb90141e8aa7a326ace0566366114e869.pack + diff --git a/tests/resources/reftable/revert-rename.git/objects/pack/pack-4363774fb90141e8aa7a326ace0566366114e869.idx b/tests/resources/reftable/revert-rename.git/objects/pack/pack-4363774fb90141e8aa7a326ace0566366114e869.idx new file mode 100644 index 000000000..3fb48ea94 Binary files /dev/null and b/tests/resources/reftable/revert-rename.git/objects/pack/pack-4363774fb90141e8aa7a326ace0566366114e869.idx differ diff --git a/tests/resources/reftable/revert-rename.git/objects/pack/pack-4363774fb90141e8aa7a326ace0566366114e869.pack b/tests/resources/reftable/revert-rename.git/objects/pack/pack-4363774fb90141e8aa7a326ace0566366114e869.pack new file mode 100644 index 000000000..e078ec2aa Binary files /dev/null and b/tests/resources/reftable/revert-rename.git/objects/pack/pack-4363774fb90141e8aa7a326ace0566366114e869.pack differ diff --git a/tests/resources/reftable/revert-rename.git/refs/heads b/tests/resources/reftable/revert-rename.git/refs/heads new file mode 100644 index 000000000..3e639a56a --- /dev/null +++ b/tests/resources/reftable/revert-rename.git/refs/heads @@ -0,0 +1 @@ +this repository uses the reftable format diff --git a/tests/resources/reftable/revert-rename.git/reftable/0x000000000001-0x000000000001-89f81501.ref b/tests/resources/reftable/revert-rename.git/reftable/0x000000000001-0x000000000001-89f81501.ref new file mode 100644 index 000000000..bb9af191f Binary files /dev/null and b/tests/resources/reftable/revert-rename.git/reftable/0x000000000001-0x000000000001-89f81501.ref differ diff --git a/tests/resources/reftable/revert-rename.git/reftable/tables.list b/tests/resources/reftable/revert-rename.git/reftable/tables.list new file mode 100644 index 000000000..a494b856a --- /dev/null +++ b/tests/resources/reftable/revert-rename.git/reftable/tables.list @@ -0,0 +1 @@ +0x000000000001-0x000000000001-89f81501.ref diff --git a/tests/resources/reftable/revert/.gitted/HEAD b/tests/resources/reftable/revert/.gitted/HEAD new file mode 100644 index 000000000..fe6d7e5fa --- /dev/null +++ b/tests/resources/reftable/revert/.gitted/HEAD @@ -0,0 +1 @@ +ref: refs/heads/.invalid diff --git a/tests/resources/reftable/revert/.gitted/config b/tests/resources/reftable/revert/.gitted/config new file mode 100644 index 000000000..9bec4bcc7 --- /dev/null +++ b/tests/resources/reftable/revert/.gitted/config @@ -0,0 +1,10 @@ +[core] + repositoryformatversion = 1 + filemode = false + bare = false + logallrefupdates = true + symlinks = false + ignorecase = true + hideDotFiles = dotGitOnly +[extensions] + refstorage = reftable diff --git a/tests/resources/reftable/revert/.gitted/index b/tests/resources/reftable/revert/.gitted/index new file mode 100644 index 000000000..3513c04a6 Binary files /dev/null and b/tests/resources/reftable/revert/.gitted/index differ diff --git a/tests/resources/reftable/revert/.gitted/info/exclude b/tests/resources/reftable/revert/.gitted/info/exclude new file mode 100644 index 000000000..f00680973 --- /dev/null +++ b/tests/resources/reftable/revert/.gitted/info/exclude @@ -0,0 +1,6 @@ +# git ls-files --others --exclude-from=.git/info/exclude +# Lines that start with '#' are comments. +# For a project mostly in C, the following would be a good set of +# exclude patterns (uncomment them if you want to use them): +# *.[oa] +# *~ diff --git a/tests/resources/reftable/revert/.gitted/objects/00/c97c9299419874a7bfc4d853d462c568e1be2d b/tests/resources/reftable/revert/.gitted/objects/00/c97c9299419874a7bfc4d853d462c568e1be2d new file mode 100644 index 000000000..b4e9635c6 Binary files /dev/null and b/tests/resources/reftable/revert/.gitted/objects/00/c97c9299419874a7bfc4d853d462c568e1be2d differ diff --git a/tests/resources/reftable/revert/.gitted/objects/0a/a8c7e40d342fff78d60b29a4ba8e993ed79c51 b/tests/resources/reftable/revert/.gitted/objects/0a/a8c7e40d342fff78d60b29a4ba8e993ed79c51 new file mode 100644 index 000000000..5c811ef89 --- /dev/null +++ b/tests/resources/reftable/revert/.gitted/objects/0a/a8c7e40d342fff78d60b29a4ba8e993ed79c51 @@ -0,0 +1,2 @@ +xK +0@]s%4?q @2Ѐ@3{{$itf@L91OIKcdrYXcsW>R]ʸ Gଭx U:jz/? \ No newline at end of file diff --git a/tests/resources/reftable/revert/.gitted/objects/0a/b09ea6d4c3634bdf6c221626d8b6f7dd890767 b/tests/resources/reftable/revert/.gitted/objects/0a/b09ea6d4c3634bdf6c221626d8b6f7dd890767 new file mode 100644 index 000000000..c050e5a89 Binary files /dev/null and b/tests/resources/reftable/revert/.gitted/objects/0a/b09ea6d4c3634bdf6c221626d8b6f7dd890767 differ diff --git a/tests/resources/reftable/revert/.gitted/objects/0a/d19525be6d8cae5e5deb2770fc244b65255057 b/tests/resources/reftable/revert/.gitted/objects/0a/d19525be6d8cae5e5deb2770fc244b65255057 new file mode 100644 index 000000000..4aa0459d8 Binary files /dev/null and b/tests/resources/reftable/revert/.gitted/objects/0a/d19525be6d8cae5e5deb2770fc244b65255057 differ diff --git a/tests/resources/reftable/revert/.gitted/objects/0c/db66192ee192f70f891f05a47636057420e871 b/tests/resources/reftable/revert/.gitted/objects/0c/db66192ee192f70f891f05a47636057420e871 new file mode 100644 index 000000000..31c107fc4 Binary files /dev/null and b/tests/resources/reftable/revert/.gitted/objects/0c/db66192ee192f70f891f05a47636057420e871 differ diff --git a/tests/resources/reftable/revert/.gitted/objects/0f/5bfcf58c558d865da6be0281d7795993646cee b/tests/resources/reftable/revert/.gitted/objects/0f/5bfcf58c558d865da6be0281d7795993646cee new file mode 100644 index 000000000..fb4fc763a Binary files /dev/null and b/tests/resources/reftable/revert/.gitted/objects/0f/5bfcf58c558d865da6be0281d7795993646cee differ diff --git a/tests/resources/reftable/revert/.gitted/objects/10/10c8f4711d60d04bad16197a0f4b0d4d19c542 b/tests/resources/reftable/revert/.gitted/objects/10/10c8f4711d60d04bad16197a0f4b0d4d19c542 new file mode 100644 index 000000000..083f7467b Binary files /dev/null and b/tests/resources/reftable/revert/.gitted/objects/10/10c8f4711d60d04bad16197a0f4b0d4d19c542 differ diff --git a/tests/resources/reftable/revert/.gitted/objects/13/a6fdfd10bd74b1f258fb58801215985dd2e797 b/tests/resources/reftable/revert/.gitted/objects/13/a6fdfd10bd74b1f258fb58801215985dd2e797 new file mode 100644 index 000000000..3c54aab0c Binary files /dev/null and b/tests/resources/reftable/revert/.gitted/objects/13/a6fdfd10bd74b1f258fb58801215985dd2e797 differ diff --git a/tests/resources/reftable/revert/.gitted/objects/13/ee9cd5d8e1023c218e0e1ea684ec0c582b5050 b/tests/resources/reftable/revert/.gitted/objects/13/ee9cd5d8e1023c218e0e1ea684ec0c582b5050 new file mode 100644 index 000000000..aed4647a6 Binary files /dev/null and b/tests/resources/reftable/revert/.gitted/objects/13/ee9cd5d8e1023c218e0e1ea684ec0c582b5050 differ diff --git a/tests/resources/reftable/revert/.gitted/objects/15/6ef9bcb968dccec8472a0f2eff49f1a713bc6b b/tests/resources/reftable/revert/.gitted/objects/15/6ef9bcb968dccec8472a0f2eff49f1a713bc6b new file mode 100644 index 000000000..3ee2a189b Binary files /dev/null and b/tests/resources/reftable/revert/.gitted/objects/15/6ef9bcb968dccec8472a0f2eff49f1a713bc6b differ diff --git a/tests/resources/reftable/revert/.gitted/objects/18/1aab27ddb37b40d9a284fb4733497006d57091 b/tests/resources/reftable/revert/.gitted/objects/18/1aab27ddb37b40d9a284fb4733497006d57091 new file mode 100644 index 000000000..6b422b808 Binary files /dev/null and b/tests/resources/reftable/revert/.gitted/objects/18/1aab27ddb37b40d9a284fb4733497006d57091 differ diff --git a/tests/resources/reftable/revert/.gitted/objects/1b/c915c5cb7185a9438de28a7b1a7dfe8c01ee7f b/tests/resources/reftable/revert/.gitted/objects/1b/c915c5cb7185a9438de28a7b1a7dfe8c01ee7f new file mode 100644 index 000000000..0a6955b5d Binary files /dev/null and b/tests/resources/reftable/revert/.gitted/objects/1b/c915c5cb7185a9438de28a7b1a7dfe8c01ee7f differ diff --git a/tests/resources/reftable/revert/.gitted/objects/1f/a4e069a641f10f5fb7588138b2d147fcd22c36 b/tests/resources/reftable/revert/.gitted/objects/1f/a4e069a641f10f5fb7588138b2d147fcd22c36 new file mode 100644 index 000000000..3df134a8d Binary files /dev/null and b/tests/resources/reftable/revert/.gitted/objects/1f/a4e069a641f10f5fb7588138b2d147fcd22c36 differ diff --git a/tests/resources/reftable/revert/.gitted/objects/1f/f0c423042b46cb1d617b81efb715defbe8054d b/tests/resources/reftable/revert/.gitted/objects/1f/f0c423042b46cb1d617b81efb715defbe8054d new file mode 100644 index 000000000..2ed1a2292 Binary files /dev/null and b/tests/resources/reftable/revert/.gitted/objects/1f/f0c423042b46cb1d617b81efb715defbe8054d differ diff --git a/tests/resources/reftable/revert/.gitted/objects/21/a96a98ed84d45866e1de6e266fd3a61a4ae9dc b/tests/resources/reftable/revert/.gitted/objects/21/a96a98ed84d45866e1de6e266fd3a61a4ae9dc new file mode 100644 index 000000000..95842dbf8 Binary files /dev/null and b/tests/resources/reftable/revert/.gitted/objects/21/a96a98ed84d45866e1de6e266fd3a61a4ae9dc differ diff --git a/tests/resources/reftable/revert/.gitted/objects/29/6a6d3be1dff05c5d1f631d2459389fa7b619eb b/tests/resources/reftable/revert/.gitted/objects/29/6a6d3be1dff05c5d1f631d2459389fa7b619eb new file mode 100644 index 000000000..5555268fd Binary files /dev/null and b/tests/resources/reftable/revert/.gitted/objects/29/6a6d3be1dff05c5d1f631d2459389fa7b619eb differ diff --git a/tests/resources/reftable/revert/.gitted/objects/2d/440f2b3147d3dc7ad1085813478d6d869d5a4d b/tests/resources/reftable/revert/.gitted/objects/2d/440f2b3147d3dc7ad1085813478d6d869d5a4d new file mode 100644 index 000000000..c06cc9472 --- /dev/null +++ b/tests/resources/reftable/revert/.gitted/objects/2d/440f2b3147d3dc7ad1085813478d6d869d5a4d @@ -0,0 +1,2 @@ +xK +1D]}%I3"nt:΀I$3)W(9oqޘaaQ9Ryf"]JvYmиtN92%\F!/DHƊkmp"ךZ̃5o^S?QP8Y~J)G;zRAq :VYmQ K +pAП5sȅgJgU"IR'[og?oomϣ+fuťXt=6'/47:yL:c \ No newline at end of file diff --git a/tests/resources/reftable/revert/.gitted/objects/6b/ccd0dc58cea5ccff86014f3d64b31bd8c02a37 b/tests/resources/reftable/revert/.gitted/objects/6b/ccd0dc58cea5ccff86014f3d64b31bd8c02a37 new file mode 100644 index 000000000..2664da480 Binary files /dev/null and b/tests/resources/reftable/revert/.gitted/objects/6b/ccd0dc58cea5ccff86014f3d64b31bd8c02a37 differ diff --git a/tests/resources/reftable/revert/.gitted/objects/71/eb9c2b53dbbf3c45fb28b27c850db4b7fb8011 b/tests/resources/reftable/revert/.gitted/objects/71/eb9c2b53dbbf3c45fb28b27c850db4b7fb8011 new file mode 100644 index 000000000..995a1e626 Binary files /dev/null and b/tests/resources/reftable/revert/.gitted/objects/71/eb9c2b53dbbf3c45fb28b27c850db4b7fb8011 differ diff --git a/tests/resources/reftable/revert/.gitted/objects/72/333f47d4e83616630ff3b0ffe4c0faebcc3c45 b/tests/resources/reftable/revert/.gitted/objects/72/333f47d4e83616630ff3b0ffe4c0faebcc3c45 new file mode 100644 index 000000000..1f6978703 Binary files /dev/null and b/tests/resources/reftable/revert/.gitted/objects/72/333f47d4e83616630ff3b0ffe4c0faebcc3c45 differ diff --git a/tests/resources/reftable/revert/.gitted/objects/73/ec36fa120f8066963a0bc9105bb273dbd903d7 b/tests/resources/reftable/revert/.gitted/objects/73/ec36fa120f8066963a0bc9105bb273dbd903d7 new file mode 100644 index 000000000..3c8d2c20a Binary files /dev/null and b/tests/resources/reftable/revert/.gitted/objects/73/ec36fa120f8066963a0bc9105bb273dbd903d7 differ diff --git a/tests/resources/reftable/revert/.gitted/objects/74/7726e021bc5f44b86de60e3032fd6f9f1b8383 b/tests/resources/reftable/revert/.gitted/objects/74/7726e021bc5f44b86de60e3032fd6f9f1b8383 new file mode 100644 index 000000000..e4d14776f Binary files /dev/null and b/tests/resources/reftable/revert/.gitted/objects/74/7726e021bc5f44b86de60e3032fd6f9f1b8383 differ diff --git a/tests/resources/reftable/revert/.gitted/objects/75/ec9929465623f17ff3ad68c0438ea56faba815 b/tests/resources/reftable/revert/.gitted/objects/75/ec9929465623f17ff3ad68c0438ea56faba815 new file mode 100644 index 000000000..a3609c7de Binary files /dev/null and b/tests/resources/reftable/revert/.gitted/objects/75/ec9929465623f17ff3ad68c0438ea56faba815 differ diff --git a/tests/resources/reftable/revert/.gitted/objects/77/31926a337c4eaba1e2187d90ebfa0a93659382 b/tests/resources/reftable/revert/.gitted/objects/77/31926a337c4eaba1e2187d90ebfa0a93659382 new file mode 100644 index 000000000..b87fa1543 Binary files /dev/null and b/tests/resources/reftable/revert/.gitted/objects/77/31926a337c4eaba1e2187d90ebfa0a93659382 differ diff --git a/tests/resources/reftable/revert/.gitted/objects/83/f65df4606c4f8dbf8da43de25de1b7e4c03238 b/tests/resources/reftable/revert/.gitted/objects/83/f65df4606c4f8dbf8da43de25de1b7e4c03238 new file mode 100644 index 000000000..152ed5f77 Binary files /dev/null and b/tests/resources/reftable/revert/.gitted/objects/83/f65df4606c4f8dbf8da43de25de1b7e4c03238 differ diff --git a/tests/resources/reftable/revert/.gitted/objects/87/59ad453cf01cf7daf14e2a668f8218f9a678eb b/tests/resources/reftable/revert/.gitted/objects/87/59ad453cf01cf7daf14e2a668f8218f9a678eb new file mode 100644 index 000000000..ab19acf83 Binary files /dev/null and b/tests/resources/reftable/revert/.gitted/objects/87/59ad453cf01cf7daf14e2a668f8218f9a678eb differ diff --git a/tests/resources/reftable/revert/.gitted/objects/8b/e77695228eadd004606af0508462457961ca4a b/tests/resources/reftable/revert/.gitted/objects/8b/e77695228eadd004606af0508462457961ca4a new file mode 100644 index 000000000..951917ce3 Binary files /dev/null and b/tests/resources/reftable/revert/.gitted/objects/8b/e77695228eadd004606af0508462457961ca4a differ diff --git a/tests/resources/reftable/revert/.gitted/objects/8f/d40e13fff575b63e86af87175e70fa7fb92f80 b/tests/resources/reftable/revert/.gitted/objects/8f/d40e13fff575b63e86af87175e70fa7fb92f80 new file mode 100644 index 000000000..9ff861728 Binary files /dev/null and b/tests/resources/reftable/revert/.gitted/objects/8f/d40e13fff575b63e86af87175e70fa7fb92f80 differ diff --git a/tests/resources/reftable/revert/.gitted/objects/97/e52d5e81f541080cd6b92829fb85bc4d81d90b b/tests/resources/reftable/revert/.gitted/objects/97/e52d5e81f541080cd6b92829fb85bc4d81d90b new file mode 100644 index 000000000..416ae0f13 Binary files /dev/null and b/tests/resources/reftable/revert/.gitted/objects/97/e52d5e81f541080cd6b92829fb85bc4d81d90b differ diff --git a/tests/resources/reftable/revert/.gitted/objects/97/f3574e92f1730d365fb9e00c10e3c507c1cfe9 b/tests/resources/reftable/revert/.gitted/objects/97/f3574e92f1730d365fb9e00c10e3c507c1cfe9 new file mode 100644 index 000000000..12ebc58df Binary files /dev/null and b/tests/resources/reftable/revert/.gitted/objects/97/f3574e92f1730d365fb9e00c10e3c507c1cfe9 differ diff --git a/tests/resources/reftable/revert/.gitted/objects/9a/95fd974e03c5b93828ceedd28755965b5d5c60 b/tests/resources/reftable/revert/.gitted/objects/9a/95fd974e03c5b93828ceedd28755965b5d5c60 new file mode 100644 index 000000000..bb93a34bb Binary files /dev/null and b/tests/resources/reftable/revert/.gitted/objects/9a/95fd974e03c5b93828ceedd28755965b5d5c60 differ diff --git a/tests/resources/reftable/revert/.gitted/objects/a6/9f74efcb51634b88e04ea81273158a85257f41 b/tests/resources/reftable/revert/.gitted/objects/a6/9f74efcb51634b88e04ea81273158a85257f41 new file mode 100644 index 000000000..b96831f10 Binary files /dev/null and b/tests/resources/reftable/revert/.gitted/objects/a6/9f74efcb51634b88e04ea81273158a85257f41 differ diff --git a/tests/resources/reftable/revert/.gitted/objects/a8/c86221b400b836010567cc3593db6e96c1a83a b/tests/resources/reftable/revert/.gitted/objects/a8/c86221b400b836010567cc3593db6e96c1a83a new file mode 100644 index 000000000..29654616e Binary files /dev/null and b/tests/resources/reftable/revert/.gitted/objects/a8/c86221b400b836010567cc3593db6e96c1a83a differ diff --git a/tests/resources/reftable/revert/.gitted/objects/aa/7e281435d1fe6740d712f4bcc6fe89c425bedc b/tests/resources/reftable/revert/.gitted/objects/aa/7e281435d1fe6740d712f4bcc6fe89c425bedc new file mode 100644 index 000000000..f0dd67d3b Binary files /dev/null and b/tests/resources/reftable/revert/.gitted/objects/aa/7e281435d1fe6740d712f4bcc6fe89c425bedc differ diff --git a/tests/resources/reftable/revert/.gitted/objects/ac/c4d33902092efeb3b714aa0b1007c329e2f2e6 b/tests/resources/reftable/revert/.gitted/objects/ac/c4d33902092efeb3b714aa0b1007c329e2f2e6 new file mode 100644 index 000000000..91bb68b41 --- /dev/null +++ b/tests/resources/reftable/revert/.gitted/objects/ac/c4d33902092efeb3b714aa0b1007c329e2f2e6 @@ -0,0 +1,2 @@ +x[ +1 @QJW t6 F,LW8pe1llU.LiT BdN0z"!:ML䮽$ \ No newline at end of file diff --git a/tests/resources/reftable/revert/.gitted/objects/b7/a55408832174c54708906a372a9be2ffe3649b b/tests/resources/reftable/revert/.gitted/objects/b7/a55408832174c54708906a372a9be2ffe3649b new file mode 100644 index 000000000..77d4e20f9 Binary files /dev/null and b/tests/resources/reftable/revert/.gitted/objects/b7/a55408832174c54708906a372a9be2ffe3649b differ diff --git a/tests/resources/reftable/revert/.gitted/objects/be/ead165e017269e8dc0dd6f01195726a2e1e01b b/tests/resources/reftable/revert/.gitted/objects/be/ead165e017269e8dc0dd6f01195726a2e1e01b new file mode 100644 index 000000000..57de3f278 Binary files /dev/null and b/tests/resources/reftable/revert/.gitted/objects/be/ead165e017269e8dc0dd6f01195726a2e1e01b differ diff --git a/tests/resources/reftable/revert/.gitted/objects/ce/f56612d71a6af8d8015691e4865f7fece905b5 b/tests/resources/reftable/revert/.gitted/objects/ce/f56612d71a6af8d8015691e4865f7fece905b5 new file mode 100644 index 000000000..564588539 Binary files /dev/null and b/tests/resources/reftable/revert/.gitted/objects/ce/f56612d71a6af8d8015691e4865f7fece905b5 differ diff --git a/tests/resources/reftable/revert/.gitted/objects/d1/d403d22cbe24592d725f442835cf46fe60c8ac b/tests/resources/reftable/revert/.gitted/objects/d1/d403d22cbe24592d725f442835cf46fe60c8ac new file mode 100644 index 000000000..2190bb449 Binary files /dev/null and b/tests/resources/reftable/revert/.gitted/objects/d1/d403d22cbe24592d725f442835cf46fe60c8ac differ diff --git a/tests/resources/reftable/revert/.gitted/objects/dd/9a159c89509e73fd37d6af99619994cf7dfc06 b/tests/resources/reftable/revert/.gitted/objects/dd/9a159c89509e73fd37d6af99619994cf7dfc06 new file mode 100644 index 000000000..ed80d0aa5 Binary files /dev/null and b/tests/resources/reftable/revert/.gitted/objects/dd/9a159c89509e73fd37d6af99619994cf7dfc06 differ diff --git a/tests/resources/reftable/revert/.gitted/objects/e3/4ef1afe54eb526fd92eec66084125f340f1d65 b/tests/resources/reftable/revert/.gitted/objects/e3/4ef1afe54eb526fd92eec66084125f340f1d65 new file mode 100644 index 000000000..fc19ebd3d Binary files /dev/null and b/tests/resources/reftable/revert/.gitted/objects/e3/4ef1afe54eb526fd92eec66084125f340f1d65 differ diff --git a/tests/resources/reftable/revert/.gitted/objects/e5/f831f064adf9224d8c3ce556959d9d61b3c0a9 b/tests/resources/reftable/revert/.gitted/objects/e5/f831f064adf9224d8c3ce556959d9d61b3c0a9 new file mode 100644 index 000000000..665f1a1a2 --- /dev/null +++ b/tests/resources/reftable/revert/.gitted/objects/e5/f831f064adf9224d8c3ce556959d9d61b3c0a9 @@ -0,0 +1 @@ +xOIj1Yh|[3K>`Ib +h8y@*j]FWB D2 (4Q#N(,ckcۀ0SqL1˔6],$`2c,Û|.p]Z uWk]so[+[}bbf|'dDСD~jpêGc˺A|ki` \ No newline at end of file diff --git a/tests/resources/reftable/revert/.gitted/objects/ea/392a157085bc32daccd59aa1998fe2f5fb9fc0 b/tests/resources/reftable/revert/.gitted/objects/ea/392a157085bc32daccd59aa1998fe2f5fb9fc0 new file mode 100644 index 000000000..1451a6ac4 Binary files /dev/null and b/tests/resources/reftable/revert/.gitted/objects/ea/392a157085bc32daccd59aa1998fe2f5fb9fc0 differ diff --git a/tests/resources/reftable/revert/.gitted/objects/eb/b03002cee5d66c7732dd06241119fe72ab96a5 b/tests/resources/reftable/revert/.gitted/objects/eb/b03002cee5d66c7732dd06241119fe72ab96a5 new file mode 100644 index 000000000..802125ebb --- /dev/null +++ b/tests/resources/reftable/revert/.gitted/objects/eb/b03002cee5d66c7732dd06241119fe72ab96a5 @@ -0,0 +1,2 @@ +x 1E=i@I6&Aċ@6;dGlXwHkUa` \ No newline at end of file diff --git a/tests/resources/reftable/revert/.gitted/objects/ee/c6adcb2f3ceca0cadeccfe01b19382252ece9b b/tests/resources/reftable/revert/.gitted/objects/ee/c6adcb2f3ceca0cadeccfe01b19382252ece9b new file mode 100644 index 000000000..f59f3d48d Binary files /dev/null and b/tests/resources/reftable/revert/.gitted/objects/ee/c6adcb2f3ceca0cadeccfe01b19382252ece9b differ diff --git a/tests/resources/reftable/revert/.gitted/objects/f4/e107c230d08a60fb419d19869f1f282b272d9c b/tests/resources/reftable/revert/.gitted/objects/f4/e107c230d08a60fb419d19869f1f282b272d9c new file mode 100644 index 000000000..029da1ba9 Binary files /dev/null and b/tests/resources/reftable/revert/.gitted/objects/f4/e107c230d08a60fb419d19869f1f282b272d9c differ diff --git a/tests/resources/reftable/revert/.gitted/refs/heads b/tests/resources/reftable/revert/.gitted/refs/heads new file mode 100644 index 000000000..3e639a56a --- /dev/null +++ b/tests/resources/reftable/revert/.gitted/refs/heads @@ -0,0 +1 @@ +this repository uses the reftable format diff --git a/tests/resources/reftable/revert/.gitted/reftable/0x000000000001-0x000000000001-0834e617.ref b/tests/resources/reftable/revert/.gitted/reftable/0x000000000001-0x000000000001-0834e617.ref new file mode 100644 index 000000000..c8dd77425 Binary files /dev/null and b/tests/resources/reftable/revert/.gitted/reftable/0x000000000001-0x000000000001-0834e617.ref differ diff --git a/tests/resources/reftable/revert/.gitted/reftable/tables.list b/tests/resources/reftable/revert/.gitted/reftable/tables.list new file mode 100644 index 000000000..1cbe0071e --- /dev/null +++ b/tests/resources/reftable/revert/.gitted/reftable/tables.list @@ -0,0 +1 @@ +0x000000000001-0x000000000001-0834e617.ref diff --git a/tests/resources/reftable/revert/file1.txt b/tests/resources/reftable/revert/file1.txt new file mode 100644 index 000000000..84b225940 --- /dev/null +++ b/tests/resources/reftable/revert/file1.txt @@ -0,0 +1,14 @@ +!File one! +!File one! +File one! +File one +File one +File one +File one +File one +File one +File one +File one! +!File one! +!File one! +!File one! diff --git a/tests/resources/reftable/revert/file2.txt b/tests/resources/reftable/revert/file2.txt new file mode 100644 index 000000000..acb5747b3 --- /dev/null +++ b/tests/resources/reftable/revert/file2.txt @@ -0,0 +1,16 @@ +File two +File two +File two +File two +File two +File two +File two +File two +File two +File two +File two +File two +File two +File two +File two +File two diff --git a/tests/resources/reftable/revert/file3.txt b/tests/resources/reftable/revert/file3.txt new file mode 100644 index 000000000..b0330597f --- /dev/null +++ b/tests/resources/reftable/revert/file3.txt @@ -0,0 +1,16 @@ +File three +File three +File three +File three +File three +File three +File three +File three +File three +File three +File three +File three +File three +File three +File three +File three diff --git a/tests/resources/reftable/revert/file6.txt b/tests/resources/reftable/revert/file6.txt new file mode 100644 index 000000000..5c0cd5d56 --- /dev/null +++ b/tests/resources/reftable/revert/file6.txt @@ -0,0 +1,14 @@ +File six, actually! +File four! +File four! +File four! +File four! +File four! +File four! +File four! +File four! +File four! +File four! +File four! +File four! +File four! diff --git a/tests/resources/reftable/revwalk.git/HEAD b/tests/resources/reftable/revwalk.git/HEAD new file mode 100644 index 000000000..fe6d7e5fa --- /dev/null +++ b/tests/resources/reftable/revwalk.git/HEAD @@ -0,0 +1 @@ +ref: refs/heads/.invalid diff --git a/tests/resources/reftable/revwalk.git/config b/tests/resources/reftable/revwalk.git/config new file mode 100644 index 000000000..76c954a5d --- /dev/null +++ b/tests/resources/reftable/revwalk.git/config @@ -0,0 +1,8 @@ +[core] + bare = true + repositoryformatversion = 1 + filemode = false + symlinks = false + ignorecase = true +[extensions] + refstorage = reftable diff --git a/tests/resources/reftable/revwalk.git/description b/tests/resources/reftable/revwalk.git/description new file mode 100644 index 000000000..498b267a8 --- /dev/null +++ b/tests/resources/reftable/revwalk.git/description @@ -0,0 +1 @@ +Unnamed repository; edit this file 'description' to name the repository. diff --git a/tests/resources/reftable/revwalk.git/objects/info/packs b/tests/resources/reftable/revwalk.git/objects/info/packs new file mode 100644 index 000000000..d8d85b895 --- /dev/null +++ b/tests/resources/reftable/revwalk.git/objects/info/packs @@ -0,0 +1,2 @@ +P pack-9adacb9971981a1a3264fd473da5b800f2715959.pack + diff --git a/tests/resources/reftable/revwalk.git/objects/pack/pack-9adacb9971981a1a3264fd473da5b800f2715959.idx b/tests/resources/reftable/revwalk.git/objects/pack/pack-9adacb9971981a1a3264fd473da5b800f2715959.idx new file mode 100644 index 000000000..e157b386e Binary files /dev/null and b/tests/resources/reftable/revwalk.git/objects/pack/pack-9adacb9971981a1a3264fd473da5b800f2715959.idx differ diff --git a/tests/resources/reftable/revwalk.git/objects/pack/pack-9adacb9971981a1a3264fd473da5b800f2715959.pack b/tests/resources/reftable/revwalk.git/objects/pack/pack-9adacb9971981a1a3264fd473da5b800f2715959.pack new file mode 100644 index 000000000..2a61f9403 Binary files /dev/null and b/tests/resources/reftable/revwalk.git/objects/pack/pack-9adacb9971981a1a3264fd473da5b800f2715959.pack differ diff --git a/tests/resources/reftable/revwalk.git/refs/heads b/tests/resources/reftable/revwalk.git/refs/heads new file mode 100644 index 000000000..3e639a56a --- /dev/null +++ b/tests/resources/reftable/revwalk.git/refs/heads @@ -0,0 +1 @@ +this repository uses the reftable format diff --git a/tests/resources/reftable/revwalk.git/reftable/0x000000000001-0x000000000001-3d6d7a1b.ref b/tests/resources/reftable/revwalk.git/reftable/0x000000000001-0x000000000001-3d6d7a1b.ref new file mode 100644 index 000000000..3de3f3237 Binary files /dev/null and b/tests/resources/reftable/revwalk.git/reftable/0x000000000001-0x000000000001-3d6d7a1b.ref differ diff --git a/tests/resources/reftable/revwalk.git/reftable/tables.list b/tests/resources/reftable/revwalk.git/reftable/tables.list new file mode 100644 index 000000000..6dc732f7f --- /dev/null +++ b/tests/resources/reftable/revwalk.git/reftable/tables.list @@ -0,0 +1 @@ +0x000000000001-0x000000000001-3d6d7a1b.ref diff --git a/tests/resources/reftable/shallow.git/HEAD b/tests/resources/reftable/shallow.git/HEAD new file mode 100644 index 000000000..fe6d7e5fa --- /dev/null +++ b/tests/resources/reftable/shallow.git/HEAD @@ -0,0 +1 @@ +ref: refs/heads/.invalid diff --git a/tests/resources/reftable/shallow.git/config b/tests/resources/reftable/shallow.git/config new file mode 100644 index 000000000..5e7ef4434 --- /dev/null +++ b/tests/resources/reftable/shallow.git/config @@ -0,0 +1,10 @@ +[core] + repositoryformatversion = 1 + filemode = true + bare = true + ignorecase = true + precomposeunicode = false +[remote "origin"] + url = file://testrepo.git +[extensions] + refstorage = reftable diff --git a/tests/resources/reftable/shallow.git/objects/pack/pack-706e49b161700946489570d96153e5be4dc31ad4.idx b/tests/resources/reftable/shallow.git/objects/pack/pack-706e49b161700946489570d96153e5be4dc31ad4.idx new file mode 100644 index 000000000..bfc7d24ff Binary files /dev/null and b/tests/resources/reftable/shallow.git/objects/pack/pack-706e49b161700946489570d96153e5be4dc31ad4.idx differ diff --git a/tests/resources/reftable/shallow.git/objects/pack/pack-706e49b161700946489570d96153e5be4dc31ad4.pack b/tests/resources/reftable/shallow.git/objects/pack/pack-706e49b161700946489570d96153e5be4dc31ad4.pack new file mode 100644 index 000000000..ccc6932fc Binary files /dev/null and b/tests/resources/reftable/shallow.git/objects/pack/pack-706e49b161700946489570d96153e5be4dc31ad4.pack differ diff --git a/tests/resources/reftable/shallow.git/refs/heads b/tests/resources/reftable/shallow.git/refs/heads new file mode 100644 index 000000000..3e639a56a --- /dev/null +++ b/tests/resources/reftable/shallow.git/refs/heads @@ -0,0 +1 @@ +this repository uses the reftable format diff --git a/tests/resources/reftable/shallow.git/reftable/0x000000000001-0x000000000001-2fd8d5a0.ref b/tests/resources/reftable/shallow.git/reftable/0x000000000001-0x000000000001-2fd8d5a0.ref new file mode 100644 index 000000000..ea0147905 Binary files /dev/null and b/tests/resources/reftable/shallow.git/reftable/0x000000000001-0x000000000001-2fd8d5a0.ref differ diff --git a/tests/resources/reftable/shallow.git/reftable/tables.list b/tests/resources/reftable/shallow.git/reftable/tables.list new file mode 100644 index 000000000..f19e77d17 --- /dev/null +++ b/tests/resources/reftable/shallow.git/reftable/tables.list @@ -0,0 +1 @@ +0x000000000001-0x000000000001-2fd8d5a0.ref diff --git a/tests/resources/reftable/shallow.git/shallow b/tests/resources/reftable/shallow.git/shallow new file mode 100644 index 000000000..9536ad89c --- /dev/null +++ b/tests/resources/reftable/shallow.git/shallow @@ -0,0 +1 @@ +be3563ae3f795b2b4353bcce3a527ad0a4f7f644 diff --git a/tests/resources/reftable/splitindex/.gitted/HEAD b/tests/resources/reftable/splitindex/.gitted/HEAD new file mode 100644 index 000000000..fe6d7e5fa --- /dev/null +++ b/tests/resources/reftable/splitindex/.gitted/HEAD @@ -0,0 +1 @@ +ref: refs/heads/.invalid diff --git a/tests/resources/reftable/splitindex/.gitted/config b/tests/resources/reftable/splitindex/.gitted/config new file mode 100644 index 000000000..77747ae00 --- /dev/null +++ b/tests/resources/reftable/splitindex/.gitted/config @@ -0,0 +1,10 @@ +[core] + repositoryformatversion = 1 + filemode = true + bare = false + logallrefupdates = true + ignorecase = true + precomposeunicode = true + splitIndex = true +[extensions] + refstorage = reftable diff --git a/tests/resources/reftable/splitindex/.gitted/index b/tests/resources/reftable/splitindex/.gitted/index new file mode 100644 index 000000000..ff3448847 Binary files /dev/null and b/tests/resources/reftable/splitindex/.gitted/index differ diff --git a/tests/resources/reftable/splitindex/.gitted/info/exclude b/tests/resources/reftable/splitindex/.gitted/info/exclude new file mode 100644 index 000000000..a5196d1be --- /dev/null +++ b/tests/resources/reftable/splitindex/.gitted/info/exclude @@ -0,0 +1,6 @@ +# git ls-files --others --exclude-from=.git/info/exclude +# Lines that start with '#' are comments. +# For a project mostly in C, the following would be a good set of +# exclude patterns (uncomment them if you want to use them): +# *.[oa] +# *~ diff --git a/tests/resources/reftable/splitindex/.gitted/objects/.gitkeep b/tests/resources/reftable/splitindex/.gitted/objects/.gitkeep new file mode 100644 index 000000000..e69de29bb diff --git a/tests/resources/reftable/splitindex/.gitted/refs/heads b/tests/resources/reftable/splitindex/.gitted/refs/heads new file mode 100644 index 000000000..3e639a56a --- /dev/null +++ b/tests/resources/reftable/splitindex/.gitted/refs/heads @@ -0,0 +1 @@ +this repository uses the reftable format diff --git a/tests/resources/reftable/splitindex/.gitted/reftable/0x000000000001-0x000000000001-70555e38.ref b/tests/resources/reftable/splitindex/.gitted/reftable/0x000000000001-0x000000000001-70555e38.ref new file mode 100644 index 000000000..f5b66c330 Binary files /dev/null and b/tests/resources/reftable/splitindex/.gitted/reftable/0x000000000001-0x000000000001-70555e38.ref differ diff --git a/tests/resources/reftable/splitindex/.gitted/reftable/tables.list b/tests/resources/reftable/splitindex/.gitted/reftable/tables.list new file mode 100644 index 000000000..1f3471a56 --- /dev/null +++ b/tests/resources/reftable/splitindex/.gitted/reftable/tables.list @@ -0,0 +1 @@ +0x000000000001-0x000000000001-70555e38.ref diff --git a/tests/resources/reftable/splitindex/.gitted/sharedindex.39d890139ee5356c7ef572216cebcd27aa41f9df b/tests/resources/reftable/splitindex/.gitted/sharedindex.39d890139ee5356c7ef572216cebcd27aa41f9df new file mode 100644 index 000000000..3330d716f Binary files /dev/null and b/tests/resources/reftable/splitindex/.gitted/sharedindex.39d890139ee5356c7ef572216cebcd27aa41f9df differ diff --git a/tests/resources/reftable/status/.gitted/COMMIT_EDITMSG b/tests/resources/reftable/status/.gitted/COMMIT_EDITMSG new file mode 100644 index 000000000..1a25cd4a6 --- /dev/null +++ b/tests/resources/reftable/status/.gitted/COMMIT_EDITMSG @@ -0,0 +1 @@ +Add a file which name should appear before the "subdir/" folder while being dealt with by the treewalker diff --git a/tests/resources/reftable/status/.gitted/HEAD b/tests/resources/reftable/status/.gitted/HEAD new file mode 100644 index 000000000..fe6d7e5fa --- /dev/null +++ b/tests/resources/reftable/status/.gitted/HEAD @@ -0,0 +1 @@ +ref: refs/heads/.invalid diff --git a/tests/resources/reftable/status/.gitted/config b/tests/resources/reftable/status/.gitted/config new file mode 100644 index 000000000..0694d84cb --- /dev/null +++ b/tests/resources/reftable/status/.gitted/config @@ -0,0 +1,8 @@ +[core] + repositoryformatversion = 1 + filemode = true + bare = false + logallrefupdates = true + ignorecase = true +[extensions] + refstorage = reftable diff --git a/tests/resources/reftable/status/.gitted/description b/tests/resources/reftable/status/.gitted/description new file mode 100644 index 000000000..498b267a8 --- /dev/null +++ b/tests/resources/reftable/status/.gitted/description @@ -0,0 +1 @@ +Unnamed repository; edit this file 'description' to name the repository. diff --git a/tests/resources/reftable/status/.gitted/index b/tests/resources/reftable/status/.gitted/index new file mode 100644 index 000000000..2af99a183 Binary files /dev/null and b/tests/resources/reftable/status/.gitted/index differ diff --git a/tests/resources/reftable/status/.gitted/info/exclude b/tests/resources/reftable/status/.gitted/info/exclude new file mode 100644 index 000000000..0c4042a6a --- /dev/null +++ b/tests/resources/reftable/status/.gitted/info/exclude @@ -0,0 +1,8 @@ +# git ls-files --others --exclude-from=.git/info/exclude +# Lines that start with '#' are comments. +# For a project mostly in C, the following would be a good set of +# exclude patterns (uncomment them if you want to use them): +# *.[oa] +# *~ +ignored* + diff --git a/tests/resources/reftable/status/.gitted/objects/00/17bd4ab1ec30440b17bae1680cff124ab5f1f6 b/tests/resources/reftable/status/.gitted/objects/00/17bd4ab1ec30440b17bae1680cff124ab5f1f6 new file mode 100644 index 000000000..b256d95a3 --- /dev/null +++ b/tests/resources/reftable/status/.gitted/objects/00/17bd4ab1ec30440b17bae1680cff124ab5f1f6 @@ -0,0 +1,2 @@ +xA E]sfh)1] +#STWpK^~9ܡ-"C'؅)Fvbv "wEk{nRί6#sO pD663WxV?9 \ No newline at end of file diff --git a/tests/resources/reftable/status/.gitted/objects/06/1d42a44cacde5726057b67558821d95db96f19 b/tests/resources/reftable/status/.gitted/objects/06/1d42a44cacde5726057b67558821d95db96f19 new file mode 100644 index 000000000..82e02cb0e Binary files /dev/null and b/tests/resources/reftable/status/.gitted/objects/06/1d42a44cacde5726057b67558821d95db96f19 differ diff --git a/tests/resources/reftable/status/.gitted/objects/18/88c805345ba265b0ee9449b8877b6064592058 b/tests/resources/reftable/status/.gitted/objects/18/88c805345ba265b0ee9449b8877b6064592058 new file mode 100644 index 000000000..e3cad2f02 Binary files /dev/null and b/tests/resources/reftable/status/.gitted/objects/18/88c805345ba265b0ee9449b8877b6064592058 differ diff --git a/tests/resources/reftable/status/.gitted/objects/19/d9cc8584ac2c7dcf57d2680375e80f099dc481 b/tests/resources/reftable/status/.gitted/objects/19/d9cc8584ac2c7dcf57d2680375e80f099dc481 new file mode 100644 index 000000000..2d5e711b9 Binary files /dev/null and b/tests/resources/reftable/status/.gitted/objects/19/d9cc8584ac2c7dcf57d2680375e80f099dc481 differ diff --git a/tests/resources/reftable/status/.gitted/objects/26/a125ee1bfc5df1e1b2e9441bbe63c8a7ae989f b/tests/resources/reftable/status/.gitted/objects/26/a125ee1bfc5df1e1b2e9441bbe63c8a7ae989f new file mode 100644 index 000000000..f7dddc4ff --- /dev/null +++ b/tests/resources/reftable/status/.gitted/objects/26/a125ee1bfc5df1e1b2e9441bbe63c8a7ae989f @@ -0,0 +1,2 @@ +xMn )V (̀BD޾LЍRȷވ@,9̜tNj6f`M6Z;h Zp ڙY,37/;42x&gϟۉIm|j \ No newline at end of file diff --git a/tests/resources/reftable/status/.gitted/objects/2b/d0a343aeef7a2cf0d158478966a6e587ff3863 b/tests/resources/reftable/status/.gitted/objects/2b/d0a343aeef7a2cf0d158478966a6e587ff3863 new file mode 100644 index 000000000..d10ca636b Binary files /dev/null and b/tests/resources/reftable/status/.gitted/objects/2b/d0a343aeef7a2cf0d158478966a6e587ff3863 differ diff --git a/tests/resources/reftable/status/.gitted/objects/32/504b727382542f9f089e24fddac5e78533e96c b/tests/resources/reftable/status/.gitted/objects/32/504b727382542f9f089e24fddac5e78533e96c new file mode 100644 index 000000000..7fca67be8 Binary files /dev/null and b/tests/resources/reftable/status/.gitted/objects/32/504b727382542f9f089e24fddac5e78533e96c differ diff --git a/tests/resources/reftable/status/.gitted/objects/37/fcb02ccc1a85d1941e7f106d52dc3702dcf0d0 b/tests/resources/reftable/status/.gitted/objects/37/fcb02ccc1a85d1941e7f106d52dc3702dcf0d0 new file mode 100644 index 000000000..b75481b51 Binary files /dev/null and b/tests/resources/reftable/status/.gitted/objects/37/fcb02ccc1a85d1941e7f106d52dc3702dcf0d0 differ diff --git a/tests/resources/reftable/status/.gitted/objects/45/2e4244b5d083ddf0460acf1ecc74db9dcfa11a b/tests/resources/reftable/status/.gitted/objects/45/2e4244b5d083ddf0460acf1ecc74db9dcfa11a new file mode 100644 index 000000000..5b47461e9 Binary files /dev/null and b/tests/resources/reftable/status/.gitted/objects/45/2e4244b5d083ddf0460acf1ecc74db9dcfa11a differ diff --git a/tests/resources/reftable/status/.gitted/objects/52/9a16e8e762d4acb7b9636ff540a00831f9155a b/tests/resources/reftable/status/.gitted/objects/52/9a16e8e762d4acb7b9636ff540a00831f9155a new file mode 100644 index 000000000..615009ad0 Binary files /dev/null and b/tests/resources/reftable/status/.gitted/objects/52/9a16e8e762d4acb7b9636ff540a00831f9155a differ diff --git a/tests/resources/reftable/status/.gitted/objects/53/ace0d1cc1145a5f4fe4f78a186a60263190733 b/tests/resources/reftable/status/.gitted/objects/53/ace0d1cc1145a5f4fe4f78a186a60263190733 new file mode 100644 index 000000000..cdb7e961a Binary files /dev/null and b/tests/resources/reftable/status/.gitted/objects/53/ace0d1cc1145a5f4fe4f78a186a60263190733 differ diff --git a/tests/resources/reftable/status/.gitted/objects/54/52d32f1dd538eb0405e8a83cc185f79e25e80f b/tests/resources/reftable/status/.gitted/objects/54/52d32f1dd538eb0405e8a83cc185f79e25e80f new file mode 100644 index 000000000..a72dff646 Binary files /dev/null and b/tests/resources/reftable/status/.gitted/objects/54/52d32f1dd538eb0405e8a83cc185f79e25e80f differ diff --git a/tests/resources/reftable/status/.gitted/objects/55/d316c9ba708999f1918e9677d01dfcae69c6b9 b/tests/resources/reftable/status/.gitted/objects/55/d316c9ba708999f1918e9677d01dfcae69c6b9 new file mode 100644 index 000000000..72807f3d0 Binary files /dev/null and b/tests/resources/reftable/status/.gitted/objects/55/d316c9ba708999f1918e9677d01dfcae69c6b9 differ diff --git a/tests/resources/reftable/status/.gitted/objects/70/bd9443ada07063e7fbf0b3ff5c13f7494d89c2 b/tests/resources/reftable/status/.gitted/objects/70/bd9443ada07063e7fbf0b3ff5c13f7494d89c2 new file mode 100644 index 000000000..3665a8f7c Binary files /dev/null and b/tests/resources/reftable/status/.gitted/objects/70/bd9443ada07063e7fbf0b3ff5c13f7494d89c2 differ diff --git a/tests/resources/reftable/status/.gitted/objects/73/5b6a258cd196a8f7c9428419b02c1dca93fd75 b/tests/resources/reftable/status/.gitted/objects/73/5b6a258cd196a8f7c9428419b02c1dca93fd75 new file mode 100644 index 000000000..08e6fd246 Binary files /dev/null and b/tests/resources/reftable/status/.gitted/objects/73/5b6a258cd196a8f7c9428419b02c1dca93fd75 differ diff --git a/tests/resources/reftable/status/.gitted/objects/75/6e27627e67bfbc048d01ece5819c6de733d7ea b/tests/resources/reftable/status/.gitted/objects/75/6e27627e67bfbc048d01ece5819c6de733d7ea new file mode 100644 index 000000000..8f3fa89e5 Binary files /dev/null and b/tests/resources/reftable/status/.gitted/objects/75/6e27627e67bfbc048d01ece5819c6de733d7ea differ diff --git a/tests/resources/reftable/status/.gitted/objects/90/6ee7711f4f4928ddcb2a5f8fbc500deba0d2a8 b/tests/resources/reftable/status/.gitted/objects/90/6ee7711f4f4928ddcb2a5f8fbc500deba0d2a8 new file mode 100644 index 000000000..bb732b08e Binary files /dev/null and b/tests/resources/reftable/status/.gitted/objects/90/6ee7711f4f4928ddcb2a5f8fbc500deba0d2a8 differ diff --git a/tests/resources/reftable/status/.gitted/objects/90/b8c29d8ba39434d1c63e1b093daaa26e5bd972 b/tests/resources/reftable/status/.gitted/objects/90/b8c29d8ba39434d1c63e1b093daaa26e5bd972 new file mode 100644 index 000000000..7a96618ff Binary files /dev/null and b/tests/resources/reftable/status/.gitted/objects/90/b8c29d8ba39434d1c63e1b093daaa26e5bd972 differ diff --git a/tests/resources/reftable/status/.gitted/objects/9c/2e02cdffa8d73e6c189074594477a6baf87960 b/tests/resources/reftable/status/.gitted/objects/9c/2e02cdffa8d73e6c189074594477a6baf87960 new file mode 100644 index 000000000..20a3c497e Binary files /dev/null and b/tests/resources/reftable/status/.gitted/objects/9c/2e02cdffa8d73e6c189074594477a6baf87960 differ diff --git a/tests/resources/reftable/status/.gitted/objects/a0/de7e0ac200c489c41c59dfa910154a70264e6e b/tests/resources/reftable/status/.gitted/objects/a0/de7e0ac200c489c41c59dfa910154a70264e6e new file mode 100644 index 000000000..a1789c9a6 Binary files /dev/null and b/tests/resources/reftable/status/.gitted/objects/a0/de7e0ac200c489c41c59dfa910154a70264e6e differ diff --git a/tests/resources/reftable/status/.gitted/objects/a6/191982709b746d5650e93c2acf34ef74e11504 b/tests/resources/reftable/status/.gitted/objects/a6/191982709b746d5650e93c2acf34ef74e11504 new file mode 100644 index 000000000..cc1f377b3 Binary files /dev/null and b/tests/resources/reftable/status/.gitted/objects/a6/191982709b746d5650e93c2acf34ef74e11504 differ diff --git a/tests/resources/reftable/status/.gitted/objects/a6/be623522ce87a1d862128ac42672604f7b468b b/tests/resources/reftable/status/.gitted/objects/a6/be623522ce87a1d862128ac42672604f7b468b new file mode 100644 index 000000000..c47298347 Binary files /dev/null and b/tests/resources/reftable/status/.gitted/objects/a6/be623522ce87a1d862128ac42672604f7b468b differ diff --git a/tests/resources/reftable/status/.gitted/objects/aa/27a641456848200fdb7f7c99ba36f8a0952877 b/tests/resources/reftable/status/.gitted/objects/aa/27a641456848200fdb7f7c99ba36f8a0952877 new file mode 100644 index 000000000..a4669ccbb Binary files /dev/null and b/tests/resources/reftable/status/.gitted/objects/aa/27a641456848200fdb7f7c99ba36f8a0952877 differ diff --git a/tests/resources/reftable/status/.gitted/objects/d4/27e0b2e138501a3d15cc376077a3631e15bd46 b/tests/resources/reftable/status/.gitted/objects/d4/27e0b2e138501a3d15cc376077a3631e15bd46 new file mode 100644 index 000000000..0b3611ae4 Binary files /dev/null and b/tests/resources/reftable/status/.gitted/objects/d4/27e0b2e138501a3d15cc376077a3631e15bd46 differ diff --git a/tests/resources/reftable/status/.gitted/objects/da/bc8af9bd6e9f5bbe96a176f1a24baf3d1f8916 b/tests/resources/reftable/status/.gitted/objects/da/bc8af9bd6e9f5bbe96a176f1a24baf3d1f8916 new file mode 100644 index 000000000..3e3c03c96 Binary files /dev/null and b/tests/resources/reftable/status/.gitted/objects/da/bc8af9bd6e9f5bbe96a176f1a24baf3d1f8916 differ diff --git a/tests/resources/reftable/status/.gitted/objects/e8/ee89e15bbe9b20137715232387b3de5b28972e b/tests/resources/reftable/status/.gitted/objects/e8/ee89e15bbe9b20137715232387b3de5b28972e new file mode 100644 index 000000000..cfc2413d5 Binary files /dev/null and b/tests/resources/reftable/status/.gitted/objects/e8/ee89e15bbe9b20137715232387b3de5b28972e differ diff --git a/tests/resources/reftable/status/.gitted/objects/e9/b9107f290627c04d097733a10055af941f6bca b/tests/resources/reftable/status/.gitted/objects/e9/b9107f290627c04d097733a10055af941f6bca new file mode 100644 index 000000000..1266d3eac Binary files /dev/null and b/tests/resources/reftable/status/.gitted/objects/e9/b9107f290627c04d097733a10055af941f6bca differ diff --git a/tests/resources/reftable/status/.gitted/objects/ed/062903b8f6f3dccb2fa81117ba6590944ef9bd b/tests/resources/reftable/status/.gitted/objects/ed/062903b8f6f3dccb2fa81117ba6590944ef9bd new file mode 100644 index 000000000..8fa8c1707 Binary files /dev/null and b/tests/resources/reftable/status/.gitted/objects/ed/062903b8f6f3dccb2fa81117ba6590944ef9bd differ diff --git a/tests/resources/reftable/status/.gitted/objects/ee/3fa1b8c00aff7fe02065fdb50864bb0d932ccf b/tests/resources/reftable/status/.gitted/objects/ee/3fa1b8c00aff7fe02065fdb50864bb0d932ccf new file mode 100644 index 000000000..974b72dfd Binary files /dev/null and b/tests/resources/reftable/status/.gitted/objects/ee/3fa1b8c00aff7fe02065fdb50864bb0d932ccf differ diff --git a/tests/resources/reftable/status/.gitted/refs/heads b/tests/resources/reftable/status/.gitted/refs/heads new file mode 100644 index 000000000..3e639a56a --- /dev/null +++ b/tests/resources/reftable/status/.gitted/refs/heads @@ -0,0 +1 @@ +this repository uses the reftable format diff --git a/tests/resources/reftable/status/.gitted/reftable/0x000000000001-0x000000000003-f8cba57d.ref b/tests/resources/reftable/status/.gitted/reftable/0x000000000001-0x000000000003-f8cba57d.ref new file mode 100644 index 000000000..80b99c976 Binary files /dev/null and b/tests/resources/reftable/status/.gitted/reftable/0x000000000001-0x000000000003-f8cba57d.ref differ diff --git a/tests/resources/reftable/status/.gitted/reftable/tables.list b/tests/resources/reftable/status/.gitted/reftable/tables.list new file mode 100644 index 000000000..b96874b2a --- /dev/null +++ b/tests/resources/reftable/status/.gitted/reftable/tables.list @@ -0,0 +1 @@ +0x000000000001-0x000000000003-f8cba57d.ref diff --git a/tests/resources/reftable/status/current_file b/tests/resources/reftable/status/current_file new file mode 100644 index 000000000..a0de7e0ac --- /dev/null +++ b/tests/resources/reftable/status/current_file @@ -0,0 +1 @@ +current_file diff --git a/tests/resources/reftable/status/ignored_file b/tests/resources/reftable/status/ignored_file new file mode 100644 index 000000000..6a79f808a --- /dev/null +++ b/tests/resources/reftable/status/ignored_file @@ -0,0 +1 @@ +ignored_file diff --git a/tests/resources/reftable/status/modified_file b/tests/resources/reftable/status/modified_file new file mode 100644 index 000000000..0a5396305 --- /dev/null +++ b/tests/resources/reftable/status/modified_file @@ -0,0 +1,2 @@ +modified_file +modified_file diff --git a/tests/resources/reftable/status/new_file b/tests/resources/reftable/status/new_file new file mode 100644 index 000000000..d4fa8600b --- /dev/null +++ b/tests/resources/reftable/status/new_file @@ -0,0 +1 @@ +new_file diff --git a/tests/resources/reftable/status/staged_changes b/tests/resources/reftable/status/staged_changes new file mode 100644 index 000000000..55d316c9b --- /dev/null +++ b/tests/resources/reftable/status/staged_changes @@ -0,0 +1,2 @@ +staged_changes +staged_changes diff --git a/tests/resources/reftable/status/staged_changes_modified_file b/tests/resources/reftable/status/staged_changes_modified_file new file mode 100644 index 000000000..011c3440d --- /dev/null +++ b/tests/resources/reftable/status/staged_changes_modified_file @@ -0,0 +1,3 @@ +staged_changes_modified_file +staged_changes_modified_file +staged_changes_modified_file diff --git a/tests/resources/reftable/status/staged_delete_modified_file b/tests/resources/reftable/status/staged_delete_modified_file new file mode 100644 index 000000000..dabc8af9b --- /dev/null +++ b/tests/resources/reftable/status/staged_delete_modified_file @@ -0,0 +1 @@ +staged_delete_modified_file diff --git a/tests/resources/reftable/status/staged_new_file b/tests/resources/reftable/status/staged_new_file new file mode 100644 index 000000000..529a16e8e --- /dev/null +++ b/tests/resources/reftable/status/staged_new_file @@ -0,0 +1 @@ +staged_new_file diff --git a/tests/resources/reftable/status/staged_new_file_modified_file b/tests/resources/reftable/status/staged_new_file_modified_file new file mode 100644 index 000000000..8b090c06d --- /dev/null +++ b/tests/resources/reftable/status/staged_new_file_modified_file @@ -0,0 +1,2 @@ +staged_new_file_modified_file +staged_new_file_modified_file diff --git a/tests/resources/reftable/status/subdir.txt b/tests/resources/reftable/status/subdir.txt new file mode 100644 index 000000000..e8ee89e15 --- /dev/null +++ b/tests/resources/reftable/status/subdir.txt @@ -0,0 +1,2 @@ +Is it a bird? +Is it a plane? diff --git a/tests/resources/reftable/status/subdir/current_file b/tests/resources/reftable/status/subdir/current_file new file mode 100644 index 000000000..53ace0d1c --- /dev/null +++ b/tests/resources/reftable/status/subdir/current_file @@ -0,0 +1 @@ +subdir/current_file diff --git a/tests/resources/reftable/status/subdir/modified_file b/tests/resources/reftable/status/subdir/modified_file new file mode 100644 index 000000000..57274b75e --- /dev/null +++ b/tests/resources/reftable/status/subdir/modified_file @@ -0,0 +1,2 @@ +subdir/modified_file +subdir/modified_file diff --git a/tests/resources/reftable/status/subdir/new_file b/tests/resources/reftable/status/subdir/new_file new file mode 100644 index 000000000..80a86a693 --- /dev/null +++ b/tests/resources/reftable/status/subdir/new_file @@ -0,0 +1 @@ +subdir/new_file diff --git a/tests/resources/reftable/status/这 b/tests/resources/reftable/status/这 new file mode 100644 index 000000000..f0ff9a197 --- /dev/null +++ b/tests/resources/reftable/status/这 @@ -0,0 +1 @@ +This diff --git a/tests/resources/reftable/status_skiphash/.gitted/COMMIT_EDITMSG b/tests/resources/reftable/status_skiphash/.gitted/COMMIT_EDITMSG new file mode 100644 index 000000000..ea450f959 --- /dev/null +++ b/tests/resources/reftable/status_skiphash/.gitted/COMMIT_EDITMSG @@ -0,0 +1 @@ +New file diff --git a/tests/resources/reftable/status_skiphash/.gitted/HEAD b/tests/resources/reftable/status_skiphash/.gitted/HEAD new file mode 100644 index 000000000..fe6d7e5fa --- /dev/null +++ b/tests/resources/reftable/status_skiphash/.gitted/HEAD @@ -0,0 +1 @@ +ref: refs/heads/.invalid diff --git a/tests/resources/reftable/status_skiphash/.gitted/MERGE_RR b/tests/resources/reftable/status_skiphash/.gitted/MERGE_RR new file mode 100644 index 000000000..e69de29bb diff --git a/tests/resources/reftable/status_skiphash/.gitted/config b/tests/resources/reftable/status_skiphash/.gitted/config new file mode 100644 index 000000000..63ec977c1 --- /dev/null +++ b/tests/resources/reftable/status_skiphash/.gitted/config @@ -0,0 +1,11 @@ +[core] + repositoryformatversion = 1 + filemode = false + bare = false + logallrefupdates = true + symlinks = false + ignorecase = true +[index] + skipHash = true +[extensions] + refstorage = reftable diff --git a/tests/resources/reftable/status_skiphash/.gitted/description b/tests/resources/reftable/status_skiphash/.gitted/description new file mode 100644 index 000000000..498b267a8 --- /dev/null +++ b/tests/resources/reftable/status_skiphash/.gitted/description @@ -0,0 +1 @@ +Unnamed repository; edit this file 'description' to name the repository. diff --git a/tests/resources/reftable/status_skiphash/.gitted/index b/tests/resources/reftable/status_skiphash/.gitted/index new file mode 100644 index 000000000..1963fe0d3 Binary files /dev/null and b/tests/resources/reftable/status_skiphash/.gitted/index differ diff --git a/tests/resources/reftable/status_skiphash/.gitted/info/exclude b/tests/resources/reftable/status_skiphash/.gitted/info/exclude new file mode 100644 index 000000000..a5196d1be --- /dev/null +++ b/tests/resources/reftable/status_skiphash/.gitted/info/exclude @@ -0,0 +1,6 @@ +# git ls-files --others --exclude-from=.git/info/exclude +# Lines that start with '#' are comments. +# For a project mostly in C, the following would be a good set of +# exclude patterns (uncomment them if you want to use them): +# *.[oa] +# *~ diff --git a/tests/resources/reftable/status_skiphash/.gitted/objects/34/f4c90b237fcb4c677772a6093f3cba239c41a5 b/tests/resources/reftable/status_skiphash/.gitted/objects/34/f4c90b237fcb4c677772a6093f3cba239c41a5 new file mode 100644 index 000000000..0513158cb Binary files /dev/null and b/tests/resources/reftable/status_skiphash/.gitted/objects/34/f4c90b237fcb4c677772a6093f3cba239c41a5 differ diff --git a/tests/resources/reftable/status_skiphash/.gitted/objects/71/a21e67674e9717aa7380e5782ec5e070a8d7e0 b/tests/resources/reftable/status_skiphash/.gitted/objects/71/a21e67674e9717aa7380e5782ec5e070a8d7e0 new file mode 100644 index 000000000..7c48fa4f4 Binary files /dev/null and b/tests/resources/reftable/status_skiphash/.gitted/objects/71/a21e67674e9717aa7380e5782ec5e070a8d7e0 differ diff --git a/tests/resources/reftable/status_skiphash/.gitted/objects/d7/c1f165e51adbbfd7760162b7a5802d4117740c b/tests/resources/reftable/status_skiphash/.gitted/objects/d7/c1f165e51adbbfd7760162b7a5802d4117740c new file mode 100644 index 000000000..c685321ce Binary files /dev/null and b/tests/resources/reftable/status_skiphash/.gitted/objects/d7/c1f165e51adbbfd7760162b7a5802d4117740c differ diff --git a/tests/resources/reftable/status_skiphash/.gitted/refs/heads b/tests/resources/reftable/status_skiphash/.gitted/refs/heads new file mode 100644 index 000000000..3e639a56a --- /dev/null +++ b/tests/resources/reftable/status_skiphash/.gitted/refs/heads @@ -0,0 +1 @@ +this repository uses the reftable format diff --git a/tests/resources/reftable/status_skiphash/.gitted/reftable/0x000000000001-0x000000000001-5b50d7c7.ref b/tests/resources/reftable/status_skiphash/.gitted/reftable/0x000000000001-0x000000000001-5b50d7c7.ref new file mode 100644 index 000000000..52c41cdac Binary files /dev/null and b/tests/resources/reftable/status_skiphash/.gitted/reftable/0x000000000001-0x000000000001-5b50d7c7.ref differ diff --git a/tests/resources/reftable/status_skiphash/.gitted/reftable/tables.list b/tests/resources/reftable/status_skiphash/.gitted/reftable/tables.list new file mode 100644 index 000000000..5f76b331b --- /dev/null +++ b/tests/resources/reftable/status_skiphash/.gitted/reftable/tables.list @@ -0,0 +1 @@ +0x000000000001-0x000000000001-5b50d7c7.ref diff --git a/tests/resources/reftable/status_skiphash/new_file b/tests/resources/reftable/status_skiphash/new_file new file mode 100644 index 000000000..badcfca34 --- /dev/null +++ b/tests/resources/reftable/status_skiphash/new_file @@ -0,0 +1 @@ +new_file diff --git a/tests/resources/reftable/submod2/.gitted/HEAD b/tests/resources/reftable/submod2/.gitted/HEAD new file mode 100644 index 000000000..fe6d7e5fa --- /dev/null +++ b/tests/resources/reftable/submod2/.gitted/HEAD @@ -0,0 +1 @@ +ref: refs/heads/.invalid diff --git a/tests/resources/reftable/submod2/.gitted/config b/tests/resources/reftable/submod2/.gitted/config new file mode 100644 index 000000000..e6484fbd6 --- /dev/null +++ b/tests/resources/reftable/submod2/.gitted/config @@ -0,0 +1,22 @@ +[core] + repositoryformatversion = 1 + filemode = true + bare = false + logallrefupdates = true + ignorecase = true +[submodule "sm_missing_commits"] + url = ../submod2_target +[submodule "sm_unchanged"] + url = ../submod2_target +[submodule "sm_changed_file"] + url = ../submod2_target +[submodule "sm_changed_index"] + url = ../submod2_target +[submodule "sm_changed_head"] + url = ../submod2_target +[submodule "sm_changed_untracked_file"] + url = ../submod2_target +[submodule "sm_added_and_uncommited"] + url = ../submod2_target +[extensions] + refstorage = reftable diff --git a/tests/resources/reftable/submod2/.gitted/description b/tests/resources/reftable/submod2/.gitted/description new file mode 100644 index 000000000..498b267a8 --- /dev/null +++ b/tests/resources/reftable/submod2/.gitted/description @@ -0,0 +1 @@ +Unnamed repository; edit this file 'description' to name the repository. diff --git a/tests/resources/reftable/submod2/.gitted/index b/tests/resources/reftable/submod2/.gitted/index new file mode 100644 index 000000000..0c17e8629 Binary files /dev/null and b/tests/resources/reftable/submod2/.gitted/index differ diff --git a/tests/resources/reftable/submod2/.gitted/info/exclude b/tests/resources/reftable/submod2/.gitted/info/exclude new file mode 100644 index 000000000..a5196d1be --- /dev/null +++ b/tests/resources/reftable/submod2/.gitted/info/exclude @@ -0,0 +1,6 @@ +# git ls-files --others --exclude-from=.git/info/exclude +# Lines that start with '#' are comments. +# For a project mostly in C, the following would be a good set of +# exclude patterns (uncomment them if you want to use them): +# *.[oa] +# *~ diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_added_and_uncommited/HEAD b/tests/resources/reftable/submod2/.gitted/modules/sm_added_and_uncommited/HEAD new file mode 100644 index 000000000..cb089cd89 --- /dev/null +++ b/tests/resources/reftable/submod2/.gitted/modules/sm_added_and_uncommited/HEAD @@ -0,0 +1 @@ +ref: refs/heads/master diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_added_and_uncommited/config b/tests/resources/reftable/submod2/.gitted/modules/sm_added_and_uncommited/config new file mode 100644 index 000000000..2d0583e99 --- /dev/null +++ b/tests/resources/reftable/submod2/.gitted/modules/sm_added_and_uncommited/config @@ -0,0 +1,13 @@ +[core] + repositoryformatversion = 0 + filemode = true + bare = false + logallrefupdates = true + worktree = ../../../sm_added_and_uncommited + ignorecase = true +[remote "origin"] + fetch = +refs/heads/*:refs/remotes/origin/* + url = /Users/rb/src/libgit2/tests-clar/resources/submod2_target +[branch "master"] + remote = origin + merge = refs/heads/master diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_added_and_uncommited/description b/tests/resources/reftable/submod2/.gitted/modules/sm_added_and_uncommited/description new file mode 100644 index 000000000..498b267a8 --- /dev/null +++ b/tests/resources/reftable/submod2/.gitted/modules/sm_added_and_uncommited/description @@ -0,0 +1 @@ +Unnamed repository; edit this file 'description' to name the repository. diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_added_and_uncommited/index b/tests/resources/reftable/submod2/.gitted/modules/sm_added_and_uncommited/index new file mode 100644 index 000000000..65140a510 Binary files /dev/null and b/tests/resources/reftable/submod2/.gitted/modules/sm_added_and_uncommited/index differ diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_added_and_uncommited/info/exclude b/tests/resources/reftable/submod2/.gitted/modules/sm_added_and_uncommited/info/exclude new file mode 100644 index 000000000..a5196d1be --- /dev/null +++ b/tests/resources/reftable/submod2/.gitted/modules/sm_added_and_uncommited/info/exclude @@ -0,0 +1,6 @@ +# git ls-files --others --exclude-from=.git/info/exclude +# Lines that start with '#' are comments. +# For a project mostly in C, the following would be a good set of +# exclude patterns (uncomment them if you want to use them): +# *.[oa] +# *~ diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_added_and_uncommited/logs/HEAD b/tests/resources/reftable/submod2/.gitted/modules/sm_added_and_uncommited/logs/HEAD new file mode 100644 index 000000000..53753e7dd --- /dev/null +++ b/tests/resources/reftable/submod2/.gitted/modules/sm_added_and_uncommited/logs/HEAD @@ -0,0 +1 @@ +0000000000000000000000000000000000000000 480095882d281ed676fe5b863569520e54a7d5c0 Russell Belfer 1342560316 -0700 clone: from /Users/rb/src/libgit2/tests-clar/resources/submod2_target diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_added_and_uncommited/logs/refs/heads/master b/tests/resources/reftable/submod2/.gitted/modules/sm_added_and_uncommited/logs/refs/heads/master new file mode 100644 index 000000000..53753e7dd --- /dev/null +++ b/tests/resources/reftable/submod2/.gitted/modules/sm_added_and_uncommited/logs/refs/heads/master @@ -0,0 +1 @@ +0000000000000000000000000000000000000000 480095882d281ed676fe5b863569520e54a7d5c0 Russell Belfer 1342560316 -0700 clone: from /Users/rb/src/libgit2/tests-clar/resources/submod2_target diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_added_and_uncommited/logs/refs/remotes/origin/HEAD b/tests/resources/reftable/submod2/.gitted/modules/sm_added_and_uncommited/logs/refs/remotes/origin/HEAD new file mode 100644 index 000000000..53753e7dd --- /dev/null +++ b/tests/resources/reftable/submod2/.gitted/modules/sm_added_and_uncommited/logs/refs/remotes/origin/HEAD @@ -0,0 +1 @@ +0000000000000000000000000000000000000000 480095882d281ed676fe5b863569520e54a7d5c0 Russell Belfer 1342560316 -0700 clone: from /Users/rb/src/libgit2/tests-clar/resources/submod2_target diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_added_and_uncommited/objects/06/362fe2fdb7010d0e447b4fb450d405420479a1 b/tests/resources/reftable/submod2/.gitted/modules/sm_added_and_uncommited/objects/06/362fe2fdb7010d0e447b4fb450d405420479a1 new file mode 100644 index 000000000..f4b7094c5 Binary files /dev/null and b/tests/resources/reftable/submod2/.gitted/modules/sm_added_and_uncommited/objects/06/362fe2fdb7010d0e447b4fb450d405420479a1 differ diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_added_and_uncommited/objects/0e/6a3ca48bd47cfe67681acf39aa0b10a0b92484 b/tests/resources/reftable/submod2/.gitted/modules/sm_added_and_uncommited/objects/0e/6a3ca48bd47cfe67681acf39aa0b10a0b92484 new file mode 100644 index 000000000..56c845e49 Binary files /dev/null and b/tests/resources/reftable/submod2/.gitted/modules/sm_added_and_uncommited/objects/0e/6a3ca48bd47cfe67681acf39aa0b10a0b92484 differ diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_added_and_uncommited/objects/17/d0ece6e96460a06592d9d9d000de37ba4232c5 b/tests/resources/reftable/submod2/.gitted/modules/sm_added_and_uncommited/objects/17/d0ece6e96460a06592d9d9d000de37ba4232c5 new file mode 100644 index 000000000..bd179b5f5 Binary files /dev/null and b/tests/resources/reftable/submod2/.gitted/modules/sm_added_and_uncommited/objects/17/d0ece6e96460a06592d9d9d000de37ba4232c5 differ diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_added_and_uncommited/objects/41/bd4bc3df978de695f67ace64c560913da11653 b/tests/resources/reftable/submod2/.gitted/modules/sm_added_and_uncommited/objects/41/bd4bc3df978de695f67ace64c560913da11653 new file mode 100644 index 000000000..ccf49bd15 Binary files /dev/null and b/tests/resources/reftable/submod2/.gitted/modules/sm_added_and_uncommited/objects/41/bd4bc3df978de695f67ace64c560913da11653 differ diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_added_and_uncommited/objects/48/0095882d281ed676fe5b863569520e54a7d5c0 b/tests/resources/reftable/submod2/.gitted/modules/sm_added_and_uncommited/objects/48/0095882d281ed676fe5b863569520e54a7d5c0 new file mode 100644 index 000000000..53029069a Binary files /dev/null and b/tests/resources/reftable/submod2/.gitted/modules/sm_added_and_uncommited/objects/48/0095882d281ed676fe5b863569520e54a7d5c0 differ diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_added_and_uncommited/objects/5e/4963595a9774b90524d35a807169049de8ccad b/tests/resources/reftable/submod2/.gitted/modules/sm_added_and_uncommited/objects/5e/4963595a9774b90524d35a807169049de8ccad new file mode 100644 index 000000000..38c791eba Binary files /dev/null and b/tests/resources/reftable/submod2/.gitted/modules/sm_added_and_uncommited/objects/5e/4963595a9774b90524d35a807169049de8ccad differ diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_added_and_uncommited/objects/6b/31c659545507c381e9cd34ec508f16c04e149e b/tests/resources/reftable/submod2/.gitted/modules/sm_added_and_uncommited/objects/6b/31c659545507c381e9cd34ec508f16c04e149e new file mode 100644 index 000000000..a26d29993 --- /dev/null +++ b/tests/resources/reftable/submod2/.gitted/modules/sm_added_and_uncommited/objects/6b/31c659545507c381e9cd34ec508f16c04e149e @@ -0,0 +1,2 @@ +xQ +!Evoy*_@g#hOh^9wSòf1*[Ic Ԥpk Α\S߇l@.^QpF(:D5zr~ en8 \ No newline at end of file diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_added_and_uncommited/objects/73/ba924a80437097795ae839e66e187c55d3babf b/tests/resources/reftable/submod2/.gitted/modules/sm_added_and_uncommited/objects/73/ba924a80437097795ae839e66e187c55d3babf new file mode 100644 index 000000000..83d1ba481 Binary files /dev/null and b/tests/resources/reftable/submod2/.gitted/modules/sm_added_and_uncommited/objects/73/ba924a80437097795ae839e66e187c55d3babf differ diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_added_and_uncommited/objects/78/0d7397f5e8f8f477fb55b7af3accc2154b2d4a b/tests/resources/reftable/submod2/.gitted/modules/sm_added_and_uncommited/objects/78/0d7397f5e8f8f477fb55b7af3accc2154b2d4a new file mode 100644 index 000000000..6d27af8a8 --- /dev/null +++ b/tests/resources/reftable/submod2/.gitted/modules/sm_added_and_uncommited/objects/78/0d7397f5e8f8f477fb55b7af3accc2154b2d4a @@ -0,0 +1,2 @@ +x-10 Fa0p(N-ӡғq]>ks*? |m“i@mV'`).-1 x +uxt(+ \ No newline at end of file diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_added_and_uncommited/objects/78/9efbdadaa4a582778d4584385495559ea0994b b/tests/resources/reftable/submod2/.gitted/modules/sm_added_and_uncommited/objects/78/9efbdadaa4a582778d4584385495559ea0994b new file mode 100644 index 000000000..17458840b --- /dev/null +++ b/tests/resources/reftable/submod2/.gitted/modules/sm_added_and_uncommited/objects/78/9efbdadaa4a582778d4584385495559ea0994b @@ -0,0 +1,2 @@ +x 0 )?= NlOkj8&r +qJW7B<fK8#Q1C-"e̫>'@ \ No newline at end of file diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_added_and_uncommited/objects/88/34b635dd468a83cb012f6feace968c1c9f5d6e b/tests/resources/reftable/submod2/.gitted/modules/sm_added_and_uncommited/objects/88/34b635dd468a83cb012f6feace968c1c9f5d6e new file mode 100644 index 000000000..83cc29fb1 Binary files /dev/null and b/tests/resources/reftable/submod2/.gitted/modules/sm_added_and_uncommited/objects/88/34b635dd468a83cb012f6feace968c1c9f5d6e differ diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_added_and_uncommited/objects/d0/5f2cd5cc77addf68ed6f50d622c9a4f732e6c5 b/tests/resources/reftable/submod2/.gitted/modules/sm_added_and_uncommited/objects/d0/5f2cd5cc77addf68ed6f50d622c9a4f732e6c5 new file mode 100644 index 000000000..55bda40ef Binary files /dev/null and b/tests/resources/reftable/submod2/.gitted/modules/sm_added_and_uncommited/objects/d0/5f2cd5cc77addf68ed6f50d622c9a4f732e6c5 differ diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_added_and_uncommited/packed-refs b/tests/resources/reftable/submod2/.gitted/modules/sm_added_and_uncommited/packed-refs new file mode 100644 index 000000000..5a4ebc47c --- /dev/null +++ b/tests/resources/reftable/submod2/.gitted/modules/sm_added_and_uncommited/packed-refs @@ -0,0 +1,2 @@ +# pack-refs with: peeled +480095882d281ed676fe5b863569520e54a7d5c0 refs/remotes/origin/master diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_added_and_uncommited/refs/heads/master b/tests/resources/reftable/submod2/.gitted/modules/sm_added_and_uncommited/refs/heads/master new file mode 100644 index 000000000..e12c44d7a --- /dev/null +++ b/tests/resources/reftable/submod2/.gitted/modules/sm_added_and_uncommited/refs/heads/master @@ -0,0 +1 @@ +480095882d281ed676fe5b863569520e54a7d5c0 diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_added_and_uncommited/refs/remotes/origin/HEAD b/tests/resources/reftable/submod2/.gitted/modules/sm_added_and_uncommited/refs/remotes/origin/HEAD new file mode 100644 index 000000000..6efe28fff --- /dev/null +++ b/tests/resources/reftable/submod2/.gitted/modules/sm_added_and_uncommited/refs/remotes/origin/HEAD @@ -0,0 +1 @@ +ref: refs/remotes/origin/master diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_changed_file/HEAD b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_file/HEAD new file mode 100644 index 000000000..cb089cd89 --- /dev/null +++ b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_file/HEAD @@ -0,0 +1 @@ +ref: refs/heads/master diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_changed_file/config b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_file/config new file mode 100644 index 000000000..10cc2508e --- /dev/null +++ b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_file/config @@ -0,0 +1,13 @@ +[core] + repositoryformatversion = 0 + filemode = true + bare = false + logallrefupdates = true + worktree = ../../../sm_changed_file + ignorecase = true +[remote "origin"] + fetch = +refs/heads/*:refs/remotes/origin/* + url = /Users/rb/src/libgit2/tests-clar/resources/submod2_target +[branch "master"] + remote = origin + merge = refs/heads/master diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_changed_file/description b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_file/description new file mode 100644 index 000000000..498b267a8 --- /dev/null +++ b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_file/description @@ -0,0 +1 @@ +Unnamed repository; edit this file 'description' to name the repository. diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_changed_file/index b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_file/index new file mode 100644 index 000000000..6914a3b6e Binary files /dev/null and b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_file/index differ diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_changed_file/info/exclude b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_file/info/exclude new file mode 100644 index 000000000..a5196d1be --- /dev/null +++ b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_file/info/exclude @@ -0,0 +1,6 @@ +# git ls-files --others --exclude-from=.git/info/exclude +# Lines that start with '#' are comments. +# For a project mostly in C, the following would be a good set of +# exclude patterns (uncomment them if you want to use them): +# *.[oa] +# *~ diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_changed_file/logs/HEAD b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_file/logs/HEAD new file mode 100644 index 000000000..e5cb63f8d --- /dev/null +++ b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_file/logs/HEAD @@ -0,0 +1 @@ +0000000000000000000000000000000000000000 480095882d281ed676fe5b863569520e54a7d5c0 Russell Belfer 1342560173 -0700 clone: from /Users/rb/src/libgit2/tests-clar/resources/submod2_target diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_changed_file/logs/refs/heads/master b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_file/logs/refs/heads/master new file mode 100644 index 000000000..e5cb63f8d --- /dev/null +++ b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_file/logs/refs/heads/master @@ -0,0 +1 @@ +0000000000000000000000000000000000000000 480095882d281ed676fe5b863569520e54a7d5c0 Russell Belfer 1342560173 -0700 clone: from /Users/rb/src/libgit2/tests-clar/resources/submod2_target diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_changed_file/logs/refs/remotes/origin/HEAD b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_file/logs/refs/remotes/origin/HEAD new file mode 100644 index 000000000..e5cb63f8d --- /dev/null +++ b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_file/logs/refs/remotes/origin/HEAD @@ -0,0 +1 @@ +0000000000000000000000000000000000000000 480095882d281ed676fe5b863569520e54a7d5c0 Russell Belfer 1342560173 -0700 clone: from /Users/rb/src/libgit2/tests-clar/resources/submod2_target diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_changed_file/objects/06/362fe2fdb7010d0e447b4fb450d405420479a1 b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_file/objects/06/362fe2fdb7010d0e447b4fb450d405420479a1 new file mode 100644 index 000000000..f4b7094c5 Binary files /dev/null and b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_file/objects/06/362fe2fdb7010d0e447b4fb450d405420479a1 differ diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_changed_file/objects/0e/6a3ca48bd47cfe67681acf39aa0b10a0b92484 b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_file/objects/0e/6a3ca48bd47cfe67681acf39aa0b10a0b92484 new file mode 100644 index 000000000..56c845e49 Binary files /dev/null and b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_file/objects/0e/6a3ca48bd47cfe67681acf39aa0b10a0b92484 differ diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_changed_file/objects/17/d0ece6e96460a06592d9d9d000de37ba4232c5 b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_file/objects/17/d0ece6e96460a06592d9d9d000de37ba4232c5 new file mode 100644 index 000000000..bd179b5f5 Binary files /dev/null and b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_file/objects/17/d0ece6e96460a06592d9d9d000de37ba4232c5 differ diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_changed_file/objects/41/bd4bc3df978de695f67ace64c560913da11653 b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_file/objects/41/bd4bc3df978de695f67ace64c560913da11653 new file mode 100644 index 000000000..ccf49bd15 Binary files /dev/null and b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_file/objects/41/bd4bc3df978de695f67ace64c560913da11653 differ diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_changed_file/objects/48/0095882d281ed676fe5b863569520e54a7d5c0 b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_file/objects/48/0095882d281ed676fe5b863569520e54a7d5c0 new file mode 100644 index 000000000..53029069a Binary files /dev/null and b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_file/objects/48/0095882d281ed676fe5b863569520e54a7d5c0 differ diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_changed_file/objects/5e/4963595a9774b90524d35a807169049de8ccad b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_file/objects/5e/4963595a9774b90524d35a807169049de8ccad new file mode 100644 index 000000000..38c791eba Binary files /dev/null and b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_file/objects/5e/4963595a9774b90524d35a807169049de8ccad differ diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_changed_file/objects/6b/31c659545507c381e9cd34ec508f16c04e149e b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_file/objects/6b/31c659545507c381e9cd34ec508f16c04e149e new file mode 100644 index 000000000..a26d29993 --- /dev/null +++ b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_file/objects/6b/31c659545507c381e9cd34ec508f16c04e149e @@ -0,0 +1,2 @@ +xQ +!Evoy*_@g#hOh^9wSòf1*[Ic Ԥpk Α\S߇l@.^QpF(:D5zr~ en8 \ No newline at end of file diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_changed_file/objects/73/ba924a80437097795ae839e66e187c55d3babf b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_file/objects/73/ba924a80437097795ae839e66e187c55d3babf new file mode 100644 index 000000000..83d1ba481 Binary files /dev/null and b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_file/objects/73/ba924a80437097795ae839e66e187c55d3babf differ diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_changed_file/objects/78/0d7397f5e8f8f477fb55b7af3accc2154b2d4a b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_file/objects/78/0d7397f5e8f8f477fb55b7af3accc2154b2d4a new file mode 100644 index 000000000..6d27af8a8 --- /dev/null +++ b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_file/objects/78/0d7397f5e8f8f477fb55b7af3accc2154b2d4a @@ -0,0 +1,2 @@ +x-10 Fa0p(N-ӡғq]>ks*? |m“i@mV'`).-1 x +uxt(+ \ No newline at end of file diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_changed_file/objects/78/9efbdadaa4a582778d4584385495559ea0994b b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_file/objects/78/9efbdadaa4a582778d4584385495559ea0994b new file mode 100644 index 000000000..17458840b --- /dev/null +++ b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_file/objects/78/9efbdadaa4a582778d4584385495559ea0994b @@ -0,0 +1,2 @@ +x 0 )?= NlOkj8&r +qJW7B<fK8#Q1C-"e̫>'@ \ No newline at end of file diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_changed_file/objects/88/34b635dd468a83cb012f6feace968c1c9f5d6e b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_file/objects/88/34b635dd468a83cb012f6feace968c1c9f5d6e new file mode 100644 index 000000000..83cc29fb1 Binary files /dev/null and b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_file/objects/88/34b635dd468a83cb012f6feace968c1c9f5d6e differ diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_changed_file/objects/d0/5f2cd5cc77addf68ed6f50d622c9a4f732e6c5 b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_file/objects/d0/5f2cd5cc77addf68ed6f50d622c9a4f732e6c5 new file mode 100644 index 000000000..55bda40ef Binary files /dev/null and b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_file/objects/d0/5f2cd5cc77addf68ed6f50d622c9a4f732e6c5 differ diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_changed_file/packed-refs b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_file/packed-refs new file mode 100644 index 000000000..5a4ebc47c --- /dev/null +++ b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_file/packed-refs @@ -0,0 +1,2 @@ +# pack-refs with: peeled +480095882d281ed676fe5b863569520e54a7d5c0 refs/remotes/origin/master diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_changed_file/refs/heads/master b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_file/refs/heads/master new file mode 100644 index 000000000..e12c44d7a --- /dev/null +++ b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_file/refs/heads/master @@ -0,0 +1 @@ +480095882d281ed676fe5b863569520e54a7d5c0 diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_changed_file/refs/remotes/origin/HEAD b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_file/refs/remotes/origin/HEAD new file mode 100644 index 000000000..6efe28fff --- /dev/null +++ b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_file/refs/remotes/origin/HEAD @@ -0,0 +1 @@ +ref: refs/remotes/origin/master diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_changed_head/COMMIT_EDITMSG b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_head/COMMIT_EDITMSG new file mode 100644 index 000000000..6b8d1e3fc --- /dev/null +++ b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_head/COMMIT_EDITMSG @@ -0,0 +1 @@ +Making a change in a submodule diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_changed_head/HEAD b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_head/HEAD new file mode 100644 index 000000000..cb089cd89 --- /dev/null +++ b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_head/HEAD @@ -0,0 +1 @@ +ref: refs/heads/master diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_changed_head/config b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_head/config new file mode 100644 index 000000000..7d002536a --- /dev/null +++ b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_head/config @@ -0,0 +1,13 @@ +[core] + repositoryformatversion = 0 + filemode = true + bare = false + logallrefupdates = true + worktree = ../../../sm_changed_head + ignorecase = true +[remote "origin"] + fetch = +refs/heads/*:refs/remotes/origin/* + url = /Users/rb/src/libgit2/tests-clar/resources/submod2_target +[branch "master"] + remote = origin + merge = refs/heads/master diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_changed_head/description b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_head/description new file mode 100644 index 000000000..498b267a8 --- /dev/null +++ b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_head/description @@ -0,0 +1 @@ +Unnamed repository; edit this file 'description' to name the repository. diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_changed_head/index b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_head/index new file mode 100644 index 000000000..728fa292f Binary files /dev/null and b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_head/index differ diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_changed_head/info/exclude b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_head/info/exclude new file mode 100644 index 000000000..a5196d1be --- /dev/null +++ b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_head/info/exclude @@ -0,0 +1,6 @@ +# git ls-files --others --exclude-from=.git/info/exclude +# Lines that start with '#' are comments. +# For a project mostly in C, the following would be a good set of +# exclude patterns (uncomment them if you want to use them): +# *.[oa] +# *~ diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_changed_head/logs/HEAD b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_head/logs/HEAD new file mode 100644 index 000000000..cabdeb2b5 --- /dev/null +++ b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_head/logs/HEAD @@ -0,0 +1,2 @@ +0000000000000000000000000000000000000000 480095882d281ed676fe5b863569520e54a7d5c0 Russell Belfer 1342560179 -0700 clone: from /Users/rb/src/libgit2/tests-clar/resources/submod2_target +480095882d281ed676fe5b863569520e54a7d5c0 3d9386c507f6b093471a3e324085657a3c2b4247 Russell Belfer 1342560431 -0700 commit: Making a change in a submodule diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_changed_head/logs/refs/heads/master b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_head/logs/refs/heads/master new file mode 100644 index 000000000..cabdeb2b5 --- /dev/null +++ b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_head/logs/refs/heads/master @@ -0,0 +1,2 @@ +0000000000000000000000000000000000000000 480095882d281ed676fe5b863569520e54a7d5c0 Russell Belfer 1342560179 -0700 clone: from /Users/rb/src/libgit2/tests-clar/resources/submod2_target +480095882d281ed676fe5b863569520e54a7d5c0 3d9386c507f6b093471a3e324085657a3c2b4247 Russell Belfer 1342560431 -0700 commit: Making a change in a submodule diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_changed_head/logs/refs/remotes/origin/HEAD b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_head/logs/refs/remotes/origin/HEAD new file mode 100644 index 000000000..257ca21d1 --- /dev/null +++ b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_head/logs/refs/remotes/origin/HEAD @@ -0,0 +1 @@ +0000000000000000000000000000000000000000 480095882d281ed676fe5b863569520e54a7d5c0 Russell Belfer 1342560179 -0700 clone: from /Users/rb/src/libgit2/tests-clar/resources/submod2_target diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_changed_head/objects/06/362fe2fdb7010d0e447b4fb450d405420479a1 b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_head/objects/06/362fe2fdb7010d0e447b4fb450d405420479a1 new file mode 100644 index 000000000..f4b7094c5 Binary files /dev/null and b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_head/objects/06/362fe2fdb7010d0e447b4fb450d405420479a1 differ diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_changed_head/objects/0e/6a3ca48bd47cfe67681acf39aa0b10a0b92484 b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_head/objects/0e/6a3ca48bd47cfe67681acf39aa0b10a0b92484 new file mode 100644 index 000000000..56c845e49 Binary files /dev/null and b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_head/objects/0e/6a3ca48bd47cfe67681acf39aa0b10a0b92484 differ diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_changed_head/objects/17/d0ece6e96460a06592d9d9d000de37ba4232c5 b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_head/objects/17/d0ece6e96460a06592d9d9d000de37ba4232c5 new file mode 100644 index 000000000..bd179b5f5 Binary files /dev/null and b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_head/objects/17/d0ece6e96460a06592d9d9d000de37ba4232c5 differ diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_changed_head/objects/3d/9386c507f6b093471a3e324085657a3c2b4247 b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_head/objects/3d/9386c507f6b093471a3e324085657a3c2b4247 new file mode 100644 index 000000000..a2c371642 --- /dev/null +++ b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_head/objects/3d/9386c507f6b093471a3e324085657a3c2b4247 @@ -0,0 +1,3 @@ +xKj!E3vj#<<@Ouq .)ql osFa#v )g#{':Tl`b40 ;fr4 + +zU-/glm\'LjrhXG_+l ʚE`;=]J \ No newline at end of file diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_changed_head/objects/41/bd4bc3df978de695f67ace64c560913da11653 b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_head/objects/41/bd4bc3df978de695f67ace64c560913da11653 new file mode 100644 index 000000000..ccf49bd15 Binary files /dev/null and b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_head/objects/41/bd4bc3df978de695f67ace64c560913da11653 differ diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_changed_head/objects/48/0095882d281ed676fe5b863569520e54a7d5c0 b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_head/objects/48/0095882d281ed676fe5b863569520e54a7d5c0 new file mode 100644 index 000000000..53029069a Binary files /dev/null and b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_head/objects/48/0095882d281ed676fe5b863569520e54a7d5c0 differ diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_changed_head/objects/5e/4963595a9774b90524d35a807169049de8ccad b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_head/objects/5e/4963595a9774b90524d35a807169049de8ccad new file mode 100644 index 000000000..38c791eba Binary files /dev/null and b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_head/objects/5e/4963595a9774b90524d35a807169049de8ccad differ diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_changed_head/objects/6b/31c659545507c381e9cd34ec508f16c04e149e b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_head/objects/6b/31c659545507c381e9cd34ec508f16c04e149e new file mode 100644 index 000000000..a26d29993 --- /dev/null +++ b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_head/objects/6b/31c659545507c381e9cd34ec508f16c04e149e @@ -0,0 +1,2 @@ +xQ +!Evoy*_@g#hOh^9wSòf1*[Ic Ԥpk Α\S߇l@.^QpF(:D5zr~ en8 \ No newline at end of file diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_changed_head/objects/73/ba924a80437097795ae839e66e187c55d3babf b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_head/objects/73/ba924a80437097795ae839e66e187c55d3babf new file mode 100644 index 000000000..83d1ba481 Binary files /dev/null and b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_head/objects/73/ba924a80437097795ae839e66e187c55d3babf differ diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_changed_head/objects/77/fb0ed3e58568d6ad362c78de08ab8649d76e29 b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_head/objects/77/fb0ed3e58568d6ad362c78de08ab8649d76e29 new file mode 100644 index 000000000..f8a236f3d Binary files /dev/null and b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_head/objects/77/fb0ed3e58568d6ad362c78de08ab8649d76e29 differ diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_changed_head/objects/78/0d7397f5e8f8f477fb55b7af3accc2154b2d4a b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_head/objects/78/0d7397f5e8f8f477fb55b7af3accc2154b2d4a new file mode 100644 index 000000000..6d27af8a8 --- /dev/null +++ b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_head/objects/78/0d7397f5e8f8f477fb55b7af3accc2154b2d4a @@ -0,0 +1,2 @@ +x-10 Fa0p(N-ӡғq]>ks*? |m“i@mV'`).-1 x +uxt(+ \ No newline at end of file diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_changed_head/objects/78/9efbdadaa4a582778d4584385495559ea0994b b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_head/objects/78/9efbdadaa4a582778d4584385495559ea0994b new file mode 100644 index 000000000..17458840b --- /dev/null +++ b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_head/objects/78/9efbdadaa4a582778d4584385495559ea0994b @@ -0,0 +1,2 @@ +x 0 )?= NlOkj8&r +qJW7B<fK8#Q1C-"e̫>'@ \ No newline at end of file diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_changed_head/objects/88/34b635dd468a83cb012f6feace968c1c9f5d6e b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_head/objects/88/34b635dd468a83cb012f6feace968c1c9f5d6e new file mode 100644 index 000000000..83cc29fb1 Binary files /dev/null and b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_head/objects/88/34b635dd468a83cb012f6feace968c1c9f5d6e differ diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_changed_head/objects/8e/b1e637ed9fc8e5454fa20d38f809091f9395f4 b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_head/objects/8e/b1e637ed9fc8e5454fa20d38f809091f9395f4 new file mode 100644 index 000000000..8155b3e87 --- /dev/null +++ b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_head/objects/8e/b1e637ed9fc8e5454fa20d38f809091f9395f4 @@ -0,0 +1,2 @@ +xMM; +1) ZPr3k lEnl!crz ,e +lEZxuPYx QC*fuLcfR3T0'үj~G^s1b2zVk]5<v'> \ No newline at end of file diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_changed_head/objects/d0/5f2cd5cc77addf68ed6f50d622c9a4f732e6c5 b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_head/objects/d0/5f2cd5cc77addf68ed6f50d622c9a4f732e6c5 new file mode 100644 index 000000000..55bda40ef Binary files /dev/null and b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_head/objects/d0/5f2cd5cc77addf68ed6f50d622c9a4f732e6c5 differ diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_changed_head/packed-refs b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_head/packed-refs new file mode 100644 index 000000000..5a4ebc47c --- /dev/null +++ b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_head/packed-refs @@ -0,0 +1,2 @@ +# pack-refs with: peeled +480095882d281ed676fe5b863569520e54a7d5c0 refs/remotes/origin/master diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_changed_head/refs/heads/master b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_head/refs/heads/master new file mode 100644 index 000000000..ae079bd79 --- /dev/null +++ b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_head/refs/heads/master @@ -0,0 +1 @@ +3d9386c507f6b093471a3e324085657a3c2b4247 diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_changed_head/refs/remotes/origin/HEAD b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_head/refs/remotes/origin/HEAD new file mode 100644 index 000000000..6efe28fff --- /dev/null +++ b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_head/refs/remotes/origin/HEAD @@ -0,0 +1 @@ +ref: refs/remotes/origin/master diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_changed_index/HEAD b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_index/HEAD new file mode 100644 index 000000000..cb089cd89 --- /dev/null +++ b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_index/HEAD @@ -0,0 +1 @@ +ref: refs/heads/master diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_changed_index/config b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_index/config new file mode 100644 index 000000000..0274ff7e3 --- /dev/null +++ b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_index/config @@ -0,0 +1,13 @@ +[core] + repositoryformatversion = 0 + filemode = true + bare = false + logallrefupdates = true + worktree = ../../../sm_changed_index + ignorecase = true +[remote "origin"] + fetch = +refs/heads/*:refs/remotes/origin/* + url = /Users/rb/src/libgit2/tests-clar/resources/submod2_target +[branch "master"] + remote = origin + merge = refs/heads/master diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_changed_index/description b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_index/description new file mode 100644 index 000000000..498b267a8 --- /dev/null +++ b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_index/description @@ -0,0 +1 @@ +Unnamed repository; edit this file 'description' to name the repository. diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_changed_index/index b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_index/index new file mode 100644 index 000000000..6fad3b43e Binary files /dev/null and b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_index/index differ diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_changed_index/info/exclude b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_index/info/exclude new file mode 100644 index 000000000..a5196d1be --- /dev/null +++ b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_index/info/exclude @@ -0,0 +1,6 @@ +# git ls-files --others --exclude-from=.git/info/exclude +# Lines that start with '#' are comments. +# For a project mostly in C, the following would be a good set of +# exclude patterns (uncomment them if you want to use them): +# *.[oa] +# *~ diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_changed_index/logs/HEAD b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_index/logs/HEAD new file mode 100644 index 000000000..80eb54102 --- /dev/null +++ b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_index/logs/HEAD @@ -0,0 +1 @@ +0000000000000000000000000000000000000000 480095882d281ed676fe5b863569520e54a7d5c0 Russell Belfer 1342560175 -0700 clone: from /Users/rb/src/libgit2/tests-clar/resources/submod2_target diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_changed_index/logs/refs/heads/master b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_index/logs/refs/heads/master new file mode 100644 index 000000000..80eb54102 --- /dev/null +++ b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_index/logs/refs/heads/master @@ -0,0 +1 @@ +0000000000000000000000000000000000000000 480095882d281ed676fe5b863569520e54a7d5c0 Russell Belfer 1342560175 -0700 clone: from /Users/rb/src/libgit2/tests-clar/resources/submod2_target diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_changed_index/logs/refs/remotes/origin/HEAD b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_index/logs/refs/remotes/origin/HEAD new file mode 100644 index 000000000..80eb54102 --- /dev/null +++ b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_index/logs/refs/remotes/origin/HEAD @@ -0,0 +1 @@ +0000000000000000000000000000000000000000 480095882d281ed676fe5b863569520e54a7d5c0 Russell Belfer 1342560175 -0700 clone: from /Users/rb/src/libgit2/tests-clar/resources/submod2_target diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_changed_index/objects/06/362fe2fdb7010d0e447b4fb450d405420479a1 b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_index/objects/06/362fe2fdb7010d0e447b4fb450d405420479a1 new file mode 100644 index 000000000..f4b7094c5 Binary files /dev/null and b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_index/objects/06/362fe2fdb7010d0e447b4fb450d405420479a1 differ diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_changed_index/objects/0e/6a3ca48bd47cfe67681acf39aa0b10a0b92484 b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_index/objects/0e/6a3ca48bd47cfe67681acf39aa0b10a0b92484 new file mode 100644 index 000000000..56c845e49 Binary files /dev/null and b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_index/objects/0e/6a3ca48bd47cfe67681acf39aa0b10a0b92484 differ diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_changed_index/objects/17/d0ece6e96460a06592d9d9d000de37ba4232c5 b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_index/objects/17/d0ece6e96460a06592d9d9d000de37ba4232c5 new file mode 100644 index 000000000..bd179b5f5 Binary files /dev/null and b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_index/objects/17/d0ece6e96460a06592d9d9d000de37ba4232c5 differ diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_changed_index/objects/41/bd4bc3df978de695f67ace64c560913da11653 b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_index/objects/41/bd4bc3df978de695f67ace64c560913da11653 new file mode 100644 index 000000000..ccf49bd15 Binary files /dev/null and b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_index/objects/41/bd4bc3df978de695f67ace64c560913da11653 differ diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_changed_index/objects/48/0095882d281ed676fe5b863569520e54a7d5c0 b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_index/objects/48/0095882d281ed676fe5b863569520e54a7d5c0 new file mode 100644 index 000000000..53029069a Binary files /dev/null and b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_index/objects/48/0095882d281ed676fe5b863569520e54a7d5c0 differ diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_changed_index/objects/5e/4963595a9774b90524d35a807169049de8ccad b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_index/objects/5e/4963595a9774b90524d35a807169049de8ccad new file mode 100644 index 000000000..38c791eba Binary files /dev/null and b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_index/objects/5e/4963595a9774b90524d35a807169049de8ccad differ diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_changed_index/objects/6b/31c659545507c381e9cd34ec508f16c04e149e b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_index/objects/6b/31c659545507c381e9cd34ec508f16c04e149e new file mode 100644 index 000000000..a26d29993 --- /dev/null +++ b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_index/objects/6b/31c659545507c381e9cd34ec508f16c04e149e @@ -0,0 +1,2 @@ +xQ +!Evoy*_@g#hOh^9wSòf1*[Ic Ԥpk Α\S߇l@.^QpF(:D5zr~ en8 \ No newline at end of file diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_changed_index/objects/73/ba924a80437097795ae839e66e187c55d3babf b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_index/objects/73/ba924a80437097795ae839e66e187c55d3babf new file mode 100644 index 000000000..83d1ba481 Binary files /dev/null and b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_index/objects/73/ba924a80437097795ae839e66e187c55d3babf differ diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_changed_index/objects/78/0d7397f5e8f8f477fb55b7af3accc2154b2d4a b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_index/objects/78/0d7397f5e8f8f477fb55b7af3accc2154b2d4a new file mode 100644 index 000000000..6d27af8a8 --- /dev/null +++ b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_index/objects/78/0d7397f5e8f8f477fb55b7af3accc2154b2d4a @@ -0,0 +1,2 @@ +x-10 Fa0p(N-ӡғq]>ks*? |m“i@mV'`).-1 x +uxt(+ \ No newline at end of file diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_changed_index/objects/78/9efbdadaa4a582778d4584385495559ea0994b b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_index/objects/78/9efbdadaa4a582778d4584385495559ea0994b new file mode 100644 index 000000000..17458840b --- /dev/null +++ b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_index/objects/78/9efbdadaa4a582778d4584385495559ea0994b @@ -0,0 +1,2 @@ +x 0 )?= NlOkj8&r +qJW7B<fK8#Q1C-"e̫>'@ \ No newline at end of file diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_changed_index/objects/88/34b635dd468a83cb012f6feace968c1c9f5d6e b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_index/objects/88/34b635dd468a83cb012f6feace968c1c9f5d6e new file mode 100644 index 000000000..83cc29fb1 Binary files /dev/null and b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_index/objects/88/34b635dd468a83cb012f6feace968c1c9f5d6e differ diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_changed_index/objects/a0/2d31770687965547ab7a04cee199b29ee458d6 b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_index/objects/a0/2d31770687965547ab7a04cee199b29ee458d6 new file mode 100644 index 000000000..cb3f5a002 Binary files /dev/null and b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_index/objects/a0/2d31770687965547ab7a04cee199b29ee458d6 differ diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_changed_index/objects/d0/5f2cd5cc77addf68ed6f50d622c9a4f732e6c5 b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_index/objects/d0/5f2cd5cc77addf68ed6f50d622c9a4f732e6c5 new file mode 100644 index 000000000..55bda40ef Binary files /dev/null and b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_index/objects/d0/5f2cd5cc77addf68ed6f50d622c9a4f732e6c5 differ diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_changed_index/packed-refs b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_index/packed-refs new file mode 100644 index 000000000..5a4ebc47c --- /dev/null +++ b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_index/packed-refs @@ -0,0 +1,2 @@ +# pack-refs with: peeled +480095882d281ed676fe5b863569520e54a7d5c0 refs/remotes/origin/master diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_changed_index/refs/heads/master b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_index/refs/heads/master new file mode 100644 index 000000000..e12c44d7a --- /dev/null +++ b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_index/refs/heads/master @@ -0,0 +1 @@ +480095882d281ed676fe5b863569520e54a7d5c0 diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_changed_index/refs/remotes/origin/HEAD b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_index/refs/remotes/origin/HEAD new file mode 100644 index 000000000..6efe28fff --- /dev/null +++ b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_index/refs/remotes/origin/HEAD @@ -0,0 +1 @@ +ref: refs/remotes/origin/master diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_changed_untracked_file/HEAD b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_untracked_file/HEAD new file mode 100644 index 000000000..cb089cd89 --- /dev/null +++ b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_untracked_file/HEAD @@ -0,0 +1 @@ +ref: refs/heads/master diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_changed_untracked_file/config b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_untracked_file/config new file mode 100644 index 000000000..7f2584476 --- /dev/null +++ b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_untracked_file/config @@ -0,0 +1,13 @@ +[core] + repositoryformatversion = 0 + filemode = true + bare = false + logallrefupdates = true + worktree = ../../../sm_changed_untracked_file + ignorecase = true +[remote "origin"] + fetch = +refs/heads/*:refs/remotes/origin/* + url = /Users/rb/src/libgit2/tests-clar/resources/submod2_target +[branch "master"] + remote = origin + merge = refs/heads/master diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_changed_untracked_file/description b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_untracked_file/description new file mode 100644 index 000000000..498b267a8 --- /dev/null +++ b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_untracked_file/description @@ -0,0 +1 @@ +Unnamed repository; edit this file 'description' to name the repository. diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_changed_untracked_file/index b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_untracked_file/index new file mode 100644 index 000000000..598e30a32 Binary files /dev/null and b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_untracked_file/index differ diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_changed_untracked_file/info/exclude b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_untracked_file/info/exclude new file mode 100644 index 000000000..a5196d1be --- /dev/null +++ b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_untracked_file/info/exclude @@ -0,0 +1,6 @@ +# git ls-files --others --exclude-from=.git/info/exclude +# Lines that start with '#' are comments. +# For a project mostly in C, the following would be a good set of +# exclude patterns (uncomment them if you want to use them): +# *.[oa] +# *~ diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_changed_untracked_file/logs/HEAD b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_untracked_file/logs/HEAD new file mode 100644 index 000000000..d1beafbd6 --- /dev/null +++ b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_untracked_file/logs/HEAD @@ -0,0 +1 @@ +0000000000000000000000000000000000000000 480095882d281ed676fe5b863569520e54a7d5c0 Russell Belfer 1342560186 -0700 clone: from /Users/rb/src/libgit2/tests-clar/resources/submod2_target diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_changed_untracked_file/logs/refs/heads/master b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_untracked_file/logs/refs/heads/master new file mode 100644 index 000000000..d1beafbd6 --- /dev/null +++ b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_untracked_file/logs/refs/heads/master @@ -0,0 +1 @@ +0000000000000000000000000000000000000000 480095882d281ed676fe5b863569520e54a7d5c0 Russell Belfer 1342560186 -0700 clone: from /Users/rb/src/libgit2/tests-clar/resources/submod2_target diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_changed_untracked_file/logs/refs/remotes/origin/HEAD b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_untracked_file/logs/refs/remotes/origin/HEAD new file mode 100644 index 000000000..d1beafbd6 --- /dev/null +++ b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_untracked_file/logs/refs/remotes/origin/HEAD @@ -0,0 +1 @@ +0000000000000000000000000000000000000000 480095882d281ed676fe5b863569520e54a7d5c0 Russell Belfer 1342560186 -0700 clone: from /Users/rb/src/libgit2/tests-clar/resources/submod2_target diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_changed_untracked_file/objects/06/362fe2fdb7010d0e447b4fb450d405420479a1 b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_untracked_file/objects/06/362fe2fdb7010d0e447b4fb450d405420479a1 new file mode 100644 index 000000000..f4b7094c5 Binary files /dev/null and b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_untracked_file/objects/06/362fe2fdb7010d0e447b4fb450d405420479a1 differ diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_changed_untracked_file/objects/0e/6a3ca48bd47cfe67681acf39aa0b10a0b92484 b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_untracked_file/objects/0e/6a3ca48bd47cfe67681acf39aa0b10a0b92484 new file mode 100644 index 000000000..56c845e49 Binary files /dev/null and b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_untracked_file/objects/0e/6a3ca48bd47cfe67681acf39aa0b10a0b92484 differ diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_changed_untracked_file/objects/17/d0ece6e96460a06592d9d9d000de37ba4232c5 b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_untracked_file/objects/17/d0ece6e96460a06592d9d9d000de37ba4232c5 new file mode 100644 index 000000000..bd179b5f5 Binary files /dev/null and b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_untracked_file/objects/17/d0ece6e96460a06592d9d9d000de37ba4232c5 differ diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_changed_untracked_file/objects/41/bd4bc3df978de695f67ace64c560913da11653 b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_untracked_file/objects/41/bd4bc3df978de695f67ace64c560913da11653 new file mode 100644 index 000000000..ccf49bd15 Binary files /dev/null and b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_untracked_file/objects/41/bd4bc3df978de695f67ace64c560913da11653 differ diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_changed_untracked_file/objects/48/0095882d281ed676fe5b863569520e54a7d5c0 b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_untracked_file/objects/48/0095882d281ed676fe5b863569520e54a7d5c0 new file mode 100644 index 000000000..53029069a Binary files /dev/null and b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_untracked_file/objects/48/0095882d281ed676fe5b863569520e54a7d5c0 differ diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_changed_untracked_file/objects/5e/4963595a9774b90524d35a807169049de8ccad b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_untracked_file/objects/5e/4963595a9774b90524d35a807169049de8ccad new file mode 100644 index 000000000..38c791eba Binary files /dev/null and b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_untracked_file/objects/5e/4963595a9774b90524d35a807169049de8ccad differ diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_changed_untracked_file/objects/6b/31c659545507c381e9cd34ec508f16c04e149e b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_untracked_file/objects/6b/31c659545507c381e9cd34ec508f16c04e149e new file mode 100644 index 000000000..a26d29993 --- /dev/null +++ b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_untracked_file/objects/6b/31c659545507c381e9cd34ec508f16c04e149e @@ -0,0 +1,2 @@ +xQ +!Evoy*_@g#hOh^9wSòf1*[Ic Ԥpk Α\S߇l@.^QpF(:D5zr~ en8 \ No newline at end of file diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_changed_untracked_file/objects/73/ba924a80437097795ae839e66e187c55d3babf b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_untracked_file/objects/73/ba924a80437097795ae839e66e187c55d3babf new file mode 100644 index 000000000..83d1ba481 Binary files /dev/null and b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_untracked_file/objects/73/ba924a80437097795ae839e66e187c55d3babf differ diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_changed_untracked_file/objects/78/0d7397f5e8f8f477fb55b7af3accc2154b2d4a b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_untracked_file/objects/78/0d7397f5e8f8f477fb55b7af3accc2154b2d4a new file mode 100644 index 000000000..6d27af8a8 --- /dev/null +++ b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_untracked_file/objects/78/0d7397f5e8f8f477fb55b7af3accc2154b2d4a @@ -0,0 +1,2 @@ +x-10 Fa0p(N-ӡғq]>ks*? |m“i@mV'`).-1 x +uxt(+ \ No newline at end of file diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_changed_untracked_file/objects/78/9efbdadaa4a582778d4584385495559ea0994b b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_untracked_file/objects/78/9efbdadaa4a582778d4584385495559ea0994b new file mode 100644 index 000000000..17458840b --- /dev/null +++ b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_untracked_file/objects/78/9efbdadaa4a582778d4584385495559ea0994b @@ -0,0 +1,2 @@ +x 0 )?= NlOkj8&r +qJW7B<fK8#Q1C-"e̫>'@ \ No newline at end of file diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_changed_untracked_file/objects/88/34b635dd468a83cb012f6feace968c1c9f5d6e b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_untracked_file/objects/88/34b635dd468a83cb012f6feace968c1c9f5d6e new file mode 100644 index 000000000..83cc29fb1 Binary files /dev/null and b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_untracked_file/objects/88/34b635dd468a83cb012f6feace968c1c9f5d6e differ diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_changed_untracked_file/objects/d0/5f2cd5cc77addf68ed6f50d622c9a4f732e6c5 b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_untracked_file/objects/d0/5f2cd5cc77addf68ed6f50d622c9a4f732e6c5 new file mode 100644 index 000000000..55bda40ef Binary files /dev/null and b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_untracked_file/objects/d0/5f2cd5cc77addf68ed6f50d622c9a4f732e6c5 differ diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_changed_untracked_file/packed-refs b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_untracked_file/packed-refs new file mode 100644 index 000000000..5a4ebc47c --- /dev/null +++ b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_untracked_file/packed-refs @@ -0,0 +1,2 @@ +# pack-refs with: peeled +480095882d281ed676fe5b863569520e54a7d5c0 refs/remotes/origin/master diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_changed_untracked_file/refs/heads/master b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_untracked_file/refs/heads/master new file mode 100644 index 000000000..e12c44d7a --- /dev/null +++ b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_untracked_file/refs/heads/master @@ -0,0 +1 @@ +480095882d281ed676fe5b863569520e54a7d5c0 diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_changed_untracked_file/refs/remotes/origin/HEAD b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_untracked_file/refs/remotes/origin/HEAD new file mode 100644 index 000000000..6efe28fff --- /dev/null +++ b/tests/resources/reftable/submod2/.gitted/modules/sm_changed_untracked_file/refs/remotes/origin/HEAD @@ -0,0 +1 @@ +ref: refs/remotes/origin/master diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_missing_commits/HEAD b/tests/resources/reftable/submod2/.gitted/modules/sm_missing_commits/HEAD new file mode 100644 index 000000000..cb089cd89 --- /dev/null +++ b/tests/resources/reftable/submod2/.gitted/modules/sm_missing_commits/HEAD @@ -0,0 +1 @@ +ref: refs/heads/master diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_missing_commits/config b/tests/resources/reftable/submod2/.gitted/modules/sm_missing_commits/config new file mode 100644 index 000000000..45fbb30cf --- /dev/null +++ b/tests/resources/reftable/submod2/.gitted/modules/sm_missing_commits/config @@ -0,0 +1,13 @@ +[core] + repositoryformatversion = 0 + filemode = true + bare = false + logallrefupdates = true + worktree = ../../../sm_missing_commits + ignorecase = true +[remote "origin"] + fetch = +refs/heads/*:refs/remotes/origin/* + url = /Users/rb/src/libgit2/tests-clar/resources/submod2_target +[branch "master"] + remote = origin + merge = refs/heads/master diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_missing_commits/description b/tests/resources/reftable/submod2/.gitted/modules/sm_missing_commits/description new file mode 100644 index 000000000..498b267a8 --- /dev/null +++ b/tests/resources/reftable/submod2/.gitted/modules/sm_missing_commits/description @@ -0,0 +1 @@ +Unnamed repository; edit this file 'description' to name the repository. diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_missing_commits/index b/tests/resources/reftable/submod2/.gitted/modules/sm_missing_commits/index new file mode 100644 index 000000000..490356524 Binary files /dev/null and b/tests/resources/reftable/submod2/.gitted/modules/sm_missing_commits/index differ diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_missing_commits/info/exclude b/tests/resources/reftable/submod2/.gitted/modules/sm_missing_commits/info/exclude new file mode 100644 index 000000000..a5196d1be --- /dev/null +++ b/tests/resources/reftable/submod2/.gitted/modules/sm_missing_commits/info/exclude @@ -0,0 +1,6 @@ +# git ls-files --others --exclude-from=.git/info/exclude +# Lines that start with '#' are comments. +# For a project mostly in C, the following would be a good set of +# exclude patterns (uncomment them if you want to use them): +# *.[oa] +# *~ diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_missing_commits/logs/HEAD b/tests/resources/reftable/submod2/.gitted/modules/sm_missing_commits/logs/HEAD new file mode 100644 index 000000000..ee08c9706 --- /dev/null +++ b/tests/resources/reftable/submod2/.gitted/modules/sm_missing_commits/logs/HEAD @@ -0,0 +1 @@ +0000000000000000000000000000000000000000 5e4963595a9774b90524d35a807169049de8ccad Russell Belfer 1342559796 -0700 clone: from /Users/rb/src/libgit2/tests-clar/resources/submod2_target diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_missing_commits/logs/refs/heads/master b/tests/resources/reftable/submod2/.gitted/modules/sm_missing_commits/logs/refs/heads/master new file mode 100644 index 000000000..ee08c9706 --- /dev/null +++ b/tests/resources/reftable/submod2/.gitted/modules/sm_missing_commits/logs/refs/heads/master @@ -0,0 +1 @@ +0000000000000000000000000000000000000000 5e4963595a9774b90524d35a807169049de8ccad Russell Belfer 1342559796 -0700 clone: from /Users/rb/src/libgit2/tests-clar/resources/submod2_target diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_missing_commits/logs/refs/remotes/origin/HEAD b/tests/resources/reftable/submod2/.gitted/modules/sm_missing_commits/logs/refs/remotes/origin/HEAD new file mode 100644 index 000000000..ee08c9706 --- /dev/null +++ b/tests/resources/reftable/submod2/.gitted/modules/sm_missing_commits/logs/refs/remotes/origin/HEAD @@ -0,0 +1 @@ +0000000000000000000000000000000000000000 5e4963595a9774b90524d35a807169049de8ccad Russell Belfer 1342559796 -0700 clone: from /Users/rb/src/libgit2/tests-clar/resources/submod2_target diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_missing_commits/objects/06/362fe2fdb7010d0e447b4fb450d405420479a1 b/tests/resources/reftable/submod2/.gitted/modules/sm_missing_commits/objects/06/362fe2fdb7010d0e447b4fb450d405420479a1 new file mode 100644 index 000000000..f4b7094c5 Binary files /dev/null and b/tests/resources/reftable/submod2/.gitted/modules/sm_missing_commits/objects/06/362fe2fdb7010d0e447b4fb450d405420479a1 differ diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_missing_commits/objects/0e/6a3ca48bd47cfe67681acf39aa0b10a0b92484 b/tests/resources/reftable/submod2/.gitted/modules/sm_missing_commits/objects/0e/6a3ca48bd47cfe67681acf39aa0b10a0b92484 new file mode 100644 index 000000000..56c845e49 Binary files /dev/null and b/tests/resources/reftable/submod2/.gitted/modules/sm_missing_commits/objects/0e/6a3ca48bd47cfe67681acf39aa0b10a0b92484 differ diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_missing_commits/objects/17/d0ece6e96460a06592d9d9d000de37ba4232c5 b/tests/resources/reftable/submod2/.gitted/modules/sm_missing_commits/objects/17/d0ece6e96460a06592d9d9d000de37ba4232c5 new file mode 100644 index 000000000..bd179b5f5 Binary files /dev/null and b/tests/resources/reftable/submod2/.gitted/modules/sm_missing_commits/objects/17/d0ece6e96460a06592d9d9d000de37ba4232c5 differ diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_missing_commits/objects/41/bd4bc3df978de695f67ace64c560913da11653 b/tests/resources/reftable/submod2/.gitted/modules/sm_missing_commits/objects/41/bd4bc3df978de695f67ace64c560913da11653 new file mode 100644 index 000000000..ccf49bd15 Binary files /dev/null and b/tests/resources/reftable/submod2/.gitted/modules/sm_missing_commits/objects/41/bd4bc3df978de695f67ace64c560913da11653 differ diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_missing_commits/objects/5e/4963595a9774b90524d35a807169049de8ccad b/tests/resources/reftable/submod2/.gitted/modules/sm_missing_commits/objects/5e/4963595a9774b90524d35a807169049de8ccad new file mode 100644 index 000000000..38c791eba Binary files /dev/null and b/tests/resources/reftable/submod2/.gitted/modules/sm_missing_commits/objects/5e/4963595a9774b90524d35a807169049de8ccad differ diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_missing_commits/objects/6b/31c659545507c381e9cd34ec508f16c04e149e b/tests/resources/reftable/submod2/.gitted/modules/sm_missing_commits/objects/6b/31c659545507c381e9cd34ec508f16c04e149e new file mode 100644 index 000000000..a26d29993 --- /dev/null +++ b/tests/resources/reftable/submod2/.gitted/modules/sm_missing_commits/objects/6b/31c659545507c381e9cd34ec508f16c04e149e @@ -0,0 +1,2 @@ +xQ +!Evoy*_@g#hOh^9wSòf1*[Ic Ԥpk Α\S߇l@.^QpF(:D5zr~ en8 \ No newline at end of file diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_missing_commits/objects/78/0d7397f5e8f8f477fb55b7af3accc2154b2d4a b/tests/resources/reftable/submod2/.gitted/modules/sm_missing_commits/objects/78/0d7397f5e8f8f477fb55b7af3accc2154b2d4a new file mode 100644 index 000000000..6d27af8a8 --- /dev/null +++ b/tests/resources/reftable/submod2/.gitted/modules/sm_missing_commits/objects/78/0d7397f5e8f8f477fb55b7af3accc2154b2d4a @@ -0,0 +1,2 @@ +x-10 Fa0p(N-ӡғq]>ks*? |m“i@mV'`).-1 x +uxt(+ \ No newline at end of file diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_missing_commits/objects/88/34b635dd468a83cb012f6feace968c1c9f5d6e b/tests/resources/reftable/submod2/.gitted/modules/sm_missing_commits/objects/88/34b635dd468a83cb012f6feace968c1c9f5d6e new file mode 100644 index 000000000..83cc29fb1 Binary files /dev/null and b/tests/resources/reftable/submod2/.gitted/modules/sm_missing_commits/objects/88/34b635dd468a83cb012f6feace968c1c9f5d6e differ diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_missing_commits/objects/d0/5f2cd5cc77addf68ed6f50d622c9a4f732e6c5 b/tests/resources/reftable/submod2/.gitted/modules/sm_missing_commits/objects/d0/5f2cd5cc77addf68ed6f50d622c9a4f732e6c5 new file mode 100644 index 000000000..55bda40ef Binary files /dev/null and b/tests/resources/reftable/submod2/.gitted/modules/sm_missing_commits/objects/d0/5f2cd5cc77addf68ed6f50d622c9a4f732e6c5 differ diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_missing_commits/packed-refs b/tests/resources/reftable/submod2/.gitted/modules/sm_missing_commits/packed-refs new file mode 100644 index 000000000..66fbf5daf --- /dev/null +++ b/tests/resources/reftable/submod2/.gitted/modules/sm_missing_commits/packed-refs @@ -0,0 +1,2 @@ +# pack-refs with: peeled +5e4963595a9774b90524d35a807169049de8ccad refs/remotes/origin/master diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_missing_commits/refs/heads/master b/tests/resources/reftable/submod2/.gitted/modules/sm_missing_commits/refs/heads/master new file mode 100644 index 000000000..3913aca5d --- /dev/null +++ b/tests/resources/reftable/submod2/.gitted/modules/sm_missing_commits/refs/heads/master @@ -0,0 +1 @@ +5e4963595a9774b90524d35a807169049de8ccad diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_missing_commits/refs/remotes/origin/HEAD b/tests/resources/reftable/submod2/.gitted/modules/sm_missing_commits/refs/remotes/origin/HEAD new file mode 100644 index 000000000..6efe28fff --- /dev/null +++ b/tests/resources/reftable/submod2/.gitted/modules/sm_missing_commits/refs/remotes/origin/HEAD @@ -0,0 +1 @@ +ref: refs/remotes/origin/master diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_unchanged/HEAD b/tests/resources/reftable/submod2/.gitted/modules/sm_unchanged/HEAD new file mode 100644 index 000000000..cb089cd89 --- /dev/null +++ b/tests/resources/reftable/submod2/.gitted/modules/sm_unchanged/HEAD @@ -0,0 +1 @@ +ref: refs/heads/master diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_unchanged/config b/tests/resources/reftable/submod2/.gitted/modules/sm_unchanged/config new file mode 100644 index 000000000..fc706c9dd --- /dev/null +++ b/tests/resources/reftable/submod2/.gitted/modules/sm_unchanged/config @@ -0,0 +1,13 @@ +[core] + repositoryformatversion = 0 + filemode = true + bare = false + logallrefupdates = true + worktree = ../../../sm_unchanged + ignorecase = true +[remote "origin"] + fetch = +refs/heads/*:refs/remotes/origin/* + url = /Users/rb/src/libgit2/tests-clar/resources/submod2_target +[branch "master"] + remote = origin + merge = refs/heads/master diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_unchanged/description b/tests/resources/reftable/submod2/.gitted/modules/sm_unchanged/description new file mode 100644 index 000000000..498b267a8 --- /dev/null +++ b/tests/resources/reftable/submod2/.gitted/modules/sm_unchanged/description @@ -0,0 +1 @@ +Unnamed repository; edit this file 'description' to name the repository. diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_unchanged/index b/tests/resources/reftable/submod2/.gitted/modules/sm_unchanged/index new file mode 100644 index 000000000..629c849ec Binary files /dev/null and b/tests/resources/reftable/submod2/.gitted/modules/sm_unchanged/index differ diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_unchanged/info/exclude b/tests/resources/reftable/submod2/.gitted/modules/sm_unchanged/info/exclude new file mode 100644 index 000000000..a5196d1be --- /dev/null +++ b/tests/resources/reftable/submod2/.gitted/modules/sm_unchanged/info/exclude @@ -0,0 +1,6 @@ +# git ls-files --others --exclude-from=.git/info/exclude +# Lines that start with '#' are comments. +# For a project mostly in C, the following would be a good set of +# exclude patterns (uncomment them if you want to use them): +# *.[oa] +# *~ diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_unchanged/logs/HEAD b/tests/resources/reftable/submod2/.gitted/modules/sm_unchanged/logs/HEAD new file mode 100644 index 000000000..72653286a --- /dev/null +++ b/tests/resources/reftable/submod2/.gitted/modules/sm_unchanged/logs/HEAD @@ -0,0 +1 @@ +0000000000000000000000000000000000000000 480095882d281ed676fe5b863569520e54a7d5c0 Russell Belfer 1342560169 -0700 clone: from /Users/rb/src/libgit2/tests-clar/resources/submod2_target diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_unchanged/logs/refs/heads/master b/tests/resources/reftable/submod2/.gitted/modules/sm_unchanged/logs/refs/heads/master new file mode 100644 index 000000000..72653286a --- /dev/null +++ b/tests/resources/reftable/submod2/.gitted/modules/sm_unchanged/logs/refs/heads/master @@ -0,0 +1 @@ +0000000000000000000000000000000000000000 480095882d281ed676fe5b863569520e54a7d5c0 Russell Belfer 1342560169 -0700 clone: from /Users/rb/src/libgit2/tests-clar/resources/submod2_target diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_unchanged/logs/refs/remotes/origin/HEAD b/tests/resources/reftable/submod2/.gitted/modules/sm_unchanged/logs/refs/remotes/origin/HEAD new file mode 100644 index 000000000..72653286a --- /dev/null +++ b/tests/resources/reftable/submod2/.gitted/modules/sm_unchanged/logs/refs/remotes/origin/HEAD @@ -0,0 +1 @@ +0000000000000000000000000000000000000000 480095882d281ed676fe5b863569520e54a7d5c0 Russell Belfer 1342560169 -0700 clone: from /Users/rb/src/libgit2/tests-clar/resources/submod2_target diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_unchanged/objects/06/362fe2fdb7010d0e447b4fb450d405420479a1 b/tests/resources/reftable/submod2/.gitted/modules/sm_unchanged/objects/06/362fe2fdb7010d0e447b4fb450d405420479a1 new file mode 100644 index 000000000..f4b7094c5 Binary files /dev/null and b/tests/resources/reftable/submod2/.gitted/modules/sm_unchanged/objects/06/362fe2fdb7010d0e447b4fb450d405420479a1 differ diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_unchanged/objects/0e/6a3ca48bd47cfe67681acf39aa0b10a0b92484 b/tests/resources/reftable/submod2/.gitted/modules/sm_unchanged/objects/0e/6a3ca48bd47cfe67681acf39aa0b10a0b92484 new file mode 100644 index 000000000..56c845e49 Binary files /dev/null and b/tests/resources/reftable/submod2/.gitted/modules/sm_unchanged/objects/0e/6a3ca48bd47cfe67681acf39aa0b10a0b92484 differ diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_unchanged/objects/17/d0ece6e96460a06592d9d9d000de37ba4232c5 b/tests/resources/reftable/submod2/.gitted/modules/sm_unchanged/objects/17/d0ece6e96460a06592d9d9d000de37ba4232c5 new file mode 100644 index 000000000..bd179b5f5 Binary files /dev/null and b/tests/resources/reftable/submod2/.gitted/modules/sm_unchanged/objects/17/d0ece6e96460a06592d9d9d000de37ba4232c5 differ diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_unchanged/objects/41/bd4bc3df978de695f67ace64c560913da11653 b/tests/resources/reftable/submod2/.gitted/modules/sm_unchanged/objects/41/bd4bc3df978de695f67ace64c560913da11653 new file mode 100644 index 000000000..ccf49bd15 Binary files /dev/null and b/tests/resources/reftable/submod2/.gitted/modules/sm_unchanged/objects/41/bd4bc3df978de695f67ace64c560913da11653 differ diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_unchanged/objects/48/0095882d281ed676fe5b863569520e54a7d5c0 b/tests/resources/reftable/submod2/.gitted/modules/sm_unchanged/objects/48/0095882d281ed676fe5b863569520e54a7d5c0 new file mode 100644 index 000000000..53029069a Binary files /dev/null and b/tests/resources/reftable/submod2/.gitted/modules/sm_unchanged/objects/48/0095882d281ed676fe5b863569520e54a7d5c0 differ diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_unchanged/objects/5e/4963595a9774b90524d35a807169049de8ccad b/tests/resources/reftable/submod2/.gitted/modules/sm_unchanged/objects/5e/4963595a9774b90524d35a807169049de8ccad new file mode 100644 index 000000000..38c791eba Binary files /dev/null and b/tests/resources/reftable/submod2/.gitted/modules/sm_unchanged/objects/5e/4963595a9774b90524d35a807169049de8ccad differ diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_unchanged/objects/6b/31c659545507c381e9cd34ec508f16c04e149e b/tests/resources/reftable/submod2/.gitted/modules/sm_unchanged/objects/6b/31c659545507c381e9cd34ec508f16c04e149e new file mode 100644 index 000000000..a26d29993 --- /dev/null +++ b/tests/resources/reftable/submod2/.gitted/modules/sm_unchanged/objects/6b/31c659545507c381e9cd34ec508f16c04e149e @@ -0,0 +1,2 @@ +xQ +!Evoy*_@g#hOh^9wSòf1*[Ic Ԥpk Α\S߇l@.^QpF(:D5zr~ en8 \ No newline at end of file diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_unchanged/objects/73/ba924a80437097795ae839e66e187c55d3babf b/tests/resources/reftable/submod2/.gitted/modules/sm_unchanged/objects/73/ba924a80437097795ae839e66e187c55d3babf new file mode 100644 index 000000000..83d1ba481 Binary files /dev/null and b/tests/resources/reftable/submod2/.gitted/modules/sm_unchanged/objects/73/ba924a80437097795ae839e66e187c55d3babf differ diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_unchanged/objects/78/0d7397f5e8f8f477fb55b7af3accc2154b2d4a b/tests/resources/reftable/submod2/.gitted/modules/sm_unchanged/objects/78/0d7397f5e8f8f477fb55b7af3accc2154b2d4a new file mode 100644 index 000000000..6d27af8a8 --- /dev/null +++ b/tests/resources/reftable/submod2/.gitted/modules/sm_unchanged/objects/78/0d7397f5e8f8f477fb55b7af3accc2154b2d4a @@ -0,0 +1,2 @@ +x-10 Fa0p(N-ӡғq]>ks*? |m“i@mV'`).-1 x +uxt(+ \ No newline at end of file diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_unchanged/objects/78/9efbdadaa4a582778d4584385495559ea0994b b/tests/resources/reftable/submod2/.gitted/modules/sm_unchanged/objects/78/9efbdadaa4a582778d4584385495559ea0994b new file mode 100644 index 000000000..17458840b --- /dev/null +++ b/tests/resources/reftable/submod2/.gitted/modules/sm_unchanged/objects/78/9efbdadaa4a582778d4584385495559ea0994b @@ -0,0 +1,2 @@ +x 0 )?= NlOkj8&r +qJW7B<fK8#Q1C-"e̫>'@ \ No newline at end of file diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_unchanged/objects/88/34b635dd468a83cb012f6feace968c1c9f5d6e b/tests/resources/reftable/submod2/.gitted/modules/sm_unchanged/objects/88/34b635dd468a83cb012f6feace968c1c9f5d6e new file mode 100644 index 000000000..83cc29fb1 Binary files /dev/null and b/tests/resources/reftable/submod2/.gitted/modules/sm_unchanged/objects/88/34b635dd468a83cb012f6feace968c1c9f5d6e differ diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_unchanged/objects/d0/5f2cd5cc77addf68ed6f50d622c9a4f732e6c5 b/tests/resources/reftable/submod2/.gitted/modules/sm_unchanged/objects/d0/5f2cd5cc77addf68ed6f50d622c9a4f732e6c5 new file mode 100644 index 000000000..55bda40ef Binary files /dev/null and b/tests/resources/reftable/submod2/.gitted/modules/sm_unchanged/objects/d0/5f2cd5cc77addf68ed6f50d622c9a4f732e6c5 differ diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_unchanged/packed-refs b/tests/resources/reftable/submod2/.gitted/modules/sm_unchanged/packed-refs new file mode 100644 index 000000000..5a4ebc47c --- /dev/null +++ b/tests/resources/reftable/submod2/.gitted/modules/sm_unchanged/packed-refs @@ -0,0 +1,2 @@ +# pack-refs with: peeled +480095882d281ed676fe5b863569520e54a7d5c0 refs/remotes/origin/master diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_unchanged/refs/heads/master b/tests/resources/reftable/submod2/.gitted/modules/sm_unchanged/refs/heads/master new file mode 100644 index 000000000..e12c44d7a --- /dev/null +++ b/tests/resources/reftable/submod2/.gitted/modules/sm_unchanged/refs/heads/master @@ -0,0 +1 @@ +480095882d281ed676fe5b863569520e54a7d5c0 diff --git a/tests/resources/reftable/submod2/.gitted/modules/sm_unchanged/refs/remotes/origin/HEAD b/tests/resources/reftable/submod2/.gitted/modules/sm_unchanged/refs/remotes/origin/HEAD new file mode 100644 index 000000000..6efe28fff --- /dev/null +++ b/tests/resources/reftable/submod2/.gitted/modules/sm_unchanged/refs/remotes/origin/HEAD @@ -0,0 +1 @@ +ref: refs/remotes/origin/master diff --git a/tests/resources/reftable/submod2/.gitted/objects/09/460e5b6cbcb05a3e404593c32a3aa7221eca0e b/tests/resources/reftable/submod2/.gitted/objects/09/460e5b6cbcb05a3e404593c32a3aa7221eca0e new file mode 100644 index 000000000..f1ea5f4c8 Binary files /dev/null and b/tests/resources/reftable/submod2/.gitted/objects/09/460e5b6cbcb05a3e404593c32a3aa7221eca0e differ diff --git a/tests/resources/reftable/submod2/.gitted/objects/14/fe9ccf104058df25e0a08361c4494e167ef243 b/tests/resources/reftable/submod2/.gitted/objects/14/fe9ccf104058df25e0a08361c4494e167ef243 new file mode 100644 index 000000000..d3c8582e3 --- /dev/null +++ b/tests/resources/reftable/submod2/.gitted/objects/14/fe9ccf104058df25e0a08361c4494e167ef243 @@ -0,0 +1 @@ +xM F]sfhcc;ހ@I(_O{s%@> ^!F'!諲l_q4E޶RݏS'n>>m^\w^$X_迦xE_.9} \ No newline at end of file diff --git a/tests/resources/reftable/submod2/.gitted/objects/22/ce3e0311dda73a5992d54a4a595518d3876ea7 b/tests/resources/reftable/submod2/.gitted/objects/22/ce3e0311dda73a5992d54a4a595518d3876ea7 new file mode 100644 index 000000000..fce6a94b5 --- /dev/null +++ b/tests/resources/reftable/submod2/.gitted/objects/22/ce3e0311dda73a5992d54a4a595518d3876ea7 @@ -0,0 +1,4 @@ +x +0Eݶ_Q. +. W"!1 !3 >+.9=3W(n-:;j[" W{ޕQZW,2 iviyh T/={ !@b(bJcSPrŌ +{`|%imp콡=IÿW26B@)|)g \ No newline at end of file diff --git a/tests/resources/reftable/submod2/.gitted/objects/25/5546424b0efb847b1bfc91dbf7348b277f8970 b/tests/resources/reftable/submod2/.gitted/objects/25/5546424b0efb847b1bfc91dbf7348b277f8970 new file mode 100644 index 000000000..2965becf6 Binary files /dev/null and b/tests/resources/reftable/submod2/.gitted/objects/25/5546424b0efb847b1bfc91dbf7348b277f8970 differ diff --git a/tests/resources/reftable/submod2/.gitted/objects/2a/30f1e6f94b20917005a21273f65b406d0f8bad b/tests/resources/reftable/submod2/.gitted/objects/2a/30f1e6f94b20917005a21273f65b406d0f8bad new file mode 100644 index 000000000..08faf0fa8 Binary files /dev/null and b/tests/resources/reftable/submod2/.gitted/objects/2a/30f1e6f94b20917005a21273f65b406d0f8bad differ diff --git a/tests/resources/reftable/submod2/.gitted/objects/42/cfb95cd01bf9225b659b5ee3edcc78e8eeb478 b/tests/resources/reftable/submod2/.gitted/objects/42/cfb95cd01bf9225b659b5ee3edcc78e8eeb478 new file mode 100644 index 000000000..ee7848ae6 Binary files /dev/null and b/tests/resources/reftable/submod2/.gitted/objects/42/cfb95cd01bf9225b659b5ee3edcc78e8eeb478 differ diff --git a/tests/resources/reftable/submod2/.gitted/objects/57/958699c2dc394f81cfc76950e9c3ac3025c398 b/tests/resources/reftable/submod2/.gitted/objects/57/958699c2dc394f81cfc76950e9c3ac3025c398 new file mode 100644 index 000000000..ca9203a6e Binary files /dev/null and b/tests/resources/reftable/submod2/.gitted/objects/57/958699c2dc394f81cfc76950e9c3ac3025c398 differ diff --git a/tests/resources/reftable/submod2/.gitted/objects/59/01da4f1c67756eeadc5121d206bec2431f253b b/tests/resources/reftable/submod2/.gitted/objects/59/01da4f1c67756eeadc5121d206bec2431f253b new file mode 100644 index 000000000..9f88f6bdf --- /dev/null +++ b/tests/resources/reftable/submod2/.gitted/objects/59/01da4f1c67756eeadc5121d206bec2431f253b @@ -0,0 +1,2 @@ +x 1ENӀ2yg@D,A$;YE6m{΁e(/2d#jȚL 2Yd:fʞ =V^DhR $^a+tn {n8xs +Ծ=<@jCŹک[>6#=-g?,F \ No newline at end of file diff --git a/tests/resources/reftable/submod2/.gitted/objects/60/7d96653d4d0a4f733107f7890c2e67b55b620d b/tests/resources/reftable/submod2/.gitted/objects/60/7d96653d4d0a4f733107f7890c2e67b55b620d new file mode 100644 index 000000000..30bee40e9 Binary files /dev/null and b/tests/resources/reftable/submod2/.gitted/objects/60/7d96653d4d0a4f733107f7890c2e67b55b620d differ diff --git a/tests/resources/reftable/submod2/.gitted/objects/74/84482eb8db738cafa696993664607500a3f2b9 b/tests/resources/reftable/submod2/.gitted/objects/74/84482eb8db738cafa696993664607500a3f2b9 new file mode 100644 index 000000000..79018042d Binary files /dev/null and b/tests/resources/reftable/submod2/.gitted/objects/74/84482eb8db738cafa696993664607500a3f2b9 differ diff --git a/tests/resources/reftable/submod2/.gitted/objects/7b/a4c5c3561daa5ab1a86215cfb0587e96d404d6 b/tests/resources/reftable/submod2/.gitted/objects/7b/a4c5c3561daa5ab1a86215cfb0587e96d404d6 new file mode 100644 index 000000000..cde89e5bb Binary files /dev/null and b/tests/resources/reftable/submod2/.gitted/objects/7b/a4c5c3561daa5ab1a86215cfb0587e96d404d6 differ diff --git a/tests/resources/reftable/submod2/.gitted/objects/87/3585b94bdeabccea991ea5e3ec1a277895b698 b/tests/resources/reftable/submod2/.gitted/objects/87/3585b94bdeabccea991ea5e3ec1a277895b698 new file mode 100644 index 000000000..41af98aa9 Binary files /dev/null and b/tests/resources/reftable/submod2/.gitted/objects/87/3585b94bdeabccea991ea5e3ec1a277895b698 differ diff --git a/tests/resources/reftable/submod2/.gitted/objects/97/4cf7c73de336b0c4e019f918f3cee367d72e84 b/tests/resources/reftable/submod2/.gitted/objects/97/4cf7c73de336b0c4e019f918f3cee367d72e84 new file mode 100644 index 000000000..160f1caf4 --- /dev/null +++ b/tests/resources/reftable/submod2/.gitted/objects/97/4cf7c73de336b0c4e019f918f3cee367d72e84 @@ -0,0 +1,2 @@ +x +0Eݶ_Bqg yi IYUp!΁s|R7=)XCAG:25:<-uU_IY\Ϥ%AF f{G qTPsu(Z{RA #̉0mŲ.8b?{vʌ \ No newline at end of file diff --git a/tests/resources/reftable/submod2/.gitted/objects/9d/bc299bc013ea253583b40bf327b5a6e4037b89 b/tests/resources/reftable/submod2/.gitted/objects/9d/bc299bc013ea253583b40bf327b5a6e4037b89 new file mode 100644 index 000000000..1ee52218d Binary files /dev/null and b/tests/resources/reftable/submod2/.gitted/objects/9d/bc299bc013ea253583b40bf327b5a6e4037b89 differ diff --git a/tests/resources/reftable/submod2/.gitted/objects/a9/104bf89e911387244ef499413960ba472066d9 b/tests/resources/reftable/submod2/.gitted/objects/a9/104bf89e911387244ef499413960ba472066d9 new file mode 100644 index 000000000..2239e14a8 Binary files /dev/null and b/tests/resources/reftable/submod2/.gitted/objects/a9/104bf89e911387244ef499413960ba472066d9 differ diff --git a/tests/resources/reftable/submod2/.gitted/objects/b6/14088620bbdc1d29549d223ceba0f4419fd4cb b/tests/resources/reftable/submod2/.gitted/objects/b6/14088620bbdc1d29549d223ceba0f4419fd4cb new file mode 100644 index 000000000..a03ea66e4 Binary files /dev/null and b/tests/resources/reftable/submod2/.gitted/objects/b6/14088620bbdc1d29549d223ceba0f4419fd4cb differ diff --git a/tests/resources/reftable/submod2/.gitted/objects/d4/07f19e50c1da1ff584beafe0d6dac7237c5d06 b/tests/resources/reftable/submod2/.gitted/objects/d4/07f19e50c1da1ff584beafe0d6dac7237c5d06 new file mode 100644 index 000000000..292303eb9 Binary files /dev/null and b/tests/resources/reftable/submod2/.gitted/objects/d4/07f19e50c1da1ff584beafe0d6dac7237c5d06 differ diff --git a/tests/resources/reftable/submod2/.gitted/objects/d9/3e95571d92cceb5de28c205f1d5f3cc8b88bc8 b/tests/resources/reftable/submod2/.gitted/objects/d9/3e95571d92cceb5de28c205f1d5f3cc8b88bc8 new file mode 100644 index 000000000..b92c7eebd --- /dev/null +++ b/tests/resources/reftable/submod2/.gitted/objects/d9/3e95571d92cceb5de28c205f1d5f3cc8b88bc8 @@ -0,0 +1,2 @@ +x +!nק} ".zuRCx}Αہt .׫6,is&%9S#IW=aߐf2ABYsНa{c^K3gwM͠Fߥ4s'NI \ No newline at end of file diff --git a/tests/resources/reftable/submod2/.gitted/objects/e3/b83bf274ee065eee48734cf8c6dfaf5e81471c b/tests/resources/reftable/submod2/.gitted/objects/e3/b83bf274ee065eee48734cf8c6dfaf5e81471c new file mode 100644 index 000000000..3c7750b12 Binary files /dev/null and b/tests/resources/reftable/submod2/.gitted/objects/e3/b83bf274ee065eee48734cf8c6dfaf5e81471c differ diff --git a/tests/resources/reftable/submod2/.gitted/objects/f5/4414c25e6d24fe39f5c3f128d7c8a17bc23833 b/tests/resources/reftable/submod2/.gitted/objects/f5/4414c25e6d24fe39f5c3f128d7c8a17bc23833 new file mode 100644 index 000000000..219620b25 --- /dev/null +++ b/tests/resources/reftable/submod2/.gitted/objects/f5/4414c25e6d24fe39f5c3f128d7c8a17bc23833 @@ -0,0 +1,2 @@ +xe +0aSbOz12 1342560358 -0700 commit (initial): Initial commit diff --git a/tests/resources/reftable/submod2/not-submodule/.gitted/logs/refs/heads/master b/tests/resources/reftable/submod2/not-submodule/.gitted/logs/refs/heads/master new file mode 100644 index 000000000..1749e7dff --- /dev/null +++ b/tests/resources/reftable/submod2/not-submodule/.gitted/logs/refs/heads/master @@ -0,0 +1 @@ +0000000000000000000000000000000000000000 68e92c611b80ee1ed8f38314ff9577f0d15b2444 Russell Belfer 1342560358 -0700 commit (initial): Initial commit diff --git a/tests/resources/reftable/submod2/not-submodule/.gitted/objects/68/e92c611b80ee1ed8f38314ff9577f0d15b2444 b/tests/resources/reftable/submod2/not-submodule/.gitted/objects/68/e92c611b80ee1ed8f38314ff9577f0d15b2444 new file mode 100644 index 000000000..8892531a7 Binary files /dev/null and b/tests/resources/reftable/submod2/not-submodule/.gitted/objects/68/e92c611b80ee1ed8f38314ff9577f0d15b2444 differ diff --git a/tests/resources/reftable/submod2/not-submodule/.gitted/objects/71/ff9927d7c8a5639e062c38a7d35c433c424627 b/tests/resources/reftable/submod2/not-submodule/.gitted/objects/71/ff9927d7c8a5639e062c38a7d35c433c424627 new file mode 100644 index 000000000..c4e1a77d7 Binary files /dev/null and b/tests/resources/reftable/submod2/not-submodule/.gitted/objects/71/ff9927d7c8a5639e062c38a7d35c433c424627 differ diff --git a/tests/resources/reftable/submod2/not-submodule/.gitted/objects/f0/1d56b18efd353ef2bb93a4585d590a0847195e b/tests/resources/reftable/submod2/not-submodule/.gitted/objects/f0/1d56b18efd353ef2bb93a4585d590a0847195e new file mode 100644 index 000000000..e9f1942a9 Binary files /dev/null and b/tests/resources/reftable/submod2/not-submodule/.gitted/objects/f0/1d56b18efd353ef2bb93a4585d590a0847195e differ diff --git a/tests/resources/reftable/submod2/not-submodule/.gitted/refs/heads/master b/tests/resources/reftable/submod2/not-submodule/.gitted/refs/heads/master new file mode 100644 index 000000000..0bd8514bd --- /dev/null +++ b/tests/resources/reftable/submod2/not-submodule/.gitted/refs/heads/master @@ -0,0 +1 @@ +68e92c611b80ee1ed8f38314ff9577f0d15b2444 diff --git a/tests/resources/reftable/submod2/not-submodule/README.txt b/tests/resources/reftable/submod2/not-submodule/README.txt new file mode 100644 index 000000000..71ff9927d --- /dev/null +++ b/tests/resources/reftable/submod2/not-submodule/README.txt @@ -0,0 +1 @@ +This is a git repo but not a submodule diff --git a/tests/resources/reftable/submod2/not/.gitted/notempty b/tests/resources/reftable/submod2/not/.gitted/notempty new file mode 100644 index 000000000..9b33ac4e4 --- /dev/null +++ b/tests/resources/reftable/submod2/not/.gitted/notempty @@ -0,0 +1 @@ +fooled you diff --git a/tests/resources/reftable/submod2/not/README.txt b/tests/resources/reftable/submod2/not/README.txt new file mode 100644 index 000000000..4f6935b98 --- /dev/null +++ b/tests/resources/reftable/submod2/not/README.txt @@ -0,0 +1 @@ +what am I really diff --git a/tests/resources/reftable/submod2/sm_added_and_uncommited/.gitted b/tests/resources/reftable/submod2/sm_added_and_uncommited/.gitted new file mode 100644 index 000000000..2b2a4cf90 --- /dev/null +++ b/tests/resources/reftable/submod2/sm_added_and_uncommited/.gitted @@ -0,0 +1 @@ +gitdir: ../.git/modules/sm_added_and_uncommited diff --git a/tests/resources/reftable/submod2/sm_added_and_uncommited/README.txt b/tests/resources/reftable/submod2/sm_added_and_uncommited/README.txt new file mode 100644 index 000000000..780d7397f --- /dev/null +++ b/tests/resources/reftable/submod2/sm_added_and_uncommited/README.txt @@ -0,0 +1,3 @@ +This is the target for submod2 submodule links. +Don't add commits casually because you make break tests. + diff --git a/tests/resources/reftable/submod2/sm_added_and_uncommited/file_to_modify b/tests/resources/reftable/submod2/sm_added_and_uncommited/file_to_modify new file mode 100644 index 000000000..789efbdad --- /dev/null +++ b/tests/resources/reftable/submod2/sm_added_and_uncommited/file_to_modify @@ -0,0 +1,3 @@ +This is a file to modify in submodules +It already has some history. +You can add local changes as needed. diff --git a/tests/resources/reftable/submod2/sm_changed_file/.gitted b/tests/resources/reftable/submod2/sm_changed_file/.gitted new file mode 100644 index 000000000..dc98b1674 --- /dev/null +++ b/tests/resources/reftable/submod2/sm_changed_file/.gitted @@ -0,0 +1 @@ +gitdir: ../.git/modules/sm_changed_file diff --git a/tests/resources/reftable/submod2/sm_changed_file/README.txt b/tests/resources/reftable/submod2/sm_changed_file/README.txt new file mode 100644 index 000000000..780d7397f --- /dev/null +++ b/tests/resources/reftable/submod2/sm_changed_file/README.txt @@ -0,0 +1,3 @@ +This is the target for submod2 submodule links. +Don't add commits casually because you make break tests. + diff --git a/tests/resources/reftable/submod2/sm_changed_file/file_to_modify b/tests/resources/reftable/submod2/sm_changed_file/file_to_modify new file mode 100644 index 000000000..e5ba67168 --- /dev/null +++ b/tests/resources/reftable/submod2/sm_changed_file/file_to_modify @@ -0,0 +1,4 @@ +This is a file to modify in submodules +It already has some history. +You can add local changes as needed. +In this case, the file is changed in the workdir diff --git a/tests/resources/reftable/submod2/sm_changed_head/.gitted b/tests/resources/reftable/submod2/sm_changed_head/.gitted new file mode 100644 index 000000000..d5419b62d --- /dev/null +++ b/tests/resources/reftable/submod2/sm_changed_head/.gitted @@ -0,0 +1 @@ +gitdir: ../.git/modules/sm_changed_head diff --git a/tests/resources/reftable/submod2/sm_changed_head/README.txt b/tests/resources/reftable/submod2/sm_changed_head/README.txt new file mode 100644 index 000000000..780d7397f --- /dev/null +++ b/tests/resources/reftable/submod2/sm_changed_head/README.txt @@ -0,0 +1,3 @@ +This is the target for submod2 submodule links. +Don't add commits casually because you make break tests. + diff --git a/tests/resources/reftable/submod2/sm_changed_head/file_to_modify b/tests/resources/reftable/submod2/sm_changed_head/file_to_modify new file mode 100644 index 000000000..8eb1e637e --- /dev/null +++ b/tests/resources/reftable/submod2/sm_changed_head/file_to_modify @@ -0,0 +1,4 @@ +This is a file to modify in submodules +It already has some history. +You can add local changes as needed. +This one has been changed and the change has been committed to HEAD. diff --git a/tests/resources/reftable/submod2/sm_changed_index/.gitted b/tests/resources/reftable/submod2/sm_changed_index/.gitted new file mode 100644 index 000000000..2c7a5b271 --- /dev/null +++ b/tests/resources/reftable/submod2/sm_changed_index/.gitted @@ -0,0 +1 @@ +gitdir: ../.git/modules/sm_changed_index diff --git a/tests/resources/reftable/submod2/sm_changed_index/README.txt b/tests/resources/reftable/submod2/sm_changed_index/README.txt new file mode 100644 index 000000000..780d7397f --- /dev/null +++ b/tests/resources/reftable/submod2/sm_changed_index/README.txt @@ -0,0 +1,3 @@ +This is the target for submod2 submodule links. +Don't add commits casually because you make break tests. + diff --git a/tests/resources/reftable/submod2/sm_changed_index/file_to_modify b/tests/resources/reftable/submod2/sm_changed_index/file_to_modify new file mode 100644 index 000000000..a02d31770 --- /dev/null +++ b/tests/resources/reftable/submod2/sm_changed_index/file_to_modify @@ -0,0 +1,4 @@ +This is a file to modify in submodules +It already has some history. +You can add local changes as needed. +Here the file is changed in the index and the workdir diff --git a/tests/resources/reftable/submod2/sm_changed_untracked_file/.gitted b/tests/resources/reftable/submod2/sm_changed_untracked_file/.gitted new file mode 100644 index 000000000..9a1070647 --- /dev/null +++ b/tests/resources/reftable/submod2/sm_changed_untracked_file/.gitted @@ -0,0 +1 @@ +gitdir: ../.git/modules/sm_changed_untracked_file diff --git a/tests/resources/reftable/submod2/sm_changed_untracked_file/README.txt b/tests/resources/reftable/submod2/sm_changed_untracked_file/README.txt new file mode 100644 index 000000000..780d7397f --- /dev/null +++ b/tests/resources/reftable/submod2/sm_changed_untracked_file/README.txt @@ -0,0 +1,3 @@ +This is the target for submod2 submodule links. +Don't add commits casually because you make break tests. + diff --git a/tests/resources/reftable/submod2/sm_changed_untracked_file/file_to_modify b/tests/resources/reftable/submod2/sm_changed_untracked_file/file_to_modify new file mode 100644 index 000000000..789efbdad --- /dev/null +++ b/tests/resources/reftable/submod2/sm_changed_untracked_file/file_to_modify @@ -0,0 +1,3 @@ +This is a file to modify in submodules +It already has some history. +You can add local changes as needed. diff --git a/tests/resources/reftable/submod2/sm_changed_untracked_file/i_am_untracked b/tests/resources/reftable/submod2/sm_changed_untracked_file/i_am_untracked new file mode 100644 index 000000000..d2bae6167 --- /dev/null +++ b/tests/resources/reftable/submod2/sm_changed_untracked_file/i_am_untracked @@ -0,0 +1 @@ +This file is untracked, but in a submodule diff --git a/tests/resources/reftable/submod2/sm_missing_commits/.gitted b/tests/resources/reftable/submod2/sm_missing_commits/.gitted new file mode 100644 index 000000000..70193be84 --- /dev/null +++ b/tests/resources/reftable/submod2/sm_missing_commits/.gitted @@ -0,0 +1 @@ +gitdir: ../.git/modules/sm_missing_commits diff --git a/tests/resources/reftable/submod2/sm_missing_commits/README.txt b/tests/resources/reftable/submod2/sm_missing_commits/README.txt new file mode 100644 index 000000000..780d7397f --- /dev/null +++ b/tests/resources/reftable/submod2/sm_missing_commits/README.txt @@ -0,0 +1,3 @@ +This is the target for submod2 submodule links. +Don't add commits casually because you make break tests. + diff --git a/tests/resources/reftable/submod2/sm_missing_commits/file_to_modify b/tests/resources/reftable/submod2/sm_missing_commits/file_to_modify new file mode 100644 index 000000000..8834b635d --- /dev/null +++ b/tests/resources/reftable/submod2/sm_missing_commits/file_to_modify @@ -0,0 +1,3 @@ +This is a file to modify in submodules +It already has some history. + diff --git a/tests/resources/reftable/submod2/sm_unchanged/.gitted b/tests/resources/reftable/submod2/sm_unchanged/.gitted new file mode 100644 index 000000000..51a679c80 --- /dev/null +++ b/tests/resources/reftable/submod2/sm_unchanged/.gitted @@ -0,0 +1 @@ +gitdir: ../.git/modules/sm_unchanged diff --git a/tests/resources/reftable/submod2/sm_unchanged/README.txt b/tests/resources/reftable/submod2/sm_unchanged/README.txt new file mode 100644 index 000000000..780d7397f --- /dev/null +++ b/tests/resources/reftable/submod2/sm_unchanged/README.txt @@ -0,0 +1,3 @@ +This is the target for submod2 submodule links. +Don't add commits casually because you make break tests. + diff --git a/tests/resources/reftable/submod2/sm_unchanged/file_to_modify b/tests/resources/reftable/submod2/sm_unchanged/file_to_modify new file mode 100644 index 000000000..789efbdad --- /dev/null +++ b/tests/resources/reftable/submod2/sm_unchanged/file_to_modify @@ -0,0 +1,3 @@ +This is a file to modify in submodules +It already has some history. +You can add local changes as needed. diff --git a/tests/resources/reftable/submod3/.gitted/HEAD b/tests/resources/reftable/submod3/.gitted/HEAD new file mode 100644 index 000000000..fe6d7e5fa --- /dev/null +++ b/tests/resources/reftable/submod3/.gitted/HEAD @@ -0,0 +1 @@ +ref: refs/heads/.invalid diff --git a/tests/resources/reftable/submod3/.gitted/config b/tests/resources/reftable/submod3/.gitted/config new file mode 100644 index 000000000..9c8008341 --- /dev/null +++ b/tests/resources/reftable/submod3/.gitted/config @@ -0,0 +1,27 @@ +[core] + repositoryformatversion = 1 + filemode = true + bare = false + logallrefupdates = true +[submodule "One"] + url = ../submod2_target +[submodule "TWO"] + url = ../submod2_target +[submodule "three"] + url = ../submod2_target +[submodule "FoUr"] + url = ../submod2_target +[submodule "Five"] + url = ../submod2_target +[submodule "six"] + url = ../submod2_target +[submodule "sEvEn"] + url = ../submod2_target +[submodule "EIGHT"] + url = ../submod2_target +[submodule "nine"] + url = ../submod2_target +[submodule "TEN"] + url = ../submod2_target +[extensions] + refstorage = reftable diff --git a/tests/resources/reftable/submod3/.gitted/index b/tests/resources/reftable/submod3/.gitted/index new file mode 100644 index 000000000..fc688e264 Binary files /dev/null and b/tests/resources/reftable/submod3/.gitted/index differ diff --git a/tests/resources/reftable/submod3/.gitted/modules/EIGHT/HEAD b/tests/resources/reftable/submod3/.gitted/modules/EIGHT/HEAD new file mode 100644 index 000000000..cb089cd89 --- /dev/null +++ b/tests/resources/reftable/submod3/.gitted/modules/EIGHT/HEAD @@ -0,0 +1 @@ +ref: refs/heads/master diff --git a/tests/resources/reftable/submod3/.gitted/modules/EIGHT/config b/tests/resources/reftable/submod3/.gitted/modules/EIGHT/config new file mode 100755 index 000000000..c95068ad7 --- /dev/null +++ b/tests/resources/reftable/submod3/.gitted/modules/EIGHT/config @@ -0,0 +1,12 @@ +[core] + repositoryformatversion = 0 + filemode = true + bare = false + logallrefupdates = true + worktree = ../../../EIGHT +[remote "origin"] + url = /tmp/libgit2_tests_5hR8uP/submod2_target + fetch = +refs/heads/*:refs/remotes/origin/* +[branch "master"] + remote = origin + merge = refs/heads/master diff --git a/tests/resources/reftable/submod3/.gitted/modules/EIGHT/index b/tests/resources/reftable/submod3/.gitted/modules/EIGHT/index new file mode 100644 index 000000000..4217b3fb9 Binary files /dev/null and b/tests/resources/reftable/submod3/.gitted/modules/EIGHT/index differ diff --git a/tests/resources/reftable/submod3/.gitted/modules/EIGHT/objects/06/362fe2fdb7010d0e447b4fb450d405420479a1 b/tests/resources/reftable/submod3/.gitted/modules/EIGHT/objects/06/362fe2fdb7010d0e447b4fb450d405420479a1 new file mode 100644 index 000000000..f4b7094c5 Binary files /dev/null and b/tests/resources/reftable/submod3/.gitted/modules/EIGHT/objects/06/362fe2fdb7010d0e447b4fb450d405420479a1 differ diff --git a/tests/resources/reftable/submod3/.gitted/modules/EIGHT/objects/0e/6a3ca48bd47cfe67681acf39aa0b10a0b92484 b/tests/resources/reftable/submod3/.gitted/modules/EIGHT/objects/0e/6a3ca48bd47cfe67681acf39aa0b10a0b92484 new file mode 100644 index 000000000..56c845e49 Binary files /dev/null and b/tests/resources/reftable/submod3/.gitted/modules/EIGHT/objects/0e/6a3ca48bd47cfe67681acf39aa0b10a0b92484 differ diff --git a/tests/resources/reftable/submod3/.gitted/modules/EIGHT/objects/17/d0ece6e96460a06592d9d9d000de37ba4232c5 b/tests/resources/reftable/submod3/.gitted/modules/EIGHT/objects/17/d0ece6e96460a06592d9d9d000de37ba4232c5 new file mode 100644 index 000000000..bd179b5f5 Binary files /dev/null and b/tests/resources/reftable/submod3/.gitted/modules/EIGHT/objects/17/d0ece6e96460a06592d9d9d000de37ba4232c5 differ diff --git a/tests/resources/reftable/submod3/.gitted/modules/EIGHT/objects/41/bd4bc3df978de695f67ace64c560913da11653 b/tests/resources/reftable/submod3/.gitted/modules/EIGHT/objects/41/bd4bc3df978de695f67ace64c560913da11653 new file mode 100644 index 000000000..ccf49bd15 Binary files /dev/null and b/tests/resources/reftable/submod3/.gitted/modules/EIGHT/objects/41/bd4bc3df978de695f67ace64c560913da11653 differ diff --git a/tests/resources/reftable/submod3/.gitted/modules/EIGHT/objects/48/0095882d281ed676fe5b863569520e54a7d5c0 b/tests/resources/reftable/submod3/.gitted/modules/EIGHT/objects/48/0095882d281ed676fe5b863569520e54a7d5c0 new file mode 100644 index 000000000..53029069a Binary files /dev/null and b/tests/resources/reftable/submod3/.gitted/modules/EIGHT/objects/48/0095882d281ed676fe5b863569520e54a7d5c0 differ diff --git a/tests/resources/reftable/submod3/.gitted/modules/EIGHT/objects/5e/4963595a9774b90524d35a807169049de8ccad b/tests/resources/reftable/submod3/.gitted/modules/EIGHT/objects/5e/4963595a9774b90524d35a807169049de8ccad new file mode 100644 index 000000000..38c791eba Binary files /dev/null and b/tests/resources/reftable/submod3/.gitted/modules/EIGHT/objects/5e/4963595a9774b90524d35a807169049de8ccad differ diff --git a/tests/resources/reftable/submod3/.gitted/modules/EIGHT/objects/6b/31c659545507c381e9cd34ec508f16c04e149e b/tests/resources/reftable/submod3/.gitted/modules/EIGHT/objects/6b/31c659545507c381e9cd34ec508f16c04e149e new file mode 100644 index 000000000..a26d29993 --- /dev/null +++ b/tests/resources/reftable/submod3/.gitted/modules/EIGHT/objects/6b/31c659545507c381e9cd34ec508f16c04e149e @@ -0,0 +1,2 @@ +xQ +!Evoy*_@g#hOh^9wSòf1*[Ic Ԥpk Α\S߇l@.^QpF(:D5zr~ en8 \ No newline at end of file diff --git a/tests/resources/reftable/submod3/.gitted/modules/EIGHT/objects/73/ba924a80437097795ae839e66e187c55d3babf b/tests/resources/reftable/submod3/.gitted/modules/EIGHT/objects/73/ba924a80437097795ae839e66e187c55d3babf new file mode 100644 index 000000000..83d1ba481 Binary files /dev/null and b/tests/resources/reftable/submod3/.gitted/modules/EIGHT/objects/73/ba924a80437097795ae839e66e187c55d3babf differ diff --git a/tests/resources/reftable/submod3/.gitted/modules/EIGHT/objects/78/0d7397f5e8f8f477fb55b7af3accc2154b2d4a b/tests/resources/reftable/submod3/.gitted/modules/EIGHT/objects/78/0d7397f5e8f8f477fb55b7af3accc2154b2d4a new file mode 100644 index 000000000..6d27af8a8 --- /dev/null +++ b/tests/resources/reftable/submod3/.gitted/modules/EIGHT/objects/78/0d7397f5e8f8f477fb55b7af3accc2154b2d4a @@ -0,0 +1,2 @@ +x-10 Fa0p(N-ӡғq]>ks*? |m“i@mV'`).-1 x +uxt(+ \ No newline at end of file diff --git a/tests/resources/reftable/submod3/.gitted/modules/EIGHT/objects/78/9efbdadaa4a582778d4584385495559ea0994b b/tests/resources/reftable/submod3/.gitted/modules/EIGHT/objects/78/9efbdadaa4a582778d4584385495559ea0994b new file mode 100644 index 000000000..17458840b --- /dev/null +++ b/tests/resources/reftable/submod3/.gitted/modules/EIGHT/objects/78/9efbdadaa4a582778d4584385495559ea0994b @@ -0,0 +1,2 @@ +x 0 )?= NlOkj8&r +qJW7B<fK8#Q1C-"e̫>'@ \ No newline at end of file diff --git a/tests/resources/reftable/submod3/.gitted/modules/EIGHT/objects/88/34b635dd468a83cb012f6feace968c1c9f5d6e b/tests/resources/reftable/submod3/.gitted/modules/EIGHT/objects/88/34b635dd468a83cb012f6feace968c1c9f5d6e new file mode 100644 index 000000000..83cc29fb1 Binary files /dev/null and b/tests/resources/reftable/submod3/.gitted/modules/EIGHT/objects/88/34b635dd468a83cb012f6feace968c1c9f5d6e differ diff --git a/tests/resources/reftable/submod3/.gitted/modules/EIGHT/objects/d0/5f2cd5cc77addf68ed6f50d622c9a4f732e6c5 b/tests/resources/reftable/submod3/.gitted/modules/EIGHT/objects/d0/5f2cd5cc77addf68ed6f50d622c9a4f732e6c5 new file mode 100644 index 000000000..55bda40ef Binary files /dev/null and b/tests/resources/reftable/submod3/.gitted/modules/EIGHT/objects/d0/5f2cd5cc77addf68ed6f50d622c9a4f732e6c5 differ diff --git a/tests/resources/reftable/submod3/.gitted/modules/EIGHT/packed-refs b/tests/resources/reftable/submod3/.gitted/modules/EIGHT/packed-refs new file mode 100644 index 000000000..def303a5f --- /dev/null +++ b/tests/resources/reftable/submod3/.gitted/modules/EIGHT/packed-refs @@ -0,0 +1,2 @@ +# pack-refs with: peeled fully-peeled +480095882d281ed676fe5b863569520e54a7d5c0 refs/remotes/origin/master diff --git a/tests/resources/reftable/submod3/.gitted/modules/EIGHT/refs/heads/master b/tests/resources/reftable/submod3/.gitted/modules/EIGHT/refs/heads/master new file mode 100644 index 000000000..e12c44d7a --- /dev/null +++ b/tests/resources/reftable/submod3/.gitted/modules/EIGHT/refs/heads/master @@ -0,0 +1 @@ +480095882d281ed676fe5b863569520e54a7d5c0 diff --git a/tests/resources/reftable/submod3/.gitted/modules/EIGHT/refs/remotes/origin/HEAD b/tests/resources/reftable/submod3/.gitted/modules/EIGHT/refs/remotes/origin/HEAD new file mode 100644 index 000000000..6efe28fff --- /dev/null +++ b/tests/resources/reftable/submod3/.gitted/modules/EIGHT/refs/remotes/origin/HEAD @@ -0,0 +1 @@ +ref: refs/remotes/origin/master diff --git a/tests/resources/reftable/submod3/.gitted/modules/Five/HEAD b/tests/resources/reftable/submod3/.gitted/modules/Five/HEAD new file mode 100644 index 000000000..cb089cd89 --- /dev/null +++ b/tests/resources/reftable/submod3/.gitted/modules/Five/HEAD @@ -0,0 +1 @@ +ref: refs/heads/master diff --git a/tests/resources/reftable/submod3/.gitted/modules/Five/config b/tests/resources/reftable/submod3/.gitted/modules/Five/config new file mode 100755 index 000000000..18259e810 --- /dev/null +++ b/tests/resources/reftable/submod3/.gitted/modules/Five/config @@ -0,0 +1,12 @@ +[core] + repositoryformatversion = 0 + filemode = true + bare = false + logallrefupdates = true + worktree = ../../../Five +[remote "origin"] + url = /tmp/libgit2_tests_5hR8uP/submod2_target + fetch = +refs/heads/*:refs/remotes/origin/* +[branch "master"] + remote = origin + merge = refs/heads/master diff --git a/tests/resources/reftable/submod3/.gitted/modules/Five/index b/tests/resources/reftable/submod3/.gitted/modules/Five/index new file mode 100644 index 000000000..bd356c824 Binary files /dev/null and b/tests/resources/reftable/submod3/.gitted/modules/Five/index differ diff --git a/tests/resources/reftable/submod3/.gitted/modules/Five/objects/06/362fe2fdb7010d0e447b4fb450d405420479a1 b/tests/resources/reftable/submod3/.gitted/modules/Five/objects/06/362fe2fdb7010d0e447b4fb450d405420479a1 new file mode 100644 index 000000000..f4b7094c5 Binary files /dev/null and b/tests/resources/reftable/submod3/.gitted/modules/Five/objects/06/362fe2fdb7010d0e447b4fb450d405420479a1 differ diff --git a/tests/resources/reftable/submod3/.gitted/modules/Five/objects/0e/6a3ca48bd47cfe67681acf39aa0b10a0b92484 b/tests/resources/reftable/submod3/.gitted/modules/Five/objects/0e/6a3ca48bd47cfe67681acf39aa0b10a0b92484 new file mode 100644 index 000000000..56c845e49 Binary files /dev/null and b/tests/resources/reftable/submod3/.gitted/modules/Five/objects/0e/6a3ca48bd47cfe67681acf39aa0b10a0b92484 differ diff --git a/tests/resources/reftable/submod3/.gitted/modules/Five/objects/17/d0ece6e96460a06592d9d9d000de37ba4232c5 b/tests/resources/reftable/submod3/.gitted/modules/Five/objects/17/d0ece6e96460a06592d9d9d000de37ba4232c5 new file mode 100644 index 000000000..bd179b5f5 Binary files /dev/null and b/tests/resources/reftable/submod3/.gitted/modules/Five/objects/17/d0ece6e96460a06592d9d9d000de37ba4232c5 differ diff --git a/tests/resources/reftable/submod3/.gitted/modules/Five/objects/41/bd4bc3df978de695f67ace64c560913da11653 b/tests/resources/reftable/submod3/.gitted/modules/Five/objects/41/bd4bc3df978de695f67ace64c560913da11653 new file mode 100644 index 000000000..ccf49bd15 Binary files /dev/null and b/tests/resources/reftable/submod3/.gitted/modules/Five/objects/41/bd4bc3df978de695f67ace64c560913da11653 differ diff --git a/tests/resources/reftable/submod3/.gitted/modules/Five/objects/48/0095882d281ed676fe5b863569520e54a7d5c0 b/tests/resources/reftable/submod3/.gitted/modules/Five/objects/48/0095882d281ed676fe5b863569520e54a7d5c0 new file mode 100644 index 000000000..53029069a Binary files /dev/null and b/tests/resources/reftable/submod3/.gitted/modules/Five/objects/48/0095882d281ed676fe5b863569520e54a7d5c0 differ diff --git a/tests/resources/reftable/submod3/.gitted/modules/Five/objects/5e/4963595a9774b90524d35a807169049de8ccad b/tests/resources/reftable/submod3/.gitted/modules/Five/objects/5e/4963595a9774b90524d35a807169049de8ccad new file mode 100644 index 000000000..38c791eba Binary files /dev/null and b/tests/resources/reftable/submod3/.gitted/modules/Five/objects/5e/4963595a9774b90524d35a807169049de8ccad differ diff --git a/tests/resources/reftable/submod3/.gitted/modules/Five/objects/6b/31c659545507c381e9cd34ec508f16c04e149e b/tests/resources/reftable/submod3/.gitted/modules/Five/objects/6b/31c659545507c381e9cd34ec508f16c04e149e new file mode 100644 index 000000000..a26d29993 --- /dev/null +++ b/tests/resources/reftable/submod3/.gitted/modules/Five/objects/6b/31c659545507c381e9cd34ec508f16c04e149e @@ -0,0 +1,2 @@ +xQ +!Evoy*_@g#hOh^9wSòf1*[Ic Ԥpk Α\S߇l@.^QpF(:D5zr~ en8 \ No newline at end of file diff --git a/tests/resources/reftable/submod3/.gitted/modules/Five/objects/73/ba924a80437097795ae839e66e187c55d3babf b/tests/resources/reftable/submod3/.gitted/modules/Five/objects/73/ba924a80437097795ae839e66e187c55d3babf new file mode 100644 index 000000000..83d1ba481 Binary files /dev/null and b/tests/resources/reftable/submod3/.gitted/modules/Five/objects/73/ba924a80437097795ae839e66e187c55d3babf differ diff --git a/tests/resources/reftable/submod3/.gitted/modules/Five/objects/78/0d7397f5e8f8f477fb55b7af3accc2154b2d4a b/tests/resources/reftable/submod3/.gitted/modules/Five/objects/78/0d7397f5e8f8f477fb55b7af3accc2154b2d4a new file mode 100644 index 000000000..6d27af8a8 --- /dev/null +++ b/tests/resources/reftable/submod3/.gitted/modules/Five/objects/78/0d7397f5e8f8f477fb55b7af3accc2154b2d4a @@ -0,0 +1,2 @@ +x-10 Fa0p(N-ӡғq]>ks*? |m“i@mV'`).-1 x +uxt(+ \ No newline at end of file diff --git a/tests/resources/reftable/submod3/.gitted/modules/Five/objects/78/9efbdadaa4a582778d4584385495559ea0994b b/tests/resources/reftable/submod3/.gitted/modules/Five/objects/78/9efbdadaa4a582778d4584385495559ea0994b new file mode 100644 index 000000000..17458840b --- /dev/null +++ b/tests/resources/reftable/submod3/.gitted/modules/Five/objects/78/9efbdadaa4a582778d4584385495559ea0994b @@ -0,0 +1,2 @@ +x 0 )?= NlOkj8&r +qJW7B<fK8#Q1C-"e̫>'@ \ No newline at end of file diff --git a/tests/resources/reftable/submod3/.gitted/modules/Five/objects/88/34b635dd468a83cb012f6feace968c1c9f5d6e b/tests/resources/reftable/submod3/.gitted/modules/Five/objects/88/34b635dd468a83cb012f6feace968c1c9f5d6e new file mode 100644 index 000000000..83cc29fb1 Binary files /dev/null and b/tests/resources/reftable/submod3/.gitted/modules/Five/objects/88/34b635dd468a83cb012f6feace968c1c9f5d6e differ diff --git a/tests/resources/reftable/submod3/.gitted/modules/Five/objects/d0/5f2cd5cc77addf68ed6f50d622c9a4f732e6c5 b/tests/resources/reftable/submod3/.gitted/modules/Five/objects/d0/5f2cd5cc77addf68ed6f50d622c9a4f732e6c5 new file mode 100644 index 000000000..55bda40ef Binary files /dev/null and b/tests/resources/reftable/submod3/.gitted/modules/Five/objects/d0/5f2cd5cc77addf68ed6f50d622c9a4f732e6c5 differ diff --git a/tests/resources/reftable/submod3/.gitted/modules/Five/packed-refs b/tests/resources/reftable/submod3/.gitted/modules/Five/packed-refs new file mode 100644 index 000000000..def303a5f --- /dev/null +++ b/tests/resources/reftable/submod3/.gitted/modules/Five/packed-refs @@ -0,0 +1,2 @@ +# pack-refs with: peeled fully-peeled +480095882d281ed676fe5b863569520e54a7d5c0 refs/remotes/origin/master diff --git a/tests/resources/reftable/submod3/.gitted/modules/Five/refs/heads/master b/tests/resources/reftable/submod3/.gitted/modules/Five/refs/heads/master new file mode 100644 index 000000000..e12c44d7a --- /dev/null +++ b/tests/resources/reftable/submod3/.gitted/modules/Five/refs/heads/master @@ -0,0 +1 @@ +480095882d281ed676fe5b863569520e54a7d5c0 diff --git a/tests/resources/reftable/submod3/.gitted/modules/Five/refs/remotes/origin/HEAD b/tests/resources/reftable/submod3/.gitted/modules/Five/refs/remotes/origin/HEAD new file mode 100644 index 000000000..6efe28fff --- /dev/null +++ b/tests/resources/reftable/submod3/.gitted/modules/Five/refs/remotes/origin/HEAD @@ -0,0 +1 @@ +ref: refs/remotes/origin/master diff --git a/tests/resources/reftable/submod3/.gitted/modules/FoUr/HEAD b/tests/resources/reftable/submod3/.gitted/modules/FoUr/HEAD new file mode 100644 index 000000000..cb089cd89 --- /dev/null +++ b/tests/resources/reftable/submod3/.gitted/modules/FoUr/HEAD @@ -0,0 +1 @@ +ref: refs/heads/master diff --git a/tests/resources/reftable/submod3/.gitted/modules/FoUr/config b/tests/resources/reftable/submod3/.gitted/modules/FoUr/config new file mode 100755 index 000000000..8e41a32a7 --- /dev/null +++ b/tests/resources/reftable/submod3/.gitted/modules/FoUr/config @@ -0,0 +1,12 @@ +[core] + repositoryformatversion = 0 + filemode = true + bare = false + logallrefupdates = true + worktree = ../../../FoUr +[remote "origin"] + url = /tmp/libgit2_tests_5hR8uP/submod2_target + fetch = +refs/heads/*:refs/remotes/origin/* +[branch "master"] + remote = origin + merge = refs/heads/master diff --git a/tests/resources/reftable/submod3/.gitted/modules/FoUr/index b/tests/resources/reftable/submod3/.gitted/modules/FoUr/index new file mode 100644 index 000000000..bfc441bb3 Binary files /dev/null and b/tests/resources/reftable/submod3/.gitted/modules/FoUr/index differ diff --git a/tests/resources/reftable/submod3/.gitted/modules/FoUr/objects/06/362fe2fdb7010d0e447b4fb450d405420479a1 b/tests/resources/reftable/submod3/.gitted/modules/FoUr/objects/06/362fe2fdb7010d0e447b4fb450d405420479a1 new file mode 100644 index 000000000..f4b7094c5 Binary files /dev/null and b/tests/resources/reftable/submod3/.gitted/modules/FoUr/objects/06/362fe2fdb7010d0e447b4fb450d405420479a1 differ diff --git a/tests/resources/reftable/submod3/.gitted/modules/FoUr/objects/0e/6a3ca48bd47cfe67681acf39aa0b10a0b92484 b/tests/resources/reftable/submod3/.gitted/modules/FoUr/objects/0e/6a3ca48bd47cfe67681acf39aa0b10a0b92484 new file mode 100644 index 000000000..56c845e49 Binary files /dev/null and b/tests/resources/reftable/submod3/.gitted/modules/FoUr/objects/0e/6a3ca48bd47cfe67681acf39aa0b10a0b92484 differ diff --git a/tests/resources/reftable/submod3/.gitted/modules/FoUr/objects/17/d0ece6e96460a06592d9d9d000de37ba4232c5 b/tests/resources/reftable/submod3/.gitted/modules/FoUr/objects/17/d0ece6e96460a06592d9d9d000de37ba4232c5 new file mode 100644 index 000000000..bd179b5f5 Binary files /dev/null and b/tests/resources/reftable/submod3/.gitted/modules/FoUr/objects/17/d0ece6e96460a06592d9d9d000de37ba4232c5 differ diff --git a/tests/resources/reftable/submod3/.gitted/modules/FoUr/objects/41/bd4bc3df978de695f67ace64c560913da11653 b/tests/resources/reftable/submod3/.gitted/modules/FoUr/objects/41/bd4bc3df978de695f67ace64c560913da11653 new file mode 100644 index 000000000..ccf49bd15 Binary files /dev/null and b/tests/resources/reftable/submod3/.gitted/modules/FoUr/objects/41/bd4bc3df978de695f67ace64c560913da11653 differ diff --git a/tests/resources/reftable/submod3/.gitted/modules/FoUr/objects/48/0095882d281ed676fe5b863569520e54a7d5c0 b/tests/resources/reftable/submod3/.gitted/modules/FoUr/objects/48/0095882d281ed676fe5b863569520e54a7d5c0 new file mode 100644 index 000000000..53029069a Binary files /dev/null and b/tests/resources/reftable/submod3/.gitted/modules/FoUr/objects/48/0095882d281ed676fe5b863569520e54a7d5c0 differ diff --git a/tests/resources/reftable/submod3/.gitted/modules/FoUr/objects/5e/4963595a9774b90524d35a807169049de8ccad b/tests/resources/reftable/submod3/.gitted/modules/FoUr/objects/5e/4963595a9774b90524d35a807169049de8ccad new file mode 100644 index 000000000..38c791eba Binary files /dev/null and b/tests/resources/reftable/submod3/.gitted/modules/FoUr/objects/5e/4963595a9774b90524d35a807169049de8ccad differ diff --git a/tests/resources/reftable/submod3/.gitted/modules/FoUr/objects/6b/31c659545507c381e9cd34ec508f16c04e149e b/tests/resources/reftable/submod3/.gitted/modules/FoUr/objects/6b/31c659545507c381e9cd34ec508f16c04e149e new file mode 100644 index 000000000..a26d29993 --- /dev/null +++ b/tests/resources/reftable/submod3/.gitted/modules/FoUr/objects/6b/31c659545507c381e9cd34ec508f16c04e149e @@ -0,0 +1,2 @@ +xQ +!Evoy*_@g#hOh^9wSòf1*[Ic Ԥpk Α\S߇l@.^QpF(:D5zr~ en8 \ No newline at end of file diff --git a/tests/resources/reftable/submod3/.gitted/modules/FoUr/objects/73/ba924a80437097795ae839e66e187c55d3babf b/tests/resources/reftable/submod3/.gitted/modules/FoUr/objects/73/ba924a80437097795ae839e66e187c55d3babf new file mode 100644 index 000000000..83d1ba481 Binary files /dev/null and b/tests/resources/reftable/submod3/.gitted/modules/FoUr/objects/73/ba924a80437097795ae839e66e187c55d3babf differ diff --git a/tests/resources/reftable/submod3/.gitted/modules/FoUr/objects/78/0d7397f5e8f8f477fb55b7af3accc2154b2d4a b/tests/resources/reftable/submod3/.gitted/modules/FoUr/objects/78/0d7397f5e8f8f477fb55b7af3accc2154b2d4a new file mode 100644 index 000000000..6d27af8a8 --- /dev/null +++ b/tests/resources/reftable/submod3/.gitted/modules/FoUr/objects/78/0d7397f5e8f8f477fb55b7af3accc2154b2d4a @@ -0,0 +1,2 @@ +x-10 Fa0p(N-ӡғq]>ks*? |m“i@mV'`).-1 x +uxt(+ \ No newline at end of file diff --git a/tests/resources/reftable/submod3/.gitted/modules/FoUr/objects/78/9efbdadaa4a582778d4584385495559ea0994b b/tests/resources/reftable/submod3/.gitted/modules/FoUr/objects/78/9efbdadaa4a582778d4584385495559ea0994b new file mode 100644 index 000000000..17458840b --- /dev/null +++ b/tests/resources/reftable/submod3/.gitted/modules/FoUr/objects/78/9efbdadaa4a582778d4584385495559ea0994b @@ -0,0 +1,2 @@ +x 0 )?= NlOkj8&r +qJW7B<fK8#Q1C-"e̫>'@ \ No newline at end of file diff --git a/tests/resources/reftable/submod3/.gitted/modules/FoUr/objects/88/34b635dd468a83cb012f6feace968c1c9f5d6e b/tests/resources/reftable/submod3/.gitted/modules/FoUr/objects/88/34b635dd468a83cb012f6feace968c1c9f5d6e new file mode 100644 index 000000000..83cc29fb1 Binary files /dev/null and b/tests/resources/reftable/submod3/.gitted/modules/FoUr/objects/88/34b635dd468a83cb012f6feace968c1c9f5d6e differ diff --git a/tests/resources/reftable/submod3/.gitted/modules/FoUr/objects/d0/5f2cd5cc77addf68ed6f50d622c9a4f732e6c5 b/tests/resources/reftable/submod3/.gitted/modules/FoUr/objects/d0/5f2cd5cc77addf68ed6f50d622c9a4f732e6c5 new file mode 100644 index 000000000..55bda40ef Binary files /dev/null and b/tests/resources/reftable/submod3/.gitted/modules/FoUr/objects/d0/5f2cd5cc77addf68ed6f50d622c9a4f732e6c5 differ diff --git a/tests/resources/reftable/submod3/.gitted/modules/FoUr/packed-refs b/tests/resources/reftable/submod3/.gitted/modules/FoUr/packed-refs new file mode 100644 index 000000000..def303a5f --- /dev/null +++ b/tests/resources/reftable/submod3/.gitted/modules/FoUr/packed-refs @@ -0,0 +1,2 @@ +# pack-refs with: peeled fully-peeled +480095882d281ed676fe5b863569520e54a7d5c0 refs/remotes/origin/master diff --git a/tests/resources/reftable/submod3/.gitted/modules/FoUr/refs/heads/master b/tests/resources/reftable/submod3/.gitted/modules/FoUr/refs/heads/master new file mode 100644 index 000000000..e12c44d7a --- /dev/null +++ b/tests/resources/reftable/submod3/.gitted/modules/FoUr/refs/heads/master @@ -0,0 +1 @@ +480095882d281ed676fe5b863569520e54a7d5c0 diff --git a/tests/resources/reftable/submod3/.gitted/modules/FoUr/refs/remotes/origin/HEAD b/tests/resources/reftable/submod3/.gitted/modules/FoUr/refs/remotes/origin/HEAD new file mode 100644 index 000000000..6efe28fff --- /dev/null +++ b/tests/resources/reftable/submod3/.gitted/modules/FoUr/refs/remotes/origin/HEAD @@ -0,0 +1 @@ +ref: refs/remotes/origin/master diff --git a/tests/resources/reftable/submod3/.gitted/modules/One/HEAD b/tests/resources/reftable/submod3/.gitted/modules/One/HEAD new file mode 100644 index 000000000..cb089cd89 --- /dev/null +++ b/tests/resources/reftable/submod3/.gitted/modules/One/HEAD @@ -0,0 +1 @@ +ref: refs/heads/master diff --git a/tests/resources/reftable/submod3/.gitted/modules/One/config b/tests/resources/reftable/submod3/.gitted/modules/One/config new file mode 100755 index 000000000..303b86d4f --- /dev/null +++ b/tests/resources/reftable/submod3/.gitted/modules/One/config @@ -0,0 +1,12 @@ +[core] + repositoryformatversion = 0 + filemode = true + bare = false + logallrefupdates = true + worktree = ../../../One +[remote "origin"] + url = /tmp/libgit2_tests_5hR8uP/submod2_target + fetch = +refs/heads/*:refs/remotes/origin/* +[branch "master"] + remote = origin + merge = refs/heads/master diff --git a/tests/resources/reftable/submod3/.gitted/modules/One/index b/tests/resources/reftable/submod3/.gitted/modules/One/index new file mode 100644 index 000000000..2fa766b9d Binary files /dev/null and b/tests/resources/reftable/submod3/.gitted/modules/One/index differ diff --git a/tests/resources/reftable/submod3/.gitted/modules/One/objects/06/362fe2fdb7010d0e447b4fb450d405420479a1 b/tests/resources/reftable/submod3/.gitted/modules/One/objects/06/362fe2fdb7010d0e447b4fb450d405420479a1 new file mode 100644 index 000000000..f4b7094c5 Binary files /dev/null and b/tests/resources/reftable/submod3/.gitted/modules/One/objects/06/362fe2fdb7010d0e447b4fb450d405420479a1 differ diff --git a/tests/resources/reftable/submod3/.gitted/modules/One/objects/0e/6a3ca48bd47cfe67681acf39aa0b10a0b92484 b/tests/resources/reftable/submod3/.gitted/modules/One/objects/0e/6a3ca48bd47cfe67681acf39aa0b10a0b92484 new file mode 100644 index 000000000..56c845e49 Binary files /dev/null and b/tests/resources/reftable/submod3/.gitted/modules/One/objects/0e/6a3ca48bd47cfe67681acf39aa0b10a0b92484 differ diff --git a/tests/resources/reftable/submod3/.gitted/modules/One/objects/17/d0ece6e96460a06592d9d9d000de37ba4232c5 b/tests/resources/reftable/submod3/.gitted/modules/One/objects/17/d0ece6e96460a06592d9d9d000de37ba4232c5 new file mode 100644 index 000000000..bd179b5f5 Binary files /dev/null and b/tests/resources/reftable/submod3/.gitted/modules/One/objects/17/d0ece6e96460a06592d9d9d000de37ba4232c5 differ diff --git a/tests/resources/reftable/submod3/.gitted/modules/One/objects/41/bd4bc3df978de695f67ace64c560913da11653 b/tests/resources/reftable/submod3/.gitted/modules/One/objects/41/bd4bc3df978de695f67ace64c560913da11653 new file mode 100644 index 000000000..ccf49bd15 Binary files /dev/null and b/tests/resources/reftable/submod3/.gitted/modules/One/objects/41/bd4bc3df978de695f67ace64c560913da11653 differ diff --git a/tests/resources/reftable/submod3/.gitted/modules/One/objects/48/0095882d281ed676fe5b863569520e54a7d5c0 b/tests/resources/reftable/submod3/.gitted/modules/One/objects/48/0095882d281ed676fe5b863569520e54a7d5c0 new file mode 100644 index 000000000..53029069a Binary files /dev/null and b/tests/resources/reftable/submod3/.gitted/modules/One/objects/48/0095882d281ed676fe5b863569520e54a7d5c0 differ diff --git a/tests/resources/reftable/submod3/.gitted/modules/One/objects/5e/4963595a9774b90524d35a807169049de8ccad b/tests/resources/reftable/submod3/.gitted/modules/One/objects/5e/4963595a9774b90524d35a807169049de8ccad new file mode 100644 index 000000000..38c791eba Binary files /dev/null and b/tests/resources/reftable/submod3/.gitted/modules/One/objects/5e/4963595a9774b90524d35a807169049de8ccad differ diff --git a/tests/resources/reftable/submod3/.gitted/modules/One/objects/6b/31c659545507c381e9cd34ec508f16c04e149e b/tests/resources/reftable/submod3/.gitted/modules/One/objects/6b/31c659545507c381e9cd34ec508f16c04e149e new file mode 100644 index 000000000..a26d29993 --- /dev/null +++ b/tests/resources/reftable/submod3/.gitted/modules/One/objects/6b/31c659545507c381e9cd34ec508f16c04e149e @@ -0,0 +1,2 @@ +xQ +!Evoy*_@g#hOh^9wSòf1*[Ic Ԥpk Α\S߇l@.^QpF(:D5zr~ en8 \ No newline at end of file diff --git a/tests/resources/reftable/submod3/.gitted/modules/One/objects/73/ba924a80437097795ae839e66e187c55d3babf b/tests/resources/reftable/submod3/.gitted/modules/One/objects/73/ba924a80437097795ae839e66e187c55d3babf new file mode 100644 index 000000000..83d1ba481 Binary files /dev/null and b/tests/resources/reftable/submod3/.gitted/modules/One/objects/73/ba924a80437097795ae839e66e187c55d3babf differ diff --git a/tests/resources/reftable/submod3/.gitted/modules/One/objects/78/0d7397f5e8f8f477fb55b7af3accc2154b2d4a b/tests/resources/reftable/submod3/.gitted/modules/One/objects/78/0d7397f5e8f8f477fb55b7af3accc2154b2d4a new file mode 100644 index 000000000..6d27af8a8 --- /dev/null +++ b/tests/resources/reftable/submod3/.gitted/modules/One/objects/78/0d7397f5e8f8f477fb55b7af3accc2154b2d4a @@ -0,0 +1,2 @@ +x-10 Fa0p(N-ӡғq]>ks*? |m“i@mV'`).-1 x +uxt(+ \ No newline at end of file diff --git a/tests/resources/reftable/submod3/.gitted/modules/One/objects/78/9efbdadaa4a582778d4584385495559ea0994b b/tests/resources/reftable/submod3/.gitted/modules/One/objects/78/9efbdadaa4a582778d4584385495559ea0994b new file mode 100644 index 000000000..17458840b --- /dev/null +++ b/tests/resources/reftable/submod3/.gitted/modules/One/objects/78/9efbdadaa4a582778d4584385495559ea0994b @@ -0,0 +1,2 @@ +x 0 )?= NlOkj8&r +qJW7B<fK8#Q1C-"e̫>'@ \ No newline at end of file diff --git a/tests/resources/reftable/submod3/.gitted/modules/One/objects/88/34b635dd468a83cb012f6feace968c1c9f5d6e b/tests/resources/reftable/submod3/.gitted/modules/One/objects/88/34b635dd468a83cb012f6feace968c1c9f5d6e new file mode 100644 index 000000000..83cc29fb1 Binary files /dev/null and b/tests/resources/reftable/submod3/.gitted/modules/One/objects/88/34b635dd468a83cb012f6feace968c1c9f5d6e differ diff --git a/tests/resources/reftable/submod3/.gitted/modules/One/objects/d0/5f2cd5cc77addf68ed6f50d622c9a4f732e6c5 b/tests/resources/reftable/submod3/.gitted/modules/One/objects/d0/5f2cd5cc77addf68ed6f50d622c9a4f732e6c5 new file mode 100644 index 000000000..55bda40ef Binary files /dev/null and b/tests/resources/reftable/submod3/.gitted/modules/One/objects/d0/5f2cd5cc77addf68ed6f50d622c9a4f732e6c5 differ diff --git a/tests/resources/reftable/submod3/.gitted/modules/One/packed-refs b/tests/resources/reftable/submod3/.gitted/modules/One/packed-refs new file mode 100644 index 000000000..def303a5f --- /dev/null +++ b/tests/resources/reftable/submod3/.gitted/modules/One/packed-refs @@ -0,0 +1,2 @@ +# pack-refs with: peeled fully-peeled +480095882d281ed676fe5b863569520e54a7d5c0 refs/remotes/origin/master diff --git a/tests/resources/reftable/submod3/.gitted/modules/One/refs/heads/master b/tests/resources/reftable/submod3/.gitted/modules/One/refs/heads/master new file mode 100644 index 000000000..e12c44d7a --- /dev/null +++ b/tests/resources/reftable/submod3/.gitted/modules/One/refs/heads/master @@ -0,0 +1 @@ +480095882d281ed676fe5b863569520e54a7d5c0 diff --git a/tests/resources/reftable/submod3/.gitted/modules/One/refs/remotes/origin/HEAD b/tests/resources/reftable/submod3/.gitted/modules/One/refs/remotes/origin/HEAD new file mode 100644 index 000000000..6efe28fff --- /dev/null +++ b/tests/resources/reftable/submod3/.gitted/modules/One/refs/remotes/origin/HEAD @@ -0,0 +1 @@ +ref: refs/remotes/origin/master diff --git a/tests/resources/reftable/submod3/.gitted/modules/TEN/HEAD b/tests/resources/reftable/submod3/.gitted/modules/TEN/HEAD new file mode 100644 index 000000000..cb089cd89 --- /dev/null +++ b/tests/resources/reftable/submod3/.gitted/modules/TEN/HEAD @@ -0,0 +1 @@ +ref: refs/heads/master diff --git a/tests/resources/reftable/submod3/.gitted/modules/TEN/config b/tests/resources/reftable/submod3/.gitted/modules/TEN/config new file mode 100755 index 000000000..0c8328835 --- /dev/null +++ b/tests/resources/reftable/submod3/.gitted/modules/TEN/config @@ -0,0 +1,12 @@ +[core] + repositoryformatversion = 0 + filemode = true + bare = false + logallrefupdates = true + worktree = ../../../TEN +[remote "origin"] + url = /tmp/libgit2_tests_5hR8uP/submod2_target + fetch = +refs/heads/*:refs/remotes/origin/* +[branch "master"] + remote = origin + merge = refs/heads/master diff --git a/tests/resources/reftable/submod3/.gitted/modules/TEN/index b/tests/resources/reftable/submod3/.gitted/modules/TEN/index new file mode 100644 index 000000000..202f0e27d Binary files /dev/null and b/tests/resources/reftable/submod3/.gitted/modules/TEN/index differ diff --git a/tests/resources/reftable/submod3/.gitted/modules/TEN/objects/06/362fe2fdb7010d0e447b4fb450d405420479a1 b/tests/resources/reftable/submod3/.gitted/modules/TEN/objects/06/362fe2fdb7010d0e447b4fb450d405420479a1 new file mode 100644 index 000000000..f4b7094c5 Binary files /dev/null and b/tests/resources/reftable/submod3/.gitted/modules/TEN/objects/06/362fe2fdb7010d0e447b4fb450d405420479a1 differ diff --git a/tests/resources/reftable/submod3/.gitted/modules/TEN/objects/0e/6a3ca48bd47cfe67681acf39aa0b10a0b92484 b/tests/resources/reftable/submod3/.gitted/modules/TEN/objects/0e/6a3ca48bd47cfe67681acf39aa0b10a0b92484 new file mode 100644 index 000000000..56c845e49 Binary files /dev/null and b/tests/resources/reftable/submod3/.gitted/modules/TEN/objects/0e/6a3ca48bd47cfe67681acf39aa0b10a0b92484 differ diff --git a/tests/resources/reftable/submod3/.gitted/modules/TEN/objects/17/d0ece6e96460a06592d9d9d000de37ba4232c5 b/tests/resources/reftable/submod3/.gitted/modules/TEN/objects/17/d0ece6e96460a06592d9d9d000de37ba4232c5 new file mode 100644 index 000000000..bd179b5f5 Binary files /dev/null and b/tests/resources/reftable/submod3/.gitted/modules/TEN/objects/17/d0ece6e96460a06592d9d9d000de37ba4232c5 differ diff --git a/tests/resources/reftable/submod3/.gitted/modules/TEN/objects/41/bd4bc3df978de695f67ace64c560913da11653 b/tests/resources/reftable/submod3/.gitted/modules/TEN/objects/41/bd4bc3df978de695f67ace64c560913da11653 new file mode 100644 index 000000000..ccf49bd15 Binary files /dev/null and b/tests/resources/reftable/submod3/.gitted/modules/TEN/objects/41/bd4bc3df978de695f67ace64c560913da11653 differ diff --git a/tests/resources/reftable/submod3/.gitted/modules/TEN/objects/48/0095882d281ed676fe5b863569520e54a7d5c0 b/tests/resources/reftable/submod3/.gitted/modules/TEN/objects/48/0095882d281ed676fe5b863569520e54a7d5c0 new file mode 100644 index 000000000..53029069a Binary files /dev/null and b/tests/resources/reftable/submod3/.gitted/modules/TEN/objects/48/0095882d281ed676fe5b863569520e54a7d5c0 differ diff --git a/tests/resources/reftable/submod3/.gitted/modules/TEN/objects/5e/4963595a9774b90524d35a807169049de8ccad b/tests/resources/reftable/submod3/.gitted/modules/TEN/objects/5e/4963595a9774b90524d35a807169049de8ccad new file mode 100644 index 000000000..38c791eba Binary files /dev/null and b/tests/resources/reftable/submod3/.gitted/modules/TEN/objects/5e/4963595a9774b90524d35a807169049de8ccad differ diff --git a/tests/resources/reftable/submod3/.gitted/modules/TEN/objects/6b/31c659545507c381e9cd34ec508f16c04e149e b/tests/resources/reftable/submod3/.gitted/modules/TEN/objects/6b/31c659545507c381e9cd34ec508f16c04e149e new file mode 100644 index 000000000..a26d29993 --- /dev/null +++ b/tests/resources/reftable/submod3/.gitted/modules/TEN/objects/6b/31c659545507c381e9cd34ec508f16c04e149e @@ -0,0 +1,2 @@ +xQ +!Evoy*_@g#hOh^9wSòf1*[Ic Ԥpk Α\S߇l@.^QpF(:D5zr~ en8 \ No newline at end of file diff --git a/tests/resources/reftable/submod3/.gitted/modules/TEN/objects/73/ba924a80437097795ae839e66e187c55d3babf b/tests/resources/reftable/submod3/.gitted/modules/TEN/objects/73/ba924a80437097795ae839e66e187c55d3babf new file mode 100644 index 000000000..83d1ba481 Binary files /dev/null and b/tests/resources/reftable/submod3/.gitted/modules/TEN/objects/73/ba924a80437097795ae839e66e187c55d3babf differ diff --git a/tests/resources/reftable/submod3/.gitted/modules/TEN/objects/78/0d7397f5e8f8f477fb55b7af3accc2154b2d4a b/tests/resources/reftable/submod3/.gitted/modules/TEN/objects/78/0d7397f5e8f8f477fb55b7af3accc2154b2d4a new file mode 100644 index 000000000..6d27af8a8 --- /dev/null +++ b/tests/resources/reftable/submod3/.gitted/modules/TEN/objects/78/0d7397f5e8f8f477fb55b7af3accc2154b2d4a @@ -0,0 +1,2 @@ +x-10 Fa0p(N-ӡғq]>ks*? |m“i@mV'`).-1 x +uxt(+ \ No newline at end of file diff --git a/tests/resources/reftable/submod3/.gitted/modules/TEN/objects/78/9efbdadaa4a582778d4584385495559ea0994b b/tests/resources/reftable/submod3/.gitted/modules/TEN/objects/78/9efbdadaa4a582778d4584385495559ea0994b new file mode 100644 index 000000000..17458840b --- /dev/null +++ b/tests/resources/reftable/submod3/.gitted/modules/TEN/objects/78/9efbdadaa4a582778d4584385495559ea0994b @@ -0,0 +1,2 @@ +x 0 )?= NlOkj8&r +qJW7B<fK8#Q1C-"e̫>'@ \ No newline at end of file diff --git a/tests/resources/reftable/submod3/.gitted/modules/TEN/objects/88/34b635dd468a83cb012f6feace968c1c9f5d6e b/tests/resources/reftable/submod3/.gitted/modules/TEN/objects/88/34b635dd468a83cb012f6feace968c1c9f5d6e new file mode 100644 index 000000000..83cc29fb1 Binary files /dev/null and b/tests/resources/reftable/submod3/.gitted/modules/TEN/objects/88/34b635dd468a83cb012f6feace968c1c9f5d6e differ diff --git a/tests/resources/reftable/submod3/.gitted/modules/TEN/objects/d0/5f2cd5cc77addf68ed6f50d622c9a4f732e6c5 b/tests/resources/reftable/submod3/.gitted/modules/TEN/objects/d0/5f2cd5cc77addf68ed6f50d622c9a4f732e6c5 new file mode 100644 index 000000000..55bda40ef Binary files /dev/null and b/tests/resources/reftable/submod3/.gitted/modules/TEN/objects/d0/5f2cd5cc77addf68ed6f50d622c9a4f732e6c5 differ diff --git a/tests/resources/reftable/submod3/.gitted/modules/TEN/packed-refs b/tests/resources/reftable/submod3/.gitted/modules/TEN/packed-refs new file mode 100644 index 000000000..def303a5f --- /dev/null +++ b/tests/resources/reftable/submod3/.gitted/modules/TEN/packed-refs @@ -0,0 +1,2 @@ +# pack-refs with: peeled fully-peeled +480095882d281ed676fe5b863569520e54a7d5c0 refs/remotes/origin/master diff --git a/tests/resources/reftable/submod3/.gitted/modules/TEN/refs/heads/master b/tests/resources/reftable/submod3/.gitted/modules/TEN/refs/heads/master new file mode 100644 index 000000000..e12c44d7a --- /dev/null +++ b/tests/resources/reftable/submod3/.gitted/modules/TEN/refs/heads/master @@ -0,0 +1 @@ +480095882d281ed676fe5b863569520e54a7d5c0 diff --git a/tests/resources/reftable/submod3/.gitted/modules/TEN/refs/remotes/origin/HEAD b/tests/resources/reftable/submod3/.gitted/modules/TEN/refs/remotes/origin/HEAD new file mode 100644 index 000000000..6efe28fff --- /dev/null +++ b/tests/resources/reftable/submod3/.gitted/modules/TEN/refs/remotes/origin/HEAD @@ -0,0 +1 @@ +ref: refs/remotes/origin/master diff --git a/tests/resources/reftable/submod3/.gitted/modules/TWO/HEAD b/tests/resources/reftable/submod3/.gitted/modules/TWO/HEAD new file mode 100644 index 000000000..cb089cd89 --- /dev/null +++ b/tests/resources/reftable/submod3/.gitted/modules/TWO/HEAD @@ -0,0 +1 @@ +ref: refs/heads/master diff --git a/tests/resources/reftable/submod3/.gitted/modules/TWO/config b/tests/resources/reftable/submod3/.gitted/modules/TWO/config new file mode 100755 index 000000000..4d9022262 --- /dev/null +++ b/tests/resources/reftable/submod3/.gitted/modules/TWO/config @@ -0,0 +1,12 @@ +[core] + repositoryformatversion = 0 + filemode = true + bare = false + logallrefupdates = true + worktree = ../../../TWO +[remote "origin"] + url = /tmp/libgit2_tests_5hR8uP/submod2_target + fetch = +refs/heads/*:refs/remotes/origin/* +[branch "master"] + remote = origin + merge = refs/heads/master diff --git a/tests/resources/reftable/submod3/.gitted/modules/TWO/index b/tests/resources/reftable/submod3/.gitted/modules/TWO/index new file mode 100644 index 000000000..42053137a Binary files /dev/null and b/tests/resources/reftable/submod3/.gitted/modules/TWO/index differ diff --git a/tests/resources/reftable/submod3/.gitted/modules/TWO/objects/06/362fe2fdb7010d0e447b4fb450d405420479a1 b/tests/resources/reftable/submod3/.gitted/modules/TWO/objects/06/362fe2fdb7010d0e447b4fb450d405420479a1 new file mode 100644 index 000000000..f4b7094c5 Binary files /dev/null and b/tests/resources/reftable/submod3/.gitted/modules/TWO/objects/06/362fe2fdb7010d0e447b4fb450d405420479a1 differ diff --git a/tests/resources/reftable/submod3/.gitted/modules/TWO/objects/0e/6a3ca48bd47cfe67681acf39aa0b10a0b92484 b/tests/resources/reftable/submod3/.gitted/modules/TWO/objects/0e/6a3ca48bd47cfe67681acf39aa0b10a0b92484 new file mode 100644 index 000000000..56c845e49 Binary files /dev/null and b/tests/resources/reftable/submod3/.gitted/modules/TWO/objects/0e/6a3ca48bd47cfe67681acf39aa0b10a0b92484 differ diff --git a/tests/resources/reftable/submod3/.gitted/modules/TWO/objects/17/d0ece6e96460a06592d9d9d000de37ba4232c5 b/tests/resources/reftable/submod3/.gitted/modules/TWO/objects/17/d0ece6e96460a06592d9d9d000de37ba4232c5 new file mode 100644 index 000000000..bd179b5f5 Binary files /dev/null and b/tests/resources/reftable/submod3/.gitted/modules/TWO/objects/17/d0ece6e96460a06592d9d9d000de37ba4232c5 differ diff --git a/tests/resources/reftable/submod3/.gitted/modules/TWO/objects/41/bd4bc3df978de695f67ace64c560913da11653 b/tests/resources/reftable/submod3/.gitted/modules/TWO/objects/41/bd4bc3df978de695f67ace64c560913da11653 new file mode 100644 index 000000000..ccf49bd15 Binary files /dev/null and b/tests/resources/reftable/submod3/.gitted/modules/TWO/objects/41/bd4bc3df978de695f67ace64c560913da11653 differ diff --git a/tests/resources/reftable/submod3/.gitted/modules/TWO/objects/48/0095882d281ed676fe5b863569520e54a7d5c0 b/tests/resources/reftable/submod3/.gitted/modules/TWO/objects/48/0095882d281ed676fe5b863569520e54a7d5c0 new file mode 100644 index 000000000..53029069a Binary files /dev/null and b/tests/resources/reftable/submod3/.gitted/modules/TWO/objects/48/0095882d281ed676fe5b863569520e54a7d5c0 differ diff --git a/tests/resources/reftable/submod3/.gitted/modules/TWO/objects/5e/4963595a9774b90524d35a807169049de8ccad b/tests/resources/reftable/submod3/.gitted/modules/TWO/objects/5e/4963595a9774b90524d35a807169049de8ccad new file mode 100644 index 000000000..38c791eba Binary files /dev/null and b/tests/resources/reftable/submod3/.gitted/modules/TWO/objects/5e/4963595a9774b90524d35a807169049de8ccad differ diff --git a/tests/resources/reftable/submod3/.gitted/modules/TWO/objects/6b/31c659545507c381e9cd34ec508f16c04e149e b/tests/resources/reftable/submod3/.gitted/modules/TWO/objects/6b/31c659545507c381e9cd34ec508f16c04e149e new file mode 100644 index 000000000..a26d29993 --- /dev/null +++ b/tests/resources/reftable/submod3/.gitted/modules/TWO/objects/6b/31c659545507c381e9cd34ec508f16c04e149e @@ -0,0 +1,2 @@ +xQ +!Evoy*_@g#hOh^9wSòf1*[Ic Ԥpk Α\S߇l@.^QpF(:D5zr~ en8 \ No newline at end of file diff --git a/tests/resources/reftable/submod3/.gitted/modules/TWO/objects/73/ba924a80437097795ae839e66e187c55d3babf b/tests/resources/reftable/submod3/.gitted/modules/TWO/objects/73/ba924a80437097795ae839e66e187c55d3babf new file mode 100644 index 000000000..83d1ba481 Binary files /dev/null and b/tests/resources/reftable/submod3/.gitted/modules/TWO/objects/73/ba924a80437097795ae839e66e187c55d3babf differ diff --git a/tests/resources/reftable/submod3/.gitted/modules/TWO/objects/78/0d7397f5e8f8f477fb55b7af3accc2154b2d4a b/tests/resources/reftable/submod3/.gitted/modules/TWO/objects/78/0d7397f5e8f8f477fb55b7af3accc2154b2d4a new file mode 100644 index 000000000..6d27af8a8 --- /dev/null +++ b/tests/resources/reftable/submod3/.gitted/modules/TWO/objects/78/0d7397f5e8f8f477fb55b7af3accc2154b2d4a @@ -0,0 +1,2 @@ +x-10 Fa0p(N-ӡғq]>ks*? |m“i@mV'`).-1 x +uxt(+ \ No newline at end of file diff --git a/tests/resources/reftable/submod3/.gitted/modules/TWO/objects/78/9efbdadaa4a582778d4584385495559ea0994b b/tests/resources/reftable/submod3/.gitted/modules/TWO/objects/78/9efbdadaa4a582778d4584385495559ea0994b new file mode 100644 index 000000000..17458840b --- /dev/null +++ b/tests/resources/reftable/submod3/.gitted/modules/TWO/objects/78/9efbdadaa4a582778d4584385495559ea0994b @@ -0,0 +1,2 @@ +x 0 )?= NlOkj8&r +qJW7B<fK8#Q1C-"e̫>'@ \ No newline at end of file diff --git a/tests/resources/reftable/submod3/.gitted/modules/TWO/objects/88/34b635dd468a83cb012f6feace968c1c9f5d6e b/tests/resources/reftable/submod3/.gitted/modules/TWO/objects/88/34b635dd468a83cb012f6feace968c1c9f5d6e new file mode 100644 index 000000000..83cc29fb1 Binary files /dev/null and b/tests/resources/reftable/submod3/.gitted/modules/TWO/objects/88/34b635dd468a83cb012f6feace968c1c9f5d6e differ diff --git a/tests/resources/reftable/submod3/.gitted/modules/TWO/objects/d0/5f2cd5cc77addf68ed6f50d622c9a4f732e6c5 b/tests/resources/reftable/submod3/.gitted/modules/TWO/objects/d0/5f2cd5cc77addf68ed6f50d622c9a4f732e6c5 new file mode 100644 index 000000000..55bda40ef Binary files /dev/null and b/tests/resources/reftable/submod3/.gitted/modules/TWO/objects/d0/5f2cd5cc77addf68ed6f50d622c9a4f732e6c5 differ diff --git a/tests/resources/reftable/submod3/.gitted/modules/TWO/packed-refs b/tests/resources/reftable/submod3/.gitted/modules/TWO/packed-refs new file mode 100644 index 000000000..def303a5f --- /dev/null +++ b/tests/resources/reftable/submod3/.gitted/modules/TWO/packed-refs @@ -0,0 +1,2 @@ +# pack-refs with: peeled fully-peeled +480095882d281ed676fe5b863569520e54a7d5c0 refs/remotes/origin/master diff --git a/tests/resources/reftable/submod3/.gitted/modules/TWO/refs/heads/master b/tests/resources/reftable/submod3/.gitted/modules/TWO/refs/heads/master new file mode 100644 index 000000000..e12c44d7a --- /dev/null +++ b/tests/resources/reftable/submod3/.gitted/modules/TWO/refs/heads/master @@ -0,0 +1 @@ +480095882d281ed676fe5b863569520e54a7d5c0 diff --git a/tests/resources/reftable/submod3/.gitted/modules/TWO/refs/remotes/origin/HEAD b/tests/resources/reftable/submod3/.gitted/modules/TWO/refs/remotes/origin/HEAD new file mode 100644 index 000000000..6efe28fff --- /dev/null +++ b/tests/resources/reftable/submod3/.gitted/modules/TWO/refs/remotes/origin/HEAD @@ -0,0 +1 @@ +ref: refs/remotes/origin/master diff --git a/tests/resources/reftable/submod3/.gitted/modules/nine/HEAD b/tests/resources/reftable/submod3/.gitted/modules/nine/HEAD new file mode 100644 index 000000000..cb089cd89 --- /dev/null +++ b/tests/resources/reftable/submod3/.gitted/modules/nine/HEAD @@ -0,0 +1 @@ +ref: refs/heads/master diff --git a/tests/resources/reftable/submod3/.gitted/modules/nine/config b/tests/resources/reftable/submod3/.gitted/modules/nine/config new file mode 100755 index 000000000..7c73f8a6d --- /dev/null +++ b/tests/resources/reftable/submod3/.gitted/modules/nine/config @@ -0,0 +1,12 @@ +[core] + repositoryformatversion = 0 + filemode = true + bare = false + logallrefupdates = true + worktree = ../../../nine +[remote "origin"] + url = /tmp/libgit2_tests_5hR8uP/submod2_target + fetch = +refs/heads/*:refs/remotes/origin/* +[branch "master"] + remote = origin + merge = refs/heads/master diff --git a/tests/resources/reftable/submod3/.gitted/modules/nine/index b/tests/resources/reftable/submod3/.gitted/modules/nine/index new file mode 100644 index 000000000..48e3e9e07 Binary files /dev/null and b/tests/resources/reftable/submod3/.gitted/modules/nine/index differ diff --git a/tests/resources/reftable/submod3/.gitted/modules/nine/objects/06/362fe2fdb7010d0e447b4fb450d405420479a1 b/tests/resources/reftable/submod3/.gitted/modules/nine/objects/06/362fe2fdb7010d0e447b4fb450d405420479a1 new file mode 100644 index 000000000..f4b7094c5 Binary files /dev/null and b/tests/resources/reftable/submod3/.gitted/modules/nine/objects/06/362fe2fdb7010d0e447b4fb450d405420479a1 differ diff --git a/tests/resources/reftable/submod3/.gitted/modules/nine/objects/0e/6a3ca48bd47cfe67681acf39aa0b10a0b92484 b/tests/resources/reftable/submod3/.gitted/modules/nine/objects/0e/6a3ca48bd47cfe67681acf39aa0b10a0b92484 new file mode 100644 index 000000000..56c845e49 Binary files /dev/null and b/tests/resources/reftable/submod3/.gitted/modules/nine/objects/0e/6a3ca48bd47cfe67681acf39aa0b10a0b92484 differ diff --git a/tests/resources/reftable/submod3/.gitted/modules/nine/objects/17/d0ece6e96460a06592d9d9d000de37ba4232c5 b/tests/resources/reftable/submod3/.gitted/modules/nine/objects/17/d0ece6e96460a06592d9d9d000de37ba4232c5 new file mode 100644 index 000000000..bd179b5f5 Binary files /dev/null and b/tests/resources/reftable/submod3/.gitted/modules/nine/objects/17/d0ece6e96460a06592d9d9d000de37ba4232c5 differ diff --git a/tests/resources/reftable/submod3/.gitted/modules/nine/objects/41/bd4bc3df978de695f67ace64c560913da11653 b/tests/resources/reftable/submod3/.gitted/modules/nine/objects/41/bd4bc3df978de695f67ace64c560913da11653 new file mode 100644 index 000000000..ccf49bd15 Binary files /dev/null and b/tests/resources/reftable/submod3/.gitted/modules/nine/objects/41/bd4bc3df978de695f67ace64c560913da11653 differ diff --git a/tests/resources/reftable/submod3/.gitted/modules/nine/objects/48/0095882d281ed676fe5b863569520e54a7d5c0 b/tests/resources/reftable/submod3/.gitted/modules/nine/objects/48/0095882d281ed676fe5b863569520e54a7d5c0 new file mode 100644 index 000000000..53029069a Binary files /dev/null and b/tests/resources/reftable/submod3/.gitted/modules/nine/objects/48/0095882d281ed676fe5b863569520e54a7d5c0 differ diff --git a/tests/resources/reftable/submod3/.gitted/modules/nine/objects/5e/4963595a9774b90524d35a807169049de8ccad b/tests/resources/reftable/submod3/.gitted/modules/nine/objects/5e/4963595a9774b90524d35a807169049de8ccad new file mode 100644 index 000000000..38c791eba Binary files /dev/null and b/tests/resources/reftable/submod3/.gitted/modules/nine/objects/5e/4963595a9774b90524d35a807169049de8ccad differ diff --git a/tests/resources/reftable/submod3/.gitted/modules/nine/objects/6b/31c659545507c381e9cd34ec508f16c04e149e b/tests/resources/reftable/submod3/.gitted/modules/nine/objects/6b/31c659545507c381e9cd34ec508f16c04e149e new file mode 100644 index 000000000..a26d29993 --- /dev/null +++ b/tests/resources/reftable/submod3/.gitted/modules/nine/objects/6b/31c659545507c381e9cd34ec508f16c04e149e @@ -0,0 +1,2 @@ +xQ +!Evoy*_@g#hOh^9wSòf1*[Ic Ԥpk Α\S߇l@.^QpF(:D5zr~ en8 \ No newline at end of file diff --git a/tests/resources/reftable/submod3/.gitted/modules/nine/objects/73/ba924a80437097795ae839e66e187c55d3babf b/tests/resources/reftable/submod3/.gitted/modules/nine/objects/73/ba924a80437097795ae839e66e187c55d3babf new file mode 100644 index 000000000..83d1ba481 Binary files /dev/null and b/tests/resources/reftable/submod3/.gitted/modules/nine/objects/73/ba924a80437097795ae839e66e187c55d3babf differ diff --git a/tests/resources/reftable/submod3/.gitted/modules/nine/objects/78/0d7397f5e8f8f477fb55b7af3accc2154b2d4a b/tests/resources/reftable/submod3/.gitted/modules/nine/objects/78/0d7397f5e8f8f477fb55b7af3accc2154b2d4a new file mode 100644 index 000000000..6d27af8a8 --- /dev/null +++ b/tests/resources/reftable/submod3/.gitted/modules/nine/objects/78/0d7397f5e8f8f477fb55b7af3accc2154b2d4a @@ -0,0 +1,2 @@ +x-10 Fa0p(N-ӡғq]>ks*? |m“i@mV'`).-1 x +uxt(+ \ No newline at end of file diff --git a/tests/resources/reftable/submod3/.gitted/modules/nine/objects/78/9efbdadaa4a582778d4584385495559ea0994b b/tests/resources/reftable/submod3/.gitted/modules/nine/objects/78/9efbdadaa4a582778d4584385495559ea0994b new file mode 100644 index 000000000..17458840b --- /dev/null +++ b/tests/resources/reftable/submod3/.gitted/modules/nine/objects/78/9efbdadaa4a582778d4584385495559ea0994b @@ -0,0 +1,2 @@ +x 0 )?= NlOkj8&r +qJW7B<fK8#Q1C-"e̫>'@ \ No newline at end of file diff --git a/tests/resources/reftable/submod3/.gitted/modules/nine/objects/88/34b635dd468a83cb012f6feace968c1c9f5d6e b/tests/resources/reftable/submod3/.gitted/modules/nine/objects/88/34b635dd468a83cb012f6feace968c1c9f5d6e new file mode 100644 index 000000000..83cc29fb1 Binary files /dev/null and b/tests/resources/reftable/submod3/.gitted/modules/nine/objects/88/34b635dd468a83cb012f6feace968c1c9f5d6e differ diff --git a/tests/resources/reftable/submod3/.gitted/modules/nine/objects/d0/5f2cd5cc77addf68ed6f50d622c9a4f732e6c5 b/tests/resources/reftable/submod3/.gitted/modules/nine/objects/d0/5f2cd5cc77addf68ed6f50d622c9a4f732e6c5 new file mode 100644 index 000000000..55bda40ef Binary files /dev/null and b/tests/resources/reftable/submod3/.gitted/modules/nine/objects/d0/5f2cd5cc77addf68ed6f50d622c9a4f732e6c5 differ diff --git a/tests/resources/reftable/submod3/.gitted/modules/nine/packed-refs b/tests/resources/reftable/submod3/.gitted/modules/nine/packed-refs new file mode 100644 index 000000000..def303a5f --- /dev/null +++ b/tests/resources/reftable/submod3/.gitted/modules/nine/packed-refs @@ -0,0 +1,2 @@ +# pack-refs with: peeled fully-peeled +480095882d281ed676fe5b863569520e54a7d5c0 refs/remotes/origin/master diff --git a/tests/resources/reftable/submod3/.gitted/modules/nine/refs/heads/master b/tests/resources/reftable/submod3/.gitted/modules/nine/refs/heads/master new file mode 100644 index 000000000..e12c44d7a --- /dev/null +++ b/tests/resources/reftable/submod3/.gitted/modules/nine/refs/heads/master @@ -0,0 +1 @@ +480095882d281ed676fe5b863569520e54a7d5c0 diff --git a/tests/resources/reftable/submod3/.gitted/modules/nine/refs/remotes/origin/HEAD b/tests/resources/reftable/submod3/.gitted/modules/nine/refs/remotes/origin/HEAD new file mode 100644 index 000000000..6efe28fff --- /dev/null +++ b/tests/resources/reftable/submod3/.gitted/modules/nine/refs/remotes/origin/HEAD @@ -0,0 +1 @@ +ref: refs/remotes/origin/master diff --git a/tests/resources/reftable/submod3/.gitted/modules/sEvEn/HEAD b/tests/resources/reftable/submod3/.gitted/modules/sEvEn/HEAD new file mode 100644 index 000000000..cb089cd89 --- /dev/null +++ b/tests/resources/reftable/submod3/.gitted/modules/sEvEn/HEAD @@ -0,0 +1 @@ +ref: refs/heads/master diff --git a/tests/resources/reftable/submod3/.gitted/modules/sEvEn/config b/tests/resources/reftable/submod3/.gitted/modules/sEvEn/config new file mode 100755 index 000000000..1ef3be7d5 --- /dev/null +++ b/tests/resources/reftable/submod3/.gitted/modules/sEvEn/config @@ -0,0 +1,12 @@ +[core] + repositoryformatversion = 0 + filemode = true + bare = false + logallrefupdates = true + worktree = ../../../sEvEn +[remote "origin"] + url = /tmp/libgit2_tests_5hR8uP/submod2_target + fetch = +refs/heads/*:refs/remotes/origin/* +[branch "master"] + remote = origin + merge = refs/heads/master diff --git a/tests/resources/reftable/submod3/.gitted/modules/sEvEn/index b/tests/resources/reftable/submod3/.gitted/modules/sEvEn/index new file mode 100644 index 000000000..0a3a842e3 Binary files /dev/null and b/tests/resources/reftable/submod3/.gitted/modules/sEvEn/index differ diff --git a/tests/resources/reftable/submod3/.gitted/modules/sEvEn/objects/06/362fe2fdb7010d0e447b4fb450d405420479a1 b/tests/resources/reftable/submod3/.gitted/modules/sEvEn/objects/06/362fe2fdb7010d0e447b4fb450d405420479a1 new file mode 100644 index 000000000..f4b7094c5 Binary files /dev/null and b/tests/resources/reftable/submod3/.gitted/modules/sEvEn/objects/06/362fe2fdb7010d0e447b4fb450d405420479a1 differ diff --git a/tests/resources/reftable/submod3/.gitted/modules/sEvEn/objects/0e/6a3ca48bd47cfe67681acf39aa0b10a0b92484 b/tests/resources/reftable/submod3/.gitted/modules/sEvEn/objects/0e/6a3ca48bd47cfe67681acf39aa0b10a0b92484 new file mode 100644 index 000000000..56c845e49 Binary files /dev/null and b/tests/resources/reftable/submod3/.gitted/modules/sEvEn/objects/0e/6a3ca48bd47cfe67681acf39aa0b10a0b92484 differ diff --git a/tests/resources/reftable/submod3/.gitted/modules/sEvEn/objects/17/d0ece6e96460a06592d9d9d000de37ba4232c5 b/tests/resources/reftable/submod3/.gitted/modules/sEvEn/objects/17/d0ece6e96460a06592d9d9d000de37ba4232c5 new file mode 100644 index 000000000..bd179b5f5 Binary files /dev/null and b/tests/resources/reftable/submod3/.gitted/modules/sEvEn/objects/17/d0ece6e96460a06592d9d9d000de37ba4232c5 differ diff --git a/tests/resources/reftable/submod3/.gitted/modules/sEvEn/objects/41/bd4bc3df978de695f67ace64c560913da11653 b/tests/resources/reftable/submod3/.gitted/modules/sEvEn/objects/41/bd4bc3df978de695f67ace64c560913da11653 new file mode 100644 index 000000000..ccf49bd15 Binary files /dev/null and b/tests/resources/reftable/submod3/.gitted/modules/sEvEn/objects/41/bd4bc3df978de695f67ace64c560913da11653 differ diff --git a/tests/resources/reftable/submod3/.gitted/modules/sEvEn/objects/48/0095882d281ed676fe5b863569520e54a7d5c0 b/tests/resources/reftable/submod3/.gitted/modules/sEvEn/objects/48/0095882d281ed676fe5b863569520e54a7d5c0 new file mode 100644 index 000000000..53029069a Binary files /dev/null and b/tests/resources/reftable/submod3/.gitted/modules/sEvEn/objects/48/0095882d281ed676fe5b863569520e54a7d5c0 differ diff --git a/tests/resources/reftable/submod3/.gitted/modules/sEvEn/objects/5e/4963595a9774b90524d35a807169049de8ccad b/tests/resources/reftable/submod3/.gitted/modules/sEvEn/objects/5e/4963595a9774b90524d35a807169049de8ccad new file mode 100644 index 000000000..38c791eba Binary files /dev/null and b/tests/resources/reftable/submod3/.gitted/modules/sEvEn/objects/5e/4963595a9774b90524d35a807169049de8ccad differ diff --git a/tests/resources/reftable/submod3/.gitted/modules/sEvEn/objects/6b/31c659545507c381e9cd34ec508f16c04e149e b/tests/resources/reftable/submod3/.gitted/modules/sEvEn/objects/6b/31c659545507c381e9cd34ec508f16c04e149e new file mode 100644 index 000000000..a26d29993 --- /dev/null +++ b/tests/resources/reftable/submod3/.gitted/modules/sEvEn/objects/6b/31c659545507c381e9cd34ec508f16c04e149e @@ -0,0 +1,2 @@ +xQ +!Evoy*_@g#hOh^9wSòf1*[Ic Ԥpk Α\S߇l@.^QpF(:D5zr~ en8 \ No newline at end of file diff --git a/tests/resources/reftable/submod3/.gitted/modules/sEvEn/objects/73/ba924a80437097795ae839e66e187c55d3babf b/tests/resources/reftable/submod3/.gitted/modules/sEvEn/objects/73/ba924a80437097795ae839e66e187c55d3babf new file mode 100644 index 000000000..83d1ba481 Binary files /dev/null and b/tests/resources/reftable/submod3/.gitted/modules/sEvEn/objects/73/ba924a80437097795ae839e66e187c55d3babf differ diff --git a/tests/resources/reftable/submod3/.gitted/modules/sEvEn/objects/78/0d7397f5e8f8f477fb55b7af3accc2154b2d4a b/tests/resources/reftable/submod3/.gitted/modules/sEvEn/objects/78/0d7397f5e8f8f477fb55b7af3accc2154b2d4a new file mode 100644 index 000000000..6d27af8a8 --- /dev/null +++ b/tests/resources/reftable/submod3/.gitted/modules/sEvEn/objects/78/0d7397f5e8f8f477fb55b7af3accc2154b2d4a @@ -0,0 +1,2 @@ +x-10 Fa0p(N-ӡғq]>ks*? |m“i@mV'`).-1 x +uxt(+ \ No newline at end of file diff --git a/tests/resources/reftable/submod3/.gitted/modules/sEvEn/objects/78/9efbdadaa4a582778d4584385495559ea0994b b/tests/resources/reftable/submod3/.gitted/modules/sEvEn/objects/78/9efbdadaa4a582778d4584385495559ea0994b new file mode 100644 index 000000000..17458840b --- /dev/null +++ b/tests/resources/reftable/submod3/.gitted/modules/sEvEn/objects/78/9efbdadaa4a582778d4584385495559ea0994b @@ -0,0 +1,2 @@ +x 0 )?= NlOkj8&r +qJW7B<fK8#Q1C-"e̫>'@ \ No newline at end of file diff --git a/tests/resources/reftable/submod3/.gitted/modules/sEvEn/objects/88/34b635dd468a83cb012f6feace968c1c9f5d6e b/tests/resources/reftable/submod3/.gitted/modules/sEvEn/objects/88/34b635dd468a83cb012f6feace968c1c9f5d6e new file mode 100644 index 000000000..83cc29fb1 Binary files /dev/null and b/tests/resources/reftable/submod3/.gitted/modules/sEvEn/objects/88/34b635dd468a83cb012f6feace968c1c9f5d6e differ diff --git a/tests/resources/reftable/submod3/.gitted/modules/sEvEn/objects/d0/5f2cd5cc77addf68ed6f50d622c9a4f732e6c5 b/tests/resources/reftable/submod3/.gitted/modules/sEvEn/objects/d0/5f2cd5cc77addf68ed6f50d622c9a4f732e6c5 new file mode 100644 index 000000000..55bda40ef Binary files /dev/null and b/tests/resources/reftable/submod3/.gitted/modules/sEvEn/objects/d0/5f2cd5cc77addf68ed6f50d622c9a4f732e6c5 differ diff --git a/tests/resources/reftable/submod3/.gitted/modules/sEvEn/packed-refs b/tests/resources/reftable/submod3/.gitted/modules/sEvEn/packed-refs new file mode 100644 index 000000000..def303a5f --- /dev/null +++ b/tests/resources/reftable/submod3/.gitted/modules/sEvEn/packed-refs @@ -0,0 +1,2 @@ +# pack-refs with: peeled fully-peeled +480095882d281ed676fe5b863569520e54a7d5c0 refs/remotes/origin/master diff --git a/tests/resources/reftable/submod3/.gitted/modules/sEvEn/refs/heads/master b/tests/resources/reftable/submod3/.gitted/modules/sEvEn/refs/heads/master new file mode 100644 index 000000000..e12c44d7a --- /dev/null +++ b/tests/resources/reftable/submod3/.gitted/modules/sEvEn/refs/heads/master @@ -0,0 +1 @@ +480095882d281ed676fe5b863569520e54a7d5c0 diff --git a/tests/resources/reftable/submod3/.gitted/modules/sEvEn/refs/remotes/origin/HEAD b/tests/resources/reftable/submod3/.gitted/modules/sEvEn/refs/remotes/origin/HEAD new file mode 100644 index 000000000..6efe28fff --- /dev/null +++ b/tests/resources/reftable/submod3/.gitted/modules/sEvEn/refs/remotes/origin/HEAD @@ -0,0 +1 @@ +ref: refs/remotes/origin/master diff --git a/tests/resources/reftable/submod3/.gitted/modules/six/HEAD b/tests/resources/reftable/submod3/.gitted/modules/six/HEAD new file mode 100644 index 000000000..cb089cd89 --- /dev/null +++ b/tests/resources/reftable/submod3/.gitted/modules/six/HEAD @@ -0,0 +1 @@ +ref: refs/heads/master diff --git a/tests/resources/reftable/submod3/.gitted/modules/six/config b/tests/resources/reftable/submod3/.gitted/modules/six/config new file mode 100755 index 000000000..4296e81a4 --- /dev/null +++ b/tests/resources/reftable/submod3/.gitted/modules/six/config @@ -0,0 +1,12 @@ +[core] + repositoryformatversion = 0 + filemode = true + bare = false + logallrefupdates = true + worktree = ../../../six +[remote "origin"] + url = /tmp/libgit2_tests_5hR8uP/submod2_target + fetch = +refs/heads/*:refs/remotes/origin/* +[branch "master"] + remote = origin + merge = refs/heads/master diff --git a/tests/resources/reftable/submod3/.gitted/modules/six/index b/tests/resources/reftable/submod3/.gitted/modules/six/index new file mode 100644 index 000000000..fbd09fde6 Binary files /dev/null and b/tests/resources/reftable/submod3/.gitted/modules/six/index differ diff --git a/tests/resources/reftable/submod3/.gitted/modules/six/objects/06/362fe2fdb7010d0e447b4fb450d405420479a1 b/tests/resources/reftable/submod3/.gitted/modules/six/objects/06/362fe2fdb7010d0e447b4fb450d405420479a1 new file mode 100644 index 000000000..f4b7094c5 Binary files /dev/null and b/tests/resources/reftable/submod3/.gitted/modules/six/objects/06/362fe2fdb7010d0e447b4fb450d405420479a1 differ diff --git a/tests/resources/reftable/submod3/.gitted/modules/six/objects/0e/6a3ca48bd47cfe67681acf39aa0b10a0b92484 b/tests/resources/reftable/submod3/.gitted/modules/six/objects/0e/6a3ca48bd47cfe67681acf39aa0b10a0b92484 new file mode 100644 index 000000000..56c845e49 Binary files /dev/null and b/tests/resources/reftable/submod3/.gitted/modules/six/objects/0e/6a3ca48bd47cfe67681acf39aa0b10a0b92484 differ diff --git a/tests/resources/reftable/submod3/.gitted/modules/six/objects/17/d0ece6e96460a06592d9d9d000de37ba4232c5 b/tests/resources/reftable/submod3/.gitted/modules/six/objects/17/d0ece6e96460a06592d9d9d000de37ba4232c5 new file mode 100644 index 000000000..bd179b5f5 Binary files /dev/null and b/tests/resources/reftable/submod3/.gitted/modules/six/objects/17/d0ece6e96460a06592d9d9d000de37ba4232c5 differ diff --git a/tests/resources/reftable/submod3/.gitted/modules/six/objects/41/bd4bc3df978de695f67ace64c560913da11653 b/tests/resources/reftable/submod3/.gitted/modules/six/objects/41/bd4bc3df978de695f67ace64c560913da11653 new file mode 100644 index 000000000..ccf49bd15 Binary files /dev/null and b/tests/resources/reftable/submod3/.gitted/modules/six/objects/41/bd4bc3df978de695f67ace64c560913da11653 differ diff --git a/tests/resources/reftable/submod3/.gitted/modules/six/objects/48/0095882d281ed676fe5b863569520e54a7d5c0 b/tests/resources/reftable/submod3/.gitted/modules/six/objects/48/0095882d281ed676fe5b863569520e54a7d5c0 new file mode 100644 index 000000000..53029069a Binary files /dev/null and b/tests/resources/reftable/submod3/.gitted/modules/six/objects/48/0095882d281ed676fe5b863569520e54a7d5c0 differ diff --git a/tests/resources/reftable/submod3/.gitted/modules/six/objects/5e/4963595a9774b90524d35a807169049de8ccad b/tests/resources/reftable/submod3/.gitted/modules/six/objects/5e/4963595a9774b90524d35a807169049de8ccad new file mode 100644 index 000000000..38c791eba Binary files /dev/null and b/tests/resources/reftable/submod3/.gitted/modules/six/objects/5e/4963595a9774b90524d35a807169049de8ccad differ diff --git a/tests/resources/reftable/submod3/.gitted/modules/six/objects/6b/31c659545507c381e9cd34ec508f16c04e149e b/tests/resources/reftable/submod3/.gitted/modules/six/objects/6b/31c659545507c381e9cd34ec508f16c04e149e new file mode 100644 index 000000000..a26d29993 --- /dev/null +++ b/tests/resources/reftable/submod3/.gitted/modules/six/objects/6b/31c659545507c381e9cd34ec508f16c04e149e @@ -0,0 +1,2 @@ +xQ +!Evoy*_@g#hOh^9wSòf1*[Ic Ԥpk Α\S߇l@.^QpF(:D5zr~ en8 \ No newline at end of file diff --git a/tests/resources/reftable/submod3/.gitted/modules/six/objects/73/ba924a80437097795ae839e66e187c55d3babf b/tests/resources/reftable/submod3/.gitted/modules/six/objects/73/ba924a80437097795ae839e66e187c55d3babf new file mode 100644 index 000000000..83d1ba481 Binary files /dev/null and b/tests/resources/reftable/submod3/.gitted/modules/six/objects/73/ba924a80437097795ae839e66e187c55d3babf differ diff --git a/tests/resources/reftable/submod3/.gitted/modules/six/objects/78/0d7397f5e8f8f477fb55b7af3accc2154b2d4a b/tests/resources/reftable/submod3/.gitted/modules/six/objects/78/0d7397f5e8f8f477fb55b7af3accc2154b2d4a new file mode 100644 index 000000000..6d27af8a8 --- /dev/null +++ b/tests/resources/reftable/submod3/.gitted/modules/six/objects/78/0d7397f5e8f8f477fb55b7af3accc2154b2d4a @@ -0,0 +1,2 @@ +x-10 Fa0p(N-ӡғq]>ks*? |m“i@mV'`).-1 x +uxt(+ \ No newline at end of file diff --git a/tests/resources/reftable/submod3/.gitted/modules/six/objects/78/9efbdadaa4a582778d4584385495559ea0994b b/tests/resources/reftable/submod3/.gitted/modules/six/objects/78/9efbdadaa4a582778d4584385495559ea0994b new file mode 100644 index 000000000..17458840b --- /dev/null +++ b/tests/resources/reftable/submod3/.gitted/modules/six/objects/78/9efbdadaa4a582778d4584385495559ea0994b @@ -0,0 +1,2 @@ +x 0 )?= NlOkj8&r +qJW7B<fK8#Q1C-"e̫>'@ \ No newline at end of file diff --git a/tests/resources/reftable/submod3/.gitted/modules/six/objects/88/34b635dd468a83cb012f6feace968c1c9f5d6e b/tests/resources/reftable/submod3/.gitted/modules/six/objects/88/34b635dd468a83cb012f6feace968c1c9f5d6e new file mode 100644 index 000000000..83cc29fb1 Binary files /dev/null and b/tests/resources/reftable/submod3/.gitted/modules/six/objects/88/34b635dd468a83cb012f6feace968c1c9f5d6e differ diff --git a/tests/resources/reftable/submod3/.gitted/modules/six/objects/d0/5f2cd5cc77addf68ed6f50d622c9a4f732e6c5 b/tests/resources/reftable/submod3/.gitted/modules/six/objects/d0/5f2cd5cc77addf68ed6f50d622c9a4f732e6c5 new file mode 100644 index 000000000..55bda40ef Binary files /dev/null and b/tests/resources/reftable/submod3/.gitted/modules/six/objects/d0/5f2cd5cc77addf68ed6f50d622c9a4f732e6c5 differ diff --git a/tests/resources/reftable/submod3/.gitted/modules/six/packed-refs b/tests/resources/reftable/submod3/.gitted/modules/six/packed-refs new file mode 100644 index 000000000..def303a5f --- /dev/null +++ b/tests/resources/reftable/submod3/.gitted/modules/six/packed-refs @@ -0,0 +1,2 @@ +# pack-refs with: peeled fully-peeled +480095882d281ed676fe5b863569520e54a7d5c0 refs/remotes/origin/master diff --git a/tests/resources/reftable/submod3/.gitted/modules/six/refs/heads/master b/tests/resources/reftable/submod3/.gitted/modules/six/refs/heads/master new file mode 100644 index 000000000..e12c44d7a --- /dev/null +++ b/tests/resources/reftable/submod3/.gitted/modules/six/refs/heads/master @@ -0,0 +1 @@ +480095882d281ed676fe5b863569520e54a7d5c0 diff --git a/tests/resources/reftable/submod3/.gitted/modules/six/refs/remotes/origin/HEAD b/tests/resources/reftable/submod3/.gitted/modules/six/refs/remotes/origin/HEAD new file mode 100644 index 000000000..6efe28fff --- /dev/null +++ b/tests/resources/reftable/submod3/.gitted/modules/six/refs/remotes/origin/HEAD @@ -0,0 +1 @@ +ref: refs/remotes/origin/master diff --git a/tests/resources/reftable/submod3/.gitted/modules/three/HEAD b/tests/resources/reftable/submod3/.gitted/modules/three/HEAD new file mode 100644 index 000000000..cb089cd89 --- /dev/null +++ b/tests/resources/reftable/submod3/.gitted/modules/three/HEAD @@ -0,0 +1 @@ +ref: refs/heads/master diff --git a/tests/resources/reftable/submod3/.gitted/modules/three/config b/tests/resources/reftable/submod3/.gitted/modules/three/config new file mode 100755 index 000000000..ba5c9663e --- /dev/null +++ b/tests/resources/reftable/submod3/.gitted/modules/three/config @@ -0,0 +1,12 @@ +[core] + repositoryformatversion = 0 + filemode = true + bare = false + logallrefupdates = true + worktree = ../../../three +[remote "origin"] + url = /tmp/libgit2_tests_5hR8uP/submod2_target + fetch = +refs/heads/*:refs/remotes/origin/* +[branch "master"] + remote = origin + merge = refs/heads/master diff --git a/tests/resources/reftable/submod3/.gitted/modules/three/index b/tests/resources/reftable/submod3/.gitted/modules/three/index new file mode 100644 index 000000000..ec4a944e0 Binary files /dev/null and b/tests/resources/reftable/submod3/.gitted/modules/three/index differ diff --git a/tests/resources/reftable/submod3/.gitted/modules/three/objects/06/362fe2fdb7010d0e447b4fb450d405420479a1 b/tests/resources/reftable/submod3/.gitted/modules/three/objects/06/362fe2fdb7010d0e447b4fb450d405420479a1 new file mode 100644 index 000000000..f4b7094c5 Binary files /dev/null and b/tests/resources/reftable/submod3/.gitted/modules/three/objects/06/362fe2fdb7010d0e447b4fb450d405420479a1 differ diff --git a/tests/resources/reftable/submod3/.gitted/modules/three/objects/0e/6a3ca48bd47cfe67681acf39aa0b10a0b92484 b/tests/resources/reftable/submod3/.gitted/modules/three/objects/0e/6a3ca48bd47cfe67681acf39aa0b10a0b92484 new file mode 100644 index 000000000..56c845e49 Binary files /dev/null and b/tests/resources/reftable/submod3/.gitted/modules/three/objects/0e/6a3ca48bd47cfe67681acf39aa0b10a0b92484 differ diff --git a/tests/resources/reftable/submod3/.gitted/modules/three/objects/17/d0ece6e96460a06592d9d9d000de37ba4232c5 b/tests/resources/reftable/submod3/.gitted/modules/three/objects/17/d0ece6e96460a06592d9d9d000de37ba4232c5 new file mode 100644 index 000000000..bd179b5f5 Binary files /dev/null and b/tests/resources/reftable/submod3/.gitted/modules/three/objects/17/d0ece6e96460a06592d9d9d000de37ba4232c5 differ diff --git a/tests/resources/reftable/submod3/.gitted/modules/three/objects/41/bd4bc3df978de695f67ace64c560913da11653 b/tests/resources/reftable/submod3/.gitted/modules/three/objects/41/bd4bc3df978de695f67ace64c560913da11653 new file mode 100644 index 000000000..ccf49bd15 Binary files /dev/null and b/tests/resources/reftable/submod3/.gitted/modules/three/objects/41/bd4bc3df978de695f67ace64c560913da11653 differ diff --git a/tests/resources/reftable/submod3/.gitted/modules/three/objects/48/0095882d281ed676fe5b863569520e54a7d5c0 b/tests/resources/reftable/submod3/.gitted/modules/three/objects/48/0095882d281ed676fe5b863569520e54a7d5c0 new file mode 100644 index 000000000..53029069a Binary files /dev/null and b/tests/resources/reftable/submod3/.gitted/modules/three/objects/48/0095882d281ed676fe5b863569520e54a7d5c0 differ diff --git a/tests/resources/reftable/submod3/.gitted/modules/three/objects/5e/4963595a9774b90524d35a807169049de8ccad b/tests/resources/reftable/submod3/.gitted/modules/three/objects/5e/4963595a9774b90524d35a807169049de8ccad new file mode 100644 index 000000000..38c791eba Binary files /dev/null and b/tests/resources/reftable/submod3/.gitted/modules/three/objects/5e/4963595a9774b90524d35a807169049de8ccad differ diff --git a/tests/resources/reftable/submod3/.gitted/modules/three/objects/6b/31c659545507c381e9cd34ec508f16c04e149e b/tests/resources/reftable/submod3/.gitted/modules/three/objects/6b/31c659545507c381e9cd34ec508f16c04e149e new file mode 100644 index 000000000..a26d29993 --- /dev/null +++ b/tests/resources/reftable/submod3/.gitted/modules/three/objects/6b/31c659545507c381e9cd34ec508f16c04e149e @@ -0,0 +1,2 @@ +xQ +!Evoy*_@g#hOh^9wSòf1*[Ic Ԥpk Α\S߇l@.^QpF(:D5zr~ en8 \ No newline at end of file diff --git a/tests/resources/reftable/submod3/.gitted/modules/three/objects/73/ba924a80437097795ae839e66e187c55d3babf b/tests/resources/reftable/submod3/.gitted/modules/three/objects/73/ba924a80437097795ae839e66e187c55d3babf new file mode 100644 index 000000000..83d1ba481 Binary files /dev/null and b/tests/resources/reftable/submod3/.gitted/modules/three/objects/73/ba924a80437097795ae839e66e187c55d3babf differ diff --git a/tests/resources/reftable/submod3/.gitted/modules/three/objects/78/0d7397f5e8f8f477fb55b7af3accc2154b2d4a b/tests/resources/reftable/submod3/.gitted/modules/three/objects/78/0d7397f5e8f8f477fb55b7af3accc2154b2d4a new file mode 100644 index 000000000..6d27af8a8 --- /dev/null +++ b/tests/resources/reftable/submod3/.gitted/modules/three/objects/78/0d7397f5e8f8f477fb55b7af3accc2154b2d4a @@ -0,0 +1,2 @@ +x-10 Fa0p(N-ӡғq]>ks*? |m“i@mV'`).-1 x +uxt(+ \ No newline at end of file diff --git a/tests/resources/reftable/submod3/.gitted/modules/three/objects/78/9efbdadaa4a582778d4584385495559ea0994b b/tests/resources/reftable/submod3/.gitted/modules/three/objects/78/9efbdadaa4a582778d4584385495559ea0994b new file mode 100644 index 000000000..17458840b --- /dev/null +++ b/tests/resources/reftable/submod3/.gitted/modules/three/objects/78/9efbdadaa4a582778d4584385495559ea0994b @@ -0,0 +1,2 @@ +x 0 )?= NlOkj8&r +qJW7B<fK8#Q1C-"e̫>'@ \ No newline at end of file diff --git a/tests/resources/reftable/submod3/.gitted/modules/three/objects/88/34b635dd468a83cb012f6feace968c1c9f5d6e b/tests/resources/reftable/submod3/.gitted/modules/three/objects/88/34b635dd468a83cb012f6feace968c1c9f5d6e new file mode 100644 index 000000000..83cc29fb1 Binary files /dev/null and b/tests/resources/reftable/submod3/.gitted/modules/three/objects/88/34b635dd468a83cb012f6feace968c1c9f5d6e differ diff --git a/tests/resources/reftable/submod3/.gitted/modules/three/objects/d0/5f2cd5cc77addf68ed6f50d622c9a4f732e6c5 b/tests/resources/reftable/submod3/.gitted/modules/three/objects/d0/5f2cd5cc77addf68ed6f50d622c9a4f732e6c5 new file mode 100644 index 000000000..55bda40ef Binary files /dev/null and b/tests/resources/reftable/submod3/.gitted/modules/three/objects/d0/5f2cd5cc77addf68ed6f50d622c9a4f732e6c5 differ diff --git a/tests/resources/reftable/submod3/.gitted/modules/three/packed-refs b/tests/resources/reftable/submod3/.gitted/modules/three/packed-refs new file mode 100644 index 000000000..def303a5f --- /dev/null +++ b/tests/resources/reftable/submod3/.gitted/modules/three/packed-refs @@ -0,0 +1,2 @@ +# pack-refs with: peeled fully-peeled +480095882d281ed676fe5b863569520e54a7d5c0 refs/remotes/origin/master diff --git a/tests/resources/reftable/submod3/.gitted/modules/three/refs/heads/master b/tests/resources/reftable/submod3/.gitted/modules/three/refs/heads/master new file mode 100644 index 000000000..e12c44d7a --- /dev/null +++ b/tests/resources/reftable/submod3/.gitted/modules/three/refs/heads/master @@ -0,0 +1 @@ +480095882d281ed676fe5b863569520e54a7d5c0 diff --git a/tests/resources/reftable/submod3/.gitted/modules/three/refs/remotes/origin/HEAD b/tests/resources/reftable/submod3/.gitted/modules/three/refs/remotes/origin/HEAD new file mode 100644 index 000000000..6efe28fff --- /dev/null +++ b/tests/resources/reftable/submod3/.gitted/modules/three/refs/remotes/origin/HEAD @@ -0,0 +1 @@ +ref: refs/remotes/origin/master diff --git a/tests/resources/reftable/submod3/.gitted/objects/0d/db6db2835a283823cd700a1d18f17b0ba6520d b/tests/resources/reftable/submod3/.gitted/objects/0d/db6db2835a283823cd700a1d18f17b0ba6520d new file mode 100644 index 000000000..8f1c5ca31 Binary files /dev/null and b/tests/resources/reftable/submod3/.gitted/objects/0d/db6db2835a283823cd700a1d18f17b0ba6520d differ diff --git a/tests/resources/reftable/submod3/.gitted/objects/0e/db4f085060fea212aecc25242d4c7685cdc01d b/tests/resources/reftable/submod3/.gitted/objects/0e/db4f085060fea212aecc25242d4c7685cdc01d new file mode 100644 index 000000000..34179a45e Binary files /dev/null and b/tests/resources/reftable/submod3/.gitted/objects/0e/db4f085060fea212aecc25242d4c7685cdc01d differ diff --git a/tests/resources/reftable/submod3/.gitted/objects/33/61720a7115648e518342a6524b29cc627ea11a b/tests/resources/reftable/submod3/.gitted/objects/33/61720a7115648e518342a6524b29cc627ea11a new file mode 100644 index 000000000..c09eabcc6 Binary files /dev/null and b/tests/resources/reftable/submod3/.gitted/objects/33/61720a7115648e518342a6524b29cc627ea11a differ diff --git a/tests/resources/reftable/submod3/.gitted/objects/4f/6ea8092cb19f39e25cd1b21c061893b6ce17bd b/tests/resources/reftable/submod3/.gitted/objects/4f/6ea8092cb19f39e25cd1b21c061893b6ce17bd new file mode 100644 index 000000000..cf653933a Binary files /dev/null and b/tests/resources/reftable/submod3/.gitted/objects/4f/6ea8092cb19f39e25cd1b21c061893b6ce17bd differ diff --git a/tests/resources/reftable/submod3/.gitted/objects/5b/6f93e4846d705ee2daa5d60348e7fc1c6715ed b/tests/resources/reftable/submod3/.gitted/objects/5b/6f93e4846d705ee2daa5d60348e7fc1c6715ed new file mode 100644 index 000000000..591d4b804 Binary files /dev/null and b/tests/resources/reftable/submod3/.gitted/objects/5b/6f93e4846d705ee2daa5d60348e7fc1c6715ed differ diff --git a/tests/resources/reftable/submod3/.gitted/objects/6e/7201a58feeaa462ac9f545928fe0b961ad9495 b/tests/resources/reftable/submod3/.gitted/objects/6e/7201a58feeaa462ac9f545928fe0b961ad9495 new file mode 100644 index 000000000..a5dc38e35 Binary files /dev/null and b/tests/resources/reftable/submod3/.gitted/objects/6e/7201a58feeaa462ac9f545928fe0b961ad9495 differ diff --git a/tests/resources/reftable/submod3/.gitted/objects/6f/b39bdc90378a0a9a05a127da035e560ced3900 b/tests/resources/reftable/submod3/.gitted/objects/6f/b39bdc90378a0a9a05a127da035e560ced3900 new file mode 100644 index 000000000..315e3b831 Binary files /dev/null and b/tests/resources/reftable/submod3/.gitted/objects/6f/b39bdc90378a0a9a05a127da035e560ced3900 differ diff --git a/tests/resources/reftable/submod3/.gitted/objects/90/459b51713bde15eb97852ff22c29270752b432 b/tests/resources/reftable/submod3/.gitted/objects/90/459b51713bde15eb97852ff22c29270752b432 new file mode 100644 index 000000000..3a2c99cc7 --- /dev/null +++ b/tests/resources/reftable/submod3/.gitted/objects/90/459b51713bde15eb97852ff22c29270752b432 @@ -0,0 +1 @@ +x !E=S4p%1Ƌ,&$,Jk=ѡUpr1N39/7[ŽR?\# +F- \ No newline at end of file diff --git a/tests/resources/reftable/submodules/testrepo/.gitted/objects/75/057dd4114e74cca1d750d0aee1647c903cb60a b/tests/resources/reftable/submodules/testrepo/.gitted/objects/75/057dd4114e74cca1d750d0aee1647c903cb60a new file mode 100644 index 000000000..2ef4faa0f Binary files /dev/null and b/tests/resources/reftable/submodules/testrepo/.gitted/objects/75/057dd4114e74cca1d750d0aee1647c903cb60a differ diff --git a/tests/resources/reftable/submodules/testrepo/.gitted/objects/76/3d71aadf09a7951596c9746c024e7eece7c7af b/tests/resources/reftable/submodules/testrepo/.gitted/objects/76/3d71aadf09a7951596c9746c024e7eece7c7af new file mode 100644 index 000000000..716b0c64b --- /dev/null +++ b/tests/resources/reftable/submodules/testrepo/.gitted/objects/76/3d71aadf09a7951596c9746c024e7eece7c7af @@ -0,0 +1 @@ +xAj!?009o}H6}jUPPZ&Y AԛpFdpz[fYPqLJ.,Z`Ů.`v q $5+9Ot>/DE/龡W*eVdf1>覭ěʙFThk.i^0?PR, \ No newline at end of file diff --git a/tests/resources/reftable/submodules/testrepo/.gitted/objects/7b/4384978d2493e851f9cca7858815fac9b10980 b/tests/resources/reftable/submodules/testrepo/.gitted/objects/7b/4384978d2493e851f9cca7858815fac9b10980 new file mode 100644 index 000000000..23c462f34 Binary files /dev/null and b/tests/resources/reftable/submodules/testrepo/.gitted/objects/7b/4384978d2493e851f9cca7858815fac9b10980 differ diff --git a/tests/resources/reftable/submodules/testrepo/.gitted/objects/81/4889a078c031f61ed08ab5fa863aea9314344d b/tests/resources/reftable/submodules/testrepo/.gitted/objects/81/4889a078c031f61ed08ab5fa863aea9314344d new file mode 100644 index 000000000..2f9b6b6e3 Binary files /dev/null and b/tests/resources/reftable/submodules/testrepo/.gitted/objects/81/4889a078c031f61ed08ab5fa863aea9314344d differ diff --git a/tests/resources/reftable/submodules/testrepo/.gitted/objects/84/96071c1b46c854b31185ea97743be6a8774479 b/tests/resources/reftable/submodules/testrepo/.gitted/objects/84/96071c1b46c854b31185ea97743be6a8774479 new file mode 100644 index 000000000..5df58dda5 Binary files /dev/null and b/tests/resources/reftable/submodules/testrepo/.gitted/objects/84/96071c1b46c854b31185ea97743be6a8774479 differ diff --git a/tests/resources/reftable/submodules/testrepo/.gitted/objects/94/4c0f6e4dfa41595e6eb3ceecdb14f50fe18162 b/tests/resources/reftable/submodules/testrepo/.gitted/objects/94/4c0f6e4dfa41595e6eb3ceecdb14f50fe18162 new file mode 100644 index 000000000..4cc3f4dff --- /dev/null +++ b/tests/resources/reftable/submodules/testrepo/.gitted/objects/94/4c0f6e4dfa41595e6eb3ceecdb14f50fe18162 @@ -0,0 +1 @@ +x+)JMU044b040031QrutueXlmmAṃJ}G;UTWRQ`6Kǥ^/-*|W3Py`%E\&g|0{Ӎ1X \ No newline at end of file diff --git a/tests/resources/reftable/submodules/testrepo/.gitted/objects/9a/03079b8a8ee85a0bee58bf9be3da8b62414ed4 b/tests/resources/reftable/submodules/testrepo/.gitted/objects/9a/03079b8a8ee85a0bee58bf9be3da8b62414ed4 new file mode 100644 index 000000000..bf7b2bb68 Binary files /dev/null and b/tests/resources/reftable/submodules/testrepo/.gitted/objects/9a/03079b8a8ee85a0bee58bf9be3da8b62414ed4 differ diff --git a/tests/resources/reftable/submodules/testrepo/.gitted/objects/9f/d738e8f7967c078dceed8190330fc8648ee56a b/tests/resources/reftable/submodules/testrepo/.gitted/objects/9f/d738e8f7967c078dceed8190330fc8648ee56a new file mode 100644 index 000000000..a79612435 --- /dev/null +++ b/tests/resources/reftable/submodules/testrepo/.gitted/objects/9f/d738e8f7967c078dceed8190330fc8648ee56a @@ -0,0 +1,3 @@ +x[ +0E*fդ "W0-Ft݁pS[Yx^ +Db CLhut}8X*4ZsYUA X3RM) s6輢Mរ&Jm;}<\@ޏpĀv?jۺL?H \ No newline at end of file diff --git a/tests/resources/reftable/submodules/testrepo/.gitted/objects/a4/a7dce85cf63874e984719f4fdd239f5145052f b/tests/resources/reftable/submodules/testrepo/.gitted/objects/a4/a7dce85cf63874e984719f4fdd239f5145052f new file mode 100644 index 000000000..f8588696b --- /dev/null +++ b/tests/resources/reftable/submodules/testrepo/.gitted/objects/a4/a7dce85cf63874e984719f4fdd239f5145052f @@ -0,0 +1,2 @@ +x;j1Dmdǎ|M3`V{ >QvL0I?!4Z=!צ8F!rsQy9]$D&l6A>jFWҵ IKNiZ%S + U~̽>' w [ DGڡQ-M>dO}\8g_ШoYr \ No newline at end of file diff --git a/tests/resources/reftable/submodules/testrepo/.gitted/objects/a6/5fedf39aefe402d3bb6e24df4d4f5fe4547750 b/tests/resources/reftable/submodules/testrepo/.gitted/objects/a6/5fedf39aefe402d3bb6e24df4d4f5fe4547750 new file mode 100644 index 000000000..29c8e824d --- /dev/null +++ b/tests/resources/reftable/submodules/testrepo/.gitted/objects/a6/5fedf39aefe402d3bb6e24df4d4f5fe4547750 @@ -0,0 +1,3 @@ +xQ +!@sBQ" ٱ r{Os0B%s)fMlhV45 &4ѕ@:D)oIr`$LYws¥Fg`$bo; U|zOu}/._ׁ~J \ No newline at end of file diff --git a/tests/resources/reftable/testrepo.git/objects/43/e968a905a821532069bb413801d35b200631cf b/tests/resources/reftable/testrepo.git/objects/43/e968a905a821532069bb413801d35b200631cf new file mode 100644 index 000000000..ec04abf68 --- /dev/null +++ b/tests/resources/reftable/testrepo.git/objects/43/e968a905a821532069bb413801d35b200631cf @@ -0,0 +1,4 @@ +xK +1]}%N'7 8 +\u5zc 68b,D20'Qb㭃@ҩRQ[94)qsmp+ +纾gG=r]/3((tRa>E \ No newline at end of file diff --git a/tests/resources/reftable/testrepo.git/objects/45/b983be36b73c0788dc9cbcb76cbb80fc7bb057 b/tests/resources/reftable/testrepo.git/objects/45/b983be36b73c0788dc9cbcb76cbb80fc7bb057 new file mode 100644 index 000000000..7ca4ceed5 Binary files /dev/null and b/tests/resources/reftable/testrepo.git/objects/45/b983be36b73c0788dc9cbcb76cbb80fc7bb057 differ diff --git a/tests/resources/reftable/testrepo.git/objects/4a/202b346bb0fb0db7eff3cffeb3c70babbd2045 b/tests/resources/reftable/testrepo.git/objects/4a/202b346bb0fb0db7eff3cffeb3c70babbd2045 new file mode 100644 index 000000000..8953b6cef --- /dev/null +++ b/tests/resources/reftable/testrepo.git/objects/4a/202b346bb0fb0db7eff3cffeb3c70babbd2045 @@ -0,0 +1,2 @@ +xQ +0D)6ͦ "xO-FbEo0 Ǥ,ske[Pn8R,EpD?g}^3 <GhYK8ЖDA);gݧjp4-r;sGA4ۺ=(in7IKFE \ No newline at end of file diff --git a/tests/resources/reftable/testrepo.git/objects/4a/23e2e65ad4e31c4c9db7dc746650bfad082679 b/tests/resources/reftable/testrepo.git/objects/4a/23e2e65ad4e31c4c9db7dc746650bfad082679 new file mode 100644 index 000000000..18e3964b3 Binary files /dev/null and b/tests/resources/reftable/testrepo.git/objects/4a/23e2e65ad4e31c4c9db7dc746650bfad082679 differ diff --git a/tests/resources/reftable/testrepo.git/objects/4b/22b35d44b5a4f589edf3dc89196399771796ea b/tests/resources/reftable/testrepo.git/objects/4b/22b35d44b5a4f589edf3dc89196399771796ea new file mode 100644 index 000000000..b4e5aa186 Binary files /dev/null and b/tests/resources/reftable/testrepo.git/objects/4b/22b35d44b5a4f589edf3dc89196399771796ea differ diff --git a/tests/resources/reftable/testrepo.git/objects/52/1d87c1ec3aef9824daf6d96cc0ae3710766d91 b/tests/resources/reftable/testrepo.git/objects/52/1d87c1ec3aef9824daf6d96cc0ae3710766d91 new file mode 100644 index 000000000..351cff823 Binary files /dev/null and b/tests/resources/reftable/testrepo.git/objects/52/1d87c1ec3aef9824daf6d96cc0ae3710766d91 differ diff --git a/tests/resources/reftable/testrepo.git/objects/5b/5b025afb0b4c913b4c338a42934a3863bf3644 b/tests/resources/reftable/testrepo.git/objects/5b/5b025afb0b4c913b4c338a42934a3863bf3644 new file mode 100644 index 000000000..c1f22c54f --- /dev/null +++ b/tests/resources/reftable/testrepo.git/objects/5b/5b025afb0b4c913b4c338a42934a3863bf3644 @@ -0,0 +1,2 @@ +x 1ENi@k2 "X$YW0YcÅszMD08!s Xgd::@X0Pw"F/RUzmZZV}|/o5I!1z:vUim}/> +F- \ No newline at end of file diff --git a/tests/resources/reftable/testrepo.git/objects/5d/0f8f7891e872d284beef38254882dc879b2602 b/tests/resources/reftable/testrepo.git/objects/5d/0f8f7891e872d284beef38254882dc879b2602 new file mode 100644 index 000000000..7a22451ed Binary files /dev/null and b/tests/resources/reftable/testrepo.git/objects/5d/0f8f7891e872d284beef38254882dc879b2602 differ diff --git a/tests/resources/reftable/testrepo.git/objects/5f/34cd6e3285089647165983482cf90873d50940 b/tests/resources/reftable/testrepo.git/objects/5f/34cd6e3285089647165983482cf90873d50940 new file mode 100644 index 000000000..b1df3bdd5 Binary files /dev/null and b/tests/resources/reftable/testrepo.git/objects/5f/34cd6e3285089647165983482cf90873d50940 differ diff --git a/tests/resources/reftable/testrepo.git/objects/75/057dd4114e74cca1d750d0aee1647c903cb60a b/tests/resources/reftable/testrepo.git/objects/75/057dd4114e74cca1d750d0aee1647c903cb60a new file mode 100644 index 000000000..2ef4faa0f Binary files /dev/null and b/tests/resources/reftable/testrepo.git/objects/75/057dd4114e74cca1d750d0aee1647c903cb60a differ diff --git a/tests/resources/reftable/testrepo.git/objects/76/3d71aadf09a7951596c9746c024e7eece7c7af b/tests/resources/reftable/testrepo.git/objects/76/3d71aadf09a7951596c9746c024e7eece7c7af new file mode 100644 index 000000000..716b0c64b --- /dev/null +++ b/tests/resources/reftable/testrepo.git/objects/76/3d71aadf09a7951596c9746c024e7eece7c7af @@ -0,0 +1 @@ +xAj!?009o}H6}jUPPZ&Y AԛpFdpz[fYPqLJ.,Z`Ů.`v q $5+9Ot>/DE/龡W*eVdf1>覭ěʙFThk.i^0?PR, \ No newline at end of file diff --git a/tests/resources/reftable/testrepo.git/objects/7b/4384978d2493e851f9cca7858815fac9b10980 b/tests/resources/reftable/testrepo.git/objects/7b/4384978d2493e851f9cca7858815fac9b10980 new file mode 100644 index 000000000..23c462f34 Binary files /dev/null and b/tests/resources/reftable/testrepo.git/objects/7b/4384978d2493e851f9cca7858815fac9b10980 differ diff --git a/tests/resources/reftable/testrepo.git/objects/81/4889a078c031f61ed08ab5fa863aea9314344d b/tests/resources/reftable/testrepo.git/objects/81/4889a078c031f61ed08ab5fa863aea9314344d new file mode 100644 index 000000000..2f9b6b6e3 Binary files /dev/null and b/tests/resources/reftable/testrepo.git/objects/81/4889a078c031f61ed08ab5fa863aea9314344d differ diff --git a/tests/resources/reftable/testrepo.git/objects/84/96071c1b46c854b31185ea97743be6a8774479 b/tests/resources/reftable/testrepo.git/objects/84/96071c1b46c854b31185ea97743be6a8774479 new file mode 100644 index 000000000..5df58dda5 Binary files /dev/null and b/tests/resources/reftable/testrepo.git/objects/84/96071c1b46c854b31185ea97743be6a8774479 differ diff --git a/tests/resources/reftable/testrepo.git/objects/84/9a5e34a26815e821f865b8479f5815a47af0fe b/tests/resources/reftable/testrepo.git/objects/84/9a5e34a26815e821f865b8479f5815a47af0fe new file mode 100644 index 000000000..71019a636 --- /dev/null +++ b/tests/resources/reftable/testrepo.git/objects/84/9a5e34a26815e821f865b8479f5815a47af0fe @@ -0,0 +1,2 @@ +xM F]s41x(IKݽ/_P@!8)es + N&FGSƄh{+CZzvF7Z-kx\[P8GK/^ l>.4 \ No newline at end of file diff --git a/tests/resources/reftable/testrepo.git/objects/8e/73b769e97678d684b809b163bebdae2911720f b/tests/resources/reftable/testrepo.git/objects/8e/73b769e97678d684b809b163bebdae2911720f new file mode 100644 index 000000000..d75977a25 --- /dev/null +++ b/tests/resources/reftable/testrepo.git/objects/8e/73b769e97678d684b809b163bebdae2911720f @@ -0,0 +1,2 @@ +xj0S)*a㚔+l8[A 33yM$m* $qG?YA5< t8r57nD#.d)~N0˄)R,|,hjQ*tC~ |uzҧݗ> +ƒd8\S]!7 s ,[P2fw^ \ No newline at end of file diff --git a/tests/resources/reftable/testrepo.git/objects/94/4c0f6e4dfa41595e6eb3ceecdb14f50fe18162 b/tests/resources/reftable/testrepo.git/objects/94/4c0f6e4dfa41595e6eb3ceecdb14f50fe18162 new file mode 100644 index 000000000..4cc3f4dff --- /dev/null +++ b/tests/resources/reftable/testrepo.git/objects/94/4c0f6e4dfa41595e6eb3ceecdb14f50fe18162 @@ -0,0 +1 @@ +x+)JMU044b040031QrutueXlmmAṃJ}G;UTWRQ`6Kǥ^/-*|W3Py`%E\&g|0{Ӎ1X \ No newline at end of file diff --git a/tests/resources/reftable/testrepo.git/objects/9a/03079b8a8ee85a0bee58bf9be3da8b62414ed4 b/tests/resources/reftable/testrepo.git/objects/9a/03079b8a8ee85a0bee58bf9be3da8b62414ed4 new file mode 100644 index 000000000..bf7b2bb68 Binary files /dev/null and b/tests/resources/reftable/testrepo.git/objects/9a/03079b8a8ee85a0bee58bf9be3da8b62414ed4 differ diff --git a/tests/resources/reftable/testrepo.git/objects/9f/13f7d0a9402c681f91dc590cf7b5470e6a77d2 b/tests/resources/reftable/testrepo.git/objects/9f/13f7d0a9402c681f91dc590cf7b5470e6a77d2 new file mode 100644 index 000000000..7f1cfb23c --- /dev/null +++ b/tests/resources/reftable/testrepo.git/objects/9f/13f7d0a9402c681f91dc590cf7b5470e6a77d2 @@ -0,0 +1,2 @@ +xM +0F]d2;XEȎ5R AE &n}ZA \ No newline at end of file diff --git a/tests/resources/reftable/testrepo.git/objects/9f/d738e8f7967c078dceed8190330fc8648ee56a b/tests/resources/reftable/testrepo.git/objects/9f/d738e8f7967c078dceed8190330fc8648ee56a new file mode 100644 index 000000000..a79612435 --- /dev/null +++ b/tests/resources/reftable/testrepo.git/objects/9f/d738e8f7967c078dceed8190330fc8648ee56a @@ -0,0 +1,3 @@ +x[ +0E*fդ "W0-Ft݁pS[Yx^ +Db CLhut}8X*4ZsYUA X3RM) s6輢Mរ&Jm;}<\@ޏpĀv?jۺL?H \ No newline at end of file diff --git a/tests/resources/reftable/testrepo.git/objects/a4/a7dce85cf63874e984719f4fdd239f5145052f b/tests/resources/reftable/testrepo.git/objects/a4/a7dce85cf63874e984719f4fdd239f5145052f new file mode 100644 index 000000000..f8588696b --- /dev/null +++ b/tests/resources/reftable/testrepo.git/objects/a4/a7dce85cf63874e984719f4fdd239f5145052f @@ -0,0 +1,2 @@ +x;j1Dmdǎ|M3`V{ >QvL0I?!4Z=!צ8F!rsQy9]$D&l6A>jFWҵ IKNiZ%S + U~̽>' w [ DGڡQ-M>dO}\8g_ШoYr \ No newline at end of file diff --git a/tests/resources/reftable/testrepo.git/objects/a6/5fedf39aefe402d3bb6e24df4d4f5fe4547750 b/tests/resources/reftable/testrepo.git/objects/a6/5fedf39aefe402d3bb6e24df4d4f5fe4547750 new file mode 100644 index 000000000..29c8e824d --- /dev/null +++ b/tests/resources/reftable/testrepo.git/objects/a6/5fedf39aefe402d3bb6e24df4d4f5fe4547750 @@ -0,0 +1,3 @@ +xQ +!@sBQ" ٱ r{!+NU(û1Di<_7.5O X[#fo; ]\e=[@t&xHhYJn \ No newline at end of file diff --git a/tests/resources/reftable/testrepo.git/objects/db/793a00a5615eca1aac97e42b3a68b1acfa8bfd b/tests/resources/reftable/testrepo.git/objects/db/793a00a5615eca1aac97e42b3a68b1acfa8bfd new file mode 100644 index 000000000..ae82880de Binary files /dev/null and b/tests/resources/reftable/testrepo.git/objects/db/793a00a5615eca1aac97e42b3a68b1acfa8bfd differ diff --git a/tests/resources/reftable/testrepo.git/objects/db/c0be625bed24b5d8f5d9a927484f2065d321af b/tests/resources/reftable/testrepo.git/objects/db/c0be625bed24b5d8f5d9a927484f2065d321af new file mode 100644 index 000000000..b966b0b2f Binary files /dev/null and b/tests/resources/reftable/testrepo.git/objects/db/c0be625bed24b5d8f5d9a927484f2065d321af differ diff --git a/tests/resources/reftable/testrepo.git/objects/e6/9de29bb2d1d6434b8b29ae775ad8c2e48c5391 b/tests/resources/reftable/testrepo.git/objects/e6/9de29bb2d1d6434b8b29ae775ad8c2e48c5391 new file mode 100644 index 000000000..711223894 Binary files /dev/null and b/tests/resources/reftable/testrepo.git/objects/e6/9de29bb2d1d6434b8b29ae775ad8c2e48c5391 differ diff --git a/tests/resources/reftable/testrepo.git/objects/e7/b4ad382349ff96dd8199000580b9b1e2042eb0 b/tests/resources/reftable/testrepo.git/objects/e7/b4ad382349ff96dd8199000580b9b1e2042eb0 new file mode 100644 index 000000000..b135eccda Binary files /dev/null and b/tests/resources/reftable/testrepo.git/objects/e7/b4ad382349ff96dd8199000580b9b1e2042eb0 differ diff --git a/tests/resources/reftable/testrepo.git/objects/f0/a2a10243ca64f935dbe3dccb89ec8bf16bdace b/tests/resources/reftable/testrepo.git/objects/f0/a2a10243ca64f935dbe3dccb89ec8bf16bdace new file mode 100644 index 000000000..1b299dc25 Binary files /dev/null and b/tests/resources/reftable/testrepo.git/objects/f0/a2a10243ca64f935dbe3dccb89ec8bf16bdace differ diff --git a/tests/resources/reftable/testrepo.git/objects/f1/425cef211cc08caa31e7b545ffb232acb098c3 b/tests/resources/reftable/testrepo.git/objects/f1/425cef211cc08caa31e7b545ffb232acb098c3 new file mode 100644 index 000000000..82e2790e8 Binary files /dev/null and b/tests/resources/reftable/testrepo.git/objects/f1/425cef211cc08caa31e7b545ffb232acb098c3 differ diff --git a/tests/resources/reftable/testrepo.git/objects/f6/0079018b664e4e79329a7ef9559c8d9e0378d1 b/tests/resources/reftable/testrepo.git/objects/f6/0079018b664e4e79329a7ef9559c8d9e0378d1 new file mode 100644 index 000000000..697c94c92 Binary files /dev/null and b/tests/resources/reftable/testrepo.git/objects/f6/0079018b664e4e79329a7ef9559c8d9e0378d1 differ diff --git a/tests/resources/reftable/testrepo.git/objects/fa/49b077972391ad58037050f2a75f74e3671e92 b/tests/resources/reftable/testrepo.git/objects/fa/49b077972391ad58037050f2a75f74e3671e92 new file mode 100644 index 000000000..112998d42 Binary files /dev/null and b/tests/resources/reftable/testrepo.git/objects/fa/49b077972391ad58037050f2a75f74e3671e92 differ diff --git a/tests/resources/reftable/testrepo.git/objects/fd/093bff70906175335656e6ce6ae05783708765 b/tests/resources/reftable/testrepo.git/objects/fd/093bff70906175335656e6ce6ae05783708765 new file mode 100644 index 000000000..12bf5f3e3 Binary files /dev/null and b/tests/resources/reftable/testrepo.git/objects/fd/093bff70906175335656e6ce6ae05783708765 differ diff --git a/tests/resources/reftable/testrepo.git/objects/fd/4959ce7510db09d4d8217fa2d1780413e05a09 b/tests/resources/reftable/testrepo.git/objects/fd/4959ce7510db09d4d8217fa2d1780413e05a09 new file mode 100644 index 000000000..158aef21f Binary files /dev/null and b/tests/resources/reftable/testrepo.git/objects/fd/4959ce7510db09d4d8217fa2d1780413e05a09 differ diff --git a/tests/resources/reftable/testrepo.git/objects/info/commit-graph b/tests/resources/reftable/testrepo.git/objects/info/commit-graph new file mode 100644 index 000000000..2ef31d83e Binary files /dev/null and b/tests/resources/reftable/testrepo.git/objects/info/commit-graph differ diff --git a/tests/resources/reftable/testrepo.git/objects/pack/multi-pack-index b/tests/resources/reftable/testrepo.git/objects/pack/multi-pack-index new file mode 100644 index 000000000..95102aeb4 Binary files /dev/null and b/tests/resources/reftable/testrepo.git/objects/pack/multi-pack-index differ diff --git a/tests/resources/reftable/testrepo.git/objects/pack/pack-a81e489679b7d3418f9ab594bda8ceb37dd4c695.idx b/tests/resources/reftable/testrepo.git/objects/pack/pack-a81e489679b7d3418f9ab594bda8ceb37dd4c695.idx new file mode 100644 index 000000000..5068f2818 Binary files /dev/null and b/tests/resources/reftable/testrepo.git/objects/pack/pack-a81e489679b7d3418f9ab594bda8ceb37dd4c695.idx differ diff --git a/tests/resources/reftable/testrepo.git/objects/pack/pack-a81e489679b7d3418f9ab594bda8ceb37dd4c695.pack b/tests/resources/reftable/testrepo.git/objects/pack/pack-a81e489679b7d3418f9ab594bda8ceb37dd4c695.pack new file mode 100644 index 000000000..a6a1f3020 Binary files /dev/null and b/tests/resources/reftable/testrepo.git/objects/pack/pack-a81e489679b7d3418f9ab594bda8ceb37dd4c695.pack differ diff --git a/tests/resources/reftable/testrepo.git/objects/pack/pack-d7c6adf9f61318f041845b01440d09aa7a91e1b5.idx b/tests/resources/reftable/testrepo.git/objects/pack/pack-d7c6adf9f61318f041845b01440d09aa7a91e1b5.idx new file mode 100644 index 000000000..94c3c71da Binary files /dev/null and b/tests/resources/reftable/testrepo.git/objects/pack/pack-d7c6adf9f61318f041845b01440d09aa7a91e1b5.idx differ diff --git a/tests/resources/reftable/testrepo.git/objects/pack/pack-d7c6adf9f61318f041845b01440d09aa7a91e1b5.pack b/tests/resources/reftable/testrepo.git/objects/pack/pack-d7c6adf9f61318f041845b01440d09aa7a91e1b5.pack new file mode 100644 index 000000000..74c7fe4f3 Binary files /dev/null and b/tests/resources/reftable/testrepo.git/objects/pack/pack-d7c6adf9f61318f041845b01440d09aa7a91e1b5.pack differ diff --git a/tests/resources/reftable/testrepo.git/objects/pack/pack-d85f5d483273108c9d8dd0e4728ccf0b2982423a.idx b/tests/resources/reftable/testrepo.git/objects/pack/pack-d85f5d483273108c9d8dd0e4728ccf0b2982423a.idx new file mode 100644 index 000000000..555cfa977 Binary files /dev/null and b/tests/resources/reftable/testrepo.git/objects/pack/pack-d85f5d483273108c9d8dd0e4728ccf0b2982423a.idx differ diff --git a/tests/resources/reftable/testrepo.git/objects/pack/pack-d85f5d483273108c9d8dd0e4728ccf0b2982423a.pack b/tests/resources/reftable/testrepo.git/objects/pack/pack-d85f5d483273108c9d8dd0e4728ccf0b2982423a.pack new file mode 100644 index 000000000..4d539ed0a Binary files /dev/null and b/tests/resources/reftable/testrepo.git/objects/pack/pack-d85f5d483273108c9d8dd0e4728ccf0b2982423a.pack differ diff --git a/tests/resources/reftable/testrepo.git/refs/heads b/tests/resources/reftable/testrepo.git/refs/heads new file mode 100644 index 000000000..3e639a56a --- /dev/null +++ b/tests/resources/reftable/testrepo.git/refs/heads @@ -0,0 +1 @@ +this repository uses the reftable format diff --git a/tests/resources/reftable/testrepo.git/reftable/0x000000000001-0x000000000007-88eb6d02.ref b/tests/resources/reftable/testrepo.git/reftable/0x000000000001-0x000000000007-88eb6d02.ref new file mode 100644 index 000000000..c5611f9c9 Binary files /dev/null and b/tests/resources/reftable/testrepo.git/reftable/0x000000000001-0x000000000007-88eb6d02.ref differ diff --git a/tests/resources/reftable/testrepo.git/reftable/0x000000000008-0x000000000009-3315eccd.ref b/tests/resources/reftable/testrepo.git/reftable/0x000000000008-0x000000000009-3315eccd.ref new file mode 100644 index 000000000..081e06dc4 Binary files /dev/null and b/tests/resources/reftable/testrepo.git/reftable/0x000000000008-0x000000000009-3315eccd.ref differ diff --git a/tests/resources/reftable/testrepo.git/reftable/0x00000000000a-0x00000000000a-d379c9a9.ref b/tests/resources/reftable/testrepo.git/reftable/0x00000000000a-0x00000000000a-d379c9a9.ref new file mode 100644 index 000000000..356d4d626 Binary files /dev/null and b/tests/resources/reftable/testrepo.git/reftable/0x00000000000a-0x00000000000a-d379c9a9.ref differ diff --git a/tests/resources/reftable/testrepo.git/reftable/tables.list b/tests/resources/reftable/testrepo.git/reftable/tables.list new file mode 100644 index 000000000..4d9f138e7 --- /dev/null +++ b/tests/resources/reftable/testrepo.git/reftable/tables.list @@ -0,0 +1,3 @@ +0x000000000001-0x000000000007-88eb6d02.ref +0x000000000008-0x000000000009-3315eccd.ref +0x00000000000a-0x00000000000a-d379c9a9.ref diff --git a/tests/resources/reftable/testrepo/.gitted/HEAD b/tests/resources/reftable/testrepo/.gitted/HEAD new file mode 100644 index 000000000..fe6d7e5fa --- /dev/null +++ b/tests/resources/reftable/testrepo/.gitted/HEAD @@ -0,0 +1 @@ +ref: refs/heads/.invalid diff --git a/tests/resources/reftable/testrepo/.gitted/HEAD_TRACKER b/tests/resources/reftable/testrepo/.gitted/HEAD_TRACKER new file mode 100644 index 000000000..40d876b4c --- /dev/null +++ b/tests/resources/reftable/testrepo/.gitted/HEAD_TRACKER @@ -0,0 +1 @@ +ref: HEAD diff --git a/tests/resources/reftable/testrepo/.gitted/config b/tests/resources/reftable/testrepo/.gitted/config new file mode 100644 index 000000000..de8285b99 --- /dev/null +++ b/tests/resources/reftable/testrepo/.gitted/config @@ -0,0 +1,11 @@ +[core] + repositoryformatversion = 1 + filemode = true + bare = false + logallrefupdates = true +[extensions] + worktreeconfig = true + refstorage = reftable +[remote "test"] + url = git://github.com/libgit2/libgit2 + fetch = +refs/heads/*:refs/remotes/test/* diff --git a/tests/resources/reftable/testrepo/.gitted/config.worktree b/tests/resources/reftable/testrepo/.gitted/config.worktree new file mode 100644 index 000000000..df9f0caf6 --- /dev/null +++ b/tests/resources/reftable/testrepo/.gitted/config.worktree @@ -0,0 +1,2 @@ +[worktreetest] + config = mainrepo diff --git a/tests/resources/reftable/testrepo/.gitted/index b/tests/resources/reftable/testrepo/.gitted/index new file mode 100644 index 000000000..963f7adbb Binary files /dev/null and b/tests/resources/reftable/testrepo/.gitted/index differ diff --git a/tests/resources/reftable/testrepo/.gitted/objects/09/9fabac3a9ea935598528c27f866e34089c2eff b/tests/resources/reftable/testrepo/.gitted/objects/09/9fabac3a9ea935598528c27f866e34089c2eff new file mode 100644 index 000000000..c60c78fb5 --- /dev/null +++ b/tests/resources/reftable/testrepo/.gitted/objects/09/9fabac3a9ea935598528c27f866e34089c2eff @@ -0,0 +1 @@ +xQ P9^@B!1F'J?#7KJhMVE,.3uVsH-;U,MPIɉ&Ĕ׍סKO.2µո$8Nݗr!lCTklUgf0sÓG( \ No newline at end of file diff --git a/tests/resources/reftable/testrepo/.gitted/objects/13/85f264afb75a56a5bec74243be9b367ba4ca08 b/tests/resources/reftable/testrepo/.gitted/objects/13/85f264afb75a56a5bec74243be9b367ba4ca08 new file mode 100644 index 000000000..cedb2a22e Binary files /dev/null and b/tests/resources/reftable/testrepo/.gitted/objects/13/85f264afb75a56a5bec74243be9b367ba4ca08 differ diff --git a/tests/resources/reftable/testrepo/.gitted/objects/14/4344043ba4d4a405da03de3844aa829ae8be0e b/tests/resources/reftable/testrepo/.gitted/objects/14/4344043ba4d4a405da03de3844aa829ae8be0e new file mode 100644 index 000000000..b7d944fa1 Binary files /dev/null and b/tests/resources/reftable/testrepo/.gitted/objects/14/4344043ba4d4a405da03de3844aa829ae8be0e differ diff --git a/tests/resources/reftable/testrepo/.gitted/objects/16/8e4ebd1c667499548ae12403b19b22a5c5e925 b/tests/resources/reftable/testrepo/.gitted/objects/16/8e4ebd1c667499548ae12403b19b22a5c5e925 new file mode 100644 index 000000000..d37b93e4f Binary files /dev/null and b/tests/resources/reftable/testrepo/.gitted/objects/16/8e4ebd1c667499548ae12403b19b22a5c5e925 differ diff --git a/tests/resources/reftable/testrepo/.gitted/objects/18/1037049a54a1eb5fab404658a3a250b44335d7 b/tests/resources/reftable/testrepo/.gitted/objects/18/1037049a54a1eb5fab404658a3a250b44335d7 new file mode 100644 index 000000000..93a16f146 Binary files /dev/null and b/tests/resources/reftable/testrepo/.gitted/objects/18/1037049a54a1eb5fab404658a3a250b44335d7 differ diff --git a/tests/resources/reftable/testrepo/.gitted/objects/18/10dff58d8a660512d4832e740f692884338ccd b/tests/resources/reftable/testrepo/.gitted/objects/18/10dff58d8a660512d4832e740f692884338ccd new file mode 100644 index 000000000..ba0bfb30c Binary files /dev/null and b/tests/resources/reftable/testrepo/.gitted/objects/18/10dff58d8a660512d4832e740f692884338ccd differ diff --git a/tests/resources/reftable/testrepo/.gitted/objects/1d/d0968be3ff95fcaecb6fa4245662db9fdc4568 b/tests/resources/reftable/testrepo/.gitted/objects/1d/d0968be3ff95fcaecb6fa4245662db9fdc4568 new file mode 100644 index 000000000..97c6b2cfa Binary files /dev/null and b/tests/resources/reftable/testrepo/.gitted/objects/1d/d0968be3ff95fcaecb6fa4245662db9fdc4568 differ diff --git a/tests/resources/reftable/testrepo/.gitted/objects/1f/67fc4386b2d171e0d21be1c447e12660561f9b b/tests/resources/reftable/testrepo/.gitted/objects/1f/67fc4386b2d171e0d21be1c447e12660561f9b new file mode 100644 index 000000000..225c45734 Binary files /dev/null and b/tests/resources/reftable/testrepo/.gitted/objects/1f/67fc4386b2d171e0d21be1c447e12660561f9b differ diff --git a/tests/resources/reftable/testrepo/.gitted/objects/27/0b8ea76056d5cad83af921837702d3e3c2924d b/tests/resources/reftable/testrepo/.gitted/objects/27/0b8ea76056d5cad83af921837702d3e3c2924d new file mode 100644 index 000000000..df40d99af Binary files /dev/null and b/tests/resources/reftable/testrepo/.gitted/objects/27/0b8ea76056d5cad83af921837702d3e3c2924d differ diff --git a/tests/resources/reftable/testrepo/.gitted/objects/2b/d0a343aeef7a2cf0d158478966a6e587ff3863 b/tests/resources/reftable/testrepo/.gitted/objects/2b/d0a343aeef7a2cf0d158478966a6e587ff3863 new file mode 100644 index 000000000..d10ca636b Binary files /dev/null and b/tests/resources/reftable/testrepo/.gitted/objects/2b/d0a343aeef7a2cf0d158478966a6e587ff3863 differ diff --git a/tests/resources/reftable/testrepo/.gitted/objects/32/59a6bd5b57fb9c1281bb7ed3167b50f224cb54 b/tests/resources/reftable/testrepo/.gitted/objects/32/59a6bd5b57fb9c1281bb7ed3167b50f224cb54 new file mode 100644 index 000000000..321eaa867 Binary files /dev/null and b/tests/resources/reftable/testrepo/.gitted/objects/32/59a6bd5b57fb9c1281bb7ed3167b50f224cb54 differ diff --git a/tests/resources/reftable/testrepo/.gitted/objects/36/97d64be941a53d4ae8f6a271e4e3fa56b022cc b/tests/resources/reftable/testrepo/.gitted/objects/36/97d64be941a53d4ae8f6a271e4e3fa56b022cc new file mode 100644 index 000000000..9bb5b623b Binary files /dev/null and b/tests/resources/reftable/testrepo/.gitted/objects/36/97d64be941a53d4ae8f6a271e4e3fa56b022cc differ diff --git a/tests/resources/reftable/testrepo/.gitted/objects/45/b983be36b73c0788dc9cbcb76cbb80fc7bb057 b/tests/resources/reftable/testrepo/.gitted/objects/45/b983be36b73c0788dc9cbcb76cbb80fc7bb057 new file mode 100644 index 000000000..7ca4ceed5 Binary files /dev/null and b/tests/resources/reftable/testrepo/.gitted/objects/45/b983be36b73c0788dc9cbcb76cbb80fc7bb057 differ diff --git a/tests/resources/reftable/testrepo/.gitted/objects/45/dd856fdd4d89b884c340ba0e047752d9b085d6 b/tests/resources/reftable/testrepo/.gitted/objects/45/dd856fdd4d89b884c340ba0e047752d9b085d6 new file mode 100644 index 000000000..a83ed9763 Binary files /dev/null and b/tests/resources/reftable/testrepo/.gitted/objects/45/dd856fdd4d89b884c340ba0e047752d9b085d6 differ diff --git a/tests/resources/reftable/testrepo/.gitted/objects/4a/202b346bb0fb0db7eff3cffeb3c70babbd2045 b/tests/resources/reftable/testrepo/.gitted/objects/4a/202b346bb0fb0db7eff3cffeb3c70babbd2045 new file mode 100644 index 000000000..8953b6cef --- /dev/null +++ b/tests/resources/reftable/testrepo/.gitted/objects/4a/202b346bb0fb0db7eff3cffeb3c70babbd2045 @@ -0,0 +1,2 @@ +xQ +0D)6ͦ "xO-FbEo0 Ǥ,ske[Pn8R,EpD?g}^3 <GhYK8ЖDA);gݧjp4-r;sGA4ۺ=(in7IKFE \ No newline at end of file diff --git a/tests/resources/reftable/testrepo/.gitted/objects/4e/0883eeeeebc1fb1735161cea82f7cb5fab7e63 b/tests/resources/reftable/testrepo/.gitted/objects/4e/0883eeeeebc1fb1735161cea82f7cb5fab7e63 new file mode 100644 index 000000000..e9150214b Binary files /dev/null and b/tests/resources/reftable/testrepo/.gitted/objects/4e/0883eeeeebc1fb1735161cea82f7cb5fab7e63 differ diff --git a/tests/resources/reftable/testrepo/.gitted/objects/4e/886e602529caa9ab11d71f86634bd1b6e0de10 b/tests/resources/reftable/testrepo/.gitted/objects/4e/886e602529caa9ab11d71f86634bd1b6e0de10 new file mode 100644 index 000000000..53168a038 Binary files /dev/null and b/tests/resources/reftable/testrepo/.gitted/objects/4e/886e602529caa9ab11d71f86634bd1b6e0de10 differ diff --git a/tests/resources/reftable/testrepo/.gitted/objects/57/43a3ef145d3638a0fa28233ca92897117ad74f b/tests/resources/reftable/testrepo/.gitted/objects/57/43a3ef145d3638a0fa28233ca92897117ad74f new file mode 100644 index 000000000..85abb27cc Binary files /dev/null and b/tests/resources/reftable/testrepo/.gitted/objects/57/43a3ef145d3638a0fa28233ca92897117ad74f differ diff --git a/tests/resources/reftable/testrepo/.gitted/objects/5b/5b025afb0b4c913b4c338a42934a3863bf3644 b/tests/resources/reftable/testrepo/.gitted/objects/5b/5b025afb0b4c913b4c338a42934a3863bf3644 new file mode 100644 index 000000000..c1f22c54f --- /dev/null +++ b/tests/resources/reftable/testrepo/.gitted/objects/5b/5b025afb0b4c913b4c338a42934a3863bf3644 @@ -0,0 +1,2 @@ +x 1ENi@k2 "X$YW0YcÅszMD08!s Xgd::@X0Pw"F/RUzmZZV}|/o5I!1z:vUim}/> +F- \ No newline at end of file diff --git a/tests/resources/reftable/testrepo/.gitted/objects/62/eb56dabb4b9929bc15dd9263c2c733b13d2dcc b/tests/resources/reftable/testrepo/.gitted/objects/62/eb56dabb4b9929bc15dd9263c2c733b13d2dcc new file mode 100644 index 000000000..b669961d8 Binary files /dev/null and b/tests/resources/reftable/testrepo/.gitted/objects/62/eb56dabb4b9929bc15dd9263c2c733b13d2dcc differ diff --git a/tests/resources/reftable/testrepo/.gitted/objects/66/3adb09143767984f7be83a91effa47e128c735 b/tests/resources/reftable/testrepo/.gitted/objects/66/3adb09143767984f7be83a91effa47e128c735 new file mode 100644 index 000000000..9ff5eb2b5 Binary files /dev/null and b/tests/resources/reftable/testrepo/.gitted/objects/66/3adb09143767984f7be83a91effa47e128c735 differ diff --git a/tests/resources/reftable/testrepo/.gitted/objects/6b/377958d8c6a4906e8573b53672a1a23a4e8ce6 b/tests/resources/reftable/testrepo/.gitted/objects/6b/377958d8c6a4906e8573b53672a1a23a4e8ce6 new file mode 100644 index 000000000..ee7c78174 Binary files /dev/null and b/tests/resources/reftable/testrepo/.gitted/objects/6b/377958d8c6a4906e8573b53672a1a23a4e8ce6 differ diff --git a/tests/resources/reftable/testrepo/.gitted/objects/6b/9b767af9992b4abad5e24ffb1ba2d688ca602e b/tests/resources/reftable/testrepo/.gitted/objects/6b/9b767af9992b4abad5e24ffb1ba2d688ca602e new file mode 100644 index 000000000..197685b86 Binary files /dev/null and b/tests/resources/reftable/testrepo/.gitted/objects/6b/9b767af9992b4abad5e24ffb1ba2d688ca602e differ diff --git a/tests/resources/reftable/testrepo/.gitted/objects/6f/d5c7dd2ab27b48c493023f794be09861e9045f b/tests/resources/reftable/testrepo/.gitted/objects/6f/d5c7dd2ab27b48c493023f794be09861e9045f new file mode 100644 index 000000000..7f0c6fe4e --- /dev/null +++ b/tests/resources/reftable/testrepo/.gitted/objects/6f/d5c7dd2ab27b48c493023f794be09861e9045f @@ -0,0 +1 @@ +xA!D}G Mr\m[F11gȢ(GRr3Co"v^hq<7AY{"&$DSg([B!ΡwƳYgl$%Eֲ'\d_w-[k'1hZt B&;:A"m%V \ No newline at end of file diff --git a/tests/resources/reftable/testrepo/.gitted/objects/75/057dd4114e74cca1d750d0aee1647c903cb60a b/tests/resources/reftable/testrepo/.gitted/objects/75/057dd4114e74cca1d750d0aee1647c903cb60a new file mode 100644 index 000000000..2ef4faa0f Binary files /dev/null and b/tests/resources/reftable/testrepo/.gitted/objects/75/057dd4114e74cca1d750d0aee1647c903cb60a differ diff --git a/tests/resources/reftable/testrepo/.gitted/objects/76/3d71aadf09a7951596c9746c024e7eece7c7af b/tests/resources/reftable/testrepo/.gitted/objects/76/3d71aadf09a7951596c9746c024e7eece7c7af new file mode 100644 index 000000000..716b0c64b --- /dev/null +++ b/tests/resources/reftable/testrepo/.gitted/objects/76/3d71aadf09a7951596c9746c024e7eece7c7af @@ -0,0 +1 @@ +xAj!?009o}H6}jUPPZ&Y AԛpFdpz[fYPqLJ.,Z`Ů.`v q $5+9Ot>/DE/龡W*eVdf1>覭ěʙFThk.i^0?PR, \ No newline at end of file diff --git a/tests/resources/reftable/testrepo/.gitted/objects/7b/2417a23b63e1fdde88c80e14b33247c6e5785a b/tests/resources/reftable/testrepo/.gitted/objects/7b/2417a23b63e1fdde88c80e14b33247c6e5785a new file mode 100644 index 000000000..db778aaae Binary files /dev/null and b/tests/resources/reftable/testrepo/.gitted/objects/7b/2417a23b63e1fdde88c80e14b33247c6e5785a differ diff --git a/tests/resources/reftable/testrepo/.gitted/objects/7b/4384978d2493e851f9cca7858815fac9b10980 b/tests/resources/reftable/testrepo/.gitted/objects/7b/4384978d2493e851f9cca7858815fac9b10980 new file mode 100644 index 000000000..23c462f34 Binary files /dev/null and b/tests/resources/reftable/testrepo/.gitted/objects/7b/4384978d2493e851f9cca7858815fac9b10980 differ diff --git a/tests/resources/reftable/testrepo/.gitted/objects/81/4889a078c031f61ed08ab5fa863aea9314344d b/tests/resources/reftable/testrepo/.gitted/objects/81/4889a078c031f61ed08ab5fa863aea9314344d new file mode 100644 index 000000000..2f9b6b6e3 Binary files /dev/null and b/tests/resources/reftable/testrepo/.gitted/objects/81/4889a078c031f61ed08ab5fa863aea9314344d differ diff --git a/tests/resources/reftable/testrepo/.gitted/objects/84/96071c1b46c854b31185ea97743be6a8774479 b/tests/resources/reftable/testrepo/.gitted/objects/84/96071c1b46c854b31185ea97743be6a8774479 new file mode 100644 index 000000000..5df58dda5 Binary files /dev/null and b/tests/resources/reftable/testrepo/.gitted/objects/84/96071c1b46c854b31185ea97743be6a8774479 differ diff --git a/tests/resources/reftable/testrepo/.gitted/objects/87/380ae84009e9c503506c2f6143a4fc6c60bf80 b/tests/resources/reftable/testrepo/.gitted/objects/87/380ae84009e9c503506c2f6143a4fc6c60bf80 new file mode 100644 index 000000000..3042f5790 Binary files /dev/null and b/tests/resources/reftable/testrepo/.gitted/objects/87/380ae84009e9c503506c2f6143a4fc6c60bf80 differ diff --git a/tests/resources/reftable/testrepo/.gitted/objects/94/4c0f6e4dfa41595e6eb3ceecdb14f50fe18162 b/tests/resources/reftable/testrepo/.gitted/objects/94/4c0f6e4dfa41595e6eb3ceecdb14f50fe18162 new file mode 100644 index 000000000..4cc3f4dff --- /dev/null +++ b/tests/resources/reftable/testrepo/.gitted/objects/94/4c0f6e4dfa41595e6eb3ceecdb14f50fe18162 @@ -0,0 +1 @@ +x+)JMU044b040031QrutueXlmmAṃJ}G;UTWRQ`6Kǥ^/-*|W3Py`%E\&g|0{Ӎ1X \ No newline at end of file diff --git a/tests/resources/reftable/testrepo/.gitted/objects/97/328ac7e3bd0bcd3900cb3e7a624d71dd0df888 b/tests/resources/reftable/testrepo/.gitted/objects/97/328ac7e3bd0bcd3900cb3e7a624d71dd0df888 new file mode 100644 index 000000000..2aa37bc43 Binary files /dev/null and b/tests/resources/reftable/testrepo/.gitted/objects/97/328ac7e3bd0bcd3900cb3e7a624d71dd0df888 differ diff --git a/tests/resources/reftable/testrepo/.gitted/objects/99/1f1b12603e1d78411c1b4042719f964efa7adf b/tests/resources/reftable/testrepo/.gitted/objects/99/1f1b12603e1d78411c1b4042719f964efa7adf new file mode 100644 index 000000000..4173754c0 Binary files /dev/null and b/tests/resources/reftable/testrepo/.gitted/objects/99/1f1b12603e1d78411c1b4042719f964efa7adf differ diff --git a/tests/resources/reftable/testrepo/.gitted/objects/9a/03079b8a8ee85a0bee58bf9be3da8b62414ed4 b/tests/resources/reftable/testrepo/.gitted/objects/9a/03079b8a8ee85a0bee58bf9be3da8b62414ed4 new file mode 100644 index 000000000..bf7b2bb68 Binary files /dev/null and b/tests/resources/reftable/testrepo/.gitted/objects/9a/03079b8a8ee85a0bee58bf9be3da8b62414ed4 differ diff --git a/tests/resources/reftable/testrepo/.gitted/objects/9b/1719f5cf069568785080a0bbabbe7c377e22ae b/tests/resources/reftable/testrepo/.gitted/objects/9b/1719f5cf069568785080a0bbabbe7c377e22ae new file mode 100644 index 000000000..13e3f581a Binary files /dev/null and b/tests/resources/reftable/testrepo/.gitted/objects/9b/1719f5cf069568785080a0bbabbe7c377e22ae differ diff --git a/tests/resources/reftable/testrepo/.gitted/objects/9f/d738e8f7967c078dceed8190330fc8648ee56a b/tests/resources/reftable/testrepo/.gitted/objects/9f/d738e8f7967c078dceed8190330fc8648ee56a new file mode 100644 index 000000000..a79612435 --- /dev/null +++ b/tests/resources/reftable/testrepo/.gitted/objects/9f/d738e8f7967c078dceed8190330fc8648ee56a @@ -0,0 +1,3 @@ +x[ +0E*fդ "W0-Ft݁pS[Yx^ +Db CLhut}8X*4ZsYUA X3RM) s6輢Mរ&Jm;}<\@ޏpĀv?jۺL?H \ No newline at end of file diff --git a/tests/resources/reftable/testrepo/.gitted/objects/a3/8d028f71eaa590febb7d716b1ca32350cf70da b/tests/resources/reftable/testrepo/.gitted/objects/a3/8d028f71eaa590febb7d716b1ca32350cf70da new file mode 100644 index 000000000..4df22ec17 Binary files /dev/null and b/tests/resources/reftable/testrepo/.gitted/objects/a3/8d028f71eaa590febb7d716b1ca32350cf70da differ diff --git a/tests/resources/reftable/testrepo/.gitted/objects/a4/a7dce85cf63874e984719f4fdd239f5145052f b/tests/resources/reftable/testrepo/.gitted/objects/a4/a7dce85cf63874e984719f4fdd239f5145052f new file mode 100644 index 000000000..f8588696b --- /dev/null +++ b/tests/resources/reftable/testrepo/.gitted/objects/a4/a7dce85cf63874e984719f4fdd239f5145052f @@ -0,0 +1,2 @@ +x;j1Dmdǎ|M3`V{ >QvL0I?!4Z=!צ8F!rsQy9]$D&l6A>jFWҵ IKNiZ%S + U~̽>' w [ DGڡQ-M>dO}\8g_ШoYr \ No newline at end of file diff --git a/tests/resources/reftable/testrepo/.gitted/objects/a6/5fedf39aefe402d3bb6e24df4d4f5fe4547750 b/tests/resources/reftable/testrepo/.gitted/objects/a6/5fedf39aefe402d3bb6e24df4d4f5fe4547750 new file mode 100644 index 000000000..29c8e824d --- /dev/null +++ b/tests/resources/reftable/testrepo/.gitted/objects/a6/5fedf39aefe402d3bb6e24df4d4f5fe4547750 @@ -0,0 +1,3 @@ +xQ +!@sBQ" ٱ r{ +F- \ No newline at end of file diff --git a/tests/resources/reftable/testrepo2/.gitted/objects/61/9f9935957e010c419cb9d15621916ddfcc0b96 b/tests/resources/reftable/testrepo2/.gitted/objects/61/9f9935957e010c419cb9d15621916ddfcc0b96 new file mode 100644 index 000000000..1fd79b477 Binary files /dev/null and b/tests/resources/reftable/testrepo2/.gitted/objects/61/9f9935957e010c419cb9d15621916ddfcc0b96 differ diff --git a/tests/resources/reftable/testrepo2/.gitted/objects/75/057dd4114e74cca1d750d0aee1647c903cb60a b/tests/resources/reftable/testrepo2/.gitted/objects/75/057dd4114e74cca1d750d0aee1647c903cb60a new file mode 100644 index 000000000..2ef4faa0f Binary files /dev/null and b/tests/resources/reftable/testrepo2/.gitted/objects/75/057dd4114e74cca1d750d0aee1647c903cb60a differ diff --git a/tests/resources/reftable/testrepo2/.gitted/objects/7f/043268ea43ce18e3540acaabf9e090c91965b0 b/tests/resources/reftable/testrepo2/.gitted/objects/7f/043268ea43ce18e3540acaabf9e090c91965b0 new file mode 100644 index 000000000..3d1016daa Binary files /dev/null and b/tests/resources/reftable/testrepo2/.gitted/objects/7f/043268ea43ce18e3540acaabf9e090c91965b0 differ diff --git a/tests/resources/reftable/testrepo2/.gitted/objects/81/4889a078c031f61ed08ab5fa863aea9314344d b/tests/resources/reftable/testrepo2/.gitted/objects/81/4889a078c031f61ed08ab5fa863aea9314344d new file mode 100644 index 000000000..2f9b6b6e3 Binary files /dev/null and b/tests/resources/reftable/testrepo2/.gitted/objects/81/4889a078c031f61ed08ab5fa863aea9314344d differ diff --git a/tests/resources/reftable/testrepo2/.gitted/objects/84/96071c1b46c854b31185ea97743be6a8774479 b/tests/resources/reftable/testrepo2/.gitted/objects/84/96071c1b46c854b31185ea97743be6a8774479 new file mode 100644 index 000000000..5df58dda5 Binary files /dev/null and b/tests/resources/reftable/testrepo2/.gitted/objects/84/96071c1b46c854b31185ea97743be6a8774479 differ diff --git a/tests/resources/reftable/testrepo2/.gitted/objects/9f/d738e8f7967c078dceed8190330fc8648ee56a b/tests/resources/reftable/testrepo2/.gitted/objects/9f/d738e8f7967c078dceed8190330fc8648ee56a new file mode 100644 index 000000000..a79612435 --- /dev/null +++ b/tests/resources/reftable/testrepo2/.gitted/objects/9f/d738e8f7967c078dceed8190330fc8648ee56a @@ -0,0 +1,3 @@ +x[ +0E*fդ "W0-Ft݁pS[Yx^ +Db CLhut}8X*4ZsYUA X3RM) s6輢Mរ&Jm;}<\@ޏpĀv?jۺL?H \ No newline at end of file diff --git a/tests/resources/reftable/testrepo2/.gitted/objects/a4/a7dce85cf63874e984719f4fdd239f5145052f b/tests/resources/reftable/testrepo2/.gitted/objects/a4/a7dce85cf63874e984719f4fdd239f5145052f new file mode 100644 index 000000000..f8588696b --- /dev/null +++ b/tests/resources/reftable/testrepo2/.gitted/objects/a4/a7dce85cf63874e984719f4fdd239f5145052f @@ -0,0 +1,2 @@ +x;j1Dmdǎ|M3`V{ >QvL0I?!4Z=!צ8F!rsQy9]$D&l6A>jFWҵ IKNiZ%S + U~̽>' w [ DGڡQ-M>dO}\8g_ШoYr \ No newline at end of file diff --git a/tests/resources/reftable/testrepo2/.gitted/objects/a7/1586c1dfe8a71c6cbf6c129f404c5642ff31bd b/tests/resources/reftable/testrepo2/.gitted/objects/a7/1586c1dfe8a71c6cbf6c129f404c5642ff31bd new file mode 100644 index 000000000..d0d7e736e Binary files /dev/null and b/tests/resources/reftable/testrepo2/.gitted/objects/a7/1586c1dfe8a71c6cbf6c129f404c5642ff31bd differ diff --git a/tests/resources/reftable/testrepo2/.gitted/objects/a8/233120f6ad708f843d861ce2b7228ec4e3dec6 b/tests/resources/reftable/testrepo2/.gitted/objects/a8/233120f6ad708f843d861ce2b7228ec4e3dec6 new file mode 100644 index 000000000..18a7f61c2 Binary files /dev/null and b/tests/resources/reftable/testrepo2/.gitted/objects/a8/233120f6ad708f843d861ce2b7228ec4e3dec6 differ diff --git a/tests/resources/reftable/testrepo2/.gitted/objects/be/3563ae3f795b2b4353bcce3a527ad0a4f7f644 b/tests/resources/reftable/testrepo2/.gitted/objects/be/3563ae3f795b2b4353bcce3a527ad0a4f7f644 new file mode 100644 index 000000000..0817229bc --- /dev/null +++ b/tests/resources/reftable/testrepo2/.gitted/objects/be/3563ae3f795b2b4353bcce3a527ad0a4f7f644 @@ -0,0 +1,3 @@ +xKj1D)zUB-0uV9<#+Wks*? |m“i@mV'`).-1 x +uxt(+ \ No newline at end of file diff --git a/tests/resources/reftable/typechanges/.gitted/modules/b/objects/78/9efbdadaa4a582778d4584385495559ea0994b b/tests/resources/reftable/typechanges/.gitted/modules/b/objects/78/9efbdadaa4a582778d4584385495559ea0994b new file mode 100644 index 000000000..17458840b --- /dev/null +++ b/tests/resources/reftable/typechanges/.gitted/modules/b/objects/78/9efbdadaa4a582778d4584385495559ea0994b @@ -0,0 +1,2 @@ +x 0 )?= NlOkj8&r +qJW7B<fK8#Q1C-"e̫>'@ \ No newline at end of file diff --git a/tests/resources/reftable/typechanges/.gitted/modules/b/objects/88/34b635dd468a83cb012f6feace968c1c9f5d6e b/tests/resources/reftable/typechanges/.gitted/modules/b/objects/88/34b635dd468a83cb012f6feace968c1c9f5d6e new file mode 100644 index 000000000..83cc29fb1 Binary files /dev/null and b/tests/resources/reftable/typechanges/.gitted/modules/b/objects/88/34b635dd468a83cb012f6feace968c1c9f5d6e differ diff --git a/tests/resources/reftable/typechanges/.gitted/modules/b/objects/d0/5f2cd5cc77addf68ed6f50d622c9a4f732e6c5 b/tests/resources/reftable/typechanges/.gitted/modules/b/objects/d0/5f2cd5cc77addf68ed6f50d622c9a4f732e6c5 new file mode 100644 index 000000000..55bda40ef Binary files /dev/null and b/tests/resources/reftable/typechanges/.gitted/modules/b/objects/d0/5f2cd5cc77addf68ed6f50d622c9a4f732e6c5 differ diff --git a/tests/resources/reftable/typechanges/.gitted/modules/b/packed-refs b/tests/resources/reftable/typechanges/.gitted/modules/b/packed-refs new file mode 100644 index 000000000..5a4ebc47c --- /dev/null +++ b/tests/resources/reftable/typechanges/.gitted/modules/b/packed-refs @@ -0,0 +1,2 @@ +# pack-refs with: peeled +480095882d281ed676fe5b863569520e54a7d5c0 refs/remotes/origin/master diff --git a/tests/resources/reftable/typechanges/.gitted/modules/b/refs/heads/master b/tests/resources/reftable/typechanges/.gitted/modules/b/refs/heads/master new file mode 100644 index 000000000..e12c44d7a --- /dev/null +++ b/tests/resources/reftable/typechanges/.gitted/modules/b/refs/heads/master @@ -0,0 +1 @@ +480095882d281ed676fe5b863569520e54a7d5c0 diff --git a/tests/resources/reftable/typechanges/.gitted/modules/b/refs/remotes/origin/HEAD b/tests/resources/reftable/typechanges/.gitted/modules/b/refs/remotes/origin/HEAD new file mode 100644 index 000000000..6efe28fff --- /dev/null +++ b/tests/resources/reftable/typechanges/.gitted/modules/b/refs/remotes/origin/HEAD @@ -0,0 +1 @@ +ref: refs/remotes/origin/master diff --git a/tests/resources/reftable/typechanges/.gitted/modules/d/HEAD b/tests/resources/reftable/typechanges/.gitted/modules/d/HEAD new file mode 100644 index 000000000..cb089cd89 --- /dev/null +++ b/tests/resources/reftable/typechanges/.gitted/modules/d/HEAD @@ -0,0 +1 @@ +ref: refs/heads/master diff --git a/tests/resources/reftable/typechanges/.gitted/modules/d/config b/tests/resources/reftable/typechanges/.gitted/modules/d/config new file mode 100644 index 000000000..42e1bddda --- /dev/null +++ b/tests/resources/reftable/typechanges/.gitted/modules/d/config @@ -0,0 +1,13 @@ +[core] + repositoryformatversion = 0 + filemode = true + bare = false + logallrefupdates = true + worktree = ../../../d + ignorecase = true +[remote "origin"] + fetch = +refs/heads/*:refs/remotes/origin/* + url = /Users/rb/src/libgit2/tests-clar/resources/submod2_target/.git +[branch "master"] + remote = origin + merge = refs/heads/master diff --git a/tests/resources/reftable/typechanges/.gitted/modules/d/description b/tests/resources/reftable/typechanges/.gitted/modules/d/description new file mode 100644 index 000000000..498b267a8 --- /dev/null +++ b/tests/resources/reftable/typechanges/.gitted/modules/d/description @@ -0,0 +1 @@ +Unnamed repository; edit this file 'description' to name the repository. diff --git a/tests/resources/reftable/typechanges/.gitted/modules/d/index b/tests/resources/reftable/typechanges/.gitted/modules/d/index new file mode 100644 index 000000000..86d0266e8 Binary files /dev/null and b/tests/resources/reftable/typechanges/.gitted/modules/d/index differ diff --git a/tests/resources/reftable/typechanges/.gitted/modules/d/info/exclude b/tests/resources/reftable/typechanges/.gitted/modules/d/info/exclude new file mode 100644 index 000000000..a5196d1be --- /dev/null +++ b/tests/resources/reftable/typechanges/.gitted/modules/d/info/exclude @@ -0,0 +1,6 @@ +# git ls-files --others --exclude-from=.git/info/exclude +# Lines that start with '#' are comments. +# For a project mostly in C, the following would be a good set of +# exclude patterns (uncomment them if you want to use them): +# *.[oa] +# *~ diff --git a/tests/resources/reftable/typechanges/.gitted/modules/d/objects/06/362fe2fdb7010d0e447b4fb450d405420479a1 b/tests/resources/reftable/typechanges/.gitted/modules/d/objects/06/362fe2fdb7010d0e447b4fb450d405420479a1 new file mode 100644 index 000000000..f4b7094c5 Binary files /dev/null and b/tests/resources/reftable/typechanges/.gitted/modules/d/objects/06/362fe2fdb7010d0e447b4fb450d405420479a1 differ diff --git a/tests/resources/reftable/typechanges/.gitted/modules/d/objects/0e/6a3ca48bd47cfe67681acf39aa0b10a0b92484 b/tests/resources/reftable/typechanges/.gitted/modules/d/objects/0e/6a3ca48bd47cfe67681acf39aa0b10a0b92484 new file mode 100644 index 000000000..56c845e49 Binary files /dev/null and b/tests/resources/reftable/typechanges/.gitted/modules/d/objects/0e/6a3ca48bd47cfe67681acf39aa0b10a0b92484 differ diff --git a/tests/resources/reftable/typechanges/.gitted/modules/d/objects/17/d0ece6e96460a06592d9d9d000de37ba4232c5 b/tests/resources/reftable/typechanges/.gitted/modules/d/objects/17/d0ece6e96460a06592d9d9d000de37ba4232c5 new file mode 100644 index 000000000..bd179b5f5 Binary files /dev/null and b/tests/resources/reftable/typechanges/.gitted/modules/d/objects/17/d0ece6e96460a06592d9d9d000de37ba4232c5 differ diff --git a/tests/resources/reftable/typechanges/.gitted/modules/d/objects/41/bd4bc3df978de695f67ace64c560913da11653 b/tests/resources/reftable/typechanges/.gitted/modules/d/objects/41/bd4bc3df978de695f67ace64c560913da11653 new file mode 100644 index 000000000..ccf49bd15 Binary files /dev/null and b/tests/resources/reftable/typechanges/.gitted/modules/d/objects/41/bd4bc3df978de695f67ace64c560913da11653 differ diff --git a/tests/resources/reftable/typechanges/.gitted/modules/d/objects/48/0095882d281ed676fe5b863569520e54a7d5c0 b/tests/resources/reftable/typechanges/.gitted/modules/d/objects/48/0095882d281ed676fe5b863569520e54a7d5c0 new file mode 100644 index 000000000..53029069a Binary files /dev/null and b/tests/resources/reftable/typechanges/.gitted/modules/d/objects/48/0095882d281ed676fe5b863569520e54a7d5c0 differ diff --git a/tests/resources/reftable/typechanges/.gitted/modules/d/objects/5e/4963595a9774b90524d35a807169049de8ccad b/tests/resources/reftable/typechanges/.gitted/modules/d/objects/5e/4963595a9774b90524d35a807169049de8ccad new file mode 100644 index 000000000..38c791eba Binary files /dev/null and b/tests/resources/reftable/typechanges/.gitted/modules/d/objects/5e/4963595a9774b90524d35a807169049de8ccad differ diff --git a/tests/resources/reftable/typechanges/.gitted/modules/d/objects/6b/31c659545507c381e9cd34ec508f16c04e149e b/tests/resources/reftable/typechanges/.gitted/modules/d/objects/6b/31c659545507c381e9cd34ec508f16c04e149e new file mode 100644 index 000000000..a26d29993 --- /dev/null +++ b/tests/resources/reftable/typechanges/.gitted/modules/d/objects/6b/31c659545507c381e9cd34ec508f16c04e149e @@ -0,0 +1,2 @@ +xQ +!Evoy*_@g#hOh^9wSòf1*[Ic Ԥpk Α\S߇l@.^QpF(:D5zr~ en8 \ No newline at end of file diff --git a/tests/resources/reftable/typechanges/.gitted/modules/d/objects/73/ba924a80437097795ae839e66e187c55d3babf b/tests/resources/reftable/typechanges/.gitted/modules/d/objects/73/ba924a80437097795ae839e66e187c55d3babf new file mode 100644 index 000000000..83d1ba481 Binary files /dev/null and b/tests/resources/reftable/typechanges/.gitted/modules/d/objects/73/ba924a80437097795ae839e66e187c55d3babf differ diff --git a/tests/resources/reftable/typechanges/.gitted/modules/d/objects/78/0d7397f5e8f8f477fb55b7af3accc2154b2d4a b/tests/resources/reftable/typechanges/.gitted/modules/d/objects/78/0d7397f5e8f8f477fb55b7af3accc2154b2d4a new file mode 100644 index 000000000..6d27af8a8 --- /dev/null +++ b/tests/resources/reftable/typechanges/.gitted/modules/d/objects/78/0d7397f5e8f8f477fb55b7af3accc2154b2d4a @@ -0,0 +1,2 @@ +x-10 Fa0p(N-ӡғq]>ks*? |m“i@mV'`).-1 x +uxt(+ \ No newline at end of file diff --git a/tests/resources/reftable/typechanges/.gitted/modules/d/objects/78/9efbdadaa4a582778d4584385495559ea0994b b/tests/resources/reftable/typechanges/.gitted/modules/d/objects/78/9efbdadaa4a582778d4584385495559ea0994b new file mode 100644 index 000000000..17458840b --- /dev/null +++ b/tests/resources/reftable/typechanges/.gitted/modules/d/objects/78/9efbdadaa4a582778d4584385495559ea0994b @@ -0,0 +1,2 @@ +x 0 )?= NlOkj8&r +qJW7B<fK8#Q1C-"e̫>'@ \ No newline at end of file diff --git a/tests/resources/reftable/typechanges/.gitted/modules/d/objects/88/34b635dd468a83cb012f6feace968c1c9f5d6e b/tests/resources/reftable/typechanges/.gitted/modules/d/objects/88/34b635dd468a83cb012f6feace968c1c9f5d6e new file mode 100644 index 000000000..83cc29fb1 Binary files /dev/null and b/tests/resources/reftable/typechanges/.gitted/modules/d/objects/88/34b635dd468a83cb012f6feace968c1c9f5d6e differ diff --git a/tests/resources/reftable/typechanges/.gitted/modules/d/objects/d0/5f2cd5cc77addf68ed6f50d622c9a4f732e6c5 b/tests/resources/reftable/typechanges/.gitted/modules/d/objects/d0/5f2cd5cc77addf68ed6f50d622c9a4f732e6c5 new file mode 100644 index 000000000..55bda40ef Binary files /dev/null and b/tests/resources/reftable/typechanges/.gitted/modules/d/objects/d0/5f2cd5cc77addf68ed6f50d622c9a4f732e6c5 differ diff --git a/tests/resources/reftable/typechanges/.gitted/modules/d/packed-refs b/tests/resources/reftable/typechanges/.gitted/modules/d/packed-refs new file mode 100644 index 000000000..5a4ebc47c --- /dev/null +++ b/tests/resources/reftable/typechanges/.gitted/modules/d/packed-refs @@ -0,0 +1,2 @@ +# pack-refs with: peeled +480095882d281ed676fe5b863569520e54a7d5c0 refs/remotes/origin/master diff --git a/tests/resources/reftable/typechanges/.gitted/modules/d/refs/heads/master b/tests/resources/reftable/typechanges/.gitted/modules/d/refs/heads/master new file mode 100644 index 000000000..e12c44d7a --- /dev/null +++ b/tests/resources/reftable/typechanges/.gitted/modules/d/refs/heads/master @@ -0,0 +1 @@ +480095882d281ed676fe5b863569520e54a7d5c0 diff --git a/tests/resources/reftable/typechanges/.gitted/modules/d/refs/remotes/origin/HEAD b/tests/resources/reftable/typechanges/.gitted/modules/d/refs/remotes/origin/HEAD new file mode 100644 index 000000000..6efe28fff --- /dev/null +++ b/tests/resources/reftable/typechanges/.gitted/modules/d/refs/remotes/origin/HEAD @@ -0,0 +1 @@ +ref: refs/remotes/origin/master diff --git a/tests/resources/reftable/typechanges/.gitted/modules/e/HEAD b/tests/resources/reftable/typechanges/.gitted/modules/e/HEAD new file mode 100644 index 000000000..cb089cd89 --- /dev/null +++ b/tests/resources/reftable/typechanges/.gitted/modules/e/HEAD @@ -0,0 +1 @@ +ref: refs/heads/master diff --git a/tests/resources/reftable/typechanges/.gitted/modules/e/config b/tests/resources/reftable/typechanges/.gitted/modules/e/config new file mode 100644 index 000000000..89b3b9b4f --- /dev/null +++ b/tests/resources/reftable/typechanges/.gitted/modules/e/config @@ -0,0 +1,13 @@ +[core] + repositoryformatversion = 0 + filemode = true + bare = false + logallrefupdates = true + worktree = ../../../e + ignorecase = true +[remote "origin"] + fetch = +refs/heads/*:refs/remotes/origin/* + url = /Users/rb/src/libgit2/tests-clar/resources/submod2_target/.git +[branch "master"] + remote = origin + merge = refs/heads/master diff --git a/tests/resources/reftable/typechanges/.gitted/modules/e/description b/tests/resources/reftable/typechanges/.gitted/modules/e/description new file mode 100644 index 000000000..498b267a8 --- /dev/null +++ b/tests/resources/reftable/typechanges/.gitted/modules/e/description @@ -0,0 +1 @@ +Unnamed repository; edit this file 'description' to name the repository. diff --git a/tests/resources/reftable/typechanges/.gitted/modules/e/index b/tests/resources/reftable/typechanges/.gitted/modules/e/index new file mode 100644 index 000000000..cd6e2da6c Binary files /dev/null and b/tests/resources/reftable/typechanges/.gitted/modules/e/index differ diff --git a/tests/resources/reftable/typechanges/.gitted/modules/e/info/exclude b/tests/resources/reftable/typechanges/.gitted/modules/e/info/exclude new file mode 100644 index 000000000..a5196d1be --- /dev/null +++ b/tests/resources/reftable/typechanges/.gitted/modules/e/info/exclude @@ -0,0 +1,6 @@ +# git ls-files --others --exclude-from=.git/info/exclude +# Lines that start with '#' are comments. +# For a project mostly in C, the following would be a good set of +# exclude patterns (uncomment them if you want to use them): +# *.[oa] +# *~ diff --git a/tests/resources/reftable/typechanges/.gitted/modules/e/objects/06/362fe2fdb7010d0e447b4fb450d405420479a1 b/tests/resources/reftable/typechanges/.gitted/modules/e/objects/06/362fe2fdb7010d0e447b4fb450d405420479a1 new file mode 100644 index 000000000..f4b7094c5 Binary files /dev/null and b/tests/resources/reftable/typechanges/.gitted/modules/e/objects/06/362fe2fdb7010d0e447b4fb450d405420479a1 differ diff --git a/tests/resources/reftable/typechanges/.gitted/modules/e/objects/0e/6a3ca48bd47cfe67681acf39aa0b10a0b92484 b/tests/resources/reftable/typechanges/.gitted/modules/e/objects/0e/6a3ca48bd47cfe67681acf39aa0b10a0b92484 new file mode 100644 index 000000000..56c845e49 Binary files /dev/null and b/tests/resources/reftable/typechanges/.gitted/modules/e/objects/0e/6a3ca48bd47cfe67681acf39aa0b10a0b92484 differ diff --git a/tests/resources/reftable/typechanges/.gitted/modules/e/objects/17/d0ece6e96460a06592d9d9d000de37ba4232c5 b/tests/resources/reftable/typechanges/.gitted/modules/e/objects/17/d0ece6e96460a06592d9d9d000de37ba4232c5 new file mode 100644 index 000000000..bd179b5f5 Binary files /dev/null and b/tests/resources/reftable/typechanges/.gitted/modules/e/objects/17/d0ece6e96460a06592d9d9d000de37ba4232c5 differ diff --git a/tests/resources/reftable/typechanges/.gitted/modules/e/objects/41/bd4bc3df978de695f67ace64c560913da11653 b/tests/resources/reftable/typechanges/.gitted/modules/e/objects/41/bd4bc3df978de695f67ace64c560913da11653 new file mode 100644 index 000000000..ccf49bd15 Binary files /dev/null and b/tests/resources/reftable/typechanges/.gitted/modules/e/objects/41/bd4bc3df978de695f67ace64c560913da11653 differ diff --git a/tests/resources/reftable/typechanges/.gitted/modules/e/objects/48/0095882d281ed676fe5b863569520e54a7d5c0 b/tests/resources/reftable/typechanges/.gitted/modules/e/objects/48/0095882d281ed676fe5b863569520e54a7d5c0 new file mode 100644 index 000000000..53029069a Binary files /dev/null and b/tests/resources/reftable/typechanges/.gitted/modules/e/objects/48/0095882d281ed676fe5b863569520e54a7d5c0 differ diff --git a/tests/resources/reftable/typechanges/.gitted/modules/e/objects/5e/4963595a9774b90524d35a807169049de8ccad b/tests/resources/reftable/typechanges/.gitted/modules/e/objects/5e/4963595a9774b90524d35a807169049de8ccad new file mode 100644 index 000000000..38c791eba Binary files /dev/null and b/tests/resources/reftable/typechanges/.gitted/modules/e/objects/5e/4963595a9774b90524d35a807169049de8ccad differ diff --git a/tests/resources/reftable/typechanges/.gitted/modules/e/objects/6b/31c659545507c381e9cd34ec508f16c04e149e b/tests/resources/reftable/typechanges/.gitted/modules/e/objects/6b/31c659545507c381e9cd34ec508f16c04e149e new file mode 100644 index 000000000..a26d29993 --- /dev/null +++ b/tests/resources/reftable/typechanges/.gitted/modules/e/objects/6b/31c659545507c381e9cd34ec508f16c04e149e @@ -0,0 +1,2 @@ +xQ +!Evoy*_@g#hOh^9wSòf1*[Ic Ԥpk Α\S߇l@.^QpF(:D5zr~ en8 \ No newline at end of file diff --git a/tests/resources/reftable/typechanges/.gitted/modules/e/objects/73/ba924a80437097795ae839e66e187c55d3babf b/tests/resources/reftable/typechanges/.gitted/modules/e/objects/73/ba924a80437097795ae839e66e187c55d3babf new file mode 100644 index 000000000..83d1ba481 Binary files /dev/null and b/tests/resources/reftable/typechanges/.gitted/modules/e/objects/73/ba924a80437097795ae839e66e187c55d3babf differ diff --git a/tests/resources/reftable/typechanges/.gitted/modules/e/objects/78/0d7397f5e8f8f477fb55b7af3accc2154b2d4a b/tests/resources/reftable/typechanges/.gitted/modules/e/objects/78/0d7397f5e8f8f477fb55b7af3accc2154b2d4a new file mode 100644 index 000000000..6d27af8a8 --- /dev/null +++ b/tests/resources/reftable/typechanges/.gitted/modules/e/objects/78/0d7397f5e8f8f477fb55b7af3accc2154b2d4a @@ -0,0 +1,2 @@ +x-10 Fa0p(N-ӡғq]>ks*? |m“i@mV'`).-1 x +uxt(+ \ No newline at end of file diff --git a/tests/resources/reftable/typechanges/.gitted/modules/e/objects/78/9efbdadaa4a582778d4584385495559ea0994b b/tests/resources/reftable/typechanges/.gitted/modules/e/objects/78/9efbdadaa4a582778d4584385495559ea0994b new file mode 100644 index 000000000..17458840b --- /dev/null +++ b/tests/resources/reftable/typechanges/.gitted/modules/e/objects/78/9efbdadaa4a582778d4584385495559ea0994b @@ -0,0 +1,2 @@ +x 0 )?= NlOkj8&r +qJW7B<fK8#Q1C-"e̫>'@ \ No newline at end of file diff --git a/tests/resources/reftable/typechanges/.gitted/modules/e/objects/88/34b635dd468a83cb012f6feace968c1c9f5d6e b/tests/resources/reftable/typechanges/.gitted/modules/e/objects/88/34b635dd468a83cb012f6feace968c1c9f5d6e new file mode 100644 index 000000000..83cc29fb1 Binary files /dev/null and b/tests/resources/reftable/typechanges/.gitted/modules/e/objects/88/34b635dd468a83cb012f6feace968c1c9f5d6e differ diff --git a/tests/resources/reftable/typechanges/.gitted/modules/e/objects/d0/5f2cd5cc77addf68ed6f50d622c9a4f732e6c5 b/tests/resources/reftable/typechanges/.gitted/modules/e/objects/d0/5f2cd5cc77addf68ed6f50d622c9a4f732e6c5 new file mode 100644 index 000000000..55bda40ef Binary files /dev/null and b/tests/resources/reftable/typechanges/.gitted/modules/e/objects/d0/5f2cd5cc77addf68ed6f50d622c9a4f732e6c5 differ diff --git a/tests/resources/reftable/typechanges/.gitted/modules/e/packed-refs b/tests/resources/reftable/typechanges/.gitted/modules/e/packed-refs new file mode 100644 index 000000000..5a4ebc47c --- /dev/null +++ b/tests/resources/reftable/typechanges/.gitted/modules/e/packed-refs @@ -0,0 +1,2 @@ +# pack-refs with: peeled +480095882d281ed676fe5b863569520e54a7d5c0 refs/remotes/origin/master diff --git a/tests/resources/reftable/typechanges/.gitted/modules/e/refs/heads/master b/tests/resources/reftable/typechanges/.gitted/modules/e/refs/heads/master new file mode 100644 index 000000000..e12c44d7a --- /dev/null +++ b/tests/resources/reftable/typechanges/.gitted/modules/e/refs/heads/master @@ -0,0 +1 @@ +480095882d281ed676fe5b863569520e54a7d5c0 diff --git a/tests/resources/reftable/typechanges/.gitted/modules/e/refs/remotes/origin/HEAD b/tests/resources/reftable/typechanges/.gitted/modules/e/refs/remotes/origin/HEAD new file mode 100644 index 000000000..6efe28fff --- /dev/null +++ b/tests/resources/reftable/typechanges/.gitted/modules/e/refs/remotes/origin/HEAD @@ -0,0 +1 @@ +ref: refs/remotes/origin/master diff --git a/tests/resources/reftable/typechanges/.gitted/objects/0d/78578795b7ca49fd8df6c4b6d27c5c02d991d8 b/tests/resources/reftable/typechanges/.gitted/objects/0d/78578795b7ca49fd8df6c4b6d27c5c02d991d8 new file mode 100644 index 000000000..f2d02f4f7 Binary files /dev/null and b/tests/resources/reftable/typechanges/.gitted/objects/0d/78578795b7ca49fd8df6c4b6d27c5c02d991d8 differ diff --git a/tests/resources/reftable/typechanges/.gitted/objects/0e/7ed140b514b8cae23254cb8656fe1674403aff b/tests/resources/reftable/typechanges/.gitted/objects/0e/7ed140b514b8cae23254cb8656fe1674403aff new file mode 100644 index 000000000..527964c92 Binary files /dev/null and b/tests/resources/reftable/typechanges/.gitted/objects/0e/7ed140b514b8cae23254cb8656fe1674403aff differ diff --git a/tests/resources/reftable/typechanges/.gitted/objects/0f/f461da9689266f482d8f6654a4400b4e33c586 b/tests/resources/reftable/typechanges/.gitted/objects/0f/f461da9689266f482d8f6654a4400b4e33c586 new file mode 100644 index 000000000..2694e4fa0 Binary files /dev/null and b/tests/resources/reftable/typechanges/.gitted/objects/0f/f461da9689266f482d8f6654a4400b4e33c586 differ diff --git a/tests/resources/reftable/typechanges/.gitted/objects/18/aa7e45bbe4c3cc24a0b079696c59d36675af97 b/tests/resources/reftable/typechanges/.gitted/objects/18/aa7e45bbe4c3cc24a0b079696c59d36675af97 new file mode 100644 index 000000000..032a960b4 Binary files /dev/null and b/tests/resources/reftable/typechanges/.gitted/objects/18/aa7e45bbe4c3cc24a0b079696c59d36675af97 differ diff --git a/tests/resources/reftable/typechanges/.gitted/objects/1b/63caae4a5ca96f78e8dfefc376c6a39a142475 b/tests/resources/reftable/typechanges/.gitted/objects/1b/63caae4a5ca96f78e8dfefc376c6a39a142475 new file mode 100644 index 000000000..d32622e67 Binary files /dev/null and b/tests/resources/reftable/typechanges/.gitted/objects/1b/63caae4a5ca96f78e8dfefc376c6a39a142475 differ diff --git a/tests/resources/reftable/typechanges/.gitted/objects/1e/abe82aa3b2365a394f6108f24435df6e193d02 b/tests/resources/reftable/typechanges/.gitted/objects/1e/abe82aa3b2365a394f6108f24435df6e193d02 new file mode 100644 index 000000000..42d5f92f3 Binary files /dev/null and b/tests/resources/reftable/typechanges/.gitted/objects/1e/abe82aa3b2365a394f6108f24435df6e193d02 differ diff --git a/tests/resources/reftable/typechanges/.gitted/objects/42/061c01a1c70097d1e4579f29a5adf40abdec95 b/tests/resources/reftable/typechanges/.gitted/objects/42/061c01a1c70097d1e4579f29a5adf40abdec95 new file mode 100644 index 000000000..0a8f32e15 Binary files /dev/null and b/tests/resources/reftable/typechanges/.gitted/objects/42/061c01a1c70097d1e4579f29a5adf40abdec95 differ diff --git a/tests/resources/reftable/typechanges/.gitted/objects/46/2838cee476a87e7cff32196b66fa18ed756592 b/tests/resources/reftable/typechanges/.gitted/objects/46/2838cee476a87e7cff32196b66fa18ed756592 new file mode 100644 index 000000000..52af51f74 Binary files /dev/null and b/tests/resources/reftable/typechanges/.gitted/objects/46/2838cee476a87e7cff32196b66fa18ed756592 differ diff --git a/tests/resources/reftable/typechanges/.gitted/objects/63/499e4ea8e096b831515ceb1d5a7593e4d87ae5 b/tests/resources/reftable/typechanges/.gitted/objects/63/499e4ea8e096b831515ceb1d5a7593e4d87ae5 new file mode 100644 index 000000000..afafa89f4 Binary files /dev/null and b/tests/resources/reftable/typechanges/.gitted/objects/63/499e4ea8e096b831515ceb1d5a7593e4d87ae5 differ diff --git a/tests/resources/reftable/typechanges/.gitted/objects/68/1af94e10eaf262f3ab7cb9b8fd5f4158ba4d3e b/tests/resources/reftable/typechanges/.gitted/objects/68/1af94e10eaf262f3ab7cb9b8fd5f4158ba4d3e new file mode 100644 index 000000000..9e518fc28 Binary files /dev/null and b/tests/resources/reftable/typechanges/.gitted/objects/68/1af94e10eaf262f3ab7cb9b8fd5f4158ba4d3e differ diff --git a/tests/resources/reftable/typechanges/.gitted/objects/6a/9008602b811e69a9b7a2d83496f39a794fdeeb b/tests/resources/reftable/typechanges/.gitted/objects/6a/9008602b811e69a9b7a2d83496f39a794fdeeb new file mode 100644 index 000000000..a245727a1 Binary files /dev/null and b/tests/resources/reftable/typechanges/.gitted/objects/6a/9008602b811e69a9b7a2d83496f39a794fdeeb differ diff --git a/tests/resources/reftable/typechanges/.gitted/objects/6e/ae26c90e8ccc4d16208972119c40635489c6f0 b/tests/resources/reftable/typechanges/.gitted/objects/6e/ae26c90e8ccc4d16208972119c40635489c6f0 new file mode 100644 index 000000000..ea35cd311 Binary files /dev/null and b/tests/resources/reftable/typechanges/.gitted/objects/6e/ae26c90e8ccc4d16208972119c40635489c6f0 differ diff --git a/tests/resources/reftable/typechanges/.gitted/objects/6f/39eabbb8a7541515e0d35971078bccb502e7e0 b/tests/resources/reftable/typechanges/.gitted/objects/6f/39eabbb8a7541515e0d35971078bccb502e7e0 new file mode 100644 index 000000000..c54817598 Binary files /dev/null and b/tests/resources/reftable/typechanges/.gitted/objects/6f/39eabbb8a7541515e0d35971078bccb502e7e0 differ diff --git a/tests/resources/reftable/typechanges/.gitted/objects/71/54d3083461536dfc71ad5542f3e65e723a06c4 b/tests/resources/reftable/typechanges/.gitted/objects/71/54d3083461536dfc71ad5542f3e65e723a06c4 new file mode 100644 index 000000000..9fdd8f245 Binary files /dev/null and b/tests/resources/reftable/typechanges/.gitted/objects/71/54d3083461536dfc71ad5542f3e65e723a06c4 differ diff --git a/tests/resources/reftable/typechanges/.gitted/objects/75/56c1d893a4c0ca85ac8ac51de47ff399758729 b/tests/resources/reftable/typechanges/.gitted/objects/75/56c1d893a4c0ca85ac8ac51de47ff399758729 new file mode 100644 index 000000000..d43630f44 Binary files /dev/null and b/tests/resources/reftable/typechanges/.gitted/objects/75/56c1d893a4c0ca85ac8ac51de47ff399758729 differ diff --git a/tests/resources/reftable/typechanges/.gitted/objects/76/fef844064c26d5e06c2508240dae661e7231b2 b/tests/resources/reftable/typechanges/.gitted/objects/76/fef844064c26d5e06c2508240dae661e7231b2 new file mode 100644 index 000000000..355ce4b5b Binary files /dev/null and b/tests/resources/reftable/typechanges/.gitted/objects/76/fef844064c26d5e06c2508240dae661e7231b2 differ diff --git a/tests/resources/reftable/typechanges/.gitted/objects/79/b9f23e85f55ea36a472a902e875bc1121a94cb b/tests/resources/reftable/typechanges/.gitted/objects/79/b9f23e85f55ea36a472a902e875bc1121a94cb new file mode 100644 index 000000000..2b07ad256 --- /dev/null +++ b/tests/resources/reftable/typechanges/.gitted/objects/79/b9f23e85f55ea36a472a902e875bc1121a94cb @@ -0,0 +1,2 @@ +xA E]sfJbq `I@ +yH;ZeBr6LPY%8&v4Jm֢^*qpJµ;Z Ơ3ZD1)"%%38_ \ No newline at end of file diff --git a/tests/resources/reftable/typechanges/.gitted/objects/85/28da0ea65eacf1f74f9ed6696adbac547963ad b/tests/resources/reftable/typechanges/.gitted/objects/85/28da0ea65eacf1f74f9ed6696adbac547963ad new file mode 100644 index 000000000..6d2da6c93 Binary files /dev/null and b/tests/resources/reftable/typechanges/.gitted/objects/85/28da0ea65eacf1f74f9ed6696adbac547963ad differ diff --git a/tests/resources/reftable/typechanges/.gitted/objects/8b/3726b365824ad5a07c537247f4bc73ed7d37ea b/tests/resources/reftable/typechanges/.gitted/objects/8b/3726b365824ad5a07c537247f4bc73ed7d37ea new file mode 100644 index 000000000..3dc333bc6 Binary files /dev/null and b/tests/resources/reftable/typechanges/.gitted/objects/8b/3726b365824ad5a07c537247f4bc73ed7d37ea differ diff --git a/tests/resources/reftable/typechanges/.gitted/objects/93/3e28c1c8a68838a763d250bdf0b2c6068289c3 b/tests/resources/reftable/typechanges/.gitted/objects/93/3e28c1c8a68838a763d250bdf0b2c6068289c3 new file mode 100644 index 000000000..02ad0e97a Binary files /dev/null and b/tests/resources/reftable/typechanges/.gitted/objects/93/3e28c1c8a68838a763d250bdf0b2c6068289c3 differ diff --git a/tests/resources/reftable/typechanges/.gitted/objects/96/2710fe5b4e453e9e827945b3487c525968ec4a b/tests/resources/reftable/typechanges/.gitted/objects/96/2710fe5b4e453e9e827945b3487c525968ec4a new file mode 100644 index 000000000..d06b06a52 Binary files /dev/null and b/tests/resources/reftable/typechanges/.gitted/objects/96/2710fe5b4e453e9e827945b3487c525968ec4a differ diff --git a/tests/resources/reftable/typechanges/.gitted/objects/96/6cf1b3598e195b31b2cde3784f9a19f0728a6f b/tests/resources/reftable/typechanges/.gitted/objects/96/6cf1b3598e195b31b2cde3784f9a19f0728a6f new file mode 100644 index 000000000..5f9ffd4ed Binary files /dev/null and b/tests/resources/reftable/typechanges/.gitted/objects/96/6cf1b3598e195b31b2cde3784f9a19f0728a6f differ diff --git a/tests/resources/reftable/typechanges/.gitted/objects/99/e8bab9ece009f0fba7eb41f850f4c12bedb9b7 b/tests/resources/reftable/typechanges/.gitted/objects/99/e8bab9ece009f0fba7eb41f850f4c12bedb9b7 new file mode 100644 index 000000000..ac17defac Binary files /dev/null and b/tests/resources/reftable/typechanges/.gitted/objects/99/e8bab9ece009f0fba7eb41f850f4c12bedb9b7 differ diff --git a/tests/resources/reftable/typechanges/.gitted/objects/9b/19edf33a03a0c59cdfc113bfa5c06179bf9b1a b/tests/resources/reftable/typechanges/.gitted/objects/9b/19edf33a03a0c59cdfc113bfa5c06179bf9b1a new file mode 100644 index 000000000..7ab83aefe --- /dev/null +++ b/tests/resources/reftable/typechanges/.gitted/objects/9b/19edf33a03a0c59cdfc113bfa5c06179bf9b1a @@ -0,0 +1,5 @@ +xI +1E]LT AJЃ7WpyӶ,ZѩUf cXcR C43Y2"NN:HɈo6,sjf#kG +cys +MGm2B +.K)k֑w8CC \ No newline at end of file diff --git a/tests/resources/reftable/typechanges/.gitted/objects/9b/db75b73836a99e3dbeea640a81de81031fdc29 b/tests/resources/reftable/typechanges/.gitted/objects/9b/db75b73836a99e3dbeea640a81de81031fdc29 new file mode 100644 index 000000000..aed4d8165 Binary files /dev/null and b/tests/resources/reftable/typechanges/.gitted/objects/9b/db75b73836a99e3dbeea640a81de81031fdc29 differ diff --git a/tests/resources/reftable/typechanges/.gitted/objects/9d/0235c7a7edc0889a18f97a42ee6db9fe688447 b/tests/resources/reftable/typechanges/.gitted/objects/9d/0235c7a7edc0889a18f97a42ee6db9fe688447 new file mode 100644 index 000000000..3e02a41b2 Binary files /dev/null and b/tests/resources/reftable/typechanges/.gitted/objects/9d/0235c7a7edc0889a18f97a42ee6db9fe688447 differ diff --git a/tests/resources/reftable/typechanges/.gitted/objects/9e/ffc457877f109b2a4319e14bee613a15f2a00d b/tests/resources/reftable/typechanges/.gitted/objects/9e/ffc457877f109b2a4319e14bee613a15f2a00d new file mode 100644 index 000000000..fb24100fc Binary files /dev/null and b/tests/resources/reftable/typechanges/.gitted/objects/9e/ffc457877f109b2a4319e14bee613a15f2a00d differ diff --git a/tests/resources/reftable/typechanges/.gitted/objects/a0/a9bad6f6f40325198f938a0e3ae981622d7707 b/tests/resources/reftable/typechanges/.gitted/objects/a0/a9bad6f6f40325198f938a0e3ae981622d7707 new file mode 100644 index 000000000..b6b7db785 Binary files /dev/null and b/tests/resources/reftable/typechanges/.gitted/objects/a0/a9bad6f6f40325198f938a0e3ae981622d7707 differ diff --git a/tests/resources/reftable/typechanges/.gitted/objects/b1/977dc4e573b812d4619754c98138c56999dc0d b/tests/resources/reftable/typechanges/.gitted/objects/b1/977dc4e573b812d4619754c98138c56999dc0d new file mode 100644 index 000000000..e1334057c Binary files /dev/null and b/tests/resources/reftable/typechanges/.gitted/objects/b1/977dc4e573b812d4619754c98138c56999dc0d differ diff --git a/tests/resources/reftable/typechanges/.gitted/objects/d7/5992dd02391e128dac332dcc78d649dd9ab095 b/tests/resources/reftable/typechanges/.gitted/objects/d7/5992dd02391e128dac332dcc78d649dd9ab095 new file mode 100644 index 000000000..65f1f530f Binary files /dev/null and b/tests/resources/reftable/typechanges/.gitted/objects/d7/5992dd02391e128dac332dcc78d649dd9ab095 differ diff --git a/tests/resources/reftable/typechanges/.gitted/objects/da/e2709d638df52212b1f43ff61797ebfedfcc7c b/tests/resources/reftable/typechanges/.gitted/objects/da/e2709d638df52212b1f43ff61797ebfedfcc7c new file mode 100644 index 000000000..355faa61f Binary files /dev/null and b/tests/resources/reftable/typechanges/.gitted/objects/da/e2709d638df52212b1f43ff61797ebfedfcc7c differ diff --git a/tests/resources/reftable/typechanges/.gitted/objects/e1/152adcb9adf37ec551ada9ba377ab53aec3bad b/tests/resources/reftable/typechanges/.gitted/objects/e1/152adcb9adf37ec551ada9ba377ab53aec3bad new file mode 100644 index 000000000..c68fdcfab Binary files /dev/null and b/tests/resources/reftable/typechanges/.gitted/objects/e1/152adcb9adf37ec551ada9ba377ab53aec3bad differ diff --git a/tests/resources/reftable/typechanges/.gitted/objects/e4/ed436a9eb0f198cda722886a5f8d6d6c836b7b b/tests/resources/reftable/typechanges/.gitted/objects/e4/ed436a9eb0f198cda722886a5f8d6d6c836b7b new file mode 100644 index 000000000..c9229ba25 Binary files /dev/null and b/tests/resources/reftable/typechanges/.gitted/objects/e4/ed436a9eb0f198cda722886a5f8d6d6c836b7b differ diff --git a/tests/resources/reftable/typechanges/.gitted/objects/e6/9de29bb2d1d6434b8b29ae775ad8c2e48c5391 b/tests/resources/reftable/typechanges/.gitted/objects/e6/9de29bb2d1d6434b8b29ae775ad8c2e48c5391 new file mode 100644 index 000000000..711223894 Binary files /dev/null and b/tests/resources/reftable/typechanges/.gitted/objects/e6/9de29bb2d1d6434b8b29ae775ad8c2e48c5391 differ diff --git a/tests/resources/reftable/typechanges/.gitted/objects/f2/0b79342712e0b2315647cd8227a573fd3bc46e b/tests/resources/reftable/typechanges/.gitted/objects/f2/0b79342712e0b2315647cd8227a573fd3bc46e new file mode 100644 index 000000000..3962ba6b4 Binary files /dev/null and b/tests/resources/reftable/typechanges/.gitted/objects/f2/0b79342712e0b2315647cd8227a573fd3bc46e differ diff --git a/tests/resources/reftable/typechanges/.gitted/objects/fd/e0147e3b59f381635a3b016e3fe6dacb70779d b/tests/resources/reftable/typechanges/.gitted/objects/fd/e0147e3b59f381635a3b016e3fe6dacb70779d new file mode 100644 index 000000000..e3663da9f Binary files /dev/null and b/tests/resources/reftable/typechanges/.gitted/objects/fd/e0147e3b59f381635a3b016e3fe6dacb70779d differ diff --git a/tests/resources/reftable/typechanges/.gitted/refs/heads b/tests/resources/reftable/typechanges/.gitted/refs/heads new file mode 100644 index 000000000..3e639a56a --- /dev/null +++ b/tests/resources/reftable/typechanges/.gitted/refs/heads @@ -0,0 +1 @@ +this repository uses the reftable format diff --git a/tests/resources/reftable/typechanges/.gitted/reftable/0x000000000001-0x000000000001-f9f9b9bb.ref b/tests/resources/reftable/typechanges/.gitted/reftable/0x000000000001-0x000000000001-f9f9b9bb.ref new file mode 100644 index 000000000..9a5667750 Binary files /dev/null and b/tests/resources/reftable/typechanges/.gitted/reftable/0x000000000001-0x000000000001-f9f9b9bb.ref differ diff --git a/tests/resources/reftable/typechanges/.gitted/reftable/tables.list b/tests/resources/reftable/typechanges/.gitted/reftable/tables.list new file mode 100644 index 000000000..7fbc79e07 --- /dev/null +++ b/tests/resources/reftable/typechanges/.gitted/reftable/tables.list @@ -0,0 +1 @@ +0x000000000001-0x000000000001-f9f9b9bb.ref diff --git a/tests/resources/reftable/typechanges/README.md b/tests/resources/reftable/typechanges/README.md new file mode 100644 index 000000000..1f5a95a9f --- /dev/null +++ b/tests/resources/reftable/typechanges/README.md @@ -0,0 +1,43 @@ +This is a test repo for libgit2 where tree entries have type changes + +Types +----- + +The key types that could be found in tree entries are: + +1. GIT_FILEMODE_NEW = 0000000 (i.e. file does not exist) +2. GIT_FILEMODE_TREE = 0040000 +3. GIT_FILEMODE_BLOB = 0100644 +4. GIT_FILEMODE_BLOB_EXECUTABLE = 0100755 +5. GIT_FILEMODE_LINK = 0120000 +6. GIT_FILEMODE_COMMIT = 0160000 + +I will try to have every type of transition somewhere in the history +of this repo. + +Commits +------- + +* `a(1--1) b(1--1) c(1--1) d(1--1) e(1--1)` + **Initial commit**
+ `79b9f23e85f55ea36a472a902e875bc1121a94cb` +* `a(1->2) b(1->3) c(1->4) d(1->5) e(1->6)` + **Create content**
+ `9bdb75b73836a99e3dbeea640a81de81031fdc29` +* `a(2->3) b(3->4) c(4->5) d(5->6) e(6->2)` + **Changes #1**
+ `0e7ed140b514b8cae23254cb8656fe1674403aff` +* `a(3->5) b(4->6) c(5->2) d(6->3) e(2->4)` + **Changes #2**
+ `9d0235c7a7edc0889a18f97a42ee6db9fe688447` +* `a(5->3) b(6->4) c(2->5) d(3->6) e(4->2)` + **Changes #3**
+ `9b19edf33a03a0c59cdfc113bfa5c06179bf9b1a` +* `a(3->2) b(4->3) c(5->4) d(6->5) e(2->6)` + **Changes #4**
+ `1b63caae4a5ca96f78e8dfefc376c6a39a142475`
+ Matches **Changes #1** except README.md +* `a(2->1) b(3->1) c(4->1) d(5->1) e(6->1)` + **Changes #5**
+ `6eae26c90e8ccc4d16208972119c40635489c6f0`
+ Matches **Initial commit** except README.md and .gitmodules diff --git a/tests/resources/reftable/typechanges/gitmodules b/tests/resources/reftable/typechanges/gitmodules new file mode 100644 index 000000000..e69de29bb diff --git a/tests/resources/reftable/unsymlinked.git/HEAD b/tests/resources/reftable/unsymlinked.git/HEAD new file mode 100644 index 000000000..fe6d7e5fa --- /dev/null +++ b/tests/resources/reftable/unsymlinked.git/HEAD @@ -0,0 +1 @@ +ref: refs/heads/.invalid diff --git a/tests/resources/reftable/unsymlinked.git/config b/tests/resources/reftable/unsymlinked.git/config new file mode 100644 index 000000000..0c3a01063 --- /dev/null +++ b/tests/resources/reftable/unsymlinked.git/config @@ -0,0 +1,8 @@ +[core] + bare = true + repositoryformatversion = 1 + filemode = false + logallrefupdates = true + ignorecase = true +[extensions] + refstorage = reftable diff --git a/tests/resources/reftable/unsymlinked.git/description b/tests/resources/reftable/unsymlinked.git/description new file mode 100644 index 000000000..498b267a8 --- /dev/null +++ b/tests/resources/reftable/unsymlinked.git/description @@ -0,0 +1 @@ +Unnamed repository; edit this file 'description' to name the repository. diff --git a/tests/resources/reftable/unsymlinked.git/info/exclude b/tests/resources/reftable/unsymlinked.git/info/exclude new file mode 100644 index 000000000..6d05881d3 --- /dev/null +++ b/tests/resources/reftable/unsymlinked.git/info/exclude @@ -0,0 +1,2 @@ +# File patterns to ignore; see `git help ignore` for more information. +# Lines that start with '#' are comments. diff --git a/tests/resources/reftable/unsymlinked.git/objects/08/8b64704e0d6b8bd061dea879418cb5442a3fbf b/tests/resources/reftable/unsymlinked.git/objects/08/8b64704e0d6b8bd061dea879418cb5442a3fbf new file mode 100644 index 000000000..953262fa9 Binary files /dev/null and b/tests/resources/reftable/unsymlinked.git/objects/08/8b64704e0d6b8bd061dea879418cb5442a3fbf differ diff --git a/tests/resources/reftable/unsymlinked.git/objects/13/a5e939bca25940c069fd2169d993dba328e30b b/tests/resources/reftable/unsymlinked.git/objects/13/a5e939bca25940c069fd2169d993dba328e30b new file mode 100644 index 000000000..91ec8fa5e Binary files /dev/null and b/tests/resources/reftable/unsymlinked.git/objects/13/a5e939bca25940c069fd2169d993dba328e30b differ diff --git a/tests/resources/reftable/unsymlinked.git/objects/19/bf568e59e3a0b363cafb4106226e62d4a4c41c b/tests/resources/reftable/unsymlinked.git/objects/19/bf568e59e3a0b363cafb4106226e62d4a4c41c new file mode 100644 index 000000000..94afd01e8 Binary files /dev/null and b/tests/resources/reftable/unsymlinked.git/objects/19/bf568e59e3a0b363cafb4106226e62d4a4c41c differ diff --git a/tests/resources/reftable/unsymlinked.git/objects/58/1fadd35b4cf320d102a152f918729011604773 b/tests/resources/reftable/unsymlinked.git/objects/58/1fadd35b4cf320d102a152f918729011604773 new file mode 100644 index 000000000..5b33d027c Binary files /dev/null and b/tests/resources/reftable/unsymlinked.git/objects/58/1fadd35b4cf320d102a152f918729011604773 differ diff --git a/tests/resources/reftable/unsymlinked.git/objects/5c/87b6791e8b13da658a14d1ef7e09b5dc3bac8c b/tests/resources/reftable/unsymlinked.git/objects/5c/87b6791e8b13da658a14d1ef7e09b5dc3bac8c new file mode 100644 index 000000000..67eb14930 Binary files /dev/null and b/tests/resources/reftable/unsymlinked.git/objects/5c/87b6791e8b13da658a14d1ef7e09b5dc3bac8c differ diff --git a/tests/resources/reftable/unsymlinked.git/objects/6f/e5f5398af85fb3de8a6aba0339b6d3bfa26a27 b/tests/resources/reftable/unsymlinked.git/objects/6f/e5f5398af85fb3de8a6aba0339b6d3bfa26a27 new file mode 100644 index 000000000..c1ea0de75 Binary files /dev/null and b/tests/resources/reftable/unsymlinked.git/objects/6f/e5f5398af85fb3de8a6aba0339b6d3bfa26a27 differ diff --git a/tests/resources/reftable/unsymlinked.git/objects/7f/ccd75616ec188b8f1b23d67506a334cc34a49d b/tests/resources/reftable/unsymlinked.git/objects/7f/ccd75616ec188b8f1b23d67506a334cc34a49d new file mode 100644 index 000000000..028505563 Binary files /dev/null and b/tests/resources/reftable/unsymlinked.git/objects/7f/ccd75616ec188b8f1b23d67506a334cc34a49d differ diff --git a/tests/resources/reftable/unsymlinked.git/objects/80/6999882bf91d24241e4077906b9017605eb1f3 b/tests/resources/reftable/unsymlinked.git/objects/80/6999882bf91d24241e4077906b9017605eb1f3 new file mode 100644 index 000000000..e866a75a6 Binary files /dev/null and b/tests/resources/reftable/unsymlinked.git/objects/80/6999882bf91d24241e4077906b9017605eb1f3 differ diff --git a/tests/resources/reftable/unsymlinked.git/objects/83/7d176303c5005505ec1e4a30231c40930c0230 b/tests/resources/reftable/unsymlinked.git/objects/83/7d176303c5005505ec1e4a30231c40930c0230 new file mode 100644 index 000000000..189ab044d Binary files /dev/null and b/tests/resources/reftable/unsymlinked.git/objects/83/7d176303c5005505ec1e4a30231c40930c0230 differ diff --git a/tests/resources/reftable/unsymlinked.git/objects/a8/595ccca04f40818ae0155c8f9c77a230e597b6 b/tests/resources/reftable/unsymlinked.git/objects/a8/595ccca04f40818ae0155c8f9c77a230e597b6 new file mode 100644 index 000000000..a2ef6be45 --- /dev/null +++ b/tests/resources/reftable/unsymlinked.git/objects/a8/595ccca04f40818ae0155c8f9c77a230e597b6 @@ -0,0 +1,2 @@ +x[ +0E*_y݀{4ShZ))| N[ks=KߙŚ[Q"4&&M*i/޴!1S*AGt)-'Um7O ccչ=z崵;(PY+*Dq^E!*/0}Z?<P慥Jp \ No newline at end of file diff --git a/tests/resources/reftable/unsymlinked.git/objects/cf/8f1cf5cce859c438d6cc067284cb5e161206e7 b/tests/resources/reftable/unsymlinked.git/objects/cf/8f1cf5cce859c438d6cc067284cb5e161206e7 new file mode 100644 index 000000000..ec274cb1d Binary files /dev/null and b/tests/resources/reftable/unsymlinked.git/objects/cf/8f1cf5cce859c438d6cc067284cb5e161206e7 differ diff --git a/tests/resources/reftable/unsymlinked.git/objects/d5/278d05c8607ec420bfee4cf219fbc0eeebfd6a b/tests/resources/reftable/unsymlinked.git/objects/d5/278d05c8607ec420bfee4cf219fbc0eeebfd6a new file mode 100644 index 000000000..c1b6a5101 Binary files /dev/null and b/tests/resources/reftable/unsymlinked.git/objects/d5/278d05c8607ec420bfee4cf219fbc0eeebfd6a differ diff --git a/tests/resources/reftable/unsymlinked.git/objects/f4/e16fb76536591a41454194058d048d8e4dd2e9 b/tests/resources/reftable/unsymlinked.git/objects/f4/e16fb76536591a41454194058d048d8e4dd2e9 new file mode 100644 index 000000000..ad751adbe Binary files /dev/null and b/tests/resources/reftable/unsymlinked.git/objects/f4/e16fb76536591a41454194058d048d8e4dd2e9 differ diff --git a/tests/resources/reftable/unsymlinked.git/objects/f9/e65619d93fdf2673882e0a261c5e93b1a84006 b/tests/resources/reftable/unsymlinked.git/objects/f9/e65619d93fdf2673882e0a261c5e93b1a84006 new file mode 100644 index 000000000..f87cd42fb Binary files /dev/null and b/tests/resources/reftable/unsymlinked.git/objects/f9/e65619d93fdf2673882e0a261c5e93b1a84006 differ diff --git a/tests/resources/reftable/unsymlinked.git/refs/heads b/tests/resources/reftable/unsymlinked.git/refs/heads new file mode 100644 index 000000000..3e639a56a --- /dev/null +++ b/tests/resources/reftable/unsymlinked.git/refs/heads @@ -0,0 +1 @@ +this repository uses the reftable format diff --git a/tests/resources/reftable/unsymlinked.git/reftable/0x000000000001-0x000000000001-bf59c165.ref b/tests/resources/reftable/unsymlinked.git/reftable/0x000000000001-0x000000000001-bf59c165.ref new file mode 100644 index 000000000..aef4950ec Binary files /dev/null and b/tests/resources/reftable/unsymlinked.git/reftable/0x000000000001-0x000000000001-bf59c165.ref differ diff --git a/tests/resources/reftable/unsymlinked.git/reftable/tables.list b/tests/resources/reftable/unsymlinked.git/reftable/tables.list new file mode 100644 index 000000000..003dc5415 --- /dev/null +++ b/tests/resources/reftable/unsymlinked.git/reftable/tables.list @@ -0,0 +1 @@ +0x000000000001-0x000000000001-bf59c165.ref diff --git a/tests/resources/reftable/userdiff/.gitted/HEAD b/tests/resources/reftable/userdiff/.gitted/HEAD new file mode 100644 index 000000000..fe6d7e5fa --- /dev/null +++ b/tests/resources/reftable/userdiff/.gitted/HEAD @@ -0,0 +1 @@ +ref: refs/heads/.invalid diff --git a/tests/resources/reftable/userdiff/.gitted/config b/tests/resources/reftable/userdiff/.gitted/config new file mode 100644 index 000000000..622302e60 --- /dev/null +++ b/tests/resources/reftable/userdiff/.gitted/config @@ -0,0 +1,9 @@ +[core] + repositoryformatversion = 1 + filemode = true + bare = false + logallrefupdates = true + ignorecase = true + precomposeunicode = true +[extensions] + refstorage = reftable diff --git a/tests/resources/reftable/userdiff/.gitted/description b/tests/resources/reftable/userdiff/.gitted/description new file mode 100644 index 000000000..498b267a8 --- /dev/null +++ b/tests/resources/reftable/userdiff/.gitted/description @@ -0,0 +1 @@ +Unnamed repository; edit this file 'description' to name the repository. diff --git a/tests/resources/reftable/userdiff/.gitted/index b/tests/resources/reftable/userdiff/.gitted/index new file mode 100644 index 000000000..548dc7bfd Binary files /dev/null and b/tests/resources/reftable/userdiff/.gitted/index differ diff --git a/tests/resources/reftable/userdiff/.gitted/info/refs b/tests/resources/reftable/userdiff/.gitted/info/refs new file mode 100644 index 000000000..b0743141d --- /dev/null +++ b/tests/resources/reftable/userdiff/.gitted/info/refs @@ -0,0 +1 @@ +60e3f7b244a5305e2c9fa4ef0e897f3b14f3b8dd refs/heads/master diff --git a/tests/resources/reftable/userdiff/.gitted/objects/09/65b377c214bbe5e0d18fcdaf556df7fa7ed7c8 b/tests/resources/reftable/userdiff/.gitted/objects/09/65b377c214bbe5e0d18fcdaf556df7fa7ed7c8 new file mode 100644 index 000000000..cbaf4c1bc Binary files /dev/null and b/tests/resources/reftable/userdiff/.gitted/objects/09/65b377c214bbe5e0d18fcdaf556df7fa7ed7c8 differ diff --git a/tests/resources/reftable/userdiff/.gitted/objects/0c/20ef1409ae1df4d5a76cdbd98d5c33ccdb6bcc b/tests/resources/reftable/userdiff/.gitted/objects/0c/20ef1409ae1df4d5a76cdbd98d5c33ccdb6bcc new file mode 100644 index 000000000..fa149da98 Binary files /dev/null and b/tests/resources/reftable/userdiff/.gitted/objects/0c/20ef1409ae1df4d5a76cdbd98d5c33ccdb6bcc differ diff --git a/tests/resources/reftable/userdiff/.gitted/objects/39/ea75107a09091ba54ff86fcc780b59477e42cd b/tests/resources/reftable/userdiff/.gitted/objects/39/ea75107a09091ba54ff86fcc780b59477e42cd new file mode 100644 index 000000000..748373621 Binary files /dev/null and b/tests/resources/reftable/userdiff/.gitted/objects/39/ea75107a09091ba54ff86fcc780b59477e42cd differ diff --git a/tests/resources/reftable/userdiff/.gitted/objects/3c/c08384deae5957247bc36776ab626cc9e0582b b/tests/resources/reftable/userdiff/.gitted/objects/3c/c08384deae5957247bc36776ab626cc9e0582b new file mode 100644 index 000000000..29b72fbbc Binary files /dev/null and b/tests/resources/reftable/userdiff/.gitted/objects/3c/c08384deae5957247bc36776ab626cc9e0582b differ diff --git a/tests/resources/reftable/userdiff/.gitted/objects/46/8d6f2afc940e14c76347fa9af26e429a3c9044 b/tests/resources/reftable/userdiff/.gitted/objects/46/8d6f2afc940e14c76347fa9af26e429a3c9044 new file mode 100644 index 000000000..5fc839170 Binary files /dev/null and b/tests/resources/reftable/userdiff/.gitted/objects/46/8d6f2afc940e14c76347fa9af26e429a3c9044 differ diff --git a/tests/resources/reftable/userdiff/.gitted/objects/53/917973acfe0111f93c2cfaacf854be245880e8 b/tests/resources/reftable/userdiff/.gitted/objects/53/917973acfe0111f93c2cfaacf854be245880e8 new file mode 100644 index 000000000..debf7e40f Binary files /dev/null and b/tests/resources/reftable/userdiff/.gitted/objects/53/917973acfe0111f93c2cfaacf854be245880e8 differ diff --git a/tests/resources/reftable/userdiff/.gitted/objects/63/1d44e0c72e8cd1b594fa11d7d1ee8a6d67ff67 b/tests/resources/reftable/userdiff/.gitted/objects/63/1d44e0c72e8cd1b594fa11d7d1ee8a6d67ff67 new file mode 100644 index 000000000..e8b884cd5 Binary files /dev/null and b/tests/resources/reftable/userdiff/.gitted/objects/63/1d44e0c72e8cd1b594fa11d7d1ee8a6d67ff67 differ diff --git a/tests/resources/reftable/userdiff/.gitted/objects/f3/be389d351e4bcc6dcc4b5fe22134ef0f63f8bd b/tests/resources/reftable/userdiff/.gitted/objects/f3/be389d351e4bcc6dcc4b5fe22134ef0f63f8bd new file mode 100644 index 000000000..cfbef992d Binary files /dev/null and b/tests/resources/reftable/userdiff/.gitted/objects/f3/be389d351e4bcc6dcc4b5fe22134ef0f63f8bd differ diff --git a/tests/resources/reftable/userdiff/.gitted/objects/info/packs b/tests/resources/reftable/userdiff/.gitted/objects/info/packs new file mode 100644 index 000000000..0c5fc2a30 --- /dev/null +++ b/tests/resources/reftable/userdiff/.gitted/objects/info/packs @@ -0,0 +1,2 @@ +P pack-1652578900ac63564f2a24b9714529821276ceb9.pack + diff --git a/tests/resources/reftable/userdiff/.gitted/objects/pack/pack-1652578900ac63564f2a24b9714529821276ceb9.idx b/tests/resources/reftable/userdiff/.gitted/objects/pack/pack-1652578900ac63564f2a24b9714529821276ceb9.idx new file mode 100644 index 000000000..6f4381cc7 Binary files /dev/null and b/tests/resources/reftable/userdiff/.gitted/objects/pack/pack-1652578900ac63564f2a24b9714529821276ceb9.idx differ diff --git a/tests/resources/reftable/userdiff/.gitted/objects/pack/pack-1652578900ac63564f2a24b9714529821276ceb9.pack b/tests/resources/reftable/userdiff/.gitted/objects/pack/pack-1652578900ac63564f2a24b9714529821276ceb9.pack new file mode 100644 index 000000000..39bd1d8f0 Binary files /dev/null and b/tests/resources/reftable/userdiff/.gitted/objects/pack/pack-1652578900ac63564f2a24b9714529821276ceb9.pack differ diff --git a/tests/resources/reftable/userdiff/.gitted/refs/heads b/tests/resources/reftable/userdiff/.gitted/refs/heads new file mode 100644 index 000000000..3e639a56a --- /dev/null +++ b/tests/resources/reftable/userdiff/.gitted/refs/heads @@ -0,0 +1 @@ +this repository uses the reftable format diff --git a/tests/resources/reftable/userdiff/.gitted/reftable/0x000000000001-0x000000000001-62a55c72.ref b/tests/resources/reftable/userdiff/.gitted/reftable/0x000000000001-0x000000000001-62a55c72.ref new file mode 100644 index 000000000..f5b66c330 Binary files /dev/null and b/tests/resources/reftable/userdiff/.gitted/reftable/0x000000000001-0x000000000001-62a55c72.ref differ diff --git a/tests/resources/reftable/userdiff/.gitted/reftable/tables.list b/tests/resources/reftable/userdiff/.gitted/reftable/tables.list new file mode 100644 index 000000000..6abfb3625 --- /dev/null +++ b/tests/resources/reftable/userdiff/.gitted/reftable/tables.list @@ -0,0 +1 @@ +0x000000000001-0x000000000001-62a55c72.ref diff --git a/tests/resources/reftable/userdiff/after/file.html b/tests/resources/reftable/userdiff/after/file.html new file mode 100644 index 000000000..2320e2f1e --- /dev/null +++ b/tests/resources/reftable/userdiff/after/file.html @@ -0,0 +1,41 @@ + + +

+
    +
  1. item 1.1
    2. +
  2. item 1.2 changed
    3. +
  3. item 1.3 changed
    4. +
  4. item 1.4
    5. +
  5. item 1.5
    6. +
  6. item 1.6
    7. +
  7. item 1.7
    8. +
  8. item 1.8
    9. +
  9. item 1.9
    10. +
  10. item 1.10 added
    11. +
+

+

+
    +
  1. item 2.1
    2. +
  2. item 2.2
    3. +
  3. item 2.3
    4. +
  4. item 2.4
    5. +
  5. item 2.5
    6. +
  6. item 2.6
    7. +
  7. item 2.7 changed
    8. +
  8. item 2.7.1 added
    9. +
  9. item 2.8
    10. +
+

+

+
    +
  1. item 3.1
    2. +
  2. item 3.2
    3. +
  3. item 3.3
    4. +
  4. item 3.4
    5. +
  5. item 3.5
    6. +
  6. item 3.6
    7. +
+

+ + diff --git a/tests/resources/reftable/userdiff/after/file.javascript b/tests/resources/reftable/userdiff/after/file.javascript new file mode 100644 index 000000000..53917973a --- /dev/null +++ b/tests/resources/reftable/userdiff/after/file.javascript @@ -0,0 +1,108 @@ +define(function(require, exports, module) { + module.exports = Player; + + var Key = require("./key") + , Direction = require("./direction"); + + function Player(game) { + this.game = game; + + this.image = new Image("./assets/fighter.png"); + this.game.resources.add(this.image); + + this.x = 0; + this.y = 0; + + this.pixelX = 10; + this.pixelY = 10; + + this.animationStep = 0; + } + + Player.prototype.update = function() { + if (!this.isWalking()) { + this.handleInput(); + } + + if (this.isWalking()) { + // Increase the animation step. + this.animationStep = ++this.animationStep % 60; + + if (this.x * 32 > this.pixelX) { + this.pixelX++; + } else if (this.x * 32 < this.pixelX) { + this.pixelX--; + } + + if (this.y * 32 > this.pixelY) { + this.pixelY++; + } else if (this.y * 32 < this.pixelY) { + this.pixelY--; + } + } else { + // Reset the animation step. + this.animationStep = 0; + } + }; + + Player.prototype.handleInput = function() { + var keyboard = this.game.keyboard, finalAction, action, inputs = { + 'moveDown': keyboard.isDown(Key.DOWN), + 'moveUp': keyboard.isDown(Key.UP), + 'moveLeft': keyboard.isDown(Key.LEFT), + 'moveRight': keyboard.isDown(Key.RIGHT) + }; + + for (action in inputs) { + if (inputs[action]) { + if (!finalAction || inputs[finalAction] < inputs[action]) { + finalAction = action; + } + } + } + + this[finalAction] && this[finalAction](); + }; + + Player.prototype.isWalking = function() { + return this.x * 32 != this.pixelX || this.y * 32 != this.pixelY; + }; + + Player.prototype.moveDown = function() { + this.y += 1; + this.direction = Direction.DOWN; + }; + + Player.prototype.moveUp = function() { + this.y -= 1; + this.direction = Direction.UP; + }; + + Player.prototype.moveLeft = function() { + this.x -= 5; + this.direction = Direction.LEFT; + }; + + Player.prototype.moveRight = function() { + this.x += 1; + this.direction = Direction.RIGHT; + }; + + Player.prototype.draw = function(context) { + var offsetX = Math.floor(this.animationStep / 15) * 32, offsetY = 0; + + switch(this.direction) { + case Direction.UP: + offsetY = 48 * 3; + break; + case Direction.RIGHT: + offsetY = 48 * 2; + break; + case Direction.LEFT: + offsetY = 48; + break; + } + + context.drawImage(this.image.data, offsetX, offsetY, 32, 48, this.pixelX, this.pixelY, 32, 48); + }; +}); diff --git a/tests/resources/reftable/userdiff/after/file.php b/tests/resources/reftable/userdiff/after/file.php new file mode 100644 index 000000000..967d6466c --- /dev/null +++ b/tests/resources/reftable/userdiff/after/file.php @@ -0,0 +1,50 @@ +unique() + */ +class UniqueGenerator +{ + protected $generator; + protected $maxRetries; + protected $moreStuff; + protected $uniques = array(); + + public function __construct(Generator $generator, $maxRetries) + { + $this->generator = $generator; + $this->maxRetries = $maxRetries + 1; + } + + /** + * Catch and proxy all generator calls but return only unique values + */ + public function __get($attribute) + { + return $this->__call($attribute, array()); + } + + /** + * Catch and proxy all generator calls with arguments but return only unique values + */ + public function __call($name, $arguments) + { + $i = 0; + if (!isset($this->uniques[$name])) { + $this->uniques[$name] = array(); + } + do { + $res = call_user_func_array(array($this->generator, $name), $arguments); + $i++; + if ($i >= $this->maxRetries) { + throw new \OverflowException(sprintf('Maximum retries of %d reached without finding a unique value', $this->maxRetries)); + } + } while (in_array($res, $this->uniques[$name])); + $this->uniques[$name][]= $res; + + return $res; + } +} diff --git a/tests/resources/reftable/userdiff/before/file.html b/tests/resources/reftable/userdiff/before/file.html new file mode 100644 index 000000000..872d19663 --- /dev/null +++ b/tests/resources/reftable/userdiff/before/file.html @@ -0,0 +1,41 @@ + + +

+
    +
  1. item 1.1
    2. +
  2. item 1.2
    3. +
  3. item 1.3
    4. +
  4. item 1.4
    5. +
  5. item 1.5
    6. +
  6. item 1.6
    7. +
  7. item 1.7
    8. +
  8. item 1.8
    9. +
  9. item 1.9
    10. +
+

+

+
    +
  1. item 2.1
    2. +
  2. item 2.2
    3. +
  3. item 2.3
    4. +
  4. item 2.4
    5. +
  5. item 2.5
    6. +
  6. item 2.6
    7. +
  7. item 2.7
    8. +
  8. item 2.8
    9. +
+

+

+
    +
  1. item 3.1
    2. +
  2. item 3.2
    3. +
  3. item 3.3
    4. +
  4. item 3.4
    5. +
  5. item 3.5
    6. +
  6. item 3.6
    7. +
  7. item 3.7
    8. +
  8. item 3.8
    9. +
+

+ + diff --git a/tests/resources/reftable/userdiff/before/file.javascript b/tests/resources/reftable/userdiff/before/file.javascript new file mode 100644 index 000000000..0965b377c --- /dev/null +++ b/tests/resources/reftable/userdiff/before/file.javascript @@ -0,0 +1,109 @@ +define(function(require, exports, module) { + module.exports = Player; + + var Key = require("./key") + , Direction = require("./direction") + , Image = require("./image"); + + function Player(game) { + this.game = game; + + this.image = new Image("./assets/fighter.png"); + this.game.resources.add(this.image); + + this.x = 0; + this.y = 0; + + this.pixelX = 0; + this.pixelY = 0; + + this.animationStep = 0; + } + + Player.prototype.update = function() { + if (!this.isWalking()) { + this.handleInput(); + } + + if (this.isWalking()) { + // Increase the animation step. + this.animationStep = ++this.animationStep % 60; + + if (this.x * 32 > this.pixelX) { + this.pixelX++; + } else if (this.x * 32 < this.pixelX) { + this.pixelX--; + } + + if (this.y * 32 > this.pixelY) { + this.pixelY++; + } else if (this.y * 32 < this.pixelY) { + this.pixelY--; + } + } else { + // Reset the animation step. + this.animationStep = 0; + } + }; + + Player.prototype.handleInput = function() { + var keyboard = this.game.keyboard, finalAction, action, inputs = { + 'moveDown': keyboard.isDown(Key.DOWN), + 'moveUp': keyboard.isDown(Key.UP), + 'moveLeft': keyboard.isDown(Key.LEFT), + 'moveRight': keyboard.isDown(Key.RIGHT) + }; + + for (action in inputs) { + if (inputs[action]) { + if (!finalAction || inputs[finalAction] < inputs[action]) { + finalAction = action; + } + } + } + + this[finalAction] && this[finalAction](); + }; + + Player.prototype.isWalking = function() { + return this.x * 32 != this.pixelX || this.y * 32 != this.pixelY; + }; + + Player.prototype.moveDown = function() { + this.y += 1; + this.direction = Direction.DOWN; + }; + + Player.prototype.moveUp = function() { + this.y -= 1; + this.direction = Direction.UP; + }; + + Player.prototype.moveLeft = function() { + this.x -= 1; + this.direction = Direction.LEFT; + }; + + Player.prototype.moveRight = function() { + this.x += 1; + this.direction = Direction.RIGHT; + }; + + Player.prototype.draw = function(context) { + var offsetX = Math.floor(this.animationStep / 15) * 32, offsetY = 0; + + switch(this.direction) { + case Direction.UP: + offsetY = 48 * 3; + break; + case Direction.RIGHT: + offsetY = 48 * 2; + break; + case Direction.LEFT: + offsetY = 48; + break; + } + + context.drawImage(this.image.data, offsetX, offsetY, 32, 48, this.pixelX, this.pixelY - 16, 32, 48); + }; +}); diff --git a/tests/resources/reftable/userdiff/before/file.php b/tests/resources/reftable/userdiff/before/file.php new file mode 100644 index 000000000..63250ad01 --- /dev/null +++ b/tests/resources/reftable/userdiff/before/file.php @@ -0,0 +1,49 @@ +unique() + */ +class UniqueGenerator +{ + protected $generator; + protected $maxRetries; + protected $uniques = array(); + + public function __construct(Generator $generator, $maxRetries) + { + $this->generator = $generator; + $this->maxRetries = $maxRetries; + } + + /** + * Catch and proxy all generator calls but return only unique values + */ + public function __get($attribute) + { + return $this->__call($attribute, array()); + } + + /** + * Catch and proxy all generator calls with arguments but return only unique values + */ + public function __call($name, $arguments) + { + if (!isset($this->uniques[$name])) { + $this->uniques[$name] = array(); + } + $i = 0; + do { + $res = call_user_func_array(array($this->generator, $name), $arguments); + $i++; + if ($i > $this->maxRetries) { + throw new \OverflowException(sprintf('Maximum retries of %d reached without finding a unique value', $this->maxRetries)); + } + } while (in_array($res, $this->uniques[$name])); + $this->uniques[$name][]= $res; + + return $res; + } +} diff --git a/tests/resources/reftable/userdiff/expected/driver/diff.html b/tests/resources/reftable/userdiff/expected/driver/diff.html new file mode 100644 index 000000000..5a428e7dc --- /dev/null +++ b/tests/resources/reftable/userdiff/expected/driver/diff.html @@ -0,0 +1,26 @@ +diff --git a/files/file.html b/files/file.html +index 872d196..2320e2f 100644 +--- a/files/file.html ++++ b/files/file.html +@@ -5,4 +5,4 @@

+
  • item 1.1
    • +-
  • item 1.2
    • +-
  • item 1.3
    • ++
  • item 1.2 changed
    • ++
  • item 1.3 changed
    • +
  • item 1.4
    • +@@ -13,2 +13,3 @@

    +
  • item 1.9
    • ++
  • item 1.10 added
    • + +@@ -23,3 +24,4 @@

    +
  • item 2.6
    • +-
  • item 2.7
    • ++
  • item 2.7 changed
    • ++
  • item 2.7.1 added
    • +
  • item 2.8
    • +@@ -35,4 +37,2 @@

    +
  • item 3.6
    • +-
  • item 3.7
    • +-
  • item 3.8
    • + diff --git a/tests/resources/reftable/userdiff/expected/driver/diff.javascript b/tests/resources/reftable/userdiff/expected/driver/diff.javascript new file mode 100644 index 000000000..4cefe5cff --- /dev/null +++ b/tests/resources/reftable/userdiff/expected/driver/diff.javascript @@ -0,0 +1,27 @@ +diff --git a/files/file.javascript b/files/file.javascript +index 0965b37..5391797 100644 +--- a/files/file.javascript ++++ b/files/file.javascript +@@ -4,4 +4,3 @@ function(require, exports, module) + var Key = require("./key") +- , Direction = require("./direction") +- , Image = require("./image"); ++ , Direction = require("./direction"); + +@@ -16,4 +15,4 @@ function Player(game) + +- this.pixelX = 0; +- this.pixelY = 0; ++ this.pixelX = 10; ++ this.pixelY = 10; + +@@ -82,3 +81,3 @@ Player.prototype.moveUp = function() + Player.prototype.moveLeft = function() { +- this.x -= 1; ++ this.x -= 5; + this.direction = Direction.LEFT; +@@ -106,3 +105,3 @@ Player.prototype.draw = function(context) + +- context.drawImage(this.image.data, offsetX, offsetY, 32, 48, this.pixelX, this.pixelY - 16, 32, 48); ++ context.drawImage(this.image.data, offsetX, offsetY, 32, 48, this.pixelX, this.pixelY, 32, 48); + }; diff --git a/tests/resources/reftable/userdiff/expected/driver/diff.php b/tests/resources/reftable/userdiff/expected/driver/diff.php new file mode 100644 index 000000000..9711b5b3e --- /dev/null +++ b/tests/resources/reftable/userdiff/expected/driver/diff.php @@ -0,0 +1,26 @@ +diff --git a/files/file.php b/files/file.php +index 63250ad..967d646 100644 +--- a/files/file.php ++++ b/files/file.php +@@ -12,2 +12,3 @@ class UniqueGenerator + protected $maxRetries; ++ protected $moreStuff; + protected $uniques = array(); +@@ -17,3 +18,3 @@ public function __construct(Generator $generator, $maxRetries) + $this->generator = $generator; +- $this->maxRetries = $maxRetries; ++ $this->maxRetries = $maxRetries + 1; + } +@@ -33,10 +34,10 @@ public function __call($name, $arguments) + { ++ $i = 0; + if (!isset($this->uniques[$name])) { + $this->uniques[$name] = array(); + } +- $i = 0; + do { + $res = call_user_func_array(array($this->generator, $name), $arguments); + $i++; +- if ($i > $this->maxRetries) { ++ if ($i >= $this->maxRetries) { + throw new \OverflowException(sprintf('Maximum retries of %d reached without finding a unique value', $this->maxRetries)); diff --git a/tests/resources/reftable/userdiff/expected/nodriver/diff.html b/tests/resources/reftable/userdiff/expected/nodriver/diff.html new file mode 100644 index 000000000..2ea4b8a16 --- /dev/null +++ b/tests/resources/reftable/userdiff/expected/nodriver/diff.html @@ -0,0 +1,26 @@ +diff --git a/files/file.html b/files/file.html +index 872d196..2320e2f 100644 +--- a/files/file.html ++++ b/files/file.html +@@ -5,4 +5,4 @@ +
  • item 1.1
    • +-
  • item 1.2
    • +-
  • item 1.3
    • ++
  • item 1.2 changed
    • ++
  • item 1.3 changed
    • +
  • item 1.4
    • +@@ -13,2 +13,3 @@ +
  • item 1.9
    • ++
  • item 1.10 added
    • + +@@ -23,3 +24,4 @@ +
  • item 2.6
    • +-
  • item 2.7
    • ++
  • item 2.7 changed
    • ++
  • item 2.7.1 added
    • +
  • item 2.8
    • +@@ -35,4 +37,2 @@ +
  • item 3.6
    • +-
  • item 3.7
    • +-
  • item 3.8
    • + diff --git a/tests/resources/reftable/userdiff/expected/nodriver/diff.javascript b/tests/resources/reftable/userdiff/expected/nodriver/diff.javascript new file mode 100644 index 000000000..4bbd54764 --- /dev/null +++ b/tests/resources/reftable/userdiff/expected/nodriver/diff.javascript @@ -0,0 +1,27 @@ +diff --git a/files/file.javascript b/files/file.javascript +index 0965b37..5391797 100644 +--- a/files/file.javascript ++++ b/files/file.javascript +@@ -4,4 +4,3 @@ define(function(require, exports, module) { + var Key = require("./key") +- , Direction = require("./direction") +- , Image = require("./image"); ++ , Direction = require("./direction"); + +@@ -16,4 +15,4 @@ define(function(require, exports, module) { + +- this.pixelX = 0; +- this.pixelY = 0; ++ this.pixelX = 10; ++ this.pixelY = 10; + +@@ -82,3 +81,3 @@ define(function(require, exports, module) { + Player.prototype.moveLeft = function() { +- this.x -= 1; ++ this.x -= 5; + this.direction = Direction.LEFT; +@@ -106,3 +105,3 @@ define(function(require, exports, module) { + +- context.drawImage(this.image.data, offsetX, offsetY, 32, 48, this.pixelX, this.pixelY - 16, 32, 48); ++ context.drawImage(this.image.data, offsetX, offsetY, 32, 48, this.pixelX, this.pixelY, 32, 48); + }; diff --git a/tests/resources/reftable/userdiff/expected/nodriver/diff.php b/tests/resources/reftable/userdiff/expected/nodriver/diff.php new file mode 100644 index 000000000..e77c094aa --- /dev/null +++ b/tests/resources/reftable/userdiff/expected/nodriver/diff.php @@ -0,0 +1,26 @@ +diff --git a/files/file.php b/files/file.php +index 63250ad..967d646 100644 +--- a/files/file.php ++++ b/files/file.php +@@ -12,2 +12,3 @@ class UniqueGenerator + protected $maxRetries; ++ protected $moreStuff; + protected $uniques = array(); +@@ -17,3 +18,3 @@ class UniqueGenerator + $this->generator = $generator; +- $this->maxRetries = $maxRetries; ++ $this->maxRetries = $maxRetries + 1; + } +@@ -33,10 +34,10 @@ class UniqueGenerator + { ++ $i = 0; + if (!isset($this->uniques[$name])) { + $this->uniques[$name] = array(); + } +- $i = 0; + do { + $res = call_user_func_array(array($this->generator, $name), $arguments); + $i++; +- if ($i > $this->maxRetries) { ++ if ($i >= $this->maxRetries) { + throw new \OverflowException(sprintf('Maximum retries of %d reached without finding a unique value', $this->maxRetries)); diff --git a/tests/resources/reftable/userdiff/files/file.html b/tests/resources/reftable/userdiff/files/file.html new file mode 100644 index 000000000..2320e2f1e --- /dev/null +++ b/tests/resources/reftable/userdiff/files/file.html @@ -0,0 +1,41 @@ + + +

    +
      +
    1. item 1.1
      2. +
    2. item 1.2 changed
      3. +
    3. item 1.3 changed
      4. +
    4. item 1.4
      5. +
    5. item 1.5
      6. +
    6. item 1.6
      7. +
    7. item 1.7
      8. +
    8. item 1.8
      9. +
    9. item 1.9
      10. +
    10. item 1.10 added
      11. +
    +

    +

    +
      +
    1. item 2.1
      2. +
    2. item 2.2
      3. +
    3. item 2.3
      4. +
    4. item 2.4
      5. +
    5. item 2.5
      6. +
    6. item 2.6
      7. +
    7. item 2.7 changed
      8. +
    8. item 2.7.1 added
      9. +
    9. item 2.8
      10. +
    +

    +

    +
      +
    1. item 3.1
      2. +
    2. item 3.2
      3. +
    3. item 3.3
      4. +
    4. item 3.4
      5. +
    5. item 3.5
      6. +
    6. item 3.6
      7. +
    +

    + + diff --git a/tests/resources/reftable/userdiff/files/file.javascript b/tests/resources/reftable/userdiff/files/file.javascript new file mode 100644 index 000000000..53917973a --- /dev/null +++ b/tests/resources/reftable/userdiff/files/file.javascript @@ -0,0 +1,108 @@ +define(function(require, exports, module) { + module.exports = Player; + + var Key = require("./key") + , Direction = require("./direction"); + + function Player(game) { + this.game = game; + + this.image = new Image("./assets/fighter.png"); + this.game.resources.add(this.image); + + this.x = 0; + this.y = 0; + + this.pixelX = 10; + this.pixelY = 10; + + this.animationStep = 0; + } + + Player.prototype.update = function() { + if (!this.isWalking()) { + this.handleInput(); + } + + if (this.isWalking()) { + // Increase the animation step. + this.animationStep = ++this.animationStep % 60; + + if (this.x * 32 > this.pixelX) { + this.pixelX++; + } else if (this.x * 32 < this.pixelX) { + this.pixelX--; + } + + if (this.y * 32 > this.pixelY) { + this.pixelY++; + } else if (this.y * 32 < this.pixelY) { + this.pixelY--; + } + } else { + // Reset the animation step. + this.animationStep = 0; + } + }; + + Player.prototype.handleInput = function() { + var keyboard = this.game.keyboard, finalAction, action, inputs = { + 'moveDown': keyboard.isDown(Key.DOWN), + 'moveUp': keyboard.isDown(Key.UP), + 'moveLeft': keyboard.isDown(Key.LEFT), + 'moveRight': keyboard.isDown(Key.RIGHT) + }; + + for (action in inputs) { + if (inputs[action]) { + if (!finalAction || inputs[finalAction] < inputs[action]) { + finalAction = action; + } + } + } + + this[finalAction] && this[finalAction](); + }; + + Player.prototype.isWalking = function() { + return this.x * 32 != this.pixelX || this.y * 32 != this.pixelY; + }; + + Player.prototype.moveDown = function() { + this.y += 1; + this.direction = Direction.DOWN; + }; + + Player.prototype.moveUp = function() { + this.y -= 1; + this.direction = Direction.UP; + }; + + Player.prototype.moveLeft = function() { + this.x -= 5; + this.direction = Direction.LEFT; + }; + + Player.prototype.moveRight = function() { + this.x += 1; + this.direction = Direction.RIGHT; + }; + + Player.prototype.draw = function(context) { + var offsetX = Math.floor(this.animationStep / 15) * 32, offsetY = 0; + + switch(this.direction) { + case Direction.UP: + offsetY = 48 * 3; + break; + case Direction.RIGHT: + offsetY = 48 * 2; + break; + case Direction.LEFT: + offsetY = 48; + break; + } + + context.drawImage(this.image.data, offsetX, offsetY, 32, 48, this.pixelX, this.pixelY, 32, 48); + }; +}); diff --git a/tests/resources/reftable/userdiff/files/file.php b/tests/resources/reftable/userdiff/files/file.php new file mode 100644 index 000000000..967d6466c --- /dev/null +++ b/tests/resources/reftable/userdiff/files/file.php @@ -0,0 +1,50 @@ +unique() + */ +class UniqueGenerator +{ + protected $generator; + protected $maxRetries; + protected $moreStuff; + protected $uniques = array(); + + public function __construct(Generator $generator, $maxRetries) + { + $this->generator = $generator; + $this->maxRetries = $maxRetries + 1; + } + + /** + * Catch and proxy all generator calls but return only unique values + */ + public function __get($attribute) + { + return $this->__call($attribute, array()); + } + + /** + * Catch and proxy all generator calls with arguments but return only unique values + */ + public function __call($name, $arguments) + { + $i = 0; + if (!isset($this->uniques[$name])) { + $this->uniques[$name] = array(); + } + do { + $res = call_user_func_array(array($this->generator, $name), $arguments); + $i++; + if ($i >= $this->maxRetries) { + throw new \OverflowException(sprintf('Maximum retries of %d reached without finding a unique value', $this->maxRetries)); + } + } while (in_array($res, $this->uniques[$name])); + $this->uniques[$name][]= $res; + + return $res; + } +} diff --git a/tests/resources/reftable/win32-forbidden/.gitted/HEAD b/tests/resources/reftable/win32-forbidden/.gitted/HEAD new file mode 100644 index 000000000..fe6d7e5fa --- /dev/null +++ b/tests/resources/reftable/win32-forbidden/.gitted/HEAD @@ -0,0 +1 @@ +ref: refs/heads/.invalid diff --git a/tests/resources/reftable/win32-forbidden/.gitted/config b/tests/resources/reftable/win32-forbidden/.gitted/config new file mode 100644 index 000000000..622302e60 --- /dev/null +++ b/tests/resources/reftable/win32-forbidden/.gitted/config @@ -0,0 +1,9 @@ +[core] + repositoryformatversion = 1 + filemode = true + bare = false + logallrefupdates = true + ignorecase = true + precomposeunicode = true +[extensions] + refstorage = reftable diff --git a/tests/resources/reftable/win32-forbidden/.gitted/index b/tests/resources/reftable/win32-forbidden/.gitted/index new file mode 100644 index 000000000..1202dd9f4 Binary files /dev/null and b/tests/resources/reftable/win32-forbidden/.gitted/index differ diff --git a/tests/resources/reftable/win32-forbidden/.gitted/info/exclude b/tests/resources/reftable/win32-forbidden/.gitted/info/exclude new file mode 100644 index 000000000..a5196d1be --- /dev/null +++ b/tests/resources/reftable/win32-forbidden/.gitted/info/exclude @@ -0,0 +1,6 @@ +# git ls-files --others --exclude-from=.git/info/exclude +# Lines that start with '#' are comments. +# For a project mostly in C, the following would be a good set of +# exclude patterns (uncomment them if you want to use them): +# *.[oa] +# *~ diff --git a/tests/resources/reftable/win32-forbidden/.gitted/objects/10/68072702a28a82c78902cf5bf82c3864cf4356 b/tests/resources/reftable/win32-forbidden/.gitted/objects/10/68072702a28a82c78902cf5bf82c3864cf4356 new file mode 100644 index 000000000..2d3b31adc Binary files /dev/null and b/tests/resources/reftable/win32-forbidden/.gitted/objects/10/68072702a28a82c78902cf5bf82c3864cf4356 differ diff --git a/tests/resources/reftable/win32-forbidden/.gitted/objects/17/6a458f94e0ea5272ce67c36bf30b6be9caf623 b/tests/resources/reftable/win32-forbidden/.gitted/objects/17/6a458f94e0ea5272ce67c36bf30b6be9caf623 new file mode 100644 index 000000000..ef8316670 Binary files /dev/null and b/tests/resources/reftable/win32-forbidden/.gitted/objects/17/6a458f94e0ea5272ce67c36bf30b6be9caf623 differ diff --git a/tests/resources/reftable/win32-forbidden/.gitted/objects/2d/7445a749d25269f32724aa621cb70b196bcc40 b/tests/resources/reftable/win32-forbidden/.gitted/objects/2d/7445a749d25269f32724aa621cb70b196bcc40 new file mode 100644 index 000000000..baddb1fc6 Binary files /dev/null and b/tests/resources/reftable/win32-forbidden/.gitted/objects/2d/7445a749d25269f32724aa621cb70b196bcc40 differ diff --git a/tests/resources/reftable/win32-forbidden/.gitted/objects/34/96991d72d500af36edef68bbfcccd1661d88db b/tests/resources/reftable/win32-forbidden/.gitted/objects/34/96991d72d500af36edef68bbfcccd1661d88db new file mode 100644 index 000000000..71b6172c6 --- /dev/null +++ b/tests/resources/reftable/win32-forbidden/.gitted/objects/34/96991d72d500af36edef68bbfcccd1661d88db @@ -0,0 +1,3 @@ +x +![whӢ}/8B*8N~@gu՜S ͡7a +f2"s e.%Q ؽ຾m[kjmGq_N3LBJŔFG:B VRO ͿҖj!= \ No newline at end of file diff --git a/tests/resources/reftable/win32-forbidden/.gitted/objects/8f/45aad6f23b9509f8786c617e19c127ae76609a b/tests/resources/reftable/win32-forbidden/.gitted/objects/8f/45aad6f23b9509f8786c617e19c127ae76609a new file mode 100644 index 000000000..8bcd980c4 --- /dev/null +++ b/tests/resources/reftable/win32-forbidden/.gitted/objects/8f/45aad6f23b9509f8786c617e19c127ae76609a @@ -0,0 +1,2 @@ +xA + ֝/k. ]`h޾"= ˕e* U+M%O4c˱ \ No newline at end of file diff --git a/tests/resources/reftable/win32-forbidden/.gitted/objects/da/623abd956bb2fd8052c708c7ed43f05d192d37 b/tests/resources/reftable/win32-forbidden/.gitted/objects/da/623abd956bb2fd8052c708c7ed43f05d192d37 new file mode 100644 index 000000000..923462306 Binary files /dev/null and b/tests/resources/reftable/win32-forbidden/.gitted/objects/da/623abd956bb2fd8052c708c7ed43f05d192d37 differ diff --git a/tests/resources/reftable/win32-forbidden/.gitted/objects/ea/c7621a652e5261ef1c1d3e7ae31b0d84fcbaba b/tests/resources/reftable/win32-forbidden/.gitted/objects/ea/c7621a652e5261ef1c1d3e7ae31b0d84fcbaba new file mode 100644 index 000000000..32b3f02ec --- /dev/null +++ b/tests/resources/reftable/win32-forbidden/.gitted/objects/ea/c7621a652e5261ef1c1d3e7ae31b0d84fcbaba @@ -0,0 +1,3 @@ +xM +B!F;BoW}BDۀ +>_m?BgqVJ =FdJTqDdBN'6Rp S+kpGrAR*Tz! vVGn5l_;U>H \ No newline at end of file diff --git a/tests/resources/reftable/win32-forbidden/.gitted/refs/heads b/tests/resources/reftable/win32-forbidden/.gitted/refs/heads new file mode 100644 index 000000000..3e639a56a --- /dev/null +++ b/tests/resources/reftable/win32-forbidden/.gitted/refs/heads @@ -0,0 +1 @@ +this repository uses the reftable format diff --git a/tests/resources/reftable/win32-forbidden/.gitted/reftable/0x000000000001-0x000000000001-be725406.ref b/tests/resources/reftable/win32-forbidden/.gitted/reftable/0x000000000001-0x000000000001-be725406.ref new file mode 100644 index 000000000..4ccd02994 Binary files /dev/null and b/tests/resources/reftable/win32-forbidden/.gitted/reftable/0x000000000001-0x000000000001-be725406.ref differ diff --git a/tests/resources/reftable/win32-forbidden/.gitted/reftable/tables.list b/tests/resources/reftable/win32-forbidden/.gitted/reftable/tables.list new file mode 100644 index 000000000..6cc5c280f --- /dev/null +++ b/tests/resources/reftable/win32-forbidden/.gitted/reftable/tables.list @@ -0,0 +1 @@ +0x000000000001-0x000000000001-be725406.ref