| /* |
| * translate-test.c -- test the eol and keyword translation subroutine |
| * |
| * ==================================================================== |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * ==================================================================== |
| */ |
| |
| |
| |
| /* Advice to those adding new tests to this file: |
| * ============================================== |
| * |
| * Read the doc string for substitute_and_verify(), then read the |
| * test functions themselves -- they're small, and they'll be very |
| * easy to understand once you know substitute_and_verify(). |
| */ |
| |
| |
| |
| #include <stdio.h> |
| #include <string.h> |
| #include <apr_general.h> |
| #include <apr_file_io.h> |
| |
| #include "../svn_test.h" |
| |
| #include "svn_pools.h" |
| #include "svn_subst.h" |
| |
| |
| |
| /*** Helpers ***/ |
| |
| /* (Almost) all the tests share the same test data. */ |
| static const char *lines[] = |
| { |
| "Line 1: fairly boring subst test data... blah blah", |
| "Line 2: fairly boring subst test data... blah blah.", |
| "Line 3: Valid $LastChangedRevision$, started unexpanded.", |
| "Line 4: fairly boring subst test data... blah blah.", |
| "Line 5: Valid $Rev$, started unexpanded.", |
| "Line 6: fairly boring subst test data... blah blah.", |
| "Line 7: fairly boring subst test data... blah blah.", |
| "Line 8: Valid $LastChangedBy$, started unexpanded.", |
| "Line 9: Valid $Author$, started unexpanded.", |
| "Line 10: fairly boring subst test data... blah blah.", |
| "Line 11: fairly boring subst test data... blah blah.", |
| "Line 12: Valid $LastChangedDate$, started unexpanded.", |
| "Line 13: Valid $Date$, started unexpanded.", |
| "Line 14: fairly boring subst test data... blah blah.", |
| "Line 15: fairly boring subst test data... blah blah.", |
| "Line 16: Valid $HeadURL$, started unexpanded.", |
| "Line 17: Valid $URL$, started unexpanded.", |
| "Line 18: fairly boring subst test data... blah blah.", |
| "Line 19: Invalid expanded keyword spanning two lines: $Author: ", |
| /* The idea here is that, were it not broken across two lines, |
| "$Author: Line 20: jrandom$" would be a valid if odd, keyword. */ |
| "Line 20: jrandom$ remainder of invalid keyword spanning two lines.", |
| "Line 21: fairly boring subst test data... blah blah.", |
| "Line 22: an unknown keyword $LastChangedSocks$.", |
| "Line 23: fairly boring subst test data... blah blah.", |
| /* In line 24, the third dollar sign terminates the first, and the |
| fourth should therefore remain a literal dollar sign. */ |
| "Line 24: keyword in a keyword: $Author: $Date$ $", |
| "Line 25: fairly boring subst test data... blah blah.", |
| "Line 26: Emptily expanded keyword $Rev: $.", |
| "Line 27: fairly boring subst test data... blah blah.", |
| "Line 28: fairly boring subst test data... blah blah.", |
| "Line 29: Valid $LastChangedRevision: 1729 $, started expanded.", |
| "Line 30: Valid $Rev: 1729 $, started expanded.", |
| "Line 31: fairly boring subst test data... blah blah.", |
| "Line 32: fairly boring subst test data... blah blah.", |
| "Line 33: Valid $LastChangedDate: 2002-01-01 $, started expanded.", |
| "Line 34: Valid $Date: 2002-01-01 $, started expanded.", |
| "Line 35: fairly boring subst test data... blah blah.", |
| "Line 36: fairly boring subst test data... blah blah.", |
| "Line 37: Valid $LastChangedBy: jrandom $, started expanded.", |
| "Line 38: Valid $Author: jrandom $, started expanded.", |
| "Line 39: fairly boring subst test data... blah blah.", |
| "Line 40: fairly boring subst test data... blah blah.", |
| "Line 41: Valid $HeadURL: http://tomato/mauve $, started expanded.", |
| "Line 42: Valid $URL: http://tomato/mauve $, started expanded.", |
| "Line 43: fairly boring subst test data... blah blah.", |
| "Line 44: fairly boring subst test data... blah blah.", |
| "Line 45: Invalid $LastChangedRevisionWithSuffix$, started unexpanded.", |
| "Line 46: Empty $Author:$, started expanded.", |
| "Line 47: fairly boring subst test data... blah blah.", |
| "Line 48: Two keywords back to back: $Author$$Rev$.", |
| "Line 49: One keyword, one not, back to back: $Author$Rev$.", |
| "Line 50: a series of dollar signs $$$$$$$$$$$$$$$$$$$$$$$$$$$$.", |
| "Line 51: same, but with embedded keyword $$$$$$$$Date$$$$$$$$$$.", |
| "Line 52: same, with expanded, empty keyword $$$$$$Date: $$$$$$.", |
| "Line 53: $This is a lengthy line designed to test a bug that was " |
| "reported about keyword expansion. The problem was that a line " |
| "had more than SVN_KEYWORD_MAX_LEN (255 at the time) characters " |
| "after an initial dollar sign, which triggered a buglet in our " |
| "svn_subst_copy_and_translate() function and resulted in, in some cases " |
| "a SEGFAULT, and in others a filthy corrupt commit. ", |
| "", /* Lines 54-69 are blank to test consecutive newlines */ |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "$Author$Rev$.", /* Line 70-73 test places where '$' abuts a newline. */ |
| ".$veR$Author$", |
| "$", |
| "$$", |
| /* Line 74-75 test for keywords containing '$', issue #1780 */ |
| "Line 74: Valid $Author: jran$dom $, started expanded.", |
| "Line 75: Valid $URL: http://tomato/mau$ve $, started expanded.", |
| /* Line 76-78 tests for a string with an unknown keyword of 252-254 bytes |
| long */ |
| "$ " |
| " " |
| " " |
| " $$", |
| "$ " |
| " " |
| " " |
| " $$", |
| "$ " |
| " " |
| " " |
| " $$", |
| /* Testing border cases, line 79-82 test for valid keywords, keywords on |
| line 83-84 are too long */ |
| "Line 79: Valid $Author: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" |
| "aaaaaaaaaaaaa$aaaaaaaaaaaaaaaaaaaaaa$aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" |
| "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa$aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" |
| "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa $, started expanded.", |
| "Line 80: Valid $Author: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa$aaaaaaaaaaaaaaa" |
| "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa$aaaaaaaaaaaaaaaaaa" |
| "aaaaaaa$aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" |
| "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa$aaaaaaa $, started " |
| "expanded.", |
| /* keyword from first dollar sign to last = 254 chars */ |
| "Line 81: Valid $Author: aaaaaaaaaaaaaaaaaaaa$aaaaaaaaaaaaaaaaaaaaaaaaaaa" |
| "aaaaaaaaaaaaa$aaaaaaaaaaaaaaaaaaaa$$aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" |
| "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa$$aaaaaaaaaaaaaaaaaaaaaaaaa" |
| "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa$$aaaaaa$$$ $, started " |
| "expanded.", |
| /* keyword from first dollar sign to last = 255 chars */ |
| "Line 82: Valid $Author: aaaaaaaaaaa$$aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" |
| "aaaaaaaaaaaaaaaaaaaaaaaaaa$$$$aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" |
| "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa$$aaaaaaaaaaaaaaaaaaaaaaaaaaa" |
| "aaaaaaaaaaaaaa$$aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa$$$ $, started " |
| "expanded.", |
| /* keyword from first dollar sign to last = 256 chars */ |
| "Line 83: Invalid $Author: aaaaaaaaaaa$$aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" |
| "aaaaaaaaaaaaaaaaaaaaaaaaaa$$$$aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" |
| "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa$$aaaaaaaaaaaaaaaaaaaaaaaaaaa" |
| "aaaaaaaaaaaaaa$$aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa$$$ $, started " |
| "expanded.", |
| "Line 84: Invalid $Author: aaaaaaaaaaa$$aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" |
| "aaaaaaaaaaaaaaaaaaaaaaaaaa$$$$aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" |
| "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa$$aaaaaaaaaaaaaaaaaaaaaaaaaaa" |
| "aaaaaaaaaaaaaa$$aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa$$$ $, started " |
| "expanded.", |
| "Line 85: end of subst test data." |
| }; |
| |
| |
| /* Return a randomly selected eol sequence. */ |
| static const char * |
| random_eol_marker(void) |
| { |
| /* Select a random eol marker from this set. */ |
| static int seeded = 0; |
| |
| /* ### todo: allowing '\r' to be in this list of possible random |
| eol_markers causes problems for the current testing framework |
| which expects a 1:1 ratio of input-line-count to output-line-count. |
| Problems occur when there are two consecutive line ending markers |
| where the first is '\r' and the second is '\n' -- our |
| translation routine reads that as a single '\r\n' which throws |
| off the linecount on the output side, and fouls up substitute_and_verify. |
| */ |
| const char *eol_markers[] = { "\n", "\r\n" }; |
| |
| if (! seeded) |
| { |
| srand(1729); /* we want errors to be reproducible */ |
| seeded = 1; |
| } |
| |
| return eol_markers[rand() |
| % ((sizeof(eol_markers)) / (sizeof(*eol_markers)))]; |
| } |
| |
| |
| /* Create FNAME with global `lines' as initial data. Use EOL_STR as |
| * the end-of-line marker between lines, or if EOL_STR is NULL, choose |
| * a random marker at each opportunity. Use POOL for any temporary |
| * allocation. |
| */ |
| static svn_error_t * |
| create_file(const char *fname, const char *eol_str, apr_pool_t *pool) |
| { |
| apr_file_t *f; |
| apr_size_t i, j; |
| |
| SVN_ERR(svn_io_file_open(&f, fname, |
| (APR_WRITE | APR_CREATE | APR_EXCL | APR_BINARY), |
| APR_OS_DEFAULT, pool)); |
| |
| for (i = 0; i < (sizeof(lines) / sizeof(*lines)); i++) |
| { |
| const char *this_eol_str = eol_str ? eol_str : random_eol_marker(); |
| |
| apr_file_printf(f, "%s", lines[i]); |
| |
| /* Is it overly paranoid to use putc(), because of worry about |
| fprintf() doing a newline conversion? */ |
| for (j = 0; this_eol_str[j]; j++) |
| { |
| SVN_ERR(svn_io_file_putc(this_eol_str[j], f, pool)); |
| } |
| } |
| |
| return svn_error_trace(svn_io_file_close(f, pool)); |
| } |
| |
| /* Set up, run, and verify the results of a substitution. |
| * |
| * Create a file TEST_NAME.src using global `lines' as the initial |
| * data, with SRC_EOL as the line separator, then convert it to file |
| * TEST_NAME.dst (using DST_EOL, REPAIR, EXPAND, REV, AUTHOR, DATE, |
| * and URL as svn_subst_copy_and_translate() does), and verify that the |
| * conversion worked. Null SRC_EOL means create a mixed eol src |
| * file. |
| * |
| * If the verification succeeds, remove both files and return |
| * SVN_NO_ERROR. |
| * |
| * If the verification fails, leave the files for post-mortem. If the |
| * failure is due to non-eol data being wrong, return |
| * SVN_ERR_MALFORMED_FILE. If the problem is an incorrect eol marker, |
| * return SVN_ERR_IO_UNKNOWN_EOL. If the problem is that a mixed eol |
| * style was repaired even though no repair flag was passed, return |
| * SVN_ERR_TEST_FAILED. |
| * |
| * Use POOL for temporary allocation. |
| * |
| * Note: as with svn_subst_copy_and_translate(), if any of DST_EOL, REV, |
| * AUTHOR, DATE, and/or URL is null, then that substitution is not |
| * performed. |
| */ |
| static svn_error_t * |
| substitute_and_verify(const char *test_name, |
| const char *src_eol, |
| const char *dst_eol, |
| svn_boolean_t repair, |
| const char *rev, |
| const char *date, |
| const char *author, |
| const char *url, |
| svn_boolean_t expand, |
| apr_pool_t *pool) |
| { |
| svn_error_t *err; |
| svn_stringbuf_t *contents; |
| apr_hash_t *keywords = apr_hash_make(pool); |
| apr_size_t idx = 0; |
| apr_size_t i; |
| const char *expect[(sizeof(lines) / sizeof(*lines))]; |
| const char *src_fname = apr_pstrcat(pool, test_name, ".src", SVN_VA_NULL); |
| const char *dst_fname = apr_pstrcat(pool, test_name, ".dst", SVN_VA_NULL); |
| svn_string_t *val; |
| apr_pool_t *subpool = svn_pool_create(pool); |
| |
| /** Clean up from previous tests, set up src data, and convert. **/ |
| SVN_ERR(svn_io_remove_file2(src_fname, TRUE, pool)); |
| SVN_ERR(svn_io_remove_file2(dst_fname, TRUE, pool)); |
| SVN_ERR(create_file(src_fname, src_eol, pool)); |
| |
| if (rev) |
| { |
| val = svn_string_create(rev, pool); |
| apr_hash_set(keywords, SVN_KEYWORD_REVISION_LONG, |
| APR_HASH_KEY_STRING, val); |
| apr_hash_set(keywords, SVN_KEYWORD_REVISION_MEDIUM, |
| APR_HASH_KEY_STRING, val); |
| apr_hash_set(keywords, SVN_KEYWORD_REVISION_SHORT, |
| APR_HASH_KEY_STRING, val); |
| } |
| if (date) |
| { |
| val = svn_string_create(date, pool); |
| apr_hash_set(keywords, SVN_KEYWORD_DATE_LONG, |
| APR_HASH_KEY_STRING, val); |
| apr_hash_set(keywords, SVN_KEYWORD_DATE_SHORT, |
| APR_HASH_KEY_STRING, val); |
| } |
| if (author) |
| { |
| val = svn_string_create(author, pool); |
| apr_hash_set(keywords, SVN_KEYWORD_AUTHOR_LONG, |
| APR_HASH_KEY_STRING, val); |
| apr_hash_set(keywords, SVN_KEYWORD_AUTHOR_SHORT, |
| APR_HASH_KEY_STRING, val); |
| } |
| if (url) |
| { |
| val = svn_string_create(url, pool); |
| apr_hash_set(keywords, SVN_KEYWORD_URL_LONG, |
| APR_HASH_KEY_STRING, val); |
| apr_hash_set(keywords, SVN_KEYWORD_URL_SHORT, |
| APR_HASH_KEY_STRING, val); |
| } |
| |
| err = svn_subst_copy_and_translate4(src_fname, dst_fname, dst_eol, repair, |
| keywords, expand, FALSE, |
| NULL, NULL, subpool); |
| svn_pool_destroy(subpool); |
| |
| /* Conversion should have failed, if src has mixed eol, and the |
| repair flag was not set, and we requested eol translation. */ |
| if ((! src_eol) && dst_eol && (! repair)) |
| { |
| if (! err) |
| { |
| return svn_error_createf |
| (SVN_ERR_TEST_FAILED, NULL, |
| "translation of '%s' should have failed, but didn't", src_fname); |
| } |
| else if (err->apr_err != SVN_ERR_IO_INCONSISTENT_EOL) |
| { |
| return svn_error_createf |
| (SVN_ERR_TEST_FAILED, err, |
| "translation of '%s' should fail, but not with this error", |
| src_fname); |
| } |
| else |
| { |
| svn_error_clear(err); |
| SVN_ERR(svn_io_remove_file2(src_fname, FALSE, pool)); |
| return SVN_NO_ERROR; |
| } |
| |
| } |
| else if (err) |
| return err; |
| |
| |
| /** Verify that the conversion worked. **/ |
| |
| for (i = 0; i < (sizeof(expect) / sizeof(*expect)); i++) |
| expect[i] = lines[i]; |
| |
| /* Certain lines contain keywords; expect their expansions. */ |
| if (rev) |
| { |
| if (expand) |
| { |
| expect[3 - 1] = |
| apr_pstrcat(pool, "Line 3: ", |
| "Valid $LastChangedRevision: ", |
| rev, |
| " $, started unexpanded.", |
| SVN_VA_NULL); |
| expect[5 - 1] = |
| apr_pstrcat(pool, "Line 5: ", |
| "Valid $Rev: ", rev, " $, started unexpanded.", |
| SVN_VA_NULL); |
| expect[26 - 1] = |
| apr_pstrcat(pool, "Line 26: ", |
| "Emptily expanded keyword $Rev: ", rev," $.", |
| SVN_VA_NULL); |
| expect[29 - 1] = |
| apr_pstrcat(pool, "Line 29: ", |
| "Valid $LastChangedRevision: ", |
| rev, |
| " $, started expanded.", |
| SVN_VA_NULL); |
| expect[30 - 1] = |
| apr_pstrcat(pool, "Line 30: ", |
| "Valid $Rev: ", |
| rev, |
| " $, started expanded.", |
| SVN_VA_NULL); |
| } |
| else /* unexpand */ |
| { |
| /* Lines 3 and 5 remain unchanged. */ |
| expect[26 - 1] = |
| "Line 26: Emptily expanded keyword $Rev$."; |
| expect[29 - 1] = |
| "Line 29: Valid $LastChangedRevision$, started expanded."; |
| expect[30 - 1] = |
| "Line 30: Valid $Rev$, started expanded."; |
| } |
| } |
| |
| if (date) |
| { |
| if (expand) |
| { |
| expect[12 - 1] = |
| apr_pstrcat(pool, "Line 12: ", |
| "Valid $LastChangedDate: ", |
| date, |
| " $, started unexpanded.", |
| SVN_VA_NULL); |
| expect[13 - 1] = |
| apr_pstrcat(pool, "Line 13: ", |
| "Valid $Date: ", date, " $, started unexpanded.", |
| SVN_VA_NULL); |
| expect[33 - 1] = |
| apr_pstrcat(pool, "Line 33: ", |
| "Valid $LastChangedDate: ", |
| date, |
| " $, started expanded.", |
| SVN_VA_NULL); |
| expect[34 - 1] = |
| apr_pstrcat(pool, "Line 34: ", |
| "Valid $Date: ", date, " $, started expanded.", |
| SVN_VA_NULL); |
| expect[51 - 1] = |
| apr_pstrcat(pool, "Line 51: ", |
| "same, but with embedded keyword ", |
| "$$$$$$$$Date: ", date, " $$$$$$$$$$.", |
| SVN_VA_NULL); |
| expect[52 - 1] = |
| apr_pstrcat(pool, "Line 52: ", |
| "same, with expanded, empty keyword ", |
| "$$$$$$Date: ", date, " $$$$$$.", |
| SVN_VA_NULL); |
| } |
| else /* unexpand */ |
| { |
| /* Lines 12 and 13 remain unchanged. */ |
| expect[33 - 1] = |
| "Line 33: Valid $LastChangedDate$, started expanded."; |
| expect[34 - 1] = |
| "Line 34: Valid $Date$, started expanded."; |
| expect[51 - 1] = |
| "Line 51: same, but with embedded keyword $$$$$$$$Date$$$$$$$$$$."; |
| expect[52 - 1] = |
| "Line 52: same, with expanded, empty keyword $$$$$$Date$$$$$$."; |
| } |
| } |
| |
| if (author) |
| { |
| if (expand) |
| { |
| expect[8 - 1] = |
| apr_pstrcat(pool, "Line 8: ", |
| "Valid $LastChangedBy: ", |
| author, |
| " $, started unexpanded.", |
| SVN_VA_NULL); |
| expect[9 - 1] = |
| apr_pstrcat(pool, "Line 9: ", |
| "Valid $Author: ", author, " $, started unexpanded.", |
| SVN_VA_NULL); |
| expect[37 - 1] = |
| apr_pstrcat(pool, "Line 37: ", |
| "Valid $LastChangedBy: ", author, |
| " $, started expanded.", SVN_VA_NULL); |
| expect[38 - 1] = |
| apr_pstrcat(pool, "Line 38: ", |
| "Valid $Author: ", author, " $, started expanded.", |
| SVN_VA_NULL); |
| expect[46 - 1] = |
| apr_pstrcat(pool, "Line 46: ", |
| "Empty $Author: ", author, " $, started expanded.", |
| SVN_VA_NULL); |
| expect[71 - 1] = |
| apr_pstrcat(pool, ".$veR$Author: ", author, " $", SVN_VA_NULL); |
| |
| expect[74 - 1] = |
| apr_pstrcat(pool, "Line 74: ", |
| "Valid $Author: ", author, " $, started expanded.", |
| SVN_VA_NULL); |
| expect[79 - 1] = |
| apr_pstrcat(pool, "Line 79: ", |
| "Valid $Author: ", author, " $, started expanded.", |
| SVN_VA_NULL); |
| expect[80 - 1] = |
| apr_pstrcat(pool, "Line 80: ", |
| "Valid $Author: ", author, " $, started expanded.", |
| SVN_VA_NULL); |
| expect[81 - 1] = |
| apr_pstrcat(pool, "Line 81: ", |
| "Valid $Author: ", author, " $, started expanded.", |
| SVN_VA_NULL); |
| expect[82 - 1] = |
| apr_pstrcat(pool, "Line 82: ", |
| "Valid $Author: ", author, " $, started expanded.", |
| SVN_VA_NULL); |
| } |
| else /* unexpand */ |
| { |
| /* Lines 8, 9, and 71 remain unchanged. */ |
| expect[37 - 1] = |
| "Line 37: Valid $LastChangedBy$, started expanded."; |
| expect[38 - 1] = |
| "Line 38: Valid $Author$, started expanded."; |
| expect[46 - 1] = |
| "Line 46: Empty $Author$, started expanded."; |
| expect[74 - 1] = |
| "Line 74: Valid $Author$, started expanded."; |
| expect[79 - 1] = |
| "Line 79: Valid $Author$, started expanded."; |
| expect[80 - 1] = |
| "Line 80: Valid $Author$, started expanded."; |
| expect[81 - 1] = |
| "Line 81: Valid $Author$, started expanded."; |
| expect[82 - 1] = |
| "Line 82: Valid $Author$, started expanded."; |
| } |
| } |
| |
| if (url) |
| { |
| if (expand) |
| { |
| expect[16 - 1] = |
| apr_pstrcat(pool, "Line 16: ", |
| "Valid $HeadURL: ", url, " $, started unexpanded.", |
| SVN_VA_NULL); |
| expect[17 - 1] = |
| apr_pstrcat(pool, "Line 17: ", |
| "Valid $URL: ", url, " $, started unexpanded.", |
| SVN_VA_NULL); |
| expect[41 - 1] = |
| apr_pstrcat(pool, "Line 41: ", |
| "Valid $HeadURL: ", url, " $, started expanded.", |
| SVN_VA_NULL); |
| expect[42 - 1] = |
| apr_pstrcat(pool, "Line 42: ", |
| "Valid $URL: ", url, " $, started expanded.", |
| SVN_VA_NULL); |
| expect[75 - 1] = |
| apr_pstrcat(pool, "Line 75: ", |
| "Valid $URL: ", url, " $, started expanded.", |
| SVN_VA_NULL); |
| } |
| else /* unexpand */ |
| { |
| /* Lines 16 and 17 and remain unchanged. */ |
| expect[41 - 1] = |
| "Line 41: Valid $HeadURL$, started expanded."; |
| expect[42 - 1] = |
| "Line 42: Valid $URL$, started expanded."; |
| expect[75 - 1] = |
| "Line 75: Valid $URL$, started expanded."; |
| } |
| } |
| |
| /* Handle lines 48, 49, and 70 specially, as they contains two valid |
| keywords. */ |
| if (rev && author) |
| { |
| if (expand) |
| { |
| expect[48 - 1] = |
| apr_pstrcat(pool, "Line 48: ", |
| "Two keywords back to back: " |
| "$Author: ", author, " $" |
| "$Rev: ", rev, " $.", |
| SVN_VA_NULL); |
| expect[49 - 1] = |
| apr_pstrcat(pool, "Line 49: ", |
| "One keyword, one not, back to back: " |
| "$Author: ", author, " $Rev$.", |
| SVN_VA_NULL); |
| expect[70 - 1] = |
| apr_pstrcat(pool, "$Author: ", author, " $Rev$.", SVN_VA_NULL); |
| } |
| /* Else Lines 48, 49, and 70 remain unchanged. */ |
| } |
| else if (rev && (! author)) |
| { |
| if (expand) |
| { |
| expect[48 - 1] = |
| apr_pstrcat(pool, "Line 48: ", |
| "Two keywords back to back: " |
| "$Author$$Rev: ", rev, " $.", |
| SVN_VA_NULL); |
| expect[49 - 1] = |
| apr_pstrcat(pool, "Line 49: ", |
| "One keyword, one not, back to back: " |
| "$Author$Rev: ", rev, " $.", |
| SVN_VA_NULL); |
| expect[70 - 1] = |
| apr_pstrcat(pool, "$Author$Rev: ", rev, " $.", SVN_VA_NULL); |
| } |
| /* Else Lines 48, 49, and 70 remain unchanged. */ |
| } |
| else if ((! rev) && author) |
| { |
| if (expand) |
| { |
| expect[48 - 1] = |
| apr_pstrcat(pool, "Line 48: ", |
| "Two keywords back to back: " |
| "$Author: ", author, " $$Rev$.", |
| SVN_VA_NULL); |
| expect[49 - 1] = |
| apr_pstrcat(pool, "Line 49: ", |
| "One keyword, one not, back to back: " |
| "$Author: ", author, " $Rev$.", |
| SVN_VA_NULL); |
| expect[70 - 1] = |
| apr_pstrcat(pool, "$Author: ", author, " $Rev$.", SVN_VA_NULL); |
| } |
| /* Else Lines 48, 49, and 70 remain unchanged. */ |
| } |
| /* Else neither rev nor author, so Lines 48, 49, and 70 remain |
| unchanged. */ |
| |
| /* Handle line 24 specially, as it contains two valid keywords. */ |
| if (date && author) |
| { |
| if (expand) |
| { |
| expect[24 - 1] = |
| apr_pstrcat(pool, "Line 24: ", |
| "keyword in a keyword: $Author: ", |
| author, |
| " $Date$ $", |
| SVN_VA_NULL); |
| } |
| else /* unexpand */ |
| { |
| expect[24 - 1] = |
| apr_pstrcat(pool, "Line 24: ", |
| "keyword in a keyword: $Author$Date$ $", |
| SVN_VA_NULL); |
| } |
| } |
| else if (date && (! author)) |
| { |
| if (expand) |
| { |
| expect[24 - 1] = |
| apr_pstrcat(pool, "Line 24: ", |
| "keyword in a keyword: $Author: $Date: ", |
| date, |
| " $ $", |
| SVN_VA_NULL); |
| } |
| /* Else Line 24 remains unchanged. */ |
| } |
| else if ((! date) && author) |
| { |
| if (expand) |
| { |
| expect[24 - 1] = |
| apr_pstrcat(pool, "Line 24: ", |
| "keyword in a keyword: $Author: ", |
| author, |
| " $Date$ $", |
| SVN_VA_NULL); |
| } |
| else /* unexpand */ |
| { |
| expect[24 - 1] = |
| apr_pstrcat(pool, "Line 24: ", |
| "keyword in a keyword: $Author$Date$ $", |
| SVN_VA_NULL); |
| } |
| } |
| /* Else neither author nor date, so Line 24 remains unchanged. */ |
| |
| /** Ready to verify. **/ |
| |
| SVN_ERR(svn_stringbuf_from_file(&contents, dst_fname, pool)); |
| |
| for (i = 0; i < (sizeof(expect) / sizeof(*expect)); i++) |
| { |
| if (contents->len < idx) |
| return svn_error_createf |
| (SVN_ERR_MALFORMED_FILE, NULL, |
| "'%s' has short contents at line %" APR_SIZE_T_FMT, |
| dst_fname, i + 1); |
| |
| if (strncmp(contents->data + idx, expect[i], strlen(expect[i])) != 0) |
| return svn_error_createf |
| (SVN_ERR_MALFORMED_FILE, NULL, |
| "'%s' has wrong contents at line %" APR_SIZE_T_FMT, |
| dst_fname, i + 1); |
| |
| /* Else, the data is correct, at least up to the next eol. */ |
| |
| idx += strlen(expect[i]); |
| |
| if (dst_eol) /* verify the promised consistent eol style */ |
| { |
| if (strncmp(contents->data + idx, dst_eol, strlen(dst_eol)) != 0) |
| return svn_error_createf |
| (SVN_ERR_IO_UNKNOWN_EOL, NULL, |
| "'%s' has wrong eol style at line %" APR_SIZE_T_FMT, dst_fname, |
| i + 1); |
| else |
| idx += strlen(dst_eol); |
| } |
| else /* allow any eol style, even inconsistent ones, loosely */ |
| { |
| while ((*(contents->data + idx) == '\r') |
| || (*(contents->data + idx) == '\n')) |
| idx++; |
| } |
| } |
| |
| /* Clean up this test, since successful. */ |
| SVN_ERR(svn_io_remove_file2(src_fname, FALSE, pool)); |
| SVN_ERR(svn_io_remove_file2(dst_fname, FALSE, pool)); |
| |
| return SVN_NO_ERROR; |
| } |
| |
| |
| |
| static svn_error_t * |
| noop(apr_pool_t *pool) |
| { |
| SVN_ERR(substitute_and_verify |
| ("noop", NULL, NULL, 0, NULL, NULL, NULL, NULL, 1, pool)); |
| |
| SVN_ERR(substitute_and_verify |
| ("noop", "\r", NULL, 0, NULL, NULL, NULL, NULL, 1, pool)); |
| |
| SVN_ERR(substitute_and_verify |
| ("noop", "\n", NULL, 0, NULL, NULL, NULL, NULL, 1, pool)); |
| |
| SVN_ERR(substitute_and_verify |
| ("noop", "\r\n", NULL, 0, NULL, NULL, NULL, NULL, 1, pool)); |
| |
| return SVN_NO_ERROR; |
| } |
| |
| |
| |
| |
| /** EOL conversion alone. **/ |
| |
| static svn_error_t * |
| crlf_to_crlf(apr_pool_t *pool) |
| { |
| return substitute_and_verify |
| ("crlf_to_crlf", "\r\n", "\r\n", 0, |
| NULL, NULL, NULL, NULL, 1, pool); |
| } |
| |
| |
| static svn_error_t * |
| lf_to_crlf(apr_pool_t *pool) |
| { |
| return substitute_and_verify |
| ("lf_to_crlf", "\n", "\r\n", 0, NULL, NULL, NULL, NULL, 1, pool); |
| } |
| |
| |
| static svn_error_t * |
| cr_to_crlf(apr_pool_t *pool) |
| { |
| return substitute_and_verify |
| ("cr_to_crlf", "\r", "\r\n", 0, NULL, NULL, NULL, NULL, 1, pool); |
| } |
| |
| |
| static svn_error_t * |
| mixed_to_crlf(apr_pool_t *pool) |
| { |
| return substitute_and_verify |
| ("mixed_to_crlf", NULL, "\r\n", 1, |
| NULL, NULL, NULL, NULL, 1, pool); |
| } |
| |
| |
| static svn_error_t * |
| lf_to_lf(apr_pool_t *pool) |
| { |
| return substitute_and_verify |
| ("lf_to_lf", "\n", "\n", 0, NULL, NULL, NULL, NULL, 1, pool); |
| } |
| |
| |
| static svn_error_t * |
| crlf_to_lf(apr_pool_t *pool) |
| { |
| return substitute_and_verify |
| ("crlf_to_lf", "\r\n", "\n", 0, NULL, NULL, NULL, NULL, 1, pool); |
| } |
| |
| |
| static svn_error_t * |
| cr_to_lf(apr_pool_t *pool) |
| { |
| return substitute_and_verify |
| ("cr_to_lf", "\r", "\n", 0, NULL, NULL, NULL, NULL, 1, pool); |
| } |
| |
| |
| static svn_error_t * |
| mixed_to_lf(apr_pool_t *pool) |
| { |
| return substitute_and_verify |
| ("mixed_to_lf", NULL, "\n", 1, NULL, NULL, NULL, NULL, 1, pool); |
| } |
| |
| |
| static svn_error_t * |
| crlf_to_cr(apr_pool_t *pool) |
| { |
| return substitute_and_verify |
| ("crlf_to_cr", "\r\n", "\r", 0, NULL, NULL, NULL, NULL, 1, pool); |
| } |
| |
| |
| static svn_error_t * |
| lf_to_cr(apr_pool_t *pool) |
| { |
| return substitute_and_verify |
| ("lf_to_cr", "\n", "\r", 0, NULL, NULL, NULL, NULL, 1, pool); |
| } |
| |
| |
| static svn_error_t * |
| cr_to_cr(apr_pool_t *pool) |
| { |
| return substitute_and_verify |
| ("cr_to_cr", "\r", "\r", 0, NULL, NULL, NULL, NULL, 1, pool); |
| } |
| |
| |
| static svn_error_t * |
| mixed_to_cr(apr_pool_t *pool) |
| { |
| return substitute_and_verify |
| ("mixed_to_cr", NULL, "\r", 1, NULL, NULL, NULL, NULL, 1, pool); |
| } |
| |
| |
| static svn_error_t * |
| mixed_no_repair(apr_pool_t *pool) |
| { |
| SVN_ERR(substitute_and_verify |
| ("mixed_no_repair", NULL, "\n", 0, |
| NULL, NULL, NULL, NULL, 1, pool)); |
| |
| SVN_ERR(substitute_and_verify |
| ("mixed_no_repair", NULL, "\r\n", 0, |
| NULL, NULL, NULL, NULL, 1, pool)); |
| |
| return SVN_NO_ERROR; |
| } |
| |
| |
| |
| /** Keyword expansion alone. **/ |
| |
| static svn_error_t * |
| expand_author(apr_pool_t *pool) |
| { |
| SVN_ERR(substitute_and_verify |
| ("author", "\n", NULL, 0, NULL, NULL, "jrandom", NULL, 1, pool)); |
| |
| SVN_ERR(substitute_and_verify |
| ("author", "\r\n", NULL, 0, NULL, NULL, "jrandom", NULL, 1, pool)); |
| |
| return SVN_NO_ERROR; |
| } |
| |
| |
| static svn_error_t * |
| expand_date(apr_pool_t *pool) |
| { |
| SVN_ERR(substitute_and_verify |
| ("date", "\n", NULL, 0, |
| NULL, "Wed Jan 9 07:49:05 2002", NULL, NULL, 1, pool)); |
| |
| SVN_ERR(substitute_and_verify |
| ("date", "\r\n", NULL, 0, |
| NULL, "Wed Jan 9 07:49:05 2002", NULL, NULL, 1, pool)); |
| |
| return SVN_NO_ERROR; |
| } |
| |
| |
| static svn_error_t * |
| expand_author_date(apr_pool_t *pool) |
| { |
| SVN_ERR(substitute_and_verify |
| ("author_date", "\n", NULL, 0, |
| NULL, "Wed Jan 9 07:49:05 2002", "jrandom", NULL, 1, pool)); |
| |
| SVN_ERR(substitute_and_verify |
| ("author_date", "\r\n", NULL, 0, |
| NULL, "Wed Jan 9 07:49:05 2002", "jrandom", NULL, 1, pool)); |
| |
| return SVN_NO_ERROR; |
| } |
| |
| |
| static svn_error_t * |
| expand_author_rev(apr_pool_t *pool) |
| { |
| SVN_ERR(substitute_and_verify |
| ("author_rev", "\n", NULL, 0, |
| "1729", NULL, "jrandom", NULL, 1, pool)); |
| |
| SVN_ERR(substitute_and_verify |
| ("author_rev", "\r\n", NULL, 0, |
| "1729", NULL, "jrandom", NULL, 1, pool)); |
| |
| return SVN_NO_ERROR; |
| } |
| |
| |
| static svn_error_t * |
| expand_rev(apr_pool_t *pool) |
| { |
| SVN_ERR(substitute_and_verify |
| ("rev", "\n", NULL, 0, |
| "1729", NULL, NULL, NULL, 1, pool)); |
| |
| SVN_ERR(substitute_and_verify |
| ("rev", "\r\n", NULL, 0, |
| "1729", NULL, NULL, NULL, 1, pool)); |
| |
| return SVN_NO_ERROR; |
| } |
| |
| |
| static svn_error_t * |
| expand_rev_url(apr_pool_t *pool) |
| { |
| SVN_ERR(substitute_and_verify |
| ("rev_url", "\n", NULL, 0, |
| "1729", NULL, NULL, "http://subversion.tigris.org", 1, pool)); |
| |
| SVN_ERR(substitute_and_verify |
| ("rev_url", "\r\n", NULL, 0, |
| "1729", NULL, NULL, "http://subversion.tigris.org", 1, pool)); |
| |
| return SVN_NO_ERROR; |
| } |
| |
| |
| static svn_error_t * |
| expand_author_date_rev_url(apr_pool_t *pool) |
| { |
| SVN_ERR(substitute_and_verify |
| ("author_date_rev_url", "\n", NULL, 0, |
| "1729", |
| "Wed Jan 9 07:49:05 2002", |
| "jrandom", |
| "http://subversion.tigris.org", |
| 1, pool)); |
| |
| SVN_ERR(substitute_and_verify |
| ("author_date_rev_url", "\r\n", NULL, 0, |
| "1729", |
| "Wed Jan 9 07:49:05 2002", |
| "jrandom", |
| "http://subversion.tigris.org", |
| 1, pool)); |
| |
| return SVN_NO_ERROR; |
| } |
| |
| |
| |
| /** Keyword expansion and EOL conversion together. **/ |
| |
| static svn_error_t * |
| lf_to_crlf_expand_author(apr_pool_t *pool) |
| { |
| return substitute_and_verify |
| ("lf_to_crlf_author", "\n", "\r\n", 0, |
| NULL, NULL, "jrandom", NULL, 1, pool); |
| } |
| |
| |
| static svn_error_t * |
| mixed_to_lf_expand_author_date(apr_pool_t *pool) |
| { |
| return substitute_and_verify |
| ("mixed_to_lf_author_date", NULL, "\n", 1, |
| NULL, "Wed Jan 9 07:49:05 2002", "jrandom", NULL, 1, pool); |
| } |
| |
| |
| static svn_error_t * |
| crlf_to_cr_expand_author_rev(apr_pool_t *pool) |
| { |
| return substitute_and_verify |
| ("crlf_to_cr_author_rev", "\r\n", "\r", 0, |
| "1729", NULL, "jrandom", NULL, 1, pool); |
| } |
| |
| |
| static svn_error_t * |
| cr_to_crlf_expand_rev(apr_pool_t *pool) |
| { |
| return substitute_and_verify |
| ("cr_to_crlf_rev", "\r", "\r\n", 0, |
| "1729", NULL, NULL, NULL, 1, pool); |
| } |
| |
| |
| static svn_error_t * |
| cr_to_crlf_expand_rev_url(apr_pool_t *pool) |
| { |
| return substitute_and_verify |
| ("cr_to_crlf_rev_url", "\r", "\r\n", 0, |
| "1729", NULL, NULL, "http://subversion.tigris.org", 1, pool); |
| } |
| |
| |
| static svn_error_t * |
| mixed_to_crlf_expand_author_date_rev_url(apr_pool_t *pool) |
| { |
| return substitute_and_verify |
| ("mixed_to_crlf_author_date_rev_url", NULL, "\r\n", 1, |
| "1729", |
| "Wed Jan 9 07:49:05 2002", |
| "jrandom", |
| "http://subversion.tigris.org", |
| 1, |
| pool); |
| } |
| |
| |
| |
| /** Keyword unexpansion alone. **/ |
| |
| static svn_error_t * |
| unexpand_author(apr_pool_t *pool) |
| { |
| SVN_ERR(substitute_and_verify |
| ("unexpand_author", "\n", NULL, 0, NULL, NULL, "jrandom", NULL, 0, pool)); |
| |
| SVN_ERR(substitute_and_verify |
| ("unexpand_author", "\r\n", NULL, 0, NULL, NULL, "jrandom", NULL, 0, pool)); |
| |
| return SVN_NO_ERROR; |
| } |
| |
| |
| static svn_error_t * |
| unexpand_date(apr_pool_t *pool) |
| { |
| SVN_ERR(substitute_and_verify |
| ("unexpand_date", "\n", NULL, 0, |
| NULL, "Wed Jan 9 07:49:05 2002", NULL, NULL, 0, pool)); |
| |
| SVN_ERR(substitute_and_verify |
| ("unexpand_date", "\r\n", NULL, 0, |
| NULL, "Wed Jan 9 07:49:05 2002", NULL, NULL, 0, pool)); |
| |
| return SVN_NO_ERROR; |
| } |
| |
| |
| static svn_error_t * |
| unexpand_author_date(apr_pool_t *pool) |
| { |
| SVN_ERR(substitute_and_verify |
| ("unexpand_author_date", "\n", NULL, 0, |
| NULL, "Wed Jan 9 07:49:05 2002", "jrandom", NULL, 0, pool)); |
| |
| SVN_ERR(substitute_and_verify |
| ("unexpand_author_date", "\r\n", NULL, 0, |
| NULL, "Wed Jan 9 07:49:05 2002", "jrandom", NULL, 0, pool)); |
| |
| return SVN_NO_ERROR; |
| } |
| |
| |
| static svn_error_t * |
| unexpand_author_rev(apr_pool_t *pool) |
| { |
| SVN_ERR(substitute_and_verify |
| ("unexpand_author_rev", "\n", NULL, 0, |
| "1729", NULL, "jrandom", NULL, 0, pool)); |
| |
| SVN_ERR(substitute_and_verify |
| ("unexpand_author_rev", "\r\n", NULL, 0, |
| "1729", NULL, "jrandom", NULL, 0, pool)); |
| |
| return SVN_NO_ERROR; |
| } |
| |
| |
| static svn_error_t * |
| unexpand_rev(apr_pool_t *pool) |
| { |
| SVN_ERR(substitute_and_verify |
| ("unexpand_rev", "\n", NULL, 0, |
| "1729", NULL, NULL, NULL, 0, pool)); |
| |
| SVN_ERR(substitute_and_verify |
| ("unexpand_rev", "\r\n", NULL, 0, |
| "1729", NULL, NULL, NULL, 0, pool)); |
| |
| return SVN_NO_ERROR; |
| } |
| |
| |
| static svn_error_t * |
| unexpand_rev_url(apr_pool_t *pool) |
| { |
| SVN_ERR(substitute_and_verify |
| ("unexpand_rev_url", "\n", NULL, 0, |
| "1729", NULL, NULL, "http://subversion.tigris.org", 0, pool)); |
| |
| SVN_ERR(substitute_and_verify |
| ("unexpand_rev_url", "\r\n", NULL, 0, |
| "1729", NULL, NULL, "http://subversion.tigris.org", 0, pool)); |
| |
| return SVN_NO_ERROR; |
| } |
| |
| |
| static svn_error_t * |
| unexpand_author_date_rev_url(apr_pool_t *pool) |
| { |
| SVN_ERR(substitute_and_verify |
| ("unexpand_author_date_rev_url", "\n", NULL, 0, |
| "1729", |
| "Wed Jan 9 07:49:05 2002", |
| "jrandom", |
| "http://subversion.tigris.org", |
| 1, pool)); |
| |
| SVN_ERR(substitute_and_verify |
| ("unexpand_author_date_rev_url", "\r\n", NULL, 0, |
| "1729", |
| "Wed Jan 9 07:49:05 2002", |
| "jrandom", |
| "http://subversion.tigris.org", |
| 1, pool)); |
| |
| return SVN_NO_ERROR; |
| } |
| |
| |
| |
| /** Keyword unexpansion and EOL conversion together. **/ |
| |
| static svn_error_t * |
| lf_to_crlf_unexpand_author(apr_pool_t *pool) |
| { |
| return substitute_and_verify |
| ("lf_to_crlf_unexpand_author", "\n", "\r\n", 0, |
| NULL, NULL, "jrandom", NULL, 0, pool); |
| } |
| |
| |
| static svn_error_t * |
| mixed_to_lf_unexpand_author_date(apr_pool_t *pool) |
| { |
| return substitute_and_verify |
| ("mixed_to_lf_unexpand_author_date", NULL, "\n", 1, |
| NULL, "Wed Jan 9 07:49:05 2002", "jrandom", NULL, 0, pool); |
| } |
| |
| |
| static svn_error_t * |
| crlf_to_cr_unexpand_author_rev(apr_pool_t *pool) |
| { |
| return substitute_and_verify |
| ("crlf_to_cr_unexpand_author_rev", "\r\n", "\r", 0, |
| "1729", NULL, "jrandom", NULL, 0, pool); |
| } |
| |
| |
| static svn_error_t * |
| cr_to_crlf_unexpand_rev(apr_pool_t *pool) |
| { |
| return substitute_and_verify |
| ("cr_to_crlf_unexpand_rev", "\r", "\r\n", 0, |
| "1729", NULL, NULL, NULL, 0, pool); |
| } |
| |
| |
| static svn_error_t * |
| cr_to_crlf_unexpand_rev_url(apr_pool_t *pool) |
| { |
| return substitute_and_verify |
| ("cr_to_crlf_unexpand_rev_url", "\r", "\r\n", 0, |
| "1729", NULL, NULL, "http://subversion.tigris.org", 0, pool); |
| } |
| |
| |
| static svn_error_t * |
| mixed_to_crlf_unexpand_author_date_rev_url(apr_pool_t *pool) |
| { |
| return substitute_and_verify |
| ("mixed_to_crlf_unexpand_author_date_rev_url", NULL, "\r\n", 1, |
| "1729", |
| "Wed Jan 9 07:49:05 2002", |
| "jrandom", |
| "http://subversion.tigris.org", |
| 0, |
| pool); |
| } |
| |
| |
| |
| /* The test table. */ |
| |
| static int max_threads = 7; |
| |
| static struct svn_test_descriptor_t test_funcs[] = |
| { |
| SVN_TEST_NULL, |
| /* The no-op conversion. */ |
| SVN_TEST_PASS2(noop, |
| "no conversions"), |
| /* Conversions resulting in crlf, no keywords involved. */ |
| SVN_TEST_PASS2(crlf_to_crlf, |
| "convert CRLF to CRLF"), |
| SVN_TEST_PASS2(lf_to_crlf, |
| "convert LF to CRLF"), |
| SVN_TEST_PASS2(cr_to_crlf, |
| "convert CR to CRLF"), |
| SVN_TEST_PASS2(mixed_to_crlf, |
| "convert mixed line endings to CRLF"), |
| /* Conversions resulting in lf, no keywords involved. */ |
| SVN_TEST_PASS2(lf_to_lf, |
| "convert LF to LF"), |
| SVN_TEST_PASS2(crlf_to_lf, |
| "convert CRLF to LF"), |
| SVN_TEST_PASS2(cr_to_lf, |
| "convert CR to LF"), |
| SVN_TEST_PASS2(mixed_to_lf, |
| "convert mixed line endings to LF"), |
| /* Conversions resulting in cr, no keywords involved. */ |
| SVN_TEST_PASS2(crlf_to_cr, |
| "convert CRLF to CR"), |
| SVN_TEST_PASS2(lf_to_cr, |
| "convert LF to CR"), |
| SVN_TEST_PASS2(cr_to_cr, |
| "convert CR to CR"), |
| SVN_TEST_PASS2(mixed_to_cr, |
| "convert mixed line endings to CR"), |
| /* Random eol stuff. */ |
| SVN_TEST_PASS2(mixed_no_repair, |
| "keep mixed line endings without repair flag"), |
| /* Keyword expansion alone, no eol conversion involved. */ |
| SVN_TEST_PASS2(expand_author, |
| "expand author"), |
| SVN_TEST_PASS2(expand_date, |
| "expand date"), |
| SVN_TEST_PASS2(expand_author_date, |
| "expand author and date"), |
| SVN_TEST_PASS2(expand_author_rev, |
| "expand author and rev"), |
| SVN_TEST_PASS2(expand_rev, |
| "expand rev"), |
| SVN_TEST_PASS2(expand_rev_url, |
| "expand rev and url"), |
| SVN_TEST_PASS2(expand_author_date_rev_url, |
| "expand author, date, rev, and url"), |
| /* Keyword expansion and eol conversion together. */ |
| SVN_TEST_PASS2(lf_to_crlf_expand_author, |
| "lf_to_crlf; expand author"), |
| SVN_TEST_PASS2(mixed_to_lf_expand_author_date, |
| "mixed_to_lf; expand author and date"), |
| SVN_TEST_PASS2(crlf_to_cr_expand_author_rev, |
| "crlf_to_cr; expand author and rev"), |
| SVN_TEST_PASS2(cr_to_crlf_expand_rev, |
| "cr_to_crlf; expand rev"), |
| SVN_TEST_PASS2(cr_to_crlf_expand_rev_url, |
| "cr_to_crlf; expand rev and url"), |
| SVN_TEST_PASS2(mixed_to_crlf_expand_author_date_rev_url, |
| "mixed_to_crlf; expand author, date, rev, and url"), |
| /* Keyword unexpansion alone, no eol conversion involved. */ |
| SVN_TEST_PASS2(unexpand_author, |
| "unexpand author"), |
| SVN_TEST_PASS2(unexpand_date, |
| "unexpand date"), |
| SVN_TEST_PASS2(unexpand_author_date, |
| "unexpand author and date"), |
| SVN_TEST_PASS2(unexpand_author_rev, |
| "unexpand author and rev"), |
| SVN_TEST_PASS2(unexpand_rev, |
| "unexpand rev"), |
| SVN_TEST_PASS2(unexpand_rev_url, |
| "unexpand rev and url"), |
| SVN_TEST_PASS2(unexpand_author_date_rev_url, |
| "unexpand author, date, rev, and url"), |
| /* Keyword unexpansion and eol conversion together. */ |
| SVN_TEST_PASS2(lf_to_crlf_unexpand_author, |
| "lf_to_crlf; unexpand author"), |
| SVN_TEST_PASS2(mixed_to_lf_unexpand_author_date, |
| "mixed_to_lf; unexpand author and date"), |
| SVN_TEST_PASS2(crlf_to_cr_unexpand_author_rev, |
| "crlf_to_cr; unexpand author and rev"), |
| SVN_TEST_PASS2(cr_to_crlf_unexpand_rev, |
| "cr_to_crlf; unexpand rev"), |
| SVN_TEST_PASS2(cr_to_crlf_unexpand_rev_url, |
| "cr_to_crlf; unexpand rev and url"), |
| SVN_TEST_PASS2(mixed_to_crlf_unexpand_author_date_rev_url, |
| "mixed_to_crlf; unexpand author, date, rev, url"), |
| SVN_TEST_NULL |
| }; |
| |
| SVN_TEST_MAIN |
