tests/filter/crlf.c

   1 #include "clar_libgit2.h"
   2 #include "git2/sys/filter.h"
   3 #include "buffer.h"
   4
   5 static git_repository *g_repo = NULL;
   6
   7 void test_filter_crlf__initialize(void)
   8 {
   9         g_repo = cl_git_sandbox_init("crlf");
  10
  11         cl_git_mkfile("crlf/.gitattributes",
  12                 "*.txt text\n*.bin binary\n*.crlf text eol=crlf\n*.lf text eol=lf\n");
  13
  14         cl_repo_set_bool(g_repo, "core.autocrlf", true);
  15 }
  16
  17 void test_filter_crlf__cleanup(void)
  18 {
  19         cl_git_sandbox_cleanup();
  20 }
  21
  22 void test_filter_crlf__to_worktree(void)
  23 {
  24         git_filter_list *fl;
  25         git_filter *crlf;
  26         git_buf out = GIT_BUF_INIT;
  27         const char *in;
  28         size_t in_len;
  29
  30         cl_git_pass(git_filter_list_new(
  31                 &fl, g_repo, GIT_FILTER_TO_WORKTREE, 0));
  32
  33         crlf = git_filter_lookup(GIT_FILTER_CRLF);
  34         cl_assert(crlf != NULL);
  35
  36         cl_git_pass(git_filter_list_push(fl, crlf, NULL));
  37
  38         in = "Some text\nRight here\n";
  39         in_len = strlen(in);
  40
  41         cl_git_pass(git_filter_list_apply_to_buffer(&out, fl, in, in_len));
  42
  43         cl_assert_equal_s("Some text\r\nRight here\r\n", out.ptr);
  44
  45         git_filter_list_free(fl);
  46         git_buf_dispose(&out);
  47 }
  48
  49 void test_filter_crlf__to_odb(void)
  50 {
  51         git_filter_list *fl;
  52         git_filter *crlf;
  53         git_buf out = GIT_BUF_INIT;
  54         const char *in;
  55         size_t in_len;
  56
  57         cl_git_pass(git_filter_list_new(
  58                 &fl, g_repo, GIT_FILTER_TO_ODB, 0));
  59
  60         crlf = git_filter_lookup(GIT_FILTER_CRLF);
  61         cl_assert(crlf != NULL);
  62
  63         cl_git_pass(git_filter_list_push(fl, crlf, NULL));
  64
  65         in = "Some text\r\nRight here\r\n";
  66         in_len = strlen(in);
  67
  68         cl_git_pass(git_filter_list_apply_to_buffer(&out, fl, in, in_len));
  69
  70         cl_assert_equal_s("Some text\nRight here\n", out.ptr);
  71
  72         git_filter_list_free(fl);
  73         git_buf_dispose(&out);
  74 }
  75
  76 void test_filter_crlf__with_safecrlf(void)
  77 {
  78         git_filter_list *fl;
  79         git_filter *crlf;
  80         git_buf out = GIT_BUF_INIT;
  81         const char *in;
  82         size_t in_len;
  83
  84         cl_repo_set_bool(g_repo, "core.safecrlf", true);
  85
  86         cl_git_pass(git_filter_list_new(
  87                 &fl, g_repo, GIT_FILTER_TO_ODB, 0));
  88
  89         crlf = git_filter_lookup(GIT_FILTER_CRLF);
  90         cl_assert(crlf != NULL);
  91
  92         cl_git_pass(git_filter_list_push(fl, crlf, NULL));
  93
  94         /* Normalized \r\n succeeds with safecrlf */
  95         in = "Normal\r\nCRLF\r\nline-endings.\r\n";
  96         in_len = strlen(in);
  97
  98         cl_git_pass(git_filter_list_apply_to_buffer(&out, fl, in, in_len));
  99         cl_assert_equal_s("Normal\nCRLF\nline-endings.\n", out.ptr);
 100
 101         /* Mix of line endings fails with safecrlf */
 102         in = "Mixed\nup\r\nLF\nand\r\nCRLF\nline-endings.\r\n";
 103         in_len = strlen(in);
 104
 105         cl_git_fail(git_filter_list_apply_to_buffer(&out, fl, in, in_len));
 106         cl_assert_equal_i(git_error_last()->klass, GIT_ERROR_FILTER);
 107
 108         /* Normalized \n fails for autocrlf=true when safecrlf=true */
 109         in = "Normal\nLF\nonly\nline-endings.\n";
 110         in_len = strlen(in);
 111
 112         cl_git_fail(git_filter_list_apply_to_buffer(&out, fl, in, in_len));
 113         cl_assert_equal_i(git_error_last()->klass, GIT_ERROR_FILTER);
 114
 115         /* String with \r but without \r\n does not fail with safecrlf */
 116         in = "Normal\nCR only\rand some more\nline-endings.\n";
 117         in_len = strlen(in);
 118
 119         cl_git_pass(git_filter_list_apply_to_buffer(&out, fl, in, in_len));
 120         cl_assert_equal_s("Normal\nCR only\rand some more\nline-endings.\n", out.ptr);
 121
 122         git_filter_list_free(fl);
 123         git_buf_dispose(&out);
 124 }
 125
 126 void test_filter_crlf__with_safecrlf_and_unsafe_allowed(void)
 127 {
 128         git_filter_list *fl;
 129         git_filter *crlf;
 130         git_buf out = GIT_BUF_INIT;
 131         const char *in;
 132         size_t in_len;
 133
 134         cl_repo_set_bool(g_repo, "core.safecrlf", true);
 135
 136         cl_git_pass(git_filter_list_new(
 137                 &fl, g_repo, GIT_FILTER_TO_ODB, GIT_FILTER_ALLOW_UNSAFE));
 138
 139         crlf = git_filter_lookup(GIT_FILTER_CRLF);
 140         cl_assert(crlf != NULL);
 141
 142         cl_git_pass(git_filter_list_push(fl, crlf, NULL));
 143
 144         /* Normalized \r\n succeeds with safecrlf */
 145         in = "Normal\r\nCRLF\r\nline-endings.\r\n";
 146         in_len = strlen(in);
 147
 148         cl_git_pass(git_filter_list_apply_to_buffer(&out, fl, in, in_len));
 149         cl_assert_equal_s("Normal\nCRLF\nline-endings.\n", out.ptr);
 150
 151         /* Mix of line endings fails with safecrlf, but allowed to pass */
 152         in = "Mixed\nup\r\nLF\nand\r\nCRLF\nline-endings.\r\n";
 153         in_len = strlen(in);
 154
 155         cl_git_pass(git_filter_list_apply_to_buffer(&out, fl, in, in_len));
 156         /* TODO: check for warning */
 157         cl_assert_equal_s("Mixed\nup\nLF\nand\nCRLF\nline-endings.\n", out.ptr);
 158
 159         /* Normalized \n fails with safecrlf, but allowed to pass */
 160         in = "Normal\nLF\nonly\nline-endings.\n";
 161         in_len = strlen(in);
 162
 163         cl_git_pass(git_filter_list_apply_to_buffer(&out, fl, in, in_len));
 164         /* TODO: check for warning */
 165         cl_assert_equal_s("Normal\nLF\nonly\nline-endings.\n", out.ptr);
 166
 167         git_filter_list_free(fl);
 168         git_buf_dispose(&out);
 169 }
 170
 171 void test_filter_crlf__no_safecrlf(void)
 172 {
 173         git_filter_list *fl;
 174         git_filter *crlf;
 175         git_buf out = GIT_BUF_INIT;
 176         const char *in;
 177         size_t in_len;
 178
 179         cl_git_pass(git_filter_list_new(
 180                 &fl, g_repo, GIT_FILTER_TO_ODB, 0));
 181
 182         crlf = git_filter_lookup(GIT_FILTER_CRLF);
 183         cl_assert(crlf != NULL);
 184
 185         cl_git_pass(git_filter_list_push(fl, crlf, NULL));
 186
 187         /* Normalized \r\n succeeds with safecrlf */
 188         in = "Normal\r\nCRLF\r\nline-endings.\r\n";
 189         in_len = strlen(in);
 190
 191         cl_git_pass(git_filter_list_apply_to_buffer(&out, fl, in, in_len));
 192         cl_assert_equal_s("Normal\nCRLF\nline-endings.\n", out.ptr);
 193
 194         /* Mix of line endings fails with safecrlf */
 195         in = "Mixed\nup\r\nLF\nand\r\nCRLF\nline-endings.\r\n";
 196         in_len = strlen(in);
 197
 198         cl_git_pass(git_filter_list_apply_to_buffer(&out, fl, in, in_len));
 199         cl_assert_equal_s("Mixed\nup\nLF\nand\nCRLF\nline-endings.\n", out.ptr);
 200
 201         /* Normalized \n fails with safecrlf */
 202         in = "Normal\nLF\nonly\nline-endings.\n";
 203         in_len = strlen(in);
 204
 205         cl_git_pass(git_filter_list_apply_to_buffer(&out, fl, in, in_len));
 206         cl_assert_equal_s("Normal\nLF\nonly\nline-endings.\n", out.ptr);
 207
 208         git_filter_list_free(fl);
 209         git_buf_dispose(&out);
 210 }
 211
 212 void test_filter_crlf__safecrlf_warn(void)
 213 {
 214         git_filter_list *fl;
 215         git_filter *crlf;
 216         git_buf out = GIT_BUF_INIT;
 217         const char *in;
 218         size_t in_len;
 219
 220         cl_repo_set_string(g_repo, "core.safecrlf", "warn");
 221
 222         cl_git_pass(git_filter_list_new(
 223                 &fl, g_repo, GIT_FILTER_TO_ODB, 0));
 224
 225         crlf = git_filter_lookup(GIT_FILTER_CRLF);
 226         cl_assert(crlf != NULL);
 227
 228         cl_git_pass(git_filter_list_push(fl, crlf, NULL));
 229
 230         /* Normalized \r\n succeeds with safecrlf=warn */
 231         in = "Normal\r\nCRLF\r\nline-endings.\r\n";
 232         in_len = strlen(in);
 233
 234         cl_git_pass(git_filter_list_apply_to_buffer(&out, fl, in, in_len));
 235         cl_assert_equal_s("Normal\nCRLF\nline-endings.\n", out.ptr);
 236
 237         /* Mix of line endings succeeds with safecrlf=warn */
 238         in = "Mixed\nup\r\nLF\nand\r\nCRLF\nline-endings.\r\n";
 239         in_len = strlen(in);
 240
 241         cl_git_pass(git_filter_list_apply_to_buffer(&out, fl, in, in_len));
 242         /* TODO: check for warning */
 243         cl_assert_equal_s("Mixed\nup\nLF\nand\nCRLF\nline-endings.\n", out.ptr);
 244
 245         /* Normalized \n is reversible, so does not fail with safecrlf=warn */
 246         in = "Normal\nLF\nonly\nline-endings.\n";
 247         in_len = strlen(in);
 248
 249         cl_git_pass(git_filter_list_apply_to_buffer(&out, fl, in, in_len));
 250         cl_assert_equal_s(in, out.ptr);
 251
 252         git_filter_list_free(fl);
 253         git_buf_dispose(&out);
 254 }