if(isTRUE(getOption("covr"))) { 

    context("recode simple vector")
    suppressWarnings(RNGversion("3.5.0"))
    
    
    expect_error(recode(1, 42))
    expect_error(recode(1))
    expect_error(recode(1, ~ 42))
    
    
    expect_identical(recode(1:5, 1~-1), c(-1, NA, NA, NA, NA))
    expect_identical(recode(1:5, 1~-1, other ~ copy), c(-1, 2, 3, 4, 5))
    expect_identical(recode(1:5, 1~-1, other() ~ copy()), c(-1, 2, 3, 4, 5))
    expect_identical(recode(1:5, 1~-1, TRUE ~ copy()), c(-1, 2, 3, 4, 5))
    b = 1:5
    recode(b) = 1~-1
    expect_identical(b, c(-1, 2, 3, 4, 5))
    
    expect_identical(recode(1:5, 1~-1, 2 ~ NA), c(-1, NA, NA, NA, NA))
    expect_identical(recode(1:5, 1~-1, 2 ~ NA, other ~ copy), c(-1, NA, 3, 4, 5))
    
    b = 1:5
    recode(b) = c(1~-1, 2 ~ NA)
    expect_identical(b, c(-1, NA, 3, 4, 5))
    
    expect_identical(recode(1:5, gt(2)~99, other ~ copy), c(1, 2, 99, 99, 99))
    expect_identical(recode(1:5, gt(2)~99), c(NA, NA, 99, 99, 99))
    
    b = 1:5
    recode(b) = gt(2)~99
    expect_identical(b, c(1, 2, 99, 99, 99))
    
    expect_identical(recode(1:5, gt(2)~99, other ~ 0), c(0, 0, 99, 99, 99))
    
    expect_identical(recode(1:5, 1:3 ~ 1, other ~ NA), c(1, 1, 1, NA, NA))
    
    expect_identical(recode(1:5, 1:3 ~ 1, 2:5 ~ 2), c(1, 1, 1, 2, 2))
    
    expect_identical(recode(1:5, lt(2) ~ 10, lt(3) ~ 11, lt(4) ~ 12, other ~ NA), c(10, 11, 12, NA, NA))
    
    expect_identical(recode(1:5, 4 ~ "four", (function(x) (x-1)<2) ~-1, other ~ copy), c(-1, -1, 3, "four", 5) )
    expect_identical(recode(1:5, 4 ~ "four", (function(x) (x-1)<2) ~-1), c(-1, -1, NA, "four", NA) )
    
    b = 1:5
    recode(b) = c(4 ~ "four", (function(x) (x-1)<2) ~-1)
    expect_identical(b, c(-1, -1, 3, "four", 5) )
    
    x = c(1,3,1,3,NA)
    y = c(8,8,8,9,9)
    z = c(4,4,4,5,5)
    
    expect_identical(recode(x, gt(2)~y, other ~ copy), c(1, 8, 1, 9, NA))
    expect_identical(recode(x, gt(2) ~ y), c(NA, 8, NA, 9, NA))
    recode(x) = gt(2)~y
    expect_identical(x, c(1, 8, 1, 9, NA))
    
    
    
    x = c(1,3,1,3,NA)
    y = c(8,8,8,9,9)
    z = c(4,4,4,5,5)
    
    expect_identical(recode(x, list(gt(2)~y), other ~ copy), c(1, 8, 1, 9, NA))
    expect_identical(recode(x, list(gt(2)~y, other ~ copy)), c(1, 8, 1, 9, NA))
    
    expect_identical(recode(x, list(gt(2)~y)), c(NA, 8, NA, 9, NA))
    recode(x) = list(gt(2)~y)
    expect_identical(x, c(1, 8, 1, 9, NA))
    
    
    x = c(1,3,1,3,NA)
    y = c(8,8,8,9,9)
    z = c(4,4,4,5,5)
    
    
    expect_identical(recode(x, gt(2)~y, le(2) ~ z, other ~ copy), c(4, 8, 4, 9, NA))
    expect_identical(recode(x, gt(2)~y, le(2) ~ z), c(4, 8, 4, 9, NA))
    
    recode(x) = c(gt(2)~y, le(2) ~ z)
    expect_identical(x, c(4, 8, 4, 9, NA))
    
    
    
    x = c(1,3,1,3,NA)
    y = c(8,8,8,9,9)
    z = c(4,4,4,5,5)
    
    expect_identical(recode(x, gt(2)~y, le(2) ~ z, other ~ 99), c(4, 8, 4, 9, 99))
    
    recode(x) = list(gt(2)~y, le(2) ~ z, other ~ 99)
    expect_identical(x, c(4, 8, 4, 9, 99))
    
    x = c(1,3,1,3,NA)
    y = c(8,8,8,9,9)
    z = c(4,4,4,5,5)
    
    expect_identical(recode(x, list(gt(2)~y, le(2) ~ z, other ~99)), c(4, 8, 4, 9, 99))
    recode(x) = list(gt(2)~y, le(2) ~ z, other ~99)
    expect_identical(x, c(4, 8, 4, 9, 99))
    
    x = c(1,3,1,3,NA)
    y = c(8,8,8,9,9)
    z = c(4,4,4,5,5)
    expect_identical(recode(x, when(z>4)~y, other ~ copy), c(1, 3, 1, 9, 9))
    expect_identical(recode(x, when(z>4)~y), c(NA, NA, NA, 9, 9))
    
    recode(x) = when(z>4)~y
    expect_identical(x, c(1, 3, 1, 9, 9))
    
    
    
   
    ##########################
    
    context("recode 'from, to' notation simple vector")
    
    expect_identical(recode(1:5, from_to(list(1, other), to = list(-1, copy))), c(-1, 2, 3, 4, 5))
    expect_identical(recode(1:5, from_to(1:2, to =c(-1, NA))), c(-1, NA, NA, NA, NA))
    
    expect_identical(recode(1:5, from_to(list(1, 2, other), to =list(-1, NA, copy))), c(-1, NA, 3, 4, 5))
    
    expect_identical(recode(1:5, from_to(list(gt(2), other), list(99, copy))), c(1, 2, 99, 99, 99))
    
    expect_identical(recode(1:5, from_to(list(gt(2)), 99)), c(NA, NA, 99, 99, 99))
    
    b = 1:5
    recode(b) = from_to(list(gt(2)), 99) 
    expect_identical(b, c(1, 2, 99, 99, 99))
    
    b = 1:5
    recode(b) = from_to(gt(2), 99) 
    expect_identical(b, c(1, 2, 99, 99, 99))
    
    
    
    expect_identical(recode(1:5, from_to(c(gt(2),other), to = c(99,0))), c(0, 0, 99, 99, 99))
    
    b = 1:5
    recode(b) = from_to(c(gt(2),copy), c(99,0))
    expect_identical(b, c(0, 0, 99, 99, 99))
    
    
    
    expect_identical(recode(1:5, from_to(list(1:3,other), to = c(1, NA))), c(1, 1, 1, NA, NA))
    
    expect_equal(recode(1:5, from_to(list(1:3, 2:5),  to =1:2)), c(1, 1, 1, 2, 2))
    
    expect_identical(recode(1:5, from_to(list(lt(2), lt(3), lt(4),other), to =c(10,  11, 12, NA))),
                     c(10, 11, 12, NA, NA))
    
    expect_identical(recode(1:5, from_to(list(4,function(x) (x-1)<2, other),  to = c("four", -1, copy))),
                     c(-1, -1, 3, "four", 5) )
    expect_identical(recode(1:5, from_to(list(4,function(x) (x-1)<2),  to = c("four", -1))),
                     c(-1, -1, NA, "four", NA) )
    
    x = c(1,3,1,3,NA)
    y = c(8,8,8,9,9)
    z = c(4,4,4,5,5)
    
    expect_identical(recode(x, from_to(list(gt(2)), to =list(y))), c(NA, 8, NA, 9, NA))
    expect_identical(recode(x, from_to(list(gt(2), other), to =list(y, copy))), c(1, 8, 1, 9, NA))
    
    
    expect_identical(recode(x, from_to(list(gt(2), le(2)), to = list(y,z))), c(4, 8, 4, 9, NA))
    expect_identical(recode(x, from_to(list(gt(2), le(2), other), to = list(y,z, copy))), c(4, 8, 4, 9, NA))
    
    expect_identical(recode(x, from_to(list(gt(2), le(2),other), to = list(y,z,99))), c(4, 8, 4, 9, 99))
    
    expect_identical(recode(x, from_to(list(when(z>4), other), to = list(y, copy))), c(1, 3, 1, 9, 9))
    
    expect_identical(recode(x, from_to(list(when(z>4)), to = list(y))), c(NA, NA, NA, 9, 9))
    
    
    
    context("recode examples")
    set.seed(123)
    v1  = sample(c(0:3,9,10), 20, replace = TRUE)
    # RECODE V1 TO V3 (0=1) (1=0) (2,3=-1) (9=9) (ELSE=SYSMIS)
    v_test = v1
    v_test[] = NA
    v_test[v1 == 0] = 1
    v_test[v1 == 1] = 0
    v_test[v1 %in% 2:3] = -1
    v_test[v1 == 9 ] = 9
    recode(v1) = c(0 ~ 1, 1 ~ 0, 2:3 ~ -1, 9 ~ 9, other ~ NA)
    expect_identical(
        v1
        , v_test)
    
    set.seed(123)
    qvar = sample((-5):20, 50, replace = TRUE)
    # RECODE QVAR(1 THRU 5=1)(6 THRU 10=2)(11 THRU HI=3)(ELSE=0).
    qvar_test = qvar
    qvar_test[] = 0
    qvar_test[qvar %in% 1:5] = 1
    qvar_test[qvar %in% 6:10] = 2
    qvar_test[qvar >= 11] = 3
    expect_identical(
        recode(qvar, 1 %thru% 5 ~ 1, 6 %thru% 10 ~ 2, ge(11) ~ 3, other ~ 0),
        qvar_test
    )
    expect_identical(
        recode(qvar, 1 | 2 %thru% 5 ~ 1, 6 %thru% 10 ~ 2, ge(11) ~ 3, other ~ 0),
        qvar_test
    )
    expect_identical(
        recode(qvar, c(1, 2 %thru% 5) ~ 1, 6 %thru% 10 ~ 2, ge(11) ~ 3, other ~ 0),
        qvar_test
    )
    recode(qvar) = c(1 %thru% 5 ~ 1, 6 %thru% 10 ~ 2, 11 %thru% Inf ~ 3, other ~ 0)
    expect_identical(
        qvar,
        qvar_test
    )
    
    
    strngvar = LETTERS
    # RECODE STRNGVAR ('A','B','C'='A')('D','E','F'='B')(ELSE=' ').
    letters_test = strngvar
    letters_test[] = " "
    letters_test[LETTERS %in% c('A','B','C')] = 'A'
    letters_test[LETTERS %in% c('D','E','F')] = 'B'
    expect_identical(
        recode(strngvar, c('A','B','C') ~ 'A', c('D','E','F') ~ 'B', other ~ ' '),
        letters_test
    )
    
    set.seed(123)
    age = sample(c(sample(5:30, 40, replace = TRUE), rep(9, 10)))
    # RECODE AGE (MISSING=9) (18 THRU HI=1) (0 THRU 18=0) INTO VOTER.
    voter_test = age
    voter_test[age == 9 ] = NA
    voter_test[voter_test %in% 0:17 ] = 0
    voter_test[voter_test %in% 18:100 ] = 1
    expect_identical(
        recode(age, 9 ~ NA, 18 %thru% Inf ~ 1, 0 %thru% 18 ~ 0),
        voter_test
    )
    
    context("recode examples from/to")
    set.seed(123)
    v1  = sample(c(0:3,9,10), 20, replace = TRUE)
    # RECODE V1 TO V3 (0=1) (1=0) (2,3=-1) (9=9) (ELSE=SYSMIS)
    v_test = v1
    v_test[] = NA
    v_test[v1 == 0] = 1
    v_test[v1 == 1] = 0
    v_test[v1 %in% 2:3] = -1
    v_test[v1 == 9 ] = 9
    fr = list(0, 1, 2:3, 9, other)
    to = list(1, 0, -1, 9, NA)
    recode(v1) = from_to(fr, to)
    expect_identical(
        v1
        , v_test)
    
    set.seed(123)
    qvar = sample((-5):20, 50, replace = TRUE)
    # RECODE QVAR(1 THRU 5=1)(6 THRU 10=2)(11 THRU HI=3)(ELSE=0).
    qvar_test = qvar
    qvar_test[] = 0
    qvar_test[qvar %in% 1:5] = 1
    qvar_test[qvar %in% 6:10] = 2
    qvar_test[qvar >= 11] = 3
    
    fr = list(1 %thru% 5, 6 %thru% 10, ge(11), other)
    to = list(1, 2, 3, 0)
    expect_identical(
        recode(qvar, from_to(fr, to)),
        qvar_test
    )
    
    
    strngvar = LETTERS
    # RECODE STRNGVAR ('A','B','C'='A')('D','E','F'='B')(ELSE=' ').
    letters_test = strngvar
    letters_test[] = " "
    letters_test[LETTERS %in% c('A','B','C')] = 'A'
    letters_test[LETTERS %in% c('D','E','F')] = 'B'
    fr = list(c('A','B','C'), c('D','E','F') , other)
    to = list("A", "B", " ")
    expect_identical(
        recode(strngvar, from_to(fr, to = to)),
        letters_test
    )
    
    set.seed(123)
    age = sample(c(sample(5:30, 40, replace = TRUE), rep(9, 10)))
    # RECODE AGE (MISSING=9) (18 THRU HI=1) (0 THRU 18=0) INTO VOTER.
    voter_test = age
    voter_test[age == 9 ] = NA
    voter_test[voter_test %in% 0:17 ] = 0
    voter_test[voter_test %in% 18:100 ] = 1
    fr = list(9, 18 %thru% Inf, 0 %thru% 18)
    to = list(NA, 1, 0)
    expect_identical(
        recode(age, from_to(fr, to = to)),
        voter_test
    )
    
    context("ifs")
    a = 1:5
    b = 5:1
    expect_identical(
        ifs(b>3 ~ 1), 
        c(1,1,NA, NA, NA)
    )
    expect_identical(
        ifs(b>3 ~ 1, TRUE ~ 3),
        c(1,1,3, 3, 3)
    )
    expect_identical(
        ifs(c(b, NA)>3 ~ 1, TRUE ~ 3),
        c(1,1,3, 3, 3, 3)
    )
    expect_identical(
        ifs(b>3 ~ 1, a>4 ~ 7, TRUE ~ 3),
        c(1,1,3, 3, 7)
        
    )
    
    expect_identical(
        ifs(b>3 ~ a),
        as.integer(c(1,2,NA,NA, NA))
    )
    expect_identical(
        ifs(b>3 ~ a, TRUE ~ "wah"),
        c("1","2","wah","wah", "wah")
    )
    
    expect_error(
        ifs(b>3 ~ cbind(a,b))
    )
    
    
    expect_error(
        ifs(45 ~ 1)
    )
    
    expect_error(
        ifs(cbind(c(T,T), c(F,F)) ~ 1)
    )
    
    
    context("recode type")
    
    a = 1:3
    var_lab(a) = "aadad"
    recode(a) = 1 ~ "bah"
    expect_identical(class(a), c("labelled", "character"))
    
    a = factor(letters[1:4])
    
    res = factor(c("a", "z", "c", "d"), levels = c("a", "b", "c", "d", "z"))
    b = recode(a, "b" ~ "z", other ~ copy)
    expect_identical(b, res)
    
    res = factor(c("z", "b", "c", "d"), levels = c("a", "b", "c", "d", "z"))
    b = recode(a, "a" ~ factor("z"))
    res2 = res
    res2[2:4] = NA
    expect_identical(b, res2) 
    
    
    b = recode(a, "a" ~ factor("z"), TRUE ~ copy)
    expect_identical(b, res) 
    
    
    a = factor(letters[1:4])
    recode(a) = "a" ~ factor("z")
    expect_identical(a, res)
    
    a = factor(letters[1:4])
    var_lab(a) = "factor"
    recode(a) = "a" ~ factor("z")
    var_lab(res) = "factor"
    expect_identical(a, res)
    
    
    a = as.POSIXct("2016-10-01")
    
    b = recode(a, "2016-10-01" ~ as.POSIXct("2016-10-02"))
    
    expect_equal(b, as.POSIXct("2016-10-02"))
    
    b = recode(a, "2016-10-01" ~ "2016-10-02")
    
    expect_equal(b, "2016-10-02")
    
    recode(a) = c("2016-10-01" ~ "2016-10-02")
    
    expect_identical(a, as.POSIXct("2016-10-02"))
    
    a = as.POSIXct(c("2016-10-01", "2017-05-10"))
    res = as.POSIXct(c("2016-10-02", "2017-05-11"))
    b = recode(a, "2016-10-01" ~ as.POSIXct("2016-10-02"), "2017-05-10" ~ "2017-05-11")
    expect_equal(b, res)
    
    recode(a) = "2016-10-01" ~ "2016-10-02"
    expect_identical(a, as.POSIXct(c("2016-10-02", "2017-05-10")))
    
    a = as.Date(c("2016-10-01", "2017-05-10"))
    res = as.Date(c("2016-10-02", "2017-05-11"))
    b = recode(a, "2016-10-01" ~ as.Date("2016-10-02"), "2017-05-10" ~ "2017-05-11")
    expect_equal(b, res)
    
    b = recode(a, "2016-10-01" ~ "2016-10-02", "2017-05-10" ~ "2017-05-11")
    expect_equal(b, as.character(res))
    
    recode(a) = "2016-10-01" ~ "2016-10-02"
    expect_identical(a, as.Date(c("2016-10-02", "2017-05-10")))
    
    context("recode copy")
    
    a = 1:5
    
    expect_identical(recode(a, 1:4 ~ NA, 5 ~ copy), c(NA, NA, NA, NA, 5L))
    
    context("type conversion")
    
    expect_identical(recode("a", "a" ~ 1), 1)
    
    context("recode to function")
    expect_identical(recode(letters, other ~ toupper), LETTERS)
    
    letters2 = letters
    recode(letters2) = c(other ~ toupper)
    expect_identical(letters2, LETTERS)
    
    
    
    context("%into%")
    
    remove_if_exists = function(...){
        for(each in unlist(list(...))){
            if(exists(each, envir = parent.frame(), inherits = FALSE)){
                rm(list = each, pos = parent.frame())
            }
        }
        invisible(NULL)
    }
    remove_if_exists("x")
    1 %into% x
    expect_identical(x, 1)
    
    remove_if_exists("y")
    x = "y"
    
    1 %into% ((x))
    expect_identical(x, "y")
    expect_identical(y, 1)
    
    remove_if_exists("x", "y", "z")
    many_vars = function() c("x", "y", "z")
    list(1,2,3) %into% many_vars()
    expect_identical(x, 1)
    expect_identical(y, 2)
    expect_identical(z, 3)
    
    remove_if_exists("x", "y", "z")
    1:3 %into% many_vars()
    expect_identical(x, 1:3)
    expect_identical(y, 1:3)
    expect_identical(z, 1:3)
    
    remove_if_exists("x", "y", "z")
    
    ..[x] = 1
    expect_identical(x, 1)
    
    remove_if_exists("y")
    x = "y"
    
    ..[(x)] = 1 
    expect_identical(x, "y")
    expect_identical(y, 1)
    
    
    remove_if_exists("x", "y", "z")
    many_vars = function() c("x", "y", "z")
    ..[many_vars()] = list(1,2,3) 
    expect_identical(x, 1)
    expect_identical(y, 2)
    expect_identical(z, 3)
    
    remove_if_exists("x", "y", "z")
    ..[many_vars()] = 1:3 
    expect_identical(x, 1:3)
    expect_identical(y, 1:3)
    expect_identical(z, 1:3)
    
    remove_if_exists("x", "y", "z")
    remove_if_exists("x1", "x2", "x3")
    
    ..[x1 %to% x3] = list(1:2, letters, TRUE)
    expect_identical(x1, 1:2)
    expect_identical(x2, letters)
    expect_identical(x3, TRUE)
    
    b = 1:5
    b2 = rev(b)
    recode(b, 1~-1, other ~ copy) %into%  b_recoded
    
    expect_identical(b_recoded, c(-1, 2, 3, 4, 5))
    
    recode(b, 1~-1, other ~ copy) %into%  "b_recoded_chr"
    expect_identical(b_recoded_chr, c(-1, 2, 3, 4, 5))
    
    recode(list(sheet(b, b2)), 1~-1, other ~ copy) %into%  qc(b_recoded)
    rownames(b_recoded) = NULL
    expect_identical(b_recoded, sheet(b = c(-1, 2, 3, 4, 5), b2 = rev( c(-1, 2, 3, 4, 5))))
    
    
    recode(sheet(b, b2), 1~10, other ~ copy) %into%  qc(b1_recoded, b2_recoded)
    expect_identical(b1_recoded, c(10, 2, 3, 4, 5))
    expect_identical(b2_recoded, rev( c(10, 2, 3, 4, 5)))
    
    rm(b1_recoded, b2_recoded)
    recode(sheet(b, b2), 1~10, other ~ copy) %into%  c(b1_recoded, b2_recoded)
    expect_identical(b1_recoded, c(10, 2, 3, 4, 5))
    expect_identical(b2_recoded, rev( c(10, 2, 3, 4, 5)))
    
    
    
    recode(as.matrix(cbind(b, b2)), 1~11, other ~ copy) %into%  qc(b1_recoded_mat, b2_recoded_mat)
    expect_identical(b1_recoded_mat, c(11, 2, 3, 4, 5))
    expect_identical(b2_recoded_mat, rev( c(11, 2, 3, 4, 5)))
    
    recode(sheet(b, b2), 1~10, other ~ copy) %into%  c(b1_recoded, b2_recoded)
    expect_identical(b1_recoded, c(10, 2, 3, 4, 5))
    expect_identical(b2_recoded, rev( c(10, 2, 3, 4, 5)))
    
    recode(list(b, b2), 1~10, other ~ copy) %into%  list(b3_recoded, b4_recoded)
    expect_identical(b3_recoded, c(10, 2, 3, 4, 5))
    expect_identical(b4_recoded, rev( c(10, 2, 3, 4, 5)))
    
    
    recode(sheet(b, b1=b, b2), 1~10, other ~ copy) %into%  text_expand('v{1:3}')
    expect_identical(v1, c(10, 2, 3, 4, 5))
    expect_identical(v2, c(10, 2, 3, 4, 5))
    expect_identical(v3, rev( c(10, 2, 3, 4, 5)))
    i = 1:3
    recode(sheet(b, b1=b, b2), 1~10, other ~ copy) %into%  text_expand('ww{i}')
    expect_identical(ww1, c(10, 2, 3, 4, 5))
    expect_identical(ww2, c(10, 2, 3, 4, 5))
    expect_identical(ww3, rev( c(10, 2, 3, 4, 5)))
    
    i = 1:2
    j = 3
    recode(sheet(b, b1=b, b2), 1~10, other ~ copy) %into%  text_expand(c('xx{i}', 'y{j}'))
    expect_identical(xx1, c(10, 2, 3, 4, 5))
    expect_identical(xx2, c(10, 2, 3, 4, 5))
    expect_identical(y3, rev( c(10, 2, 3, 4, 5)))
    
    
    i = 1:3
    recode(sheet(b, b1=b, b2), 1~10, other ~ copy) %into%  text_expand('wah{i}')
    expect_identical(wah1, c(10, 2, 3, 4, 5))
    expect_identical(wah2, c(10, 2, 3, 4, 5))
    expect_identical(wah3, rev( c(10, 2, 3, 4, 5)))
    
    i = 1:2
    j = 3
    recode(sheet(b, b1=b, b2), 1~10, other ~ copy) %into%  c(text_expand('xax{i}'), text_expand('xy{j}'))
    expect_identical(xax1, c(10, 2, 3, 4, 5))
    expect_identical(xax2, c(10, 2, 3, 4, 5))
    expect_identical(xy3, rev( c(10, 2, 3, 4, 5)))
    
    my_fun = function() c("x", "y", "z") 
    recode(sheet(b, b1=b, b2), 1~10, other ~ copy) %into%  my_fun()
    expect_identical(x, c(10, 2, 3, 4, 5))
    expect_identical(y, c(10, 2, 3, 4, 5))
    expect_identical(z, rev( c(10, 2, 3, 4, 5)))
    
    recode(sheet(b, b1=b, b2), 1~10, other ~ copy) %into%  (va1 %to% va3)
    expect_identical(va1, c(10, 2, 3, 4, 5))
    expect_identical(va2, c(10, 2, 3, 4, 5))
    expect_identical(va3, rev( c(10, 2, 3, 4, 5)))
    
    recode(sheet(b, b1=b, b2), 1~10, other ~ copy) %into%  (vb0 %to% vb2)
    expect_identical(vb0, c(10, 2, 3, 4, 5))
    expect_identical(vb1, c(10, 2, 3, 4, 5))
    expect_identical(vb2, rev( c(10, 2, 3, 4, 5)))
    
    expect_error(recode(sheet(b, b1=b, b2), 1~10, other ~ copy) %into%  (vb2 %to% vb4))
    
    expect_error(recode(sheet(b, b1=b, b2), 1~10, other ~ copy) %into%  (v0 %to% v2))
    expect_error(recode(sheet(b, b1=b, b2), 1~10, other ~ copy) %into%  (v01 %to% v002))
    recode(sheet(b, b1=b, b2), 1~10, other ~ copy) %into%  (v01 %to% v03)
    expect_identical(v01, c(10, 2, 3, 4, 5))
    expect_identical(v02, c(10, 2, 3, 4, 5))
    expect_identical(v03, rev( c(10, 2, 3, 4, 5)))
    
    recode(sheet(b, b1=b, b2), 1~10, other ~ copy) %into%  (v001 %to% v003)
    expect_identical(v001, c(10, 2, 3, 4, 5))
    expect_identical(v002, c(10, 2, 3, 4, 5))
    expect_identical(v003, rev( c(10, 2, 3, 4, 5)))
    
    recode(sheet(b, b1=b, b2), 1~10, other ~ copy) %into%  c(vax, f002 %to% f003)
    expect_identical(vax, c(10, 2, 3, 4, 5))
    expect_identical(f002, c(10, 2, 3, 4, 5))
    expect_identical(f003, rev( c(10, 2, 3, 4, 5)))
    
    recode(sheet(b, b1=b, b2), 1~42, other ~ copy) %into%  c(vax, f002 %to% f003)
    expect_identical(vax, c(42, 2, 3, 4, 5))
    expect_identical(f002, c(42, 2, 3, 4, 5))
    expect_identical(f003, rev( c(42, 2, 3, 4, 5)))
    
    expect_error(
        recode(sheet(b, b1=b, b2), 1~42, other ~ copy) %into%  c(g001 %to% gg003)
    )
    
    expect_error(
        recode(sheet(b, b1=b, b2), 1~42, other ~ copy) %into%  c(g003 %to% g001)
    )
    
    data(iris)

    expect_error(recode(sheet(b, b1=b, b2), 1~10, other ~ copy) %into%  (v0001 %to% v0002))
    
    recode(b, 1~10, other ~ copy) %into%  (v0001 %to% v0003)
    expect_identical(v0001, c(10, 2, 3, 4, 5))
    expect_identical(v0002, c(10, 2, 3, 4, 5))
    expect_identical(v0003, c(10, 2, 3, 4, 5))
    
    
    
    
    # context("recode factor")
    # 
    # df = data.frame(id = c(1,2,3,4,5),
    #                 Did_you_use_tv=factor(c("tv","","","tv","tv")),
    #                 Did_you_use_internet=factor(c("","","","int","int")))
    # 
    # new_df = df
    # 
    # recode(df[,-1], "" ~ 0, other ~ 1)
    # recode(new_df[,-1]) = c("" ~ 0, other ~ 1)
    data(iris) 
    iris_2 = iris
    res_iris = iris
    # res_iris$Species = as.character(res_iris$Species)
    res_iris[, 1:4] = scale(res_iris[, 1:4])
    recode(iris_2) = c(is.numeric ~ scale, is.factor ~ as.character)
    expect_equal(iris_2, res_iris)
    
    char_vec = c("a", "b")
    fac_vec = recode(char_vec, "b" ~ factor("a"), other ~ copy)
    expect_equal(fac_vec, factor(c("a", "a")))
    
}