1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
|
#' Check names to comply to specific rules
#'
#' @description
#' Performs various checks on character vectors, usually names.
#'
#' @templateVar fn Names
#' @param x [\code{character} || \code{NULL}]\cr
#' Names to check using rules defined via \code{type}.
#' @param type [\code{character(1)}]\cr
#' Type of formal check(s) to perform on the names.
#' \describe{
#' \item{unnamed:}{Checks \code{x} to be \code{NULL}.}
#' \item{named:}{Checks \code{x} for regular names which excludes names to be \code{NA} or empty (\code{""}).}
#' \item{unique:}{Performs checks like with \dQuote{named} and additionally tests for non-duplicated names.}
#' \item{strict:}{Performs checks like with \dQuote{unique} and additionally fails for names with UTF-8 characters and names which do not comply to R's variable name restrictions.
#' As regular expression, this is \dQuote{^[.]*[a-zA-Z]+[a-zA-Z0-9._]*$}.}
#' \item{ids:}{Same as \dQuote{strict}, but does not enforce uniqueness.}
#' }
#' Note that for zero-length \code{x}, all these name checks evaluate to \code{TRUE}.
#' @param subset.of [\code{character}]\cr
#' Names provided in \code{x} must be subset of the set \code{subset.of}.
#' @param must.include [\code{character}]\cr
#' Names provided in \code{x} must be a superset of the set \code{must.include}.
#' @param permutation.of [\code{character}]\cr
#' Names provided in \code{x} must be a permutation of the set \code{permutation.of}.
#' Duplicated names in \code{permutation.of} are stripped out and duplicated names in \code{x}
#' thus lead to a failed check.
#' Use this argument instead of \code{identical.to} if the order of the names is not relevant.
#' @param identical.to [\code{character}]\cr
#' Names provided in \code{x} must be identical to the vector \code{identical.to}.
#' Use this argument instead of \code{permutation.of} if the order of the names is relevant.
#' @param disjunct.from [\code{character}]\cr
#' Names provided in \code{x} must may not be present in the vector \code{disjunct.from}.
#' @param what [\code{character(1)}]\cr
#' Type of name vector to check, e.g. \dQuote{names} (default), \dQuote{colnames} or \dQuote{rownames}.
#' @template checker
#' @useDynLib checkmate c_check_names
#' @family attributes
#' @export
#' @examples
#' x = 1:3
#' testNames(names(x), "unnamed")
#' names(x) = letters[1:3]
#' testNames(names(x), "unique")
#'
#' cn = c("Species", "Sepal.Length", "Sepal.Width", "Petal.Length", "Petal.Width")
#' assertNames(names(iris), permutation.of = cn)
checkNames = function(x, type = "named", subset.of = NULL, must.include = NULL, permutation.of = NULL, identical.to = NULL, disjunct.from = NULL, what = "names") {
.Call(c_check_names, x, type, what) %and%
checkNamesCmp(x, subset.of, must.include, permutation.of, identical.to, disjunct.from, what)
}
checkNamesCmp = function(x, subset.of, must.include, permutation.of, identical.to, disjunct.from, what) {
if (!is.null(subset.of)) {
qassert(subset.of, "S")
msg = check_subset_internal(x, subset.of, match, what)
if (!isTRUE(msg))
return(msg)
}
if (!is.null(must.include)) {
qassert(must.include, "S")
ii = match(must.include, x)
if (anyMissing(ii)) {
return(set_msg("must include the elements %s, but is missing elements %s",
what,
set_collapse(must.include),
set_collapse(must.include[is.na(ii)])
))
}
}
if (!is.null(permutation.of)) {
permutation.of = unique(qassert(permutation.of, "S"))
msg = check_set_equal_internal(x, permutation.of, match, what)
if (!isTRUE(msg))
return(msg)
}
if (!is.null(identical.to)) {
qassert(identical.to, "S")
if (!identical(x, identical.to)) {
return(set_msg("must be a identical to set %s, but is %s",
what,
set_collapse(identical.to),
set_collapse(x)
))
}
}
if (!is.null(disjunct.from)) {
qassert(disjunct.from, "S")
msg = check_disjunct_internal(x, disjunct.from, match, what)
if (!isTRUE(msg))
return(msg)
}
return(TRUE)
}
#' @export
#' @rdname checkNames
check_names = checkNames
#' @export
#' @include makeAssertion.R
#' @template assert
#' @rdname checkNames
assertNames = makeAssertionFunction(checkNames, use.namespace = FALSE)
#' @export
#' @rdname checkNames
assert_names = assertNames
#' @export
#' @include makeTest.R
#' @rdname checkNames
testNames = makeTestFunction(checkNames)
#' @export
#' @rdname checkNames
test_names = testNames
#' @export
#' @include makeExpectation.R
#' @template expect
#' @rdname checkNames
expect_names = makeExpectationFunction(checkNames, use.namespace = FALSE)
|
