Attachment #24193 for ticket #13749

View | Details | Raw Unified | Return to ticket 13749
Collapse All | Expand All




	char *prefix;           /* hostname prefix                      */
	unsigned long num;      /* numeric suffix                       */

	/* string representation of numeric suffix, and trailing chars
	 * points into `hostname'                                       */
	char *suffix;
} hostname_t;

/* hostrange type: A single prefix with `hi' and `lo' numeric suffix values */
typedef struct {
	char *prefix;        /* alphanumeric prefix: */
	char *suffix;

	/* beginning (lo) and end (hi) of suffix range */
	unsigned long lo, hi;


static int           host_prefix_end(const char *, int dims);
static hostname_t *hostname_create(const char *);
static hostname_t *hostname_copy(const hostname_t *);
static void hostname_destroy(hostname_t *);
static int hostname_suffix_is_valid(hostname_t *);
static int hostname_suffix_width(hostname_t *, int);
static char *hostname_suffix_extra(hostname_t *, int);

static hostrange_t *hostrange_new(void);
static hostrange_t *hostrange_create_single(const char *);
static hostrange_t *hostrange_create(char *, unsigned long, unsigned long, int, char *);
static unsigned long hostrange_count(hostrange_t *);
static hostrange_t *hostrange_copy(hostrange_t *);
static void hostrange_destroy(hostrange_t *);
static hostrange_t *hostrange_delete_host(hostrange_t *, unsigned long);
static int hostrange_cmp(hostrange_t *, hostrange_t *);
static int hostrange_prefix_cmp(hostrange_t *, hostrange_t *);
static int hostrange_prefix_suffix_cmp(hostrange_t *, hostrange_t *);
static int hostrange_within_range(hostrange_t *, hostrange_t *);
static int hostrange_width_combine(hostrange_t *, hostrange_t *);
static int hostrange_empty(hostrange_t *);

static int         hostlist_expand(hostlist_t);
static int hostlist_push_range(hostlist_t, hostrange_t *);
static int         hostlist_push_hr(hostlist_t, char *, unsigned long,
		unsigned long, int, char *);
static int hostlist_insert_range(hostlist_t, hostrange_t *, int);
static void        hostlist_delete_range(hostlist_t, int n);
static void        hostlist_coalesce(hostlist_t hl);

	char *p;
	int idx = 0;
	int hostlist_base;
	int suffix_len;

	xassert(hostname);


	}

	hn->suffix = hn->hostname + idx + 1;
	suffix_len = hostname_suffix_width(hn, dims);

	if ((dims > 1) && (suffix_len != dims))
		hostlist_base = 10;

	hn->num = strtoul(hn->suffix, &p, hostlist_base);

	if (p - hn->suffix == suffix_len) {
		if (!(hn->prefix = malloc((idx + 2)))) {
			hostname_destroy(hn);
			out_of_memory("hostname prefix create");

	return hostname_create_dims(hostname, dims);
}

/*
 * make a copy of a hostname object
 */
static hostname_t *hostname_copy(const hostname_t *hn)
{
	hostname_t *ret;

	if (hn == NULL)
		return NULL;

	if ((ret = malloc(sizeof(*ret))) == NULL)
		out_of_memory("hostname copy");

	ret->hostname = strdup(hn->hostname);
	ret->prefix = strdup(hn->prefix);
	ret->suffix = hn->suffix ? ret->hostname + (hn->suffix - hn->hostname) : NULL;
	ret->num = hn->num;

	if (!ret->hostname || !ret->prefix) {
		hostname_destroy(ret);
		ret = NULL;
		out_of_memory("hostname copy");
	}

	return ret;
}

/* free a hostname object
 */
static void hostname_destroy(hostname_t *hn)


/* return the width (in characters) of the numeric part of the hostname
 */
static int hostname_suffix_width(hostname_t *hn, int dims)
{
	int idx = 0;
	if (!hn)
		return -1;
	xassert(hn->suffix);

	if (dims > 1)
		return (int) strlen(hn->suffix);
	while (hn->suffix[idx] != '\0' && isdigit(hn->suffix[idx]))
		idx++;
	return idx;
}

/* return a pointer to extra data after the numeric suffix, or NULL if none
*/
static char *hostname_suffix_extra(hostname_t *hn, int dims)
{
	int width = hostname_suffix_width(hn, dims);
	if (width > 0 && strlen(hn->suffix) > width)
		return hn->suffix + width;
	return NULL;
}

/* ----[ hostrange_t functions ]---- */

/* allocate a new hostrange object
*/
static hostrange_t *hostrange_new(void)
{
	hostrange_t *new = malloc(sizeof(*new));

	new->lo = 0L;
	new->hi = 0L;
	new->width = 0;
	new->suffix = NULL;

	return new;


/* Create a hostrange object with a prefix, hi, lo, and format width
 */
static hostrange_t *hostrange_create(char *prefix, unsigned long lo,
				     unsigned long hi, int width, char *suffix)
{
	hostrange_t *new;


	if ((new->prefix = strdup(prefix)) == NULL)
		goto error2;

	new->suffix = NULL;
	if (suffix && ((new->suffix = strdup(suffix)) == NULL))
		goto error3;

	new->lo = lo;
	new->hi = hi;
	new->width = width;


	return new;

error3:
	free(new->prefix);
error2:
	free(new);
error1:


	if (hr->singlehost)
		return hostrange_create_single(hr->prefix);
	return hostrange_create(hr->prefix, hr->lo, hr->hi, hr->width, hr->suffix);
		return hostrange_create(hr->prefix, hr->lo, hr->hi,
					hr->width);
}



		return;
	if (hr->prefix)
		free(hr->prefix);
	if (hr->suffix)
		free(hr->suffix);
	free(hr);
}


/* hostrange_cmp() is used to sort hostrange objects. It will
 * sort based on the following (in order):
 *  o result of xstrcmp on prefixes
 *  o result of xstrcmp on suffixes
 *  o if widths are compatible, then:
 *       sort based on lowest number in range
 *    else
 *       sort based on width                     */
static int hostrange_cmp(hostrange_t *h1, hostrange_t *h2)


	xassert(h1 && h2);

	if ((retval = hostrange_prefix_cmp(h1, h2)) == 0) {
		if (retval == 0) {
			if (h1->suffix && !h2->suffix)
				retval = 1;
			else if (!h1->suffix && h2->suffix)
				retval = -1;
			else if (h1->suffix && h2->suffix)
				retval = strnatcmp(h1->suffix, h2->suffix);
		}
		if (retval == 0)
			retval = hostrange_width_combine(h1, h2) ?
				h1->lo - h2->lo : h1->width - h2->width;
	}

	return retval;
}

	return retval == 0 ? h2->singlehost - h1->singlehost : retval;
}

/* compare the prefixes and suffixes of two hostrange objects
 * returns:
 *    0      if both are the same
 *    non-0  if different
 *
 * (not lexicographic, do not use in sorting) */
static int hostrange_prefix_suffix_cmp(hostrange_t *h1, hostrange_t *h2)
{
	if (hostrange_prefix_cmp(h1, h2))
		return 1;
	if (h1->suffix == NULL && h2->suffix == NULL)
		return 0;
	if (h1->suffix != NULL && h2->suffix != NULL)
		return strnatcmp(h1->suffix, h2->suffix);
	return 1;
}

/* returns true if h1 and h2 would be included in the same bracketed hostlist.
 * h1 and h2 will be in the same bracketed list iff:
 *

 */
static int hostrange_within_range(hostrange_t *h1, hostrange_t *h2)
{
	if (hostrange_prefix_suffix_cmp(h1, h2) == 0)
		return h1->singlehost || h2->singlehost ? 0 : 1;
	else
		return 0;

	return ((hr->hi < hr->lo) || (hr->hi == (unsigned long) -1));
}

/* Convert existing single hostrange with no suffix into numeric range with a suffix
 */
static int hostrange_convert_suffix(hostrange_t *hr, unsigned long n, unsigned long width, unsigned long suffix_idx)
{
	size_t prefix_len;
	xassert(hr && hr->prefix);

	prefix_len = strlen(hr->prefix);

	if (hostrange_count(hr) != 1 || hr->suffix || suffix_idx >= prefix_len || width == 0)
		return 0;

	if (!(hr->suffix = malloc(strlen(hr->prefix) - suffix_idx + hr->width + 1)))
		return 0;

	/* copy previous numeric suffix in (if any) */
	if (hr->width)
		sprintf(hr->suffix, "%s%0*lu", hr->prefix + suffix_idx, hr->width, hr->lo);
	else
		strcpy(hr->suffix, hr->prefix + suffix_idx);

	/* truncate the prefix */
	hr->prefix[suffix_idx - width] = 0;
	/* reset numeric settings */
	hr->width = width;
	hr->lo = n;
	hr->hi = n;
	hr->singlehost = 0;
	return 1;
}


/* Attempt to extract a number of the given width from a string,
 * return 0 on success, and set *res to extracted number,
 * 1 on failure
 */
static int
_extract_num_width(char *buf, size_t width, unsigned long *res)
{
	char *endptr;
	unsigned long x = strtoul(buf, &endptr, 10);
	if (x == ULONG_MAX || endptr - buf != width)
		return 1;
	*res = x;
	return 0;
}

/* Compare left suffix == right suffix + number
 * 0 on success, 1 on failure, like strcmp */
	static int
_compare_str_num(char *left, char *right, unsigned long idx, unsigned long width)
{
	if (strncmp(left, right, strlen(right)))
		return 1;
	if (width) {
		unsigned long num;
		if (_extract_num_width(left+ strlen(right), width, &num) ||
				num != idx)
			return 1;
	}
	return 0;
}

/* Compare two hostranges to see if they have a numeric part in the middle
 * of the prefix and can be combined into one range.
 * If they can, return hr1 if they can be combined into it, otherwise
 * try to fix up both to have a common suffix and return NULL
 */
static hostrange_t *
hostrange_combine_suffix(hostrange_t *hr1, hostrange_t *hr2)
{
	int i;

	xassert(hr1 && hr2);
	/* First test, to see if we can combine two single host ranges into a range
	 * with a numerical part in the middle.
	 * Can only combine if the current numeric suffix is the same, and the
	 * length of the prefixes is the same, and we don't have a prefix/suffix split already,
	 * and any numeric suffix is the same */
	if ((hr1->singlehost != hr2->singlehost) ||
			(strlen(hr1->prefix) != strlen(hr2->prefix)) ||
			hr1->suffix || hr2->suffix ||
			hr1->lo != hr2->lo ||
			hr1->hi != hr2->hi ||
			hostrange_count(hr1) != 1 ||
			hr1->width != hr2->width) {
		/* Another possibility - if this is adding a single host to an existing range,
		 * and the numeric suffix of hr2 would match the string suffix of hr1 */
		if (!hr1->singlehost && hr1->suffix &&
				hostrange_count(hr2) == 1 && hr2->suffix == NULL) {
			size_t hr1_prefix_len = strlen(hr1->prefix);
			size_t hr2_prefix_len = strlen(hr2->prefix);
			unsigned long hr2_idx;
			/* Total length should match */
			if (hr1_prefix_len + hr1->width + strlen(hr1->suffix) !=
					hr2_prefix_len + hr2->width)
				return NULL;
			/* We now may have two ranges of the form:
			 *
			 *         /-- hr1 prefix
			 *         |   /-- hr1 lo
			 *         |   |   /--- hr1 suffix
			 *         foo-1234-111
			 *         foo-1235-111
			 *         |        ^ hr2 lo
			 *         \-- hr2 prefix
			 *
			 * Walk along hr2 and compare to hr1
			 */
			/* Compare prefix */
			if (strncmp(hr1->prefix, hr2->prefix, hr1_prefix_len))
				return NULL;
			/* Extract numeric portion */
			if (_extract_num_width(hr2->prefix + hr1_prefix_len, hr1->width, &hr2_idx))
				return NULL;
			/* compare the suffix */
			if (hr1_prefix_len + hr1->width >= hr2_prefix_len ||
					_compare_str_num(hr1->suffix, hr2->prefix + hr1_prefix_len + hr1->width, hr2->lo, hr2->width))
				return NULL;
			/* If the numbers are not consecutive, we still want to convert the second entry to
			 * prefix/suffix form so that printouts can combine them */
			if (hr2_idx != hr1->hi + 1) {
				hostrange_convert_suffix(hr2, hr2_idx, hr1->width, hr1_prefix_len + hr1->width);
				return NULL;
			}
			/* At this point everything matches, expand the range of hr1 */
			hr1->hi++;
			return hr1;
		}
		return NULL;
	}

	/* Here we have two single host ranges with a numeric suffix, attempt to find
	 * a common ascending range of numbers between the two */
	for (i = 0; i < strlen(hr1->prefix); i++) {
		if (isdigit(hr1->prefix[i])) {
			unsigned long p1, p2;
			char *endp1, *endp2;
			p1 = strtoul(hr1->prefix + i, &endp1, 10);
			p2 = strtoul(hr2->prefix + i, &endp2, 10);
			/* widths of numeric field should match, but
			 * the numbers themselves should be consecutive */
			if ((endp1 - hr1->prefix) == (endp2 - hr2->prefix) && (p1 != p2)) {
				int prefix_len = i;

				/* the rest of the prefix should match as well */
				i = endp1 - hr1->prefix;
				if (strcmp(hr1->prefix + i, hr2->prefix + i) != 0) {
					return NULL;
				}
				/* Ok, we have a match, convert them to the correct suffix
				 * so that they can be coalesced above */
				hostrange_convert_suffix(hr1, p1, i - prefix_len, i);
				/* if they are consecutive, extend the first range,
				 * otherwise leave them distinct so they can be grouped in printout */
				if (p2 - p1 == 1) {
					hr1->hi = p2;
					return hr1;
				}
				hostrange_convert_suffix(hr2, p2, i - prefix_len, i);
				return NULL;
			}
		}
	}
	return NULL;
}


/* return the string representation of the last host in hostrange hr
 * and remove that host from the range (i.e. decrement hi if possible)
 *

			out_of_memory("hostrange pop");
	} else if (hostrange_count(hr) > 0) {
		size = strlen(hr->prefix) + hr->width + 16;
		if (hr->suffix) size += strlen(hr->suffix);
		if (!(host = malloc(size)))
			out_of_memory("hostrange pop");
		if ((dims > 1) && (hr->width == dims)) {


			hostlist_parse_int_to_array(hr->hi, coord, dims, 0);

			xassert(!hr->suffix);
			len = snprintf(host, size, "%s", hr->prefix);
			if (len >= 0 && len + dims < size) {
				while (i2 < dims)

			}
			hr->hi--;
		} else {
			snprintf(host, size, "%s%0*lu%s", hr->prefix,
				 hr->width, hr->hi--, hr->suffix ? hr->suffix : "");
		}
	}


			out_of_memory("hostrange shift");
	} else if (hostrange_count(hr) > 0) {
		size = strlen(hr->prefix) + hr->width + 16;
		if (hr->suffix) size += strlen(hr->suffix);
		if (!(host = malloc(size)))
			out_of_memory("hostrange shift");
		if ((dims > 1) && (hr->width == dims)) {


			hostlist_parse_int_to_array(hr->lo, coord, dims, 0);

			xassert(!hr->suffix);
			len = snprintf(host, size, "%s", hr->prefix);
			if (len >= 0 && len + dims < size) {
				while (i2 < dims)

			}
			hr->lo++;
		} else {
			snprintf(host, size, "%s%0*lu%s", hr->prefix,
				 hr->width, hr->lo++, hr->suffix ? hr->suffix : "");
		}
	}


	xassert(h1 && h2);
	xassert(hostrange_cmp(h1, h2) <= 0);

	if (hostrange_prefix_suffix_cmp(h1, h2) == 0 &&
	    hostrange_width_combine(h1, h2)) {

		if (h1->singlehost && h2->singlehost) {    /* matching singlets  */

	xassert(hostrange_cmp(h1, h2) <= 0);

	if ((h1->hi > h2->lo)
	    && (hostrange_prefix_suffix_cmp(h1, h2) == 0)
	    && (hostrange_width_combine(h1, h2))) {

		if (!(new = hostrange_copy(h1)))

/* return 1 if hostname hn is within the hostrange hr
 *        0 if not.
 */
static int hostrange_hn_within(hostrange_t *hr, hostname_t *hn_orig, int dims)
{
    hostname_t *hn = hn_orig;
    int ret = 0;

	if (hr->singlehost) {
		/*
		 *  If the current hostrange [hr] is a `singlehost' (no valid

		if (len1 == len2)
			return 0;

		/* Make a copy of the hostname to mess with */
		hn = hostname_copy(hn_orig);

		if (!hn)
			return 0;

		ldiff = len1 - len2;

		if (ldiff > 0 && (hostname_suffix_width(hn, dims) >= ldiff)) {
			/* Tack on ldiff of the hostname's suffix to
			 * that of it's prefix */
			hn->prefix = realloc(hn->prefix, len2+ldiff+1);
			if (!hn->prefix) {
				goto free_cpy;
			}
			strncat(hn->prefix, hn->suffix, ldiff);
		} else if (ldiff < 0) {
			/* strip off the ldiff here */
			hn->prefix[len2+ldiff] = '\0';
		}
			return 0;

		/* Now adjust the suffix of the hostname object. */
		hn->suffix += ldiff;


		/* Now compare them and see if they match */
		if (strcmp(hr->prefix, hn->prefix) != 0)
			goto free_cpy;
	}

	/* And check the suffix if any */
	if (hr->suffix && hostname_suffix_extra(hn, dims) &&
			strcmp(hr->suffix, hostname_suffix_extra(hn, dims)) != 0)
		goto free_cpy;

	/*
	 *  Finally, check whether [hn], with a valid numeric suffix,
	 *   falls within the range of [hr].
	 */
	if (hn->num <= hr->hi && hn->num >= hr->lo) {
		int width = hostname_suffix_width(hn, dims);
		int num = hn->num;
		ret = (_width_equiv(hr->lo, &hr->width, num, &width));
	}

free_cpy:
	if (hn != hn_orig)
		hostname_destroy(hn);
	return ret;
}



			int i2 = 0;
			int coord[dims];

			xassert(!hr->suffix);
			hostlist_parse_int_to_array(i, coord, dims, 0);
			ret = snprintf(buf + len, n - len, "%s", hr->prefix);
			if (ret < 0 || (len += ret) >= n || len + dims >= n)

			while (i2 < dims)
				buf[len++] = alpha_num[coord[i2++]];
		} else {
			ret = snprintf(buf + len, n - len, "%s%0*lu%s",
				       hr->prefix, hr->width, i, hr->suffix ? hr->suffix : "");
			if (ret < 0 || (len += ret) >= n)
				goto truncated;
		}


	if (hl->nranges > 0
	    && tail->hi == hr->lo - 1
	    && hostrange_prefix_suffix_cmp(tail, hr) == 0
	    && hostrange_width_combine(tail, hr)) {
		tail->hi = hr->hi;
	} else {

 */
static int
hostlist_push_hr(hostlist_t hl, char *prefix, unsigned long lo,
		 unsigned long hi, int width, char *suffix)
{
	hostrange_t *hr = hostrange_create(prefix, lo, hi, width, suffix);
	int retval = hostlist_push_range(hl, hr);
	hostrange_destroy(hr);
	return retval;

		} else {
			if (high < low)
				high = low;
			hostlist_push_hr(new, prefix, low, high, fmt, NULL);
		}

		error = 0;

 * RET 0 on success, -1 on failure (invalid prefix) */
static int
_push_range_list(hostlist_t hl, char *prefix, struct _range *range,
		 int n, int dims, char *suffix)
{
	int i, k, nr, rc = 0, rc1;
	char *p, *q;

				if (recurse) {
					rc1 = _push_range_list(hl, new_prefix,
							       saved_range,
							       n, dims, suffix);
					rc = MAX(rc, rc1);
				} else {
					range = saved_range;

						hostlist_push_hr(hl, new_prefix,
								 range->lo,
								 range->hi,
								 range->width, suffix);
						range++;
					}
				}


	for (k = 0; k < n; k++) {
		hostlist_push_hr(hl, prefix,
				 range->lo, range->hi, range->width, suffix);
		range++;
	}
	return 0;


	while ((tok = _next_tok(sep, &str)) != NULL) {
		if ((p = strrchr(tok, '[')) != NULL) {
			char *q, *prefix = tok, *suffix = NULL;
			*p++ = '\0';

			if ((q = strchr(p, ']'))) {
				if ((q[1] != ',') && (q[1] != '\0')) {
					/* suffix only supported for dims == 1 */
					if (dims == 1)
						suffix = q+1;
					else
						goto error;
				}
				*q = '\0';
				nr = _parse_range_list(p,
						       &ranges,

				if (nr < 0)
					goto error;
				if (_push_range_list(
					    new, prefix, ranges, nr, dims, suffix))
					goto error;
			} else {
				/* The hostname itself contains a '['


	if (hostname_suffix_is_valid(hn))
		hr = hostrange_create(hn->prefix, hn->num, hn->num,
				      hostname_suffix_width(hn, dims), hostname_suffix_extra(hn, dims));
	else
		hr = hostrange_create_single(str);


			int i2 = 0;
			int coord[dims];

			xassert(!hr->suffix);
			hostlist_parse_int_to_array(
				hr->lo + depth, coord, dims, 0);


				buf[len++] = alpha_num[coord[i2++]];
			buf[len] = '\0';
		} else {
			len = snprintf(buf + len, size - len, "%0*lu%s",
				       hr->width, hr->lo + depth, hr->suffix ? hr->suffix : "");
			if (len < 0 || len >= size)
				return NULL;
		}

		hostrange_t *hprev = hl->hr[i - 1];
		hostrange_t *hnext = hl->hr[i];

		if ((hprev->hi == hnext->lo - 1 || hprev->hi == hnext->lo) &&
		    hostrange_prefix_suffix_cmp(hprev, hnext) == 0 &&
		    hostrange_width_combine(hprev, hnext)) {
			hprev->hi = hnext->hi;
			hostlist_delete_range(hl, i);


	LOCK_HOSTLIST(hl);

    for (i = 0; i < hl->nranges - 1; i++) {
        new = hostrange_combine_suffix(hl->hr[i], hl->hr[i+1]);
        if (new) {
            /* combined, we can delete the second range */
            hostlist_delete_range(hl, i+1);
			/* try to combine this one with the next one again */
			i--;
        }
    }

	for (i = hl->nranges - 1; i > 0; i--) {

		new = hostrange_intersect(hl->hr[i - 1], hl->hr[i]);

			while (new->lo <= new->hi) {
				hostrange_t *hr = hostrange_create(new->prefix,
								   new->lo, new->lo,
								   new->width, new->suffix);

				if (new->lo > hprev->hi)
					hostlist_insert_range(hl, hr, j++);

		    int brackets)
{
	hostrange_t **hr = hl->hr;
	int i = *start, first = *start;
	int m, len = 0;
	int bracket_needed = brackets ? _is_bracket_needed(hl, i) : 0;
	int zeropad = 0;

	if (bracket_needed)
		buf[len++] = ']';

	/* All grouped ranges should have the same suffix, use the first */
	if (hr[first]->suffix) {
		xassert(n - len > 1);
		len += snprintf(buf + len, n - len - 1, "%s", hr[first]->suffix);
		if (n - len < 1)    /* no space left in buffer */
			return len;
	}

	buf[len] = '\0';
	*start = i;
	return len;

				       i->hr->width, i->hr->lo + i->depth);
			if (len < 0 || len >= size)
				goto no_next;
			if (i->hr->suffix) {
				len += snprintf(buf + len, size - len, "%s", i->hr->suffix);
				if (len < 0 || len >= size)
					goto no_next;
			}
		}
	}
	UNLOCK_HOSTLIST(i->hl);

Lines 36-41 Link Here

(-)a/testsuite/slurm_unit/common/hostlist/hostlist_nth-test.c (-1 / +56 lines)
36	#include <stdio.h>	36	#include <stdio.h>
37	#include <stdlib.h>	37	#include <stdlib.h>
38	#include <signal.h>	38	#include <signal.h>
		39	#include <assert.h>
39		40
40	#include "slurm/slurm.h"	41	#include "slurm/slurm.h"
41	#include "src/common/hostlist.h"	42	#include "src/common/hostlist.h"
Lines 48-53 hostset_t slurm_hostset_create(const char*); Link Here
48	void slurm_hostset_destroy(hostset_t);	49	void slurm_hostset_destroy(hostset_t);
49	int slurm_hostset_count(hostset_t);	50	int slurm_hostset_count(hostset_t);
50		51
		52	#define ck_assert_ptr_ne(p1, p2) ck_assert_int_ne((long int)p1, (long int)p2)
		53	#define ck_assert_ptr_eq(p1, p2) ck_assert_int_eq((long int)p1, (long int)p2)
		54
51	#ifndef NDEBUG	55	#ifndef NDEBUG
52	/* note: only works in CK_FORK mode */	56	/* note: only works in CK_FORK mode */
53	START_TEST(hostlist_nth_lo_assert_check)	57	START_TEST(hostlist_nth_lo_assert_check)
Lines 120-125 START_TEST(hostlist_nth_check) Link Here
120	}	124	}
121	END_TEST	125	END_TEST
122		126
		127	START_TEST(hostlist_suffix_check)
		128	{
		129	hostlist_t hl = NULL;
		130	char *p;
		131	int n, i;
		132	char hspec[] = "host4-abc,host[1-3]-abc,host6-abc,host7";
		133	char expect_spec[] = "host7,host[1-4,6]-abc";
		134	char *buf;
		135
		136	ck_assert_ptr_eq(slurm_hostlist_nth(hl, 0), NULL);
		137
		138	hl = slurm_hostlist_create(hspec);
		139	ck_assert_ptr_ne(hl, NULL);
		140
		141	n = slurm_hostlist_count(hl);
		142	ck_assert_int_eq(n, 6);
		143
		144	hostlist_sort(hl);
		145
		146	n = slurm_hostlist_count(hl);
		147	ck_assert_int_eq(n, 6);
		148
		149	buf = hostlist_ranged_string_malloc(hl);
		150	ck_assert_str_eq(buf, expect_spec);
		151	free(buf);
		152
		153	p = slurm_hostlist_nth(hl, 0);
		154	ck_assert_str_eq(p, "host7");
		155	free(p);
		156
		157	for (i = 1; i < 5; i++) {
		158	char host_str[16];
		159	sprintf(host_str, "host%d-abc", i);
		160	p = slurm_hostlist_nth(hl, i);
		161	ck_assert_str_eq(p, host_str);
		162	free(p);
		163	}
		164
		165	p = slurm_hostlist_nth(hl, 5);
		166	ck_assert_str_eq(p, "host6-abc");
		167	free(p);
		168
		169	for (i = 0; i < n; i++) {
		170	ck_assert_int_eq(slurm_hostlist_delete_nth(hl, 0), 1);
		171	ck_assert_int_eq(slurm_hostlist_count(hl), n-i-1);
		172	}
		173
		174	slurm_hostlist_destroy(hl);
		175	}
		176	END_TEST
		177
123	START_TEST(hostset_nth_check)	178	START_TEST(hostset_nth_check)
124	{	179	{
125	hostset_t hs;	180	hostset_t hs;
Lines 154-159 Suite *make_nonassert_suite(void) Link Here
154	TCase *tc_core = tcase_create("host_nth_check_nonassert");	209	TCase *tc_core = tcase_create("host_nth_check_nonassert");
155	tcase_add_test(tc_core, hostlist_nth_check);	210	tcase_add_test(tc_core, hostlist_nth_check);
156	tcase_add_test(tc_core, hostset_nth_check);	211	tcase_add_test(tc_core, hostset_nth_check);
		212	tcase_add_test(tc_core, hostlist_suffix_check);
157	suite_add_tcase(s, tc_core);	213	suite_add_tcase(s, tc_core);
158	return s;	214	return s;
159	}	215	}
160	-

Return to ticket 13749