Nothing
test_that("can pivot all cols to long", {
df <- tibble(x = 1:2, y = 3:4)
pv <- pivot_longer(df, x:y)
expect_named(pv, c("name", "value"))
expect_equal(pv$name, rep(names(df), 2))
expect_equal(pv$value, c(1, 3, 2, 4))
})
test_that("values interleaved correctly", {
df <- tibble(
x = c(1, 2),
y = c(10, 20),
z = c(100, 200),
)
pv <- pivot_longer(df, 1:3)
expect_equal(pv$value, c(1, 10, 100, 2, 20, 200))
})
test_that("can add multiple columns from spec", {
df <- tibble(x = 1:2, y = 3:4)
sp <- tibble(.name = c("x", "y"), .value = "v", a = 1, b = 2)
pv <- pivot_longer_spec(df, spec = sp)
expect_named(pv, c("a", "b", "v"))
})
test_that("preserves original keys", {
df <- tibble(x = 1:2, y = 2, z = 1:2)
pv <- pivot_longer(df, y:z)
expect_named(pv, c("x", "name", "value"))
expect_equal(pv$x, rep(df$x, each = 2))
})
test_that("can drop missing values", {
df <- data.frame(x = c(1, NA), y = c(NA, 2))
pv <- pivot_longer(df, x:y, values_drop_na = TRUE)
expect_equal(pv$name, c("x", "y"))
expect_equal(pv$value, c(1, 2))
})
test_that("can handle missing combinations", {
df <- tribble(
~id, ~x_1, ~x_2, ~y_2,
"A", 1, 2, "a",
"B", 3, 4, "b",
)
pv <- pivot_longer(df, -id, names_to = c(".value", "n"), names_sep = "_")
expect_named(pv, c("id", "n", "x", "y"))
expect_equal(pv$x, 1:4)
expect_equal(pv$y, c(NA, "a", NA, "b"))
})
test_that("mixed columns are automatically coerced", {
df <- data.frame(x = factor("a"), y = factor("b"))
pv <- pivot_longer(df, x:y)
expect_equal(pv$value, factor(c("a", "b")))
})
test_that("can override default output column type", {
df <- tibble(x = "x", y = 1L)
pv <- pivot_longer(df, x:y, values_transform = list(value = as.list))
expect_equal(pv$value, list("x", 1))
})
test_that("can pivot to multiple measure cols", {
df <- tibble(x = "x", y = 1)
sp <- tribble(
~.name, ~.value, ~row,
"x", "X", 1,
"y", "Y", 1,
)
pv <- pivot_longer_spec(df, sp)
expect_named(pv, c("row", "X", "Y"))
expect_equal(pv$X, "x")
expect_equal(pv$Y, 1)
})
test_that("original col order is preserved", {
df <- tribble(
~id, ~z_1, ~y_1, ~x_1, ~z_2, ~y_2, ~x_2,
"A", 1, 2, 3, 4, 5, 6,
"B", 7, 8, 9, 10, 11, 12,
)
pv <- pivot_longer(df, -id, names_to = c(".value", "n"), names_sep = "_")
expect_named(pv, c("id", "n", "z", "y", "x"))
})
test_that("handles duplicated column names", {
df <- tibble(x = 1, a = 1, a = 2, b = 3, b = 4, .name_repair = "minimal")
pv <- pivot_longer(df, -x)
expect_named(pv, c("x", "name", "value"))
expect_equal(pv$name, c("a", "a", "b", "b"))
expect_equal(pv$value, 1:4)
})
test_that("can pivot duplicated names to .value", {
df <- tibble(x = 1, a_1 = 1, a_2 = 2, b_1 = 3, b_2 = 4)
pv1 <- pivot_longer(df, -x, names_to = c(".value", NA), names_sep = "_")
pv2 <- pivot_longer(df, -x, names_to = c(".value", NA), names_pattern = "(.)_(.)")
pv3 <- pivot_longer(df, -x, names_to = ".value", names_pattern = "(.)_.")
expect_named(pv1, c("x", "a", "b"))
expect_equal(pv1$a, c(1, 2))
expect_equal(pv2, pv1)
expect_equal(pv3, pv1)
})
test_that(".value can be at any position in `names_to`", {
samp <- tibble(
i = 1:4,
y_t1 = rnorm(4),
y_t2 = rnorm(4),
z_t1 = rep(3, 4),
z_t2 = rep(-2, 4),
)
value_first <- pivot_longer(samp, -i,
names_to = c(".value", "time"), names_sep = "_")
samp2 <- dplyr::rename(samp, t1_y = y_t1,
t2_y = y_t2,
t1_z = z_t1,
t2_z = z_t2)
value_second <- pivot_longer(samp2, -i,
names_to = c("time", ".value"), names_sep = "_")
expect_identical(value_first, value_second)
})
test_that("type error message use variable names", {
df <- data.frame(abc = 1, xyz = "b")
err <- capture_error(pivot_longer(df, everything()))
expect_s3_class(err, "vctrs_error_incompatible_type")
expect_equal(err$x_arg, "abc")
expect_equal(err$y_arg, "xyz")
})
test_that("when `values_ptypes` is provided, the type error uses variable names (#1364)", {
df <- tibble(x = 1)
expect_snapshot({
(expect_error(pivot_longer(df, x, values_ptypes = character())))
})
})
test_that("when `names_ptypes` is provided, the type error uses `names_to` names (#1364)", {
df <- tibble(x = 1)
expect_snapshot({
(expect_error({
pivot_longer(
df,
cols = x,
names_to = "name",
names_ptypes = double()
)
}))
})
})
test_that("error when overwriting existing column", {
df <- tibble(x = 1, y = 2)
expect_snapshot(
(expect_error(pivot_longer(df, y, names_to = "x")))
)
expect_snapshot(
out <- pivot_longer(df, y, names_to = "x", names_repair = "unique")
)
expect_named(out, c("x...1", "x...2", "value"))
})
test_that("grouping is preserved", {
df <- tibble(g = 1, x1 = 1, x2 = 2)
out <- df %>%
dplyr::group_by(g) %>%
pivot_longer(x1:x2, names_to = "x", values_to = "v")
expect_equal(dplyr::group_vars(out), "g")
})
test_that("zero row data frame works", {
df <- tibble(x = integer(), y = integer())
pv <- pivot_longer(df, x:y)
expect_named(pv, c("name", "value"))
expect_equal(pv$name, character())
expect_equal(pv$value, integer())
})
test_that("`cols_vary` can adjust the resulting row ordering (#1312)", {
df <- tibble(x = c(1, 2), y = c(3, 4))
expect_identical(
pivot_longer(df, c(x, y), cols_vary = "fastest"),
tibble(name = c("x", "y", "x", "y"), value = c(1, 3, 2, 4))
)
expect_identical(
pivot_longer(df, c(x, y), cols_vary = "slowest"),
tibble(name = c("x", "x", "y", "y"), value = c(1, 2, 3, 4))
)
})
test_that("`cols_vary` works with id columns not part of the pivoting process", {
df <- tibble(id = c("a", "b"), x = c(1, 2), y = c(3, 4))
out <- pivot_longer(df, c(x, y), cols_vary = "fastest")
expect_identical(out$id, c("a", "a", "b", "b"))
expect_identical(
out[c("name", "value")],
pivot_longer(df[c("x", "y")], c(x, y), cols_vary = "fastest")
)
out <- pivot_longer(df, c(x, y), cols_vary = "slowest")
expect_identical(out$id, c("a", "b", "a", "b"))
expect_identical(
out[c("name", "value")],
pivot_longer(df[c("x", "y")], c(x, y), cols_vary = "slowest")
)
})
test_that("adjusting `cols_vary` works fine with `values_drop_na`", {
df <- tibble(id = c("a", "b"), x = c(1, NA), y = c(3, 4))
expect_identical(
pivot_longer(df, c(x, y), cols_vary = "slowest", values_drop_na = TRUE),
tibble(
id = c("a", "a", "b"),
name = c("x", "y", "y"),
value = c(1, 3, 4)
)
)
})
# spec --------------------------------------------------------------------
test_that("validates inputs", {
df <- tibble(x = 1)
expect_error(build_longer_spec(df, x, values_to = letters[1:2]),
class = "vctrs_error_assert"
)
})
test_that("no names doesn't generate names (#1120)", {
df <- tibble(x = 1)
expect_identical(
colnames(build_longer_spec(df, x, names_to = character())),
c(".name", ".value")
)
expect_identical(
colnames(build_longer_spec(df, x, names_to = NULL)),
c(".name", ".value")
)
})
test_that("multiple names requires names_sep/names_pattern", {
df <- tibble(x_y = 1)
expect_snapshot({
(expect_error(build_longer_spec(df, x_y, names_to = c("a", "b"))))
(expect_error(
build_longer_spec(
df,
x_y,
names_to = c("a", "b"),
names_sep = "x",
names_pattern = "x"
)
))
})
})
test_that("names_sep generates correct spec", {
df <- tibble(x_y = 1)
sp <- build_longer_spec(df, x_y, names_to = c("a", "b"), names_sep = "_")
expect_equal(sp$a, "x")
expect_equal(sp$b, "y")
})
test_that("names_sep fails with single name", {
df <- tibble(x_y = 1)
expect_snapshot({
(expect_error(build_longer_spec(df, x_y, names_to = "x", names_sep = "_")))
})
})
test_that("names_pattern generates correct spec", {
df <- tibble(zx_y = 1)
sp <- build_longer_spec(df, zx_y, names_to = c("a", "b"), names_pattern = "z(.)_(.)")
expect_equal(sp$a, "x")
expect_equal(sp$b, "y")
sp <- build_longer_spec(df, zx_y, names_to = "a", names_pattern = "z(.)")
expect_equal(sp$a, "x")
})
test_that("names_to can override value_to", {
df <- tibble(x_y = 1)
sp <- build_longer_spec(df, x_y, names_to = c("a", ".value"), names_sep = "_")
expect_equal(sp$.value, "y")
})
test_that("names_prefix strips off from beginning", {
df <- tibble(zzyz = 1)
sp <- build_longer_spec(df, zzyz, names_prefix = "z")
expect_equal(sp$name, "zyz")
})
test_that("can cast to custom type", {
df <- tibble(w1 = 1)
sp <- build_longer_spec(df, w1,
names_prefix = "w",
names_transform = list(name = as.integer)
)
expect_equal(sp$name, 1L)
})
test_that("transform is applied before cast (#1233)", {
df <- tibble(w1 = 1)
sp <- build_longer_spec(
df,
w1,
names_prefix = "w",
names_ptypes = list(name = integer()),
names_transform = list(name = as.numeric)
)
expect_identical(sp$name, 1L)
})
test_that("`names_ptypes` and `names_transform` work with single values (#1284)", {
df <- tibble(`1x2` = 1)
res <- build_longer_spec(
data = df,
cols = `1x2`,
names_to = c("one", "two"),
names_sep = "x",
names_transform = as.numeric
)
expect_identical(res$one, 1)
expect_identical(res$two, 2)
res <- build_longer_spec(
data = df,
cols = `1x2`,
names_to = c("one", "two"),
names_sep = "x",
names_transform = as.numeric,
names_ptypes = integer()
)
expect_identical(res$one, 1L)
expect_identical(res$two, 2L)
})
test_that("`names_ptypes = list()` is interpreted as recycling <list> for all name columns (#1296)", {
df <- tibble(`1x2` = 1)
res <- build_longer_spec(
data = df,
cols = `1x2`,
names_to = c("one", "two"),
names_sep = "x",
names_transform = as.list,
names_ptypes = list()
)
expect_identical(res$one, list("1"))
expect_identical(res$two, list("2"))
})
test_that("`values_ptypes` works with single empty ptypes (#1284)", {
df <- tibble(x_1 = 1, y_1 = 2)
res <- pivot_longer(
data = df,
cols = everything(),
names_to = c(".value", "set"),
names_sep = "_",
values_ptypes = integer()
)
expect_identical(res$x, 1L)
expect_identical(res$y, 2L)
})
test_that("`values_ptypes = list()` is interpreted as recycling <list> for all value columns (#1296)", {
df <- tibble(x_1 = list_of(1L, 2:3, 4L), y_1 = list_of(2:3, 4L, 5:6))
res <- pivot_longer(
data = df,
cols = everything(),
names_to = c(".value", "set"),
names_sep = "_",
values_ptypes = list()
)
expect_identical(res$x, vec_cast(df$x_1, list()))
expect_identical(res$y, vec_cast(df$y_1, list()))
})
test_that("`values_transform` works with single functions (#1284)", {
df <- tibble(x_1 = 1, y_1 = 2)
res <- pivot_longer(
data = df,
cols = everything(),
names_to = c(".value", "set"),
names_sep = "_",
values_transform = as.character
)
expect_identical(res$x, "1")
expect_identical(res$y, "2")
})
test_that("Error if the `col` can't be selected.", {
expect_snapshot({
(expect_error(pivot_longer(iris, matches("foo"))))
})
})
test_that("named `cols` gives clear error (#1104)", {
df <- data.frame(x = 1, y = 2)
expect_snapshot(pivot_longer(df, c(z = y)), error = TRUE)
})
test_that("`names_to` is validated", {
df <- tibble(x = 1)
expect_snapshot({
(expect_error(build_longer_spec(df, x, names_to = 1)))
(expect_error(build_longer_spec(df, x, names_to = c("x", "y"))))
(expect_error(build_longer_spec(df, x, names_to = c("x", "y"), names_sep = "_", names_pattern = "x")))
})
})
test_that("`names_ptypes` is validated", {
df <- tibble(x = 1)
expect_snapshot({
(expect_error(build_longer_spec(df, x, names_ptypes = 1)))
(expect_error(build_longer_spec(df, x, names_ptypes = list(integer()))))
})
})
test_that("`names_transform` is validated", {
df <- tibble(x = 1)
expect_snapshot({
(expect_error(build_longer_spec(df, x, names_transform = 1)))
(expect_error(build_longer_spec(df, x, names_transform = list(~.x))))
})
})
test_that("`values_ptypes` is validated", {
df <- tibble(x = 1)
expect_snapshot({
(expect_error(pivot_longer(df, x, values_ptypes = 1)))
(expect_error(pivot_longer(df, x, values_ptypes = list(integer()))))
})
})
test_that("`values_transform` is validated", {
df <- tibble(x = 1)
expect_snapshot({
(expect_error(pivot_longer(df, x, values_transform = 1)))
(expect_error(pivot_longer(df, x, values_transform = list(~.x))))
})
})
test_that("`cols_vary` is validated", {
df <- tibble(x = 1)
expect_snapshot({
(expect_error(pivot_longer(df, x, cols_vary = "fast")))
(expect_error(pivot_longer(df, x, cols_vary = 1)))
})
})
test_that("`pivot_longer()` catches unused input passed through the dots", {
df <- tibble(id = c("a", "b"), x = c(1, 2), y = c(3, 4))
expect_snapshot({
(expect_error(pivot_longer(df, c(x, y), 1)))
(expect_error(pivot_longer(df, c(x, y), col_vary = "slowest")))
})
})
test_that("`build_longer_spec()` requires empty dots", {
df <- tibble(id = c("a", "b"), x = c(1, 2), y = c(3, 4))
expect_snapshot({
(expect_error(build_longer_spec(df, c(x, y), 1)))
(expect_error(build_longer_spec(df, c(x, y), name_to = "name")))
})
})
test_that("`pivot_longer_spec()` requires empty dots", {
df <- tibble(id = c("a", "b"), x = c(1, 2), y = c(3, 4))
spec <- build_longer_spec(df, c(x, y))
expect_snapshot({
(expect_error(pivot_longer_spec(df, spec, 1)))
(expect_error(pivot_longer_spec(df, spec, col_vary = "slowest")))
})
})
Any scripts or data that you put into this service are public.
Add the following code to your website.
For more information on customizing the embed code, read Embedding Snippets.