Author: svn-role
Date: Wed Mar 30 04:00:07 2022
New Revision: 1899369
URL: http://svn.apache.org/viewvc?rev=1899369&view=rev
Log:
Merge the r1872030 group from trunk:
* r1872030, r1872031, r1872104, r1872107, r1872108, r1872115, r1872118,
r1872121, r1872388, r1872433, r1872910, r1872919, r1872921, r1872922,
r1872923, r1872924, r1873294, r1873297, r1875188, r1875189
Fix issue #4840, Merge assertion failure in svn_sort__array_insert
Justification:
A merge with complex mergeinfo could abort with an assertion failure.
Votes:
+1: stsp, rhuijben, markphip
+1: julianfoad (without r1875188,r1875189)
Modified:
subversion/branches/1.10.x/ (props changed)
subversion/branches/1.10.x/STATUS
subversion/branches/1.10.x/subversion/include/private/svn_sorts_private.h
subversion/branches/1.10.x/subversion/libsvn_client/merge.c
subversion/branches/1.10.x/subversion/libsvn_subr/mergeinfo.c
subversion/branches/1.10.x/subversion/libsvn_subr/sorts.c
subversion/branches/1.10.x/subversion/tests/libsvn_subr/mergeinfo-test.c
Propchange: subversion/branches/1.10.x/
------------------------------------------------------------------------------
Merged
/subversion/trunk:r1872030-1872031,1872104,1872107-1872108,1872115,1872118,1872121,1872388,1872433,1872910,1872919,1872921-1872924,1873294,1873297,1875188-1875189
Modified: subversion/branches/1.10.x/STATUS
URL:
http://svn.apache.org/viewvc/subversion/branches/1.10.x/STATUS?rev=1899369&r1=1899368&r2=1899369&view=diff
==============================================================================
--- subversion/branches/1.10.x/STATUS (original)
+++ subversion/branches/1.10.x/STATUS Wed Mar 30 04:00:07 2022
@@ -21,13 +21,3 @@ Veto-blocked changes:
Approved changes:
=================
-
- * r1872030, r1872031, r1872104, r1872107, r1872108, r1872115, r1872118,
- r1872121, r1872388, r1872433, r1872910, r1872919, r1872921, r1872922,
- r1872923, r1872924, r1873294, r1873297, r1875188, r1875189
- Fix issue #4840, Merge assertion failure in svn_sort__array_insert
- Justification:
- A merge with complex mergeinfo could abort with an assertion failure.
- Votes:
- +1: stsp, rhuijben, markphip
- +1: julianfoad (without r1875188,r1875189)
Modified:
subversion/branches/1.10.x/subversion/include/private/svn_sorts_private.h
URL:
http://svn.apache.org/viewvc/subversion/branches/1.10.x/subversion/include/private/svn_sorts_private.h?rev=1899369&r1=1899368&r2=1899369&view=diff
==============================================================================
--- subversion/branches/1.10.x/subversion/include/private/svn_sorts_private.h
(original)
+++ subversion/branches/1.10.x/subversion/include/private/svn_sorts_private.h
Wed Mar 30 04:00:07 2022
@@ -127,6 +127,16 @@ svn_sort__array_insert(apr_array_header_
const void *new_element,
int insert_index);
+/* Like svn_sort__array_insert() but raise an error if @a insert_index
+ * is less than 0 or greater than the length of the array.
+ *
+ * @note Private. For use by Subversion's own code only.
+ */
+svn_error_t *
+svn_sort__array_insert2(apr_array_header_t *array,
+ const void *new_element,
+ int insert_index);
+
/* Remove @a elements_to_delete elements starting at @a delete_index from the
* array @a arr. If @a delete_index is not a valid element of @a arr,
@@ -141,6 +151,16 @@ svn_sort__array_delete(apr_array_header_
int delete_index,
int elements_to_delete);
+/* Like svn_sort__array_delete() but raise an error if attempting
+ * to delete a range of elements that goes out of bounds of the array.
+ *
+ * @note Private. For use by Subversion's own code only.
+ */
+svn_error_t *
+svn_sort__array_delete2(apr_array_header_t *arr,
+ int delete_index,
+ int elements_to_delete);
+
/* Reverse the order of elements in @a array, in place.
*
* @note Private. For use by Subversion's own code only.
Modified: subversion/branches/1.10.x/subversion/libsvn_client/merge.c
URL:
http://svn.apache.org/viewvc/subversion/branches/1.10.x/subversion/libsvn_client/merge.c?rev=1899369&r1=1899368&r2=1899369&view=diff
==============================================================================
--- subversion/branches/1.10.x/subversion/libsvn_client/merge.c (original)
+++ subversion/branches/1.10.x/subversion/libsvn_client/merge.c Wed Mar 30
04:00:07 2022
@@ -5951,7 +5951,7 @@ get_most_inclusive_rev(const apr_array_h
remaining_ranges is inclusive of END_REV, Slice the first range in
to two at END_REV. All the allocations are persistent and allocated
from POOL. */
-static void
+static svn_error_t *
slice_remaining_ranges(apr_array_header_t *children_with_mergeinfo,
svn_boolean_t is_rollback, svn_revnum_t end_rev,
apr_pool_t *pool)
@@ -5981,10 +5981,12 @@ slice_remaining_ranges(apr_array_header_
split_range2->start = end_rev;
APR_ARRAY_IDX(child->remaining_ranges, 0,
svn_merge_range_t *) = split_range1;
- svn_sort__array_insert(child->remaining_ranges, &split_range2,
1);
+ SVN_ERR(svn_sort__array_insert2(child->remaining_ranges,
+ &split_range2, 1));
}
}
}
+ return SVN_NO_ERROR;
}
/* Helper for do_directory_merge().
@@ -6106,7 +6108,7 @@ get_child_with_mergeinfo(const apr_array
out of order and then sort afterwards. (One caller is doing a qsort
after calling this anyway.)
*/
-static void
+static svn_error_t *
insert_child_to_merge(apr_array_header_t *children_with_mergeinfo,
const svn_client__merge_path_t *insert_element,
apr_pool_t *pool)
@@ -6120,7 +6122,9 @@ insert_child_to_merge(apr_array_header_t
compare_merge_path_t_as_paths);
new_element = svn_client__merge_path_dup(insert_element, pool);
- svn_sort__array_insert(children_with_mergeinfo, &new_element, insert_index);
+ SVN_ERR(svn_sort__array_insert2(children_with_mergeinfo,
+ &new_element, insert_index));
+ return SVN_NO_ERROR;
}
/* Helper for get_mergeinfo_paths().
@@ -6181,7 +6185,7 @@ insert_parent_and_sibs_of_sw_absent_del_
parent->missing_child = child->absent;
parent->switched_child = child->switched;
/* Insert PARENT into CHILDREN_WITH_MERGEINFO. */
- insert_child_to_merge(children_with_mergeinfo, parent, pool);
+ SVN_ERR(insert_child_to_merge(children_with_mergeinfo, parent, pool));
/* Increment for loop index so we don't process the inserted element. */
(*curr_index)++;
} /*(parent == NULL) */
@@ -6218,8 +6222,8 @@ insert_parent_and_sibs_of_sw_absent_del_
sibling_of_missing = svn_client__merge_path_create(child_abspath,
pool);
- insert_child_to_merge(children_with_mergeinfo, sibling_of_missing,
- pool);
+ SVN_ERR(insert_child_to_merge(children_with_mergeinfo,
+ sibling_of_missing, pool));
}
}
@@ -6560,8 +6564,8 @@ get_mergeinfo_paths(apr_array_header_t *
svn_client__merge_path_t *switched_child =
svn_client__merge_path_create(wc_path, result_pool);
switched_child->switched = TRUE;
- insert_child_to_merge(children_with_mergeinfo, switched_child,
- result_pool);
+ SVN_ERR(insert_child_to_merge(children_with_mergeinfo,
+ switched_child, result_pool));
}
}
}
@@ -6613,8 +6617,8 @@ get_mergeinfo_paths(apr_array_header_t *
}
if (new_shallow_child)
- insert_child_to_merge(children_with_mergeinfo, shallow_child,
- result_pool);
+ SVN_ERR(insert_child_to_merge(children_with_mergeinfo,
+ shallow_child, result_pool));
}
}
@@ -6643,8 +6647,8 @@ get_mergeinfo_paths(apr_array_header_t *
svn_client__merge_path_t *absent_child =
svn_client__merge_path_create(wc_path, result_pool);
absent_child->absent = TRUE;
- insert_child_to_merge(children_with_mergeinfo, absent_child,
- result_pool);
+ SVN_ERR(insert_child_to_merge(children_with_mergeinfo,
+ absent_child, result_pool));
}
}
}
@@ -6657,8 +6661,8 @@ get_mergeinfo_paths(apr_array_header_t *
svn_client__merge_path_t *target_child =
svn_client__merge_path_create(target->abspath,
result_pool);
- insert_child_to_merge(children_with_mergeinfo, target_child,
- result_pool);
+ SVN_ERR(insert_child_to_merge(children_with_mergeinfo, target_child,
+ result_pool));
}
/* Case 8: Path is an immediate *directory* child of
@@ -6701,8 +6705,8 @@ get_mergeinfo_paths(apr_array_header_t *
&& depth == svn_depth_immediates)
immediate_child->immediate_child_dir = TRUE;
- insert_child_to_merge(children_with_mergeinfo,
- immediate_child, result_pool);
+ SVN_ERR(insert_child_to_merge(children_with_mergeinfo,
+ immediate_child, result_pool));
}
}
}
@@ -6794,9 +6798,9 @@ get_mergeinfo_paths(apr_array_header_t *
child_of_noninheritable =
svn_client__merge_path_create(child_abspath, result_pool);
child_of_noninheritable->child_of_noninheritable = TRUE;
- insert_child_to_merge(children_with_mergeinfo,
- child_of_noninheritable,
- result_pool);
+ SVN_ERR(insert_child_to_merge(children_with_mergeinfo,
+ child_of_noninheritable,
+ result_pool));
if (!dry_run && same_repos)
{
svn_mergeinfo_t mergeinfo;
@@ -7220,7 +7224,7 @@ normalize_merge_sources_internal(apr_arr
new_segment->path = original_repos_relpath;
new_segment->range_start = original_revision;
new_segment->range_end = original_revision;
- svn_sort__array_insert(segments, &new_segment, 0);
+ SVN_ERR(svn_sort__array_insert2(segments, &new_segment, 0));
}
}
}
@@ -7969,7 +7973,8 @@ process_children_with_new_mergeinfo(merg
/* Set the path's remaining_ranges equal to its parent's. */
new_child->remaining_ranges = svn_rangelist_dup(
parent->remaining_ranges, pool);
- insert_child_to_merge(children_with_mergeinfo, new_child, pool);
+ SVN_ERR(insert_child_to_merge(children_with_mergeinfo,
+ new_child, pool));
}
}
}
@@ -9501,8 +9506,9 @@ do_mergeinfo_aware_dir_merge(svn_mergein
svn_pool_clear(iterpool);
- slice_remaining_ranges(children_with_mergeinfo,
- is_rollback, end_rev, scratch_pool);
+ SVN_ERR(slice_remaining_ranges(children_with_mergeinfo,
+ is_rollback, end_rev,
+ scratch_pool));
/* Reset variables that must be reset for every drive */
merge_b->notify_begin.last_abspath = NULL;
Modified: subversion/branches/1.10.x/subversion/libsvn_subr/mergeinfo.c
URL:
http://svn.apache.org/viewvc/subversion/branches/1.10.x/subversion/libsvn_subr/mergeinfo.c?rev=1899369&r1=1899368&r2=1899369&view=diff
==============================================================================
--- subversion/branches/1.10.x/subversion/libsvn_subr/mergeinfo.c (original)
+++ subversion/branches/1.10.x/subversion/libsvn_subr/mergeinfo.c Wed Mar 30
04:00:07 2022
@@ -44,8 +44,9 @@
/* Return TRUE iff the forward revision range FIRST wholly contains the
* forward revision range SECOND and (if CONSIDER_INHERITANCE is TRUE) has
* the same inheritability. */
-static svn_boolean_t
-range_contains(const svn_merge_range_t *first, const svn_merge_range_t *second,
+static svn_error_t *
+range_contains(svn_boolean_t *result,
+ const svn_merge_range_t *first, const svn_merge_range_t *second,
svn_boolean_t consider_inheritance);
@@ -457,21 +458,48 @@ combine_with_lastrange(const svn_merge_r
}
/* Convert a single svn_merge_range_t *RANGE back into a string. */
-static char *
-range_to_string(const svn_merge_range_t *range,
+static svn_error_t *
+range_to_string(char **s,
+ const svn_merge_range_t *range,
apr_pool_t *pool)
{
const char *mark
= range->inheritable ? "" : SVN_MERGEINFO_NONINHERITABLE_STR;
if (range->start == range->end - 1)
- return apr_psprintf(pool, "%ld%s", range->end, mark);
+ *s = apr_psprintf(pool, "%ld%s", range->end, mark);
else if (range->start - 1 == range->end)
- return apr_psprintf(pool, "-%ld%s", range->start, mark);
+ *s = apr_psprintf(pool, "-%ld%s", range->start, mark);
else if (range->start < range->end)
- return apr_psprintf(pool, "%ld-%ld%s", range->start + 1, range->end, mark);
+ *s = apr_psprintf(pool, "%ld-%ld%s", range->start + 1, range->end, mark);
+ else if (range->start > range->end)
+ *s = apr_psprintf(pool, "%ld-%ld%s", range->start, range->end + 1, mark);
else
- return apr_psprintf(pool, "%ld-%ld%s", range->start, range->end + 1, mark);
+ {
+ return svn_error_createf(SVN_ERR_ASSERTION_FAIL, NULL,
+ _("bad range
{start=%ld,end=%ld,inheritable=%d}"),
+ range->start, range->end, range->inheritable);
+ }
+
+ return SVN_NO_ERROR;
+}
+
+/* Convert a single svn_merge_range_t *RANGE back into a string. */
+static char *
+range_to_string_debug(const svn_merge_range_t *range,
+ apr_pool_t *pool)
+{
+ svn_error_t *err;
+ char *s;
+
+ err = range_to_string(&s, range, pool);
+ if (err)
+ {
+ svn_error_clear(err);
+ s = apr_psprintf(pool, _("bad range {start=%ld,end=%ld,inheritable=%d}"),
+ range->start, range->end, range->inheritable);
+ }
+ return s;
}
/* Helper for svn_mergeinfo_parse()
@@ -667,10 +695,10 @@ svn_rangelist__canonicalize(svn_rangelis
"revision ranges '%s' and '%s' "
"with different inheritance "
"types"),
- range_to_string(lastrange,
- scratch_pool),
- range_to_string(range,
- scratch_pool));
+ range_to_string_debug(lastrange,
+ scratch_pool),
+ range_to_string_debug(range,
+ scratch_pool));
}
/* Combine overlapping or adjacent ranges with the
@@ -788,490 +816,349 @@ svn_mergeinfo_parse(svn_mergeinfo_t *mer
return err;
}
-/* Cleanup after svn_rangelist_merge2 when it modifies the ending range of
- a single rangelist element in-place.
-
- If *RANGE_INDEX is not a valid element in RANGELIST do nothing. Otherwise
- ensure that RANGELIST[*RANGE_INDEX]->END does not adjoin or overlap any
- subsequent ranges in RANGELIST.
-
- If overlap is found, then remove, modify, and/or add elements to RANGELIST
- as per the invariants for rangelists documented in svn_mergeinfo.h. If
- RANGELIST[*RANGE_INDEX]->END adjoins a subsequent element then combine the
- elements if their inheritability permits -- The inheritance of intersecting
- and adjoining ranges is handled as per svn_mergeinfo_merge2. Upon return
- set *RANGE_INDEX to the index of the youngest element modified, added, or
- adjoined to RANGELIST[*RANGE_INDEX].
+static const char *
+rangelist_to_string_debug(const svn_rangelist_t *rl,
+ apr_pool_t *pool)
+{
+ svn_string_t *rls;
+ svn_error_t *err;
- Note: Adjoining rangelist elements are those where the end rev of the older
- element is equal to the start rev of the younger element.
+ err = svn_rangelist_to_string(&rls, rl, pool);
+ if (err)
+ {
+ char *s = apr_psprintf(pool, _("<bad rangelist [%d ranges]: %s>"),
+ rl->nelts, err->message);
+ svn_error_clear(err);
+ return s;
+ }
+ return rls->data;
+}
- Any new elements inserted into RANGELIST are allocated in RESULT_POOL.*/
-static void
-adjust_remaining_ranges(svn_rangelist_t *rangelist,
- int *range_index,
- apr_pool_t *result_pool)
+static svn_boolean_t
+rangelist_is_sorted(const svn_rangelist_t *rangelist)
{
int i;
- int starting_index;
- int elements_to_delete = 0;
- svn_merge_range_t *modified_range;
-
- if (*range_index >= rangelist->nelts)
- return;
- starting_index = *range_index + 1;
- modified_range = APR_ARRAY_IDX(rangelist, *range_index, svn_merge_range_t *);
-
- for (i = *range_index + 1; i < rangelist->nelts; i++)
+ for (i = 1; i < rangelist->nelts; i++)
{
- svn_merge_range_t *next_range = APR_ARRAY_IDX(rangelist, i,
- svn_merge_range_t *);
+ const svn_merge_range_t *lastrange
+ = APR_ARRAY_IDX(rangelist, i-1, svn_merge_range_t *);
+ const svn_merge_range_t *thisrange
+ = APR_ARRAY_IDX(rangelist, i, svn_merge_range_t *);
- /* If MODIFIED_RANGE doesn't adjoin or overlap the next range in
- RANGELIST then we are finished. */
- if (modified_range->end < next_range->start)
- break;
+ if (svn_sort_compare_ranges(&lastrange, &thisrange) > 0)
+ return FALSE;
+ }
+ return TRUE;
+}
- /* Does MODIFIED_RANGE adjoin NEXT_RANGE? */
- if (modified_range->end == next_range->start)
- {
- if (modified_range->inheritable == next_range->inheritable)
- {
- /* Combine adjoining ranges with the same inheritability. */
- modified_range->end = next_range->end;
- elements_to_delete++;
- }
- else
- {
- /* Cannot join because inheritance differs. */
- (*range_index)++;
- }
- break;
- }
+/* Mergeinfo inheritance or absence in a rangelist interval */
+enum rangelist_interval_kind_t { MI_NONE, MI_NON_INHERITABLE, MI_INHERITABLE };
- /* Alright, we know MODIFIED_RANGE overlaps NEXT_RANGE, but how? */
- if (modified_range->end > next_range->end)
- {
- /* NEXT_RANGE is a proper subset of MODIFIED_RANGE and the two
- don't share the same end range. */
- if (modified_range->inheritable
- || (modified_range->inheritable == next_range->inheritable))
- {
- /* MODIFIED_RANGE absorbs NEXT_RANGE. */
- elements_to_delete++;
- }
- else
- {
- /* NEXT_RANGE is a proper subset MODIFIED_RANGE but
- MODIFIED_RANGE is non-inheritable and NEXT_RANGE is
- inheritable. This means MODIFIED_RANGE is truncated,
- NEXT_RANGE remains, and the portion of MODIFIED_RANGE
- younger than NEXT_RANGE is added as a separate range:
- ______________________________________________
- | |
- M MODIFIED_RANGE N
- | (!inheritable) |
- |______________________________________________|
- | |
- O NEXT_RANGE P
- | (inheritable)|
- |______________|
- |
- V
- _______________________________________________
- | | | |
- M MODIFIED_RANGE O NEXT_RANGE P NEW_RANGE N
- | (!inheritable) | (inheritable)| (!inheritable)|
- |________________|______________|_______________|
- */
- svn_merge_range_t *new_modified_range =
- apr_palloc(result_pool, sizeof(*new_modified_range));
- new_modified_range->start = next_range->end;
- new_modified_range->end = modified_range->end;
- new_modified_range->inheritable = FALSE;
- modified_range->end = next_range->start;
- (*range_index) += 2 + elements_to_delete;
- svn_sort__array_insert(rangelist, &new_modified_range,
- *range_index);
- /* Recurse with the new range. */
- adjust_remaining_ranges(rangelist, range_index, result_pool);
- break;
- }
- }
- else if (modified_range->end == next_range->end)
- {
- /* NEXT_RANGE is a proper subset MODIFIED_RANGE and share
- the same end range. */
- if (modified_range->inheritable
- || (modified_range->inheritable == next_range->inheritable))
- {
- /* MODIFIED_RANGE absorbs NEXT_RANGE. */
- elements_to_delete++;
- }
- else
- {
- /* The intersection between MODIFIED_RANGE and NEXT_RANGE is
- absorbed by the latter. */
- modified_range->end = next_range->start;
- (*range_index)++;
- }
- break;
- }
- else
- {
- /* NEXT_RANGE and MODIFIED_RANGE intersect but NEXT_RANGE is not
- a proper subset of MODIFIED_RANGE, nor do the two share the
- same end revision, i.e. they overlap. */
- if (modified_range->inheritable == next_range->inheritable)
- {
- /* Combine overlapping ranges with the same inheritability. */
- modified_range->end = next_range->end;
- elements_to_delete++;
- }
- else if (modified_range->inheritable)
- {
- /* MODIFIED_RANGE absorbs the portion of NEXT_RANGE it overlaps
- and NEXT_RANGE is truncated. */
- next_range->start = modified_range->end;
- (*range_index)++;
- }
- else
- {
- /* NEXT_RANGE absorbs the portion of MODIFIED_RANGE it overlaps
- and MODIFIED_RANGE is truncated. */
- modified_range->end = next_range->start;
- (*range_index)++;
- }
- break;
- }
+/* A rangelist interval: like svn_merge_range_t but an interval can represent
+ * a gap in the rangelist (kind = MI_NONE). */
+typedef struct rangelist_interval_t
+{
+ svn_revnum_t start, end;
+ enum rangelist_interval_kind_t kind;
+} rangelist_interval_t;
+
+/* Iterator for intervals in a rangelist. */
+typedef struct rangelist_interval_iterator_t {
+ /* iteration state: */
+ const svn_rangelist_t *rl; /* input */
+ int i; /* current interval is this range in RL or the gap before it */
+ svn_boolean_t in_range; /* current interval is range RL[I], not a gap? */
+
+ /* current interval: */
+ rangelist_interval_t interval;
+} rangelist_interval_iterator_t;
+
+/* Update IT->interval to match the current iteration state of IT.
+ * Return the iterator, or NULL if the iteration has reached its end.
+ */
+static rangelist_interval_iterator_t *
+rlii_update(rangelist_interval_iterator_t *it)
+{
+ const svn_merge_range_t *range
+ = (it->i < it->rl->nelts
+ ? APR_ARRAY_IDX(it->rl, it->i, void *) : NULL);
+
+ if (!range)
+ return NULL;
+
+ if (!it->in_range)
+ {
+ it->interval.start
+ = (it->i > 0
+ ? APR_ARRAY_IDX(it->rl, it->i - 1, svn_merge_range_t *)->end
+ : 0);
+ it->interval.end = range->start;
+ it->interval.kind = MI_NONE;
+ }
+ else
+ {
+ it->interval.start = range->start;
+ it->interval.end = range->end;
+ it->interval.kind
+ = (range->inheritable ? MI_INHERITABLE : MI_NON_INHERITABLE);
}
+ return it;
+}
- if (elements_to_delete)
- svn_sort__array_delete(rangelist, starting_index, elements_to_delete);
+/* Move to the next interval, which might be a zero-length interval.
+ * Return IT, or return NULL at the end of iteration. */
+static rangelist_interval_iterator_t *
+rlii_next_any_interval(rangelist_interval_iterator_t *it)
+{
+ /* Should be called before iteration is finished. */
+ if (it->i >= it->rl->nelts)
+ return NULL;
+
+ /* If we are in a range, move to the next pre-range gap;
+ * else, move from this pre-range gap into this range. */
+ if (it->in_range)
+ it->i++;
+ it->in_range = !it->in_range;
+ return it;
}
-#if 0 /* Temporary debug helper code */
-static svn_error_t *
-dual_dump(const char *prefix,
- const svn_rangelist_t *rangelist,
- const svn_rangelist_t *changes,
- apr_pool_t *scratch_pool)
+/* Return an iterator pointing at the first non-zero-length interval in RL,
+ * or NULL if there are none. */
+static rangelist_interval_iterator_t *
+rlii_first(const svn_rangelist_t *rl,
+ apr_pool_t *pool)
{
- svn_string_t *rls, *chg;
+ rangelist_interval_iterator_t *it = apr_palloc(pool, sizeof(*it));
- SVN_ERR(svn_rangelist_to_string(&rls, rangelist, scratch_pool));
- SVN_ERR(svn_rangelist_to_string(&chg, changes, scratch_pool));
+ it->rl = rl;
+ it->i = 0;
+ it->in_range = FALSE;
- SVN_DBG(("%s: %s / %s", prefix, rls->data, chg->data));
- return SVN_NO_ERROR;
+ /* Update, and skip empty intervals */
+ while ((it = rlii_update(it)) && it->interval.start == it->interval.end)
+ {
+ it = rlii_next_any_interval(it);
+ }
+ return it;
}
-#endif
-svn_error_t *
-svn_rangelist_merge2(svn_rangelist_t *rangelist,
- const svn_rangelist_t *chg,
- apr_pool_t *result_pool,
- apr_pool_t *scratch_pool)
+/* Move to the next non-empty interval.
+ * Intervals will be generated in this sequence:
+ * (0, MI_NONE, RL[0]->start), // i=0, !in_range
+ * (RL[0]->start, MI_* RL[0]->end), // i=0, in_range
+ * (RL[0]->end, MI_NONE, RL[1]->start),
+ * (RL[1]->start, MI_* RL[1]->end),
+ * ...
+ * (RL[n-2]->end, MI_NONE, RL[n-1]->start),
+ * (RL[n-1]->start, MI_* RL[n-1]->end),
+ * but excluding empty intervals.
+ * Return IT, or return NULL at the end of iteration. */
+static rangelist_interval_iterator_t *
+rlii_next(rangelist_interval_iterator_t *it)
{
- svn_rangelist_t *changes;
- int i = 0;
- int j;
+ it = rlii_next_any_interval(it);
- SVN_ERR(svn_rangelist__canonicalize(rangelist, scratch_pool));
+ /* Update, and skip empty intervals */
+ while ((it = rlii_update(it)) && it->interval.start == it->interval.end)
+ {
+ it = rlii_next_any_interval(it);
+ }
+ return it;
+}
- /* We may modify CHANGES, so make a copy in SCRATCH_POOL. */
- changes = svn_rangelist_dup(chg, scratch_pool);
- SVN_ERR(svn_rangelist__canonicalize(changes, scratch_pool));
+/* Rangelist builder. Accumulates consecutive intervals, combining them
+ * when possible. */
+typedef struct rangelist_builder_t {
+ svn_rangelist_t *rl; /* rangelist to build */
+ rangelist_interval_t accu_interval; /* current interval accumulator */
+ apr_pool_t *pool; /* from which to allocate ranges */
+} rangelist_builder_t;
- for (j = 0; j < changes->nelts; j++)
- {
- svn_merge_range_t *range;
- svn_merge_range_t *change =
- APR_ARRAY_IDX(changes, j, svn_merge_range_t *);
- int res;
+/* Return an initialized rangelist builder. */
+static rangelist_builder_t *
+rl_builder_new(svn_rangelist_t *rl,
+ apr_pool_t *pool)
+{
+ rangelist_builder_t *b = apr_pcalloc(pool, sizeof(*b));
- range = (i < rangelist->nelts)
- ? APR_ARRAY_IDX(rangelist, i, svn_merge_range_t *)
- : NULL;
-
- if (!range || change->end < range->start)
- {
- /* No overlap, nor adjoin, copy change to result range */
- svn_merge_range_t *chg_copy = svn_merge_range_dup(change,
- result_pool);
- svn_sort__array_insert(rangelist, &chg_copy, i++);
- continue;
- }
- else if ((change->start > range->end)
- || (change->start == range->end
- && change->inheritable != range->inheritable))
- {
- /* No overlap, nor adjoin. Check next range item against change */
- i++;
- j--;
- continue;
- }
+ b->rl = rl;
+ /* b->accu_interval = {0, 0, RL_NONE} */
+ b->pool = pool;
+ return b;
+}
- if (change->start < range->start
- && range->inheritable != change->inheritable
- && ! (change->inheritable && range_contains(change, range, FALSE))
- && ! (range->inheritable && range_contains(range, change, FALSE)))
- {
- /* Can't fold change into existing range.
- Insert new range before range */
+/* Flush the last accumulated interval in the rangelist builder B. */
+static void
+rl_builder_flush(rangelist_builder_t *b)
+{
+ if (b->accu_interval.kind > MI_NONE)
+ {
+ svn_merge_range_t *mrange = apr_pcalloc(b->pool, sizeof(*mrange));
+ mrange->start = b->accu_interval.start;
+ mrange->end = b->accu_interval.end;
+ mrange->inheritable = (b->accu_interval.kind == MI_INHERITABLE);
+ APR_ARRAY_PUSH(b->rl, svn_merge_range_t *) = mrange;
+ }
+}
- svn_merge_range_t *chg_copy = svn_merge_range_dup(change,
- result_pool);
+/* Add a new INTERVAL to the rangelist builder B. */
+static void
+rl_builder_add_interval(rangelist_builder_t *b,
+ const rangelist_interval_t *interval)
+{
+ SVN_ERR_ASSERT_NO_RETURN(interval->start < interval->end);
+ SVN_ERR_ASSERT_NO_RETURN(interval->start == b->accu_interval.end);
- chg_copy->start = MIN(change->start, range->start);
- if (! change->inheritable)
- chg_copy->end = range->start;
- else
- range->start = change->end;
+ /* Extend the accumulating interval, or end it and start another? */
+ if (interval->kind == b->accu_interval.kind)
+ {
+ b->accu_interval.end = interval->end;
+ }
+ else
+ {
+ /* Push the accumulated interval onto the building rangelist. */
+ rl_builder_flush(b);
+ /* Start accumulating a new interval */
+ b->accu_interval = *interval;
+ }
+}
- svn_sort__array_insert(rangelist, &chg_copy, i++);
+/* Set RL_OUT to the union (merge) of RL1 and RL2.
+ * On entry, RL_OUT must be an empty rangelist.
+ *
+ * Each range added to RL_OUT will be either shallow-copied from RL1 or
+ * allocated from RESULT_POOL.
+ */
+static svn_error_t *
+rangelist_merge(svn_rangelist_t *rl_out,
+ const svn_rangelist_t *rl1,
+ const svn_rangelist_t *rl2,
+ apr_pool_t *result_pool,
+ apr_pool_t *scratch_pool)
+{
+ rangelist_interval_iterator_t *it[2];
+ rangelist_builder_t *rl_builder = rl_builder_new(rl_out, result_pool);
+ svn_revnum_t r_last = 0;
+
+ /*SVN_ERR_ASSERT(svn_rangelist__is_canonical(rl1));*/
+ /*SVN_ERR_ASSERT(svn_rangelist__is_canonical(rl2));*/
+ SVN_ERR_ASSERT(rangelist_is_sorted(rl1));
+ SVN_ERR_ASSERT(rangelist_is_sorted(rl2));
+ SVN_ERR_ASSERT(rl_out->nelts == 0);
+
+ /* Initialize the input iterators and the output generator */
+ it[0] = rlii_first(rl1, scratch_pool);
+ it[1] = rlii_first(rl2, scratch_pool);
+
+ /* Keep choosing the next input revision (whether a start or end of a range)
+ * at which to consider making an output transition. */
+ while (it[0] || it[1])
+ {
+ svn_revnum_t r_next = !it[1] ? it[0]->interval.end
+ : !it[0] ? it[1]->interval.end
+ : MIN(it[0]->interval.end, it[1]->interval.end);
+ rangelist_interval_t interval;
+
+ interval.start = r_last;
+ interval.end = r_next;
+ interval.kind = !it[1] ? it[0]->interval.kind
+ : !it[0] ? it[1]->interval.kind
+ : MAX(it[0]->interval.kind, it[1]->interval.kind);
+
+ /* Accumulate */
+ SVN_ERR_ASSERT(interval.start < interval.end);
+ rl_builder_add_interval(rl_builder, &interval);
+
+ /* if we have used up either or both input intervals, increment them */
+ if (it[0] && it[0]->interval.end <= r_next)
+ it[0] = rlii_next(it[0]);
+ if (it[1] && it[1]->interval.end <= r_next)
+ it[1] = rlii_next(it[1]);
- change->start = chg_copy->end;
- if (change->start >= change->end)
- continue; /* No overlap with range left */
- }
- else
- {
- range->start = MIN(range->start, change->start);
- }
+ r_last = interval.end;
+ }
+ rl_builder_flush(rl_builder);
+ return SVN_NO_ERROR;
+}
- SVN_ERR_ASSERT(change->start >= range->start);
+svn_error_t *
+svn_rangelist_merge2(svn_rangelist_t *rangelist,
+ const svn_rangelist_t *chg,
+ apr_pool_t *result_pool,
+ apr_pool_t *scratch_pool)
+{
+ svn_error_t *err;
+ svn_rangelist_t *rangelist_orig;
- res = svn_sort_compare_ranges(&range, &change);
+#ifdef SVN_DEBUG
+ SVN_ERR_ASSERT(rangelist_is_sorted(rangelist));
+ SVN_ERR_ASSERT(rangelist_is_sorted(chg));
+#endif
- if (res == 0)
- {
- /* Only when merging two non-inheritable ranges is the result also
- non-inheritable. In all other cases ensure an inheritable
- result. */
- if (range->inheritable || change->inheritable)
- range->inheritable = TRUE;
- i++;
- continue;
- }
- else if (res < 0) /* CHANGE is younger than RANGE */
- {
- if (range->end == change->start)
- {
- /* RANGE and CHANGE adjoin */
- if (range->inheritable == change->inheritable)
- {
- /* RANGE and CHANGE have the same inheritability so
- RANGE expands to absord CHANGE. */
- range->end = change->end;
- adjust_remaining_ranges(rangelist, &i, result_pool);
- continue;
- }
- else
- {
- /* RANGE and CHANGE adjoin, but have different
- inheritability. Since RANGE is older, just
- move on to the next RANGE. */
- SVN_ERR_MALFUNCTION();
- }
- }
- else
- {
- /* RANGE and CHANGE overlap, but how? */
- if ((range->inheritable == change->inheritable)
- || range->inheritable)
- {
- /* If CHANGE is a proper subset of RANGE, it absorbs RANGE
- with no adjustment otherwise only the intersection is
- absorbed and CHANGE is truncated. */
- if (range->end >= change->end)
- continue;
- else
- {
- change->start = range->end;
- j--;
- continue;
- }
- }
- else
- {
- /* RANGE is non-inheritable and CHANGE is inheritable. */
- if (range->start < change->start)
- {
- /* CHANGE absorbs intersection with RANGE and RANGE
- is truncated. */
- svn_merge_range_t *range_copy =
- svn_merge_range_dup(range, result_pool);
- range_copy->end = change->start;
- range->start = change->start;
- svn_sort__array_insert(rangelist, &range_copy, i++);
- j--;
- continue;
- }
- else
- {
- /* CHANGE and RANGE share the same start rev, but
- RANGE is considered older because its end rev
- is older. */
- range->inheritable = TRUE;
- change->start = range->end;
- j--;
- continue;
- }
- }
- }
- }
- else /* res > 0, CHANGE is older than RANGE */
- {
- if (change->end == range->start)
- {
- /* RANGE and CHANGE adjoin */
- if (range->inheritable == change->inheritable)
- {
- /* RANGE and CHANGE have the same inheritability so we
- can simply combine the two in place. */
- range->start = change->start;
- continue;
- }
- else
- {
- /* RANGE and CHANGE have different inheritability so insert
- a copy of CHANGE into RANGELIST. */
- SVN_ERR_MALFUNCTION(); /* Already handled */
- }
- }
- else
- {
- /* RANGE and CHANGE overlap. */
- if (range->inheritable == change->inheritable)
- {
- /* RANGE and CHANGE have the same inheritability so we
- can simply combine the two in place... */
- range->start = change->start;
- if (range->end < change->end)
- {
- /* ...but if RANGE is expanded ensure that we don't
- violate any rangelist invariants. */
- range->end = change->end;
- adjust_remaining_ranges(rangelist, &i, result_pool);
- }
- continue;
- }
- else if (range->inheritable)
- {
- if (change->start < range->start)
- {
- /* RANGE is inheritable so absorbs any part of CHANGE
- it overlaps. CHANGE is truncated and the remainder
- inserted into RANGELIST. */
- SVN_ERR_MALFUNCTION(); /* Already handled */
- }
- else
- {
- /* CHANGE and RANGE share the same start rev, but
- CHANGE is considered older because CHANGE->END is
- older than RANGE->END. */
- continue;
- }
- }
- else
- {
- /* RANGE is non-inheritable and CHANGE is inheritable. */
- if (change->start < range->start)
- {
- if (change->end == range->end)
- {
- /* RANGE is a proper subset of CHANGE and share the
- same end revision, so set RANGE equal to CHANGE.
*/
- range->start = change->start;
- range->inheritable = TRUE;
- continue;
- }
- else if (change->end > range->end)
- {
- /* RANGE is a proper subset of CHANGE and CHANGE has
- a younger end revision, so set RANGE equal to its
- intersection with CHANGE and truncate CHANGE. */
- range->start = change->start;
- range->inheritable = TRUE;
- change->start = range->end;
- j--;
- continue;
- }
- else
- {
- /* CHANGE and RANGE overlap. Set RANGE equal to its
- intersection with CHANGE and take the remainder
- of RANGE and insert it into RANGELIST. */
- svn_merge_range_t *range_copy =
- svn_merge_range_dup(range, result_pool);
- range_copy->start = change->end;
- range->start = change->start;
- range->end = change->end;
- range->inheritable = TRUE;
- svn_sort__array_insert(rangelist, &range_copy, ++i);
- continue;
- }
- }
- else
- {
- /* CHANGE and RANGE share the same start rev, but
- CHANGE is considered older because its end rev
- is older.
-
- Insert the intersection of RANGE and CHANGE into
- RANGELIST and then set RANGE to the non-intersecting
- portion of RANGE. */
- svn_merge_range_t *range_copy =
- svn_merge_range_dup(range, result_pool);
- range_copy->end = change->end;
- range_copy->inheritable = TRUE;
- range->start = change->end;
- svn_sort__array_insert(rangelist, &range_copy, i++);
- continue;
- }
- }
- }
- }
- SVN_ERR_MALFUNCTION(); /* Unreachable */
- }
+ /* Move the original rangelist aside. A shallow copy suffices,
+ * as rangelist_merge() won't modify its inputs. */
+ rangelist_orig = apr_array_copy(scratch_pool, rangelist);
+ apr_array_clear(rangelist);
+ err = svn_error_trace(rangelist_merge(rangelist, rangelist_orig, chg,
+ result_pool, scratch_pool));
#ifdef SVN_DEBUG
- SVN_ERR_ASSERT(svn_rangelist__is_canonical(rangelist));
+ if (err)
+ {
+ err = svn_error_createf(SVN_ERR_ASSERTION_FAIL, err,
+ "svn_rangelist_merge2( %s / %s ): internal error",
+ rangelist_to_string_debug(rangelist_orig, scratch_pool),
+ rangelist_to_string_debug(chg, scratch_pool));
+ }
+ else if (! svn_rangelist__is_canonical(rangelist)
+ && svn_rangelist__is_canonical(rangelist_orig)
+ && svn_rangelist__is_canonical(chg))
+ {
+ err = svn_error_createf(SVN_ERR_ASSERTION_FAIL, NULL,
+ "svn_rangelist_merge2( %s / %s ): canonical inputs, "
+ "non-canonical result ( %s )",
+ rangelist_to_string_debug(rangelist_orig, scratch_pool),
+ rangelist_to_string_debug(chg, scratch_pool),
+ rangelist_to_string_debug(rangelist, scratch_pool));
+ }
#endif
- return SVN_NO_ERROR;
+ return err;
}
-/* Return TRUE iff the forward revision ranges FIRST and SECOND overlap and
- * (if CONSIDER_INHERITANCE is TRUE) have the same inheritability. */
-static svn_boolean_t
-range_intersect(const svn_merge_range_t *first, const svn_merge_range_t
*second,
+/* Set *RESULT to TRUE iff the forward revision ranges FIRST and SECOND overlap
+ * and (if CONSIDER_INHERITANCE is TRUE) have the same inheritability. */
+static svn_error_t *
+range_intersect(svn_boolean_t *result,
+ const svn_merge_range_t *first, const svn_merge_range_t
*second,
svn_boolean_t consider_inheritance)
{
- SVN_ERR_ASSERT_NO_RETURN(IS_VALID_FORWARD_RANGE(first));
- SVN_ERR_ASSERT_NO_RETURN(IS_VALID_FORWARD_RANGE(second));
+ SVN_ERR_ASSERT(IS_VALID_FORWARD_RANGE(first));
+ SVN_ERR_ASSERT(IS_VALID_FORWARD_RANGE(second));
- return (first->start + 1 <= second->end)
- && (second->start + 1 <= first->end)
- && (!consider_inheritance
- || (!(first->inheritable) == !(second->inheritable)));
+ *result = (first->start + 1 <= second->end)
+ && (second->start + 1 <= first->end)
+ && (!consider_inheritance
+ || (!(first->inheritable) == !(second->inheritable)));
+ return SVN_NO_ERROR;
}
-/* Return TRUE iff the forward revision range FIRST wholly contains the
+/* Set *RESULT to TRUE iff the forward revision range FIRST wholly contains the
* forward revision range SECOND and (if CONSIDER_INHERITANCE is TRUE) has
* the same inheritability. */
-static svn_boolean_t
-range_contains(const svn_merge_range_t *first, const svn_merge_range_t *second,
+static svn_error_t *
+range_contains(svn_boolean_t *result,
+ const svn_merge_range_t *first, const svn_merge_range_t *second,
svn_boolean_t consider_inheritance)
{
- SVN_ERR_ASSERT_NO_RETURN(IS_VALID_FORWARD_RANGE(first));
- SVN_ERR_ASSERT_NO_RETURN(IS_VALID_FORWARD_RANGE(second));
+ SVN_ERR_ASSERT(IS_VALID_FORWARD_RANGE(first));
+ SVN_ERR_ASSERT(IS_VALID_FORWARD_RANGE(second));
- return (first->start <= second->start) && (second->end <= first->end)
- && (!consider_inheritance
- || (!(first->inheritable) == !(second->inheritable)));
+ *result = (first->start <= second->start) && (second->end <= first->end)
+ && (!consider_inheritance
+ || (!(first->inheritable) == !(second->inheritable)));
+ return SVN_NO_ERROR;
}
/* Swap start and end fields of RANGE. */
@@ -1390,6 +1277,7 @@ rangelist_intersect_or_remove(svn_rangel
while (i1 < rangelist1->nelts && i2 < rangelist2->nelts)
{
svn_merge_range_t *elt1, *elt2;
+ svn_boolean_t elt1_contains_elt2, elt1_intersects_elt2;
elt1 = APR_ARRAY_IDX(rangelist1, i1, svn_merge_range_t *);
@@ -1405,6 +1293,10 @@ rangelist_intersect_or_remove(svn_rangel
elt2 = &working_elt2;
+ SVN_ERR(range_contains(&elt1_contains_elt2,
+ elt1, elt2, consider_inheritance));
+ SVN_ERR(range_intersect(&elt1_intersects_elt2,
+ elt1, elt2, consider_inheritance));
/* If the rangelist2 range is contained completely in the
rangelist1, we increment the rangelist2.
If the ranges intersect, and match exactly, we increment both
@@ -1413,7 +1305,7 @@ rangelist_intersect_or_remove(svn_rangel
the removal of rangelist1 from rangelist2, and possibly change
the rangelist2 to the remaining portion of the right part of
the removal, to test against. */
- if (range_contains(elt1, elt2, consider_inheritance))
+ if (elt1_contains_elt2)
{
if (!do_remove)
{
@@ -1434,7 +1326,7 @@ rangelist_intersect_or_remove(svn_rangel
if (elt2->start == elt1->start && elt2->end == elt1->end)
i1++;
}
- else if (range_intersect(elt1, elt2, consider_inheritance))
+ else if (elt1_intersects_elt2)
{
if (elt2->start < elt1->start)
{
@@ -1977,18 +1869,21 @@ svn_rangelist_to_string(svn_string_t **o
{
int i;
svn_merge_range_t *range;
+ char *s;
/* Handle the elements that need commas at the end. */
for (i = 0; i < rangelist->nelts - 1; i++)
{
range = APR_ARRAY_IDX(rangelist, i, svn_merge_range_t *);
- svn_stringbuf_appendcstr(buf, range_to_string(range, pool));
+ SVN_ERR(range_to_string(&s, range, pool));
+ svn_stringbuf_appendcstr(buf, s);
svn_stringbuf_appendcstr(buf, ",");
}
/* Now handle the last element, which needs no comma. */
range = APR_ARRAY_IDX(rangelist, i, svn_merge_range_t *);
- svn_stringbuf_appendcstr(buf, range_to_string(range, pool));
+ SVN_ERR(range_to_string(&s, range, pool));
+ svn_stringbuf_appendcstr(buf, s);
}
*output = svn_stringbuf__morph_into_string(buf);
Modified: subversion/branches/1.10.x/subversion/libsvn_subr/sorts.c
URL:
http://svn.apache.org/viewvc/subversion/branches/1.10.x/subversion/libsvn_subr/sorts.c?rev=1899369&r1=1899368&r2=1899369&view=diff
==============================================================================
--- subversion/branches/1.10.x/subversion/libsvn_subr/sorts.c (original)
+++ subversion/branches/1.10.x/subversion/libsvn_subr/sorts.c Wed Mar 30
04:00:07 2022
@@ -34,6 +34,8 @@
#include "svn_error.h"
#include "private/svn_sorts_private.h"
+#include "svn_private_config.h"
+
/*** svn_sort__hash() ***/
@@ -324,6 +326,20 @@ svn_sort__array_insert(apr_array_header_
memcpy(new_position, new_element, array->elt_size);
}
+svn_error_t *
+svn_sort__array_insert2(apr_array_header_t *array,
+ const void *new_element,
+ int insert_index)
+{
+ if (insert_index < 0 || insert_index > array->nelts)
+ return svn_error_createf(SVN_ERR_INCORRECT_PARAMS, NULL,
+ _("svn_sort__array_insert2: Attempted insert "
+ "at index %d in array length %d"),
+ insert_index, array->nelts);
+ svn_sort__array_insert(array, new_element, insert_index);
+ return SVN_NO_ERROR;
+}
+
void
svn_sort__array_delete(apr_array_header_t *arr,
int delete_index,
@@ -349,6 +365,23 @@ svn_sort__array_delete(apr_array_header_
}
}
+svn_error_t *
+svn_sort__array_delete2(apr_array_header_t *arr,
+ int delete_index,
+ int elements_to_delete)
+{
+ if (!(delete_index >= 0
+ && delete_index < arr->nelts
+ && elements_to_delete > 0
+ && (arr->nelts - delete_index) >= elements_to_delete))
+ return svn_error_createf(SVN_ERR_INCORRECT_PARAMS, NULL,
+ _("svn_sort__array_delete2: Attempted delete "
+ "at index %d, %d elements, in array length %d"),
+ delete_index, elements_to_delete, arr->nelts);
+ svn_sort__array_delete(arr, delete_index, elements_to_delete);
+ return SVN_NO_ERROR;
+}
+
void
svn_sort__array_reverse(apr_array_header_t *array,
apr_pool_t *scratch_pool)
Modified:
subversion/branches/1.10.x/subversion/tests/libsvn_subr/mergeinfo-test.c
URL:
http://svn.apache.org/viewvc/subversion/branches/1.10.x/subversion/tests/libsvn_subr/mergeinfo-test.c?rev=1899369&r1=1899368&r2=1899369&view=diff
==============================================================================
--- subversion/branches/1.10.x/subversion/tests/libsvn_subr/mergeinfo-test.c
(original)
+++ subversion/branches/1.10.x/subversion/tests/libsvn_subr/mergeinfo-test.c
Wed Mar 30 04:00:07 2022
@@ -33,6 +33,8 @@
#include "svn_types.h"
#include "svn_mergeinfo.h"
#include "private/svn_mergeinfo_private.h"
+#include "private/svn_sorts_private.h"
+#include "private/svn_error_private.h"
#include "../svn_test.h"
/* A quick way to create error messages. */
@@ -1783,6 +1785,701 @@ test_rangelist_loop(apr_pool_t *pool)
return SVN_NO_ERROR;
}
+
+/* A specific case where result was non-canonical, around svn 1.10 ~ 1.13. */
+static svn_error_t *
+test_rangelist_merge_canonical_result(apr_pool_t *pool)
+{
+ const char *rangelist_str = "8-10";
+ const char *changes_str = "5-10*,11-24";
+ const char *expected_str = "5-7*,8-24";
+ /* wrong result: "5-7*,8-10,11-24" */
+ svn_rangelist_t *rangelist, *changes;
+ svn_string_t *result_string;
+
+ /* prepare the inputs */
+ SVN_ERR(svn_rangelist__parse(&rangelist, rangelist_str, pool));
+ SVN_ERR(svn_rangelist__parse(&changes, changes_str, pool));
+ SVN_TEST_ASSERT(svn_rangelist__is_canonical(rangelist));
+ SVN_TEST_ASSERT(svn_rangelist__is_canonical(changes));
+
+ /* perform the merge */
+ SVN_ERR(svn_rangelist_merge2(rangelist, changes, pool, pool));
+
+ /* check the output */
+ SVN_TEST_ASSERT(svn_rangelist__is_canonical(rangelist));
+ SVN_ERR(svn_rangelist_to_string(&result_string, rangelist, pool));
+ SVN_TEST_STRING_ASSERT(result_string->data, expected_str);
+
+ return SVN_NO_ERROR;
+}
+
+/* Test svn_rangelist_merge2() with specific inputs derived from an
+ * occurrence of issue #4840 "in the wild", that triggered a hard
+ * assertion failure (abort) in a 1.10.6 release-mode build.
+ */
+static svn_error_t *
+test_rangelist_merge_array_insert_failure(apr_pool_t *pool)
+{
+ svn_rangelist_t *rx, *ry;
+ svn_string_t *rxs;
+
+ /* Simplified case with same failure mode as reported case: error
+ * "E200004: svn_sort__array_insert2:
+ * Attempted insert at index 4 in array length 3" */
+ SVN_ERR(svn_rangelist__parse(&rx, "2*,4*,6*,8", pool));
+ SVN_ERR(svn_rangelist__parse(&ry, "1-9*,11", pool));
+ SVN_ERR(svn_rangelist_merge2(rx, ry, pool, pool));
+ SVN_ERR(svn_rangelist_to_string(&rxs, rx, pool));
+ SVN_TEST_STRING_ASSERT(rxs->data, "1-7*,8,9*,11");
+
+ /* Actual reported case: in v1.10.6, aborted; after r1872118, error
+ * "E200004: svn_sort__array_insert2:
+ * Attempted insert at index 57 in array length 55". The actual "index"
+ * and "array length" numbers vary with changes such as r1823728. */
+ SVN_ERR(svn_rangelist__parse(&rx,
"997347-997597*,997884-1000223*,1000542-1000551*,1001389-1001516,1002139-1002268*,1002896-1003064*,1003320-1003468,1005939-1006089*,1006443-1006630*,1006631-1006857,1007028-1007116*,1009467-1009629,1009630-1010007*,1010774-1010860,1011036-1011502,1011672-1014004*,1014023-1014197,1014484-1014542*,1015077-1015568,1016219-1016365,1016698-1016845,1017331-1018616,1027032-1027180,1027855-1028051,1028261-1028395,1028553-1028663,1028674-1028708,1028773-1028891*,1029223-1030557,1032239-1032284*,1032801-1032959,1032960-1033074*,1033745-1033810,1034990-1035104,1035435-1036108*,1036109-1036395,1036396-1036865*,1036866-1036951,1036952-1037647*,1037648-1037750,1037751-1038548*,1038549-1038700,1038701-1042103*,1042104-1042305,1042306-1046626*,1046627-1046910,1046911-1047676*,1047677-1047818,1047819-1047914*,1047915-1048025,1048026-1048616*,1048617-1048993,1048994-1050066*,1054605-1054739,1054854-1055021",
pool));
+ SVN_ERR(svn_rangelist__parse(&ry, "1035435-1050066*,1052459-1054617", pool));
+ SVN_ERR(svn_rangelist_merge2(rx, ry, pool, pool));
+ /* Here we don't care to check the result; just that it returns "success". */
+ return SVN_NO_ERROR;
+}
+
+
+/* Random testing parameters and coverage
+ *
+ * The parameters for testing random inputs, in conjunction with the
+ * specific test case generation code, were adjusted so as to observe the
+ * tests generating each of the known failure modes. The aim is also to
+ * have sufficient coverage of inputs to discover other failure modes in
+ * future if the code is changed.
+ *
+ * There are neither theoretic nor empirical guarantees on the coverage.
+ */
+
+/* Randomize revision numbers over this small range.
+ * (With a larger range, we would find edge cases more rarely.)
+ * See comment "Random testing parameters and coverage" */
+#define RANGELIST_TESTS_MAX_REV 15
+
+/* A representation of svn_rangelist_t in which
+ * root[R] := (revision R is in the rangelist)
+ * inherit[R] := (revision R is in the rangelist and inheritable)
+ *
+ * Assuming all forward ranges.
+ */
+typedef struct rl_array_t {
+ svn_boolean_t root[RANGELIST_TESTS_MAX_REV + 1];
+ svn_boolean_t inherit[RANGELIST_TESTS_MAX_REV + 1];
+} rl_array_t;
+
+static void
+rangelist_to_array(rl_array_t *a,
+ const svn_rangelist_t *rl)
+{
+ int i;
+
+ memset(a, 0, sizeof(*a));
+ for (i = 0; i < rl->nelts; i++)
+ {
+ svn_merge_range_t *range = APR_ARRAY_IDX(rl, i, svn_merge_range_t *);
+ svn_revnum_t r;
+
+ for (r = range->start + 1; r <= range->end; r++)
+ {
+ a->root[r] = TRUE;
+ a->inherit[r] = range->inheritable;
+ }
+ }
+}
+
+/* Compute the union of two rangelists arrays.
+ * Let MA := union(BA, CA)
+ */
+static void
+rangelist_array_union(rl_array_t *ma,
+ const rl_array_t *ba,
+ const rl_array_t *ca)
+{
+ svn_revnum_t r;
+
+ for (r = 0; r <= RANGELIST_TESTS_MAX_REV; r++)
+ {
+ ma->root[r] = ba->root[r] || ca->root[r];
+ ma->inherit[r] = ba->inherit[r] || ca->inherit[r];
+ }
+}
+
+/* Return TRUE iff two rangelist arrays are equal.
+ */
+static svn_boolean_t
+rangelist_array_equal(const rl_array_t *ba,
+ const rl_array_t *ca)
+{
+ svn_revnum_t r;
+
+ for (r = 0; r <= RANGELIST_TESTS_MAX_REV; r++)
+ {
+ if (ba->root[r] != ca->root[r]
+ || ba->inherit[r] != ca->inherit[r])
+ {
+ return FALSE;
+ }
+ }
+ return TRUE;
+}
+
+#define IS_VALID_FORWARD_RANGE(range) \
+ (SVN_IS_VALID_REVNUM((range)->start) && ((range)->start < (range)->end))
+
+/* Check rangelist is sorted and contains forward ranges. */
+static svn_boolean_t
+rangelist_is_sorted(const svn_rangelist_t *rangelist)
+{
+ int i;
+
+ for (i = 0; i < rangelist->nelts; i++)
+ {
+ const svn_merge_range_t *thisrange
+ = APR_ARRAY_IDX(rangelist, i, svn_merge_range_t *);
+
+ if (!IS_VALID_FORWARD_RANGE(thisrange))
+ return FALSE;
+ }
+ for (i = 1; i < rangelist->nelts; i++)
+ {
+ const svn_merge_range_t *lastrange
+ = APR_ARRAY_IDX(rangelist, i-1, svn_merge_range_t *);
+ const svn_merge_range_t *thisrange
+ = APR_ARRAY_IDX(rangelist, i, svn_merge_range_t *);
+
+ if (svn_sort_compare_ranges(&lastrange, &thisrange) > 0)
+ return FALSE;
+ }
+ return TRUE;
+}
+
+/* Return a random number R, where 0 <= R < N.
+ */
+static int rand_less_than(int n, apr_uint32_t *seed)
+{
+ apr_uint32_t next = svn_test_rand(seed);
+ return ((apr_uint64_t)next * n) >> 32;
+}
+
+/* Return a random integer in a triangular (centre-weighted) distribution in
+ * the inclusive interval [MIN, MAX]. */
+static int
+rand_interval_triangular(int min, int max, apr_uint32_t *seed)
+{
+ int span = max - min + 1;
+
+ return min + rand_less_than(span/2 + 1, seed)
+ + rand_less_than((span+1)/2, seed);
+}
+
+/* Generate a rangelist with a random number of random ranges.
+ * Choose from 0 to NON_V_MAX_RANGES ranges, biased towards the middle.
+ */
+#define NON_V_MAX_RANGES 4 /* See "Random testing parameters and coverage" */
+static void
+rangelist_random_non_validated(svn_rangelist_t **rl,
+ apr_uint32_t *seed,
+ apr_pool_t *pool)
+{
+ svn_rangelist_t *r = apr_array_make(pool, NON_V_MAX_RANGES,
+ sizeof(svn_merge_range_t *));
+ int n_ranges = rand_interval_triangular(0, NON_V_MAX_RANGES, seed);
+ int i;
+
+ for (i = 0; i < n_ranges; i++)
+ {
+ svn_merge_range_t *mrange = apr_pcalloc(pool, sizeof(*mrange));
+
+ mrange->start = rand_less_than(RANGELIST_TESTS_MAX_REV + 1, seed);
+ mrange->end = rand_less_than(RANGELIST_TESTS_MAX_REV + 1, seed);
+ mrange->inheritable = rand_less_than(2, seed);
+ APR_ARRAY_PUSH(r, svn_merge_range_t *) = mrange;
+ }
+ *rl = r;
+}
+
+/* Compare two integers pointed to by A_P and B_P, for use with qsort(). */
+static int
+int_compare(const void *a_p, const void *b_p)
+{
+ const int *a = a_p, *b = b_p;
+
+ return (*a < *b) ? -1 : (*a > *b) ? 1 : 0;
+}
+
+/* Fill an ARRAY[ARRAY_LENGTH] with values each in the inclusive range
+ * [0, MAX]. The values are in ascending order, possibly with the same
+ * value repeated any number of times.
+ */
+static void
+ascending_values(int *array,
+ int array_length,
+ int max,
+ apr_uint32_t *seed)
+{
+ int i;
+
+ for (i = 0; i < array_length; i++)
+ array[i] = rand_less_than(max + 1, seed);
+ /* Sort them. (Some values will be repeated.) */
+ qsort(array, array_length, sizeof(*array), int_compare);
+}
+
+/* Generate a random rangelist that is not necessarily canonical
+ * but is at least sorted according to svn_sort_compare_ranges()
+ * and on which svn_rangelist__canonicalize() would succeed.
+ * Choose from 0 to SEMI_C_MAX_RANGES ranges, biased towards the middle.
+ */
+#define SEMI_C_MAX_RANGES 8
+static void
+rangelist_random_semi_canonical(svn_rangelist_t **rl,
+ apr_uint32_t *seed,
+ apr_pool_t *pool)
+{
+ svn_rangelist_t *r = apr_array_make(pool, 4, sizeof(svn_merge_range_t *));
+ int n_ranges = rand_interval_triangular(0, SEMI_C_MAX_RANGES, seed);
+ int start_and_end_revs[SEMI_C_MAX_RANGES * 2];
+ int i;
+
+ /* Choose start and end revs of the ranges. To end up with ranges evenly
+ * distributed up to RANGELIST_TESTS_MAX_REV, we start with them evenly
+ * distributed up to RANGELIST_TESTS_MAX_REV - N_RANGES, before spreading. */
+ ascending_values(start_and_end_revs, n_ranges * 2,
+ RANGELIST_TESTS_MAX_REV - n_ranges,
+ seed);
+ /* Some values will be repeated. Within one range, that is not allowed,
+ * so add 1 to the length of each range, spreading the ranges out so they
+ * still don't overlap:
+ * [(6,6), (6,8)] becomes [(6,7), (7, 10)] */
+ for (i = 0; i < n_ranges; i++)
+ {
+ start_and_end_revs[i*2] += i;
+ start_and_end_revs[i*2 + 1] += i+1;
+ }
+
+ for (i = 0; i < n_ranges; i++)
+ {
+ svn_merge_range_t *mrange = apr_pcalloc(pool, sizeof(*mrange));
+
+ mrange->start = start_and_end_revs[i * 2];
+ mrange->end = start_and_end_revs[i * 2 + 1];
+ mrange->inheritable = rand_less_than(2, seed);
+ APR_ARRAY_PUSH(r, svn_merge_range_t *) = mrange;
+ }
+ *rl = r;
+
+ /* check postconditions */
+ {
+ svn_rangelist_t *dup;
+ svn_error_t *err;
+
+ SVN_ERR_ASSERT_NO_RETURN(rangelist_is_sorted(*rl));
+ dup = svn_rangelist_dup(*rl, pool);
+ err = svn_rangelist__canonicalize(dup, pool);
+ SVN_ERR_ASSERT_NO_RETURN(!err);
+ }
+}
+
+/* Generate a random rangelist that satisfies svn_rangelist__is_canonical().
+ */
+static void
+rangelist_random_canonical(svn_rangelist_t **rl,
+ apr_uint32_t *seed,
+ apr_pool_t *pool)
+{
+ svn_rangelist_t *r;
+ int i;
+
+ rangelist_random_semi_canonical(&r, seed, pool);
+ for (i = 1; i < r->nelts; i++)
+ {
+ svn_merge_range_t *prev_mrange = APR_ARRAY_IDX(r, i-1, svn_merge_range_t
*);
+ svn_merge_range_t *mrange = APR_ARRAY_IDX(r, i, svn_merge_range_t *);
+
+ /* to be canonical: adjacent ranges need differing inheritability */
+ if (mrange->start == prev_mrange->end)
+ {
+ mrange->inheritable = !prev_mrange->inheritable;
+ }
+ }
+ *rl = r;
+
+ /* check postconditions */
+ SVN_ERR_ASSERT_NO_RETURN(svn_rangelist__is_canonical(*rl));
+}
+
+static const char *
+rangelist_to_string(const svn_rangelist_t *rl,
+ apr_pool_t *pool)
+{
+ svn_error_t *err;
+ svn_string_t *ss;
+
+ err = svn_rangelist_to_string(&ss, rl, pool);
+ if (err)
+ {
+ const char *s
+ = apr_psprintf(pool, "<rangelist[%d ranges]: %s>",
+ rl->nelts, svn_error_purge_tracing(err)->message);
+ svn_error_clear(err);
+ return s;
+ }
+ return ss->data;
+}
+
+/* Try svn_rangelist_merge2(rlx, rly) and check errors and result */
+static svn_error_t *
+rangelist_merge_random_inputs(svn_rangelist_t *rlx,
+ svn_rangelist_t *rly,
+ apr_pool_t *pool)
+{
+ rl_array_t ax, ay, a_expected, a_actual;
+ svn_rangelist_t *rlm;
+
+ rangelist_to_array(&ax, rlx);
+ rangelist_to_array(&ay, rly);
+
+ rlm = svn_rangelist_dup(rlx, pool);
+ /*printf("testcase: %s / %s\n", rangelist_to_string(rlx, pool),
rangelist_to_string(rly, pool));*/
+ SVN_ERR(svn_rangelist_merge2(rlm, rly, pool, pool));
+
+ if (!svn_rangelist__is_canonical(rlm))
+ {
+ return svn_error_createf(SVN_ERR_TEST_FAILED, NULL,
+ "non-canonical result %s",
+ rangelist_to_string(rlm, pool));
+ }
+
+ /*SVN_TEST_ASSERT(rangelist_equal(rlm, ...));*/
+ rangelist_array_union(&a_expected, &ax, &ay);
+ rangelist_to_array(&a_actual, rlm);
+ if (!rangelist_array_equal(&a_actual, &a_expected))
+ {
+ return svn_error_createf(SVN_ERR_TEST_FAILED, NULL,
+ "wrong result: (c? %d / %d) -> %s",
+ svn_rangelist__is_canonical(rlx),
+ svn_rangelist__is_canonical(rly),
+ rangelist_to_string(rlm, pool));
+ }
+
+ return SVN_NO_ERROR;
+}
+
+/* Insert a failure mode (ERR_CHAIN) into RESPONSES, keyed by a message
+ * representing its failure mode. The failure mode message is the lowest
+ * level error message in ERR_CHAIN, with some case-specific details
+ * removed to aid de-duplication. If it is new failure mode (not already in
+ * RESPONSES), store the error and return the message (hash key), else
+ * clear the error and return NULL.
+ */
+static const char *
+add_failure_mode(svn_error_t *err_chain,
+ apr_hash_t *failure_modes)
+{
+ svn_error_t *err = err_chain;
+ char buf[100];
+ const char *message;
+
+ if (!err_chain)
+ return NULL;
+
+ while (err->child)
+ err = err->child;
+ message = svn_err_best_message(err, buf, sizeof(buf));
+
+ /* For deduplication, ignore case-specific data in certain messages. */
+ if (strstr(message, "Unable to parse overlapping revision ranges '"))
+ message = "Unable to parse overlapping revision ranges '...";
+ if (strstr(message, "wrong result: (c?"))
+ message = "wrong result: (c?...";
+ if (strstr(message, "svn_sort__array_insert2: Attempted insert at index "))
+ message = "svn_sort__array_insert2: Attempted insert at index ...";
+
+ if (!svn_hash_gets(failure_modes, message))
+ {
+ svn_hash_sets(failure_modes, message, err);
+ return message;
+ }
+ else
+ {
+ svn_error_clear(err_chain);
+ return NULL;
+ }
+}
+
+static void
+clear_failure_mode_errors(apr_hash_t *failure_modes, apr_pool_t *scratch_pool)
+{
+ apr_hash_index_t *hi;
+
+ for (hi = apr_hash_first(scratch_pool, failure_modes);
+ hi;
+ hi = apr_hash_next(hi))
+ {
+ svn_error_t *err = apr_hash_this_val(hi);
+ svn_error_clear(err);
+ }
+}
+
+static svn_error_t *
+test_rangelist_merge_random_canonical_inputs(apr_pool_t *pool)
+{
+ static apr_uint32_t seed = 0;
+ apr_pool_t *iterpool = svn_pool_create(pool);
+ apr_hash_t *failure_modes = apr_hash_make(pool);
+ svn_boolean_t pass = TRUE;
+ int ix, iy;
+
+ /* "300": See comment "Random testing parameters and coverage" */
+ for (ix = 0; ix < 300; ix++)
+ {
+ svn_rangelist_t *rlx;
+
+ rangelist_random_canonical(&rlx, &seed, pool);
+
+ for (iy = 0; iy < 300; iy++)
+ {
+ svn_rangelist_t *rly;
+ svn_error_t *err;
+ const char *failure_mode;
+
+ svn_pool_clear(iterpool);
+
+ rangelist_random_canonical(&rly, &seed, iterpool);
+
+ err = svn_error_trace(rangelist_merge_random_inputs(rlx, rly,
iterpool));
+ failure_mode = add_failure_mode(err, failure_modes);
+ if (failure_mode)
+ {
+ printf("first example of a failure mode: %s / %s\n"
+ " %s\n",
+ rangelist_to_string(rlx, iterpool),
+ rangelist_to_string(rly, iterpool),
+ failure_mode);
+ /*svn_handle_error(err, stdout, FALSE);*/
+ pass = FALSE;
+ }
+ }
+ }
+
+ clear_failure_mode_errors(failure_modes, pool);
+
+ if (!pass)
+ return svn_error_createf(SVN_ERR_TEST_FAILED, NULL,
+ "Test failed: %d failure modes",
+ apr_hash_count(failure_modes));
+ return SVN_NO_ERROR;
+}
+
+/* Test svn_rangelist_merge2() with inputs that confirm to its doc-string.
+ * Fail if any errors are produced.
+ */
+static svn_error_t *
+test_rangelist_merge_random_semi_c_inputs(apr_pool_t *pool)
+{
+ static apr_uint32_t seed = 0;
+ apr_pool_t *iterpool = svn_pool_create(pool);
+ apr_hash_t *failure_modes = apr_hash_make(pool);
+ svn_boolean_t pass = TRUE;
+ int ix, iy;
+
+ /* "300": See comment "Random testing parameters and coverage" */
+ for (ix = 0; ix < 300; ix++)
+ {
+ svn_rangelist_t *rlx;
+
+ rangelist_random_semi_canonical(&rlx, &seed, pool);
+
+ for (iy = 0; iy < 300; iy++)
+ {
+ svn_rangelist_t *rly;
+ svn_error_t *err;
+ const char *failure_mode;
+
+ svn_pool_clear(iterpool);
+
+ rangelist_random_semi_canonical(&rly, &seed, iterpool);
+
+ err = svn_error_trace(rangelist_merge_random_inputs(rlx, rly,
iterpool));
+ failure_mode = add_failure_mode(err, failure_modes);
+ if (failure_mode)
+ {
+ printf("first example of a failure mode: %s / %s\n"
+ " %s\n",
+ rangelist_to_string(rlx, iterpool),
+ rangelist_to_string(rly, iterpool),
+ failure_mode);
+ /*svn_handle_error(err, stdout, FALSE);*/
+ pass = FALSE;
+ }
+ }
+ }
+
+ clear_failure_mode_errors(failure_modes, pool);
+
+ if (!pass)
+ return svn_error_createf(SVN_ERR_TEST_FAILED, NULL,
+ "Test failed: %d failure modes",
+ apr_hash_count(failure_modes));
+ return SVN_NO_ERROR;
+}
+
+/* Test svn_rangelist_merge2() with random non-validated inputs.
+ *
+ * Unlike the tests with valid inputs, this test expects many assertion
+ * failures. We don't care about those. All we care about is that it does
+ * not crash. */
+static svn_error_t *
+test_rangelist_merge_random_non_validated_inputs(apr_pool_t *pool)
+{
+ static apr_uint32_t seed = 0;
+ apr_pool_t *iterpool = svn_pool_create(pool);
+ apr_hash_t *failure_modes = apr_hash_make(pool);
+ int ix, iy;
+
+ /* "300": See comment "Random testing parameters and coverage" */
+ for (ix = 0; ix < 300; ix++)
+ {
+ svn_rangelist_t *rlx;
+
+ rangelist_random_non_validated(&rlx, &seed, pool);
+
+ for (iy = 0; iy < 300; iy++)
+ {
+ svn_rangelist_t *rly;
+ svn_error_t *err;
+
+ svn_pool_clear(iterpool);
+
+ rangelist_random_non_validated(&rly, &seed, iterpool);
+
+ err = svn_error_trace(rangelist_merge_random_inputs(rlx, rly,
iterpool));
+ add_failure_mode(err, failure_modes);
+ }
+ }
+
+ clear_failure_mode_errors(failure_modes, pool);
+
+ return SVN_NO_ERROR;
+}
+
+/* Generate random mergeinfo, in which the paths and rangelists are not
+ * necessarily valid. */
+static svn_error_t *
+mergeinfo_random_non_validated(svn_mergeinfo_t *mp,
+ apr_uint32_t *seed,
+ apr_pool_t *pool)
+{
+ svn_mergeinfo_t m = apr_hash_make(pool);
+ int n_paths = 3; /* See comment "Random testing parameters and coverage" */
+ int i;
+
+ for (i = 0; i < n_paths; i++)
+ {
+ const char *path;
+ svn_rangelist_t *rl;
+
+ /* A manually chosen distribution of valid and invalid paths:
+ See comment "Random testing parameters and coverage" */
+ switch (rand_less_than(8, seed))
+ {
+ case 0: case 1: case 2: case 3:
+ path = apr_psprintf(pool, "/path%d", i); break;
+ case 4:
+ path = apr_psprintf(pool, "path%d", i); break;
+ case 5:
+ path = apr_psprintf(pool, "//path%d", i); break;
+ case 6:
+ path = "/"; break;
+ case 7:
+ path = ""; break;
+ }
+ rangelist_random_non_validated(&rl, seed, pool);
+ svn_hash_sets(m, path, rl);
+ }
+ *mp = m;
+ return SVN_NO_ERROR;
+}
+
+#if 0
+static const char *
+mergeinfo_to_string_debug(svn_mergeinfo_t m,
+ apr_pool_t *pool)
+{
+ svn_string_t *s;
+ svn_error_t *err;
+
+ err = svn_mergeinfo_to_string(&s, m, pool);
+ if (err)
+ {
+ const char *s2 = err->message;
+ svn_error_clear(err);
+ return s2;
+ }
+ return s->data;
+}
+#endif
+
+/* Try a mergeinfo merge. This does not check the result. */
+static svn_error_t *
+mergeinfo_merge_random_inputs(const svn_mergeinfo_t mx,
+ const svn_mergeinfo_t my,
+ apr_pool_t *pool)
+{
+ svn_mergeinfo_t mm = svn_mergeinfo_dup(mx, pool);
+
+ SVN_ERR(svn_mergeinfo_merge2(mm, my, pool, pool));
+ return SVN_NO_ERROR;
+}
+
+/* Test svn_mergeinfo_merge2() with random non-validated inputs.
+ *
+ * Unlike the tests with valid inputs, this test expects many assertion
+ * failures. We don't care about those. All we care about is that it does
+ * not crash. */
+static svn_error_t *
+test_mergeinfo_merge_random_non_validated_inputs(apr_pool_t *pool)
+{
+ static apr_uint32_t seed = 0;
+ apr_pool_t *iterpool = svn_pool_create(pool);
+ int ix, iy;
+
+ for (ix = 0; ix < 300; ix++)
+ {
+ svn_mergeinfo_t mx;
+
+ SVN_ERR(mergeinfo_random_non_validated(&mx, &seed, pool));
+
+ for (iy = 0; iy < 300; iy++)
+ {
+ svn_mergeinfo_t my;
+ svn_error_t *err;
+
+ svn_pool_clear(iterpool);
+
+ SVN_ERR(mergeinfo_random_non_validated(&my, &seed, iterpool));
+
+ err = mergeinfo_merge_random_inputs(mx, my, iterpool);
+ if (err)
+ {
+ /*
+ printf("testcase FAIL: %s / %s\n",
+ mergeinfo_to_string_debug(mx, iterpool),
+ mergeinfo_to_string_debug(my, iterpool));
+ svn_handle_error(err, stdout, FALSE);
+ */
+ svn_error_clear(err);
+ }
+ }
+ }
+
+ return SVN_NO_ERROR;
+}
/* The test table. */
@@ -1831,6 +2528,18 @@ static struct svn_test_descriptor_t test
"merge of rangelists with overlaps (issue 4686)"),
SVN_TEST_PASS2(test_rangelist_loop,
"test rangelist edgecases via loop"),
+ SVN_TEST_PASS2(test_rangelist_merge_canonical_result,
+ "test rangelist merge canonical result (#4840)"),
+ SVN_TEST_PASS2(test_rangelist_merge_array_insert_failure,
+ "test rangelist merge array insert failure (#4840)"),
+ SVN_TEST_PASS2(test_rangelist_merge_random_canonical_inputs,
+ "test rangelist merge random canonical inputs"),
+ SVN_TEST_PASS2(test_rangelist_merge_random_semi_c_inputs,
+ "test rangelist merge random semi-c inputs"),
+ SVN_TEST_PASS2(test_rangelist_merge_random_non_validated_inputs,
+ "test rangelist merge random non-validated inputs"),
+ SVN_TEST_PASS2(test_mergeinfo_merge_random_non_validated_inputs,
+ "test mergeinfo merge random non-validated inputs"),
SVN_TEST_NULL
};
