Nothing
tests/testthat/testslidingwin.R
In climwin: Climate Window Analysis
# Test the outcomes of slidingwin #
#Need to vary:
# baseline model type: glm, lme4, glmer
# cinterval: day, week, month
# stat: mean, min, max, slope
# func: lin, quad, cub, inv, log
# upper: range
# lower: range
# binary: TRUE or FALSE
# k: 0 and >1
# centre: value
##########################################################
# Test regular output #
test_that("slidingwin produces the right output", {
data(Mass, envir = environment())
data(MassClimate, envir = environment())
furthest = 2
closest = 0
test <- slidingwin(xvar = list(MassClimate$Temp), cdate = MassClimate$Date, bdate = Mass$Date,
baseline = lm(Mass ~ 1, data = Mass), range = c(2, 0),
type = "relative", stat = "max", func = "lin", cmissing = FALSE)
duration <- (furthest - closest) + 1
maxmodno <- (duration * (duration + 1))/2
# Test that a list has been produced
expect_true(is.list(test))
# Test that a best model was returned
expect_false(is.na((test[[1]]$BestModel)[1]))
# Test that there are no NAs in the best model data
expect_equal(length(which(is.na(test[[1]]$BestModelData))), 0)
# Test that the best model data has at least 2 columns
expect_true(ncol(test[[1]]$BestModelData) >= 2)
# Test that there are no NAs in the output dataset
expect_equal(length(which(is.na(test[[1]]$Dataset[, 4]))), 0)
# Test that all columns were created in the dataset
expect_true(ncol(test[[1]]$Dataset) == 17)
# Test that the correct number of models were recorded in the dataset
expect_equal(maxmodno, nrow(test[[1]]$Dataset))
# Test that data was not randomised
expect_true((test[[1]]$Dataset["Randomised"])[1, ] == "no")
#Test the values we get out have stayed the same as our last R version
expect_true(round(test[[1]]$Dataset$deltaAICc[1], 1) == -2.7)
expect_true(test[[1]]$Dataset$WindowOpen[1] == 2 & test[[1]]$Dataset$WindowClose[1] == 2)
expect_true(round(test[[1]]$Dataset$ModelBeta[1], 1) == -0.7)
})
# Test output with multiple combos #
test_that("slidingwin produces multiple combos", {
data(Mass, envir = environment())
data(MassClimate, envir = environment())
furthest = 1
closest = 0
test <- slidingwin(xvar = list(Temp = MassClimate$Temp, Rain = MassClimate$Rain), cdate = MassClimate$Date, bdate = Mass$Date,
baseline = lm(Mass ~ 1, data = Mass), range = c(1, 0),
type = "relative", stat = c("max", "min"), func = c("lin", "quad"), cmissing = FALSE)
# Test that all combos of stat, func and xvar were created
expect_equal(nrow(test$combos), 8)
})
##########################################################
# Test that upper and lower work #
# Test with upper and binary:
test_that("slidingwin produces binary values with upper and binary = TRUE", {
data(Mass, envir = environment())
data(MassClimate, envir = environment())
furthest = 1
closest = 0
test <- slidingwin(xvar = list(Temp = MassClimate$Temp), cdate = MassClimate$Date, bdate = Mass$Date,
baseline = lm(Mass ~ 1, data = Mass), range = c(1, 0),
type = "relative", stat = "max", func = "lin", cmissing = FALSE,
upper = 10, binary = TRUE)
# Test that the minimum value of climate was set at 0
expect_equal(min(test[[1]]$BestModelData$climate), 0)
# Test that the maximum value of climate was set at 1
expect_equal(max(test[[1]]$BestModelData$climate), 1)
#Test the values we get out have stayed the same as our last R version
expect_true(round(test[[1]]$Dataset$deltaAICc[1], 1) == 1.2)
expect_true(test[[1]]$Dataset$WindowOpen[1] == 1 & test[[1]]$Dataset$WindowClose[1] == 0)
expect_true(round(test[[1]]$Dataset$ModelBeta[1], 1) == 1.9)
})
# Test with upper and without binary
test_that("slidingwin produces non-binary values with upper and binary = FALSE", {
data(Mass, envir = environment())
data(MassClimate, envir = environment())
furthest = 1
closest = 0
test <- slidingwin(xvar = list(Temp = MassClimate$Temp), cdate = MassClimate$Date, bdate = Mass$Date,
baseline = lm(Mass ~ 1, data = Mass), range = c(1, 0),
type = "relative", stat = "max", func = "lin", cmissing = FALSE,
upper = 10, binary = FALSE)
# Test that the minimum value of climate was set at 0
expect_equal(min(test[[1]]$BestModelData$climate), 0)
# Test that the maximum value of climate in greater than 1
expect_true(max(test[[1]]$BestModelData$climate) > 1)
#Test the values we get out have stayed the same as our last R version
expect_true(round(test[[1]]$Dataset$deltaAICc[1], 1) == 1.7)
expect_true(test[[1]]$Dataset$WindowOpen[1] == 1 & test[[1]]$Dataset$WindowClose[1] == 1)
expect_true(round(test[[1]]$Dataset$ModelBeta[1], 1) == -0.1)
})
# Test with lower and without binary
test_that("slidingwin produces non-binary values with lower and binary = FALSE", {
data(Mass, envir = environment())
data(MassClimate, envir = environment())
furthest = 1
closest = 0
test <- slidingwin(xvar = list(Temp = MassClimate$Temp), cdate = MassClimate$Date, bdate = Mass$Date,
baseline = lm(Mass ~ 1, data = Mass), range = c(1, 0),
type = "relative", stat = "max", func = "lin", cmissing = FALSE,
lower = 10, binary = FALSE)
# Test that the minumum value of climate is set at 0
expect_equal(min(test[[1]]$BestModelData$climate), 0)
# Test that the maximum value of climate is greater than 1
expect_true(max(test[[1]]$BestModelData$climate) > 1)
#Test the values we get out have stayed the same as our last R version
expect_true(round(test[[1]]$Dataset$deltaAICc[1], 1) == 1.5)
expect_true(test[[1]]$Dataset$WindowOpen[1] == 1 & test[[1]]$Dataset$WindowClose[1] == 0)
expect_true(round(test[[1]]$Dataset$ModelBeta[1], 1) == 0.1)
})
# With lower and binary
test_that("slidingwin produces binary values with lower and binary = TRUE", {
data(Mass, envir = environment())
data(MassClimate, envir = environment())
furthest = 1
closest = 0
test <- slidingwin(xvar = list(Temp = MassClimate$Temp), cdate = MassClimate$Date, bdate = Mass$Date,
baseline = lm(Mass ~ 1, data = Mass), range = c(1, 0),
type = "relative", stat = "max", func = "lin", cmissing = FALSE,
lower = 10, binary = TRUE)
# Test that the minimum value of climate is set at 0
expect_equal(min(test[[1]]$BestModelData$climate), 0)
# Test that the maximum value of climate is set at 1
expect_equal(max(test[[1]]$BestModelData$climate), 1)
#Test the values we get out have stayed the same as our last R version
expect_true(round(test[[1]]$Dataset$deltaAICc[1], 1) == 1.7)
expect_true(test[[1]]$Dataset$WindowOpen[1] == 1 & test[[1]]$Dataset$WindowClose[1] == 0)
expect_true(round(test[[1]]$Dataset$ModelBeta[1], 1) == 1.1)
})
# Test with upper, lower and binary
test_that("slidingwin produces binary values with lower/upper and binary = TRUE", {
data(Mass, envir = environment())
data(MassClimate, envir = environment())
furthest = 1
closest = 0
test <- slidingwin(xvar = list(Temp = MassClimate$Temp), cdate = MassClimate$Date, bdate = Mass$Date,
baseline = lm(Mass ~ 1, data = Mass), range = c(1, 0),
type = "relative", stat = "max", func = "lin", cmissing = FALSE,
lower = 10, upper = 15, binary = TRUE)
# Test that the minimum value of climate is set at 0
expect_equal(min(test[[1]]$BestModelData$climate), 0)
# Test that the maximum value of climate is set at 1
expect_equal(max(test[[1]]$BestModelData$climate), 1)
#Test the values we get out have stayed the same as our last R version
expect_true(round(test[[1]]$Dataset$deltaAICc[1], 1) == 0.7)
expect_true(test[[1]]$Dataset$WindowOpen[1] == 1 & test[[1]]$Dataset$WindowClose[1] == 0)
expect_true(round(test[[1]]$Dataset$ModelBeta[1], 1) == 2.2)
})
# With upper and lower but without binary
test_that("slidingwin produces non-binary values with lower/upper and binary = FALSE", {
data(Mass, envir = environment())
data(MassClimate, envir = environment())
furthest = 1
closest = 0
test <- slidingwin(xvar = list(Temp = MassClimate$Temp), cdate = MassClimate$Date, bdate = Mass$Date,
baseline = lm(Mass ~ 1, data = Mass), range = c(1, 0),
type = "relative", stat = "max", func = "lin", cmissing = FALSE,
lower = 10, upper = 15, binary = FALSE)
# Test that the minimum value of climate is set at 0
expect_equal(min(test[[1]]$BestModelData$climate), 0)
# Test that the maximum value of climate is greater than 1
expect_true(max(test[[1]]$BestModelData$climate) > 1)
#Test the values we get out have stayed the same as our last R version
expect_true(round(test[[1]]$Dataset$deltaAICc[1], 1) == 1.6)
expect_true(test[[1]]$Dataset$WindowOpen[1] == 1 & test[[1]]$Dataset$WindowClose[1] == 1)
expect_true(round(test[[1]]$Dataset$ModelBeta[1], 1) == -0.4)
})
##########################################################
# Test different settings of cmissing #
# Test when cmissing is FALSE and NAs are present (daily)#
test_that("Errors return when cmissing FALSE and NA present at a daily scale", {
data(Mass, envir = environment())
data(MassClimate, envir = environment())
MassClimate2 <- MassClimate[-491, ]
expect_error(slidingwin(xvar = list(MassClimate2$Temp), cdate = MassClimate2$Date, bdate = Mass$Date,
baseline = lm(Mass ~ 1, data = Mass), range = c(2, 0),
type = "relative", stat = "max", func = "lin", cmissing = FALSE))
expect_true(exists("missing"))
rm("missing", envir = .GlobalEnv)
})
# Test when cmissing is FALSE and NAs are present (weekly)#
test_that("Errors return when cmissing FALSE and NA present at a weekly scale", {
data(Mass, envir = environment())
data(MassClimate, envir = environment())
MassClimate2 <- MassClimate[-c(491:505), ]
expect_error(slidingwin(xvar = list(MassClimate2$Temp), cdate = MassClimate2$Date, bdate = Mass$Date,
baseline = lm(Mass ~ 1, data = Mass), range = c(2, 0),
type = "relative", stat = "max", func = "lin", cmissing = FALSE,
cinterval = "week"))
expect_true(exists("missing"))
rm("missing", envir = .GlobalEnv)
})
# Test when cmissing is FALSE and NAs are present (monthly)#
test_that("Errors return when cmissing FALSE and NA present at a monthly scale", {
data(Mass, envir = environment())
data(MassClimate, envir = environment())
MassClimate2 <- MassClimate[-c(480:520), ]
expect_error(slidingwin(xvar = list(MassClimate2$Temp), cdate = MassClimate2$Date, bdate = Mass$Date,
baseline = lm(Mass ~ 1, data = Mass), range = c(2, 0),
type = "relative", stat = "max", func = "lin", cmissing = FALSE,
cinterval = "month"))
expect_true(exists("missing"))
rm("missing", envir = .GlobalEnv)
})
# Test cmissing = FALSE with spatial replication (daily)
test_that("cmissing = FALSE with NAs and spatial replication (daily)", {
data(Mass, envir = environment())
Mass$Plot <- c(rep(c("A", "B"), 23), "A")
data(MassClimate, envir = environment())
MassClimate$Plot <- "A"
MassClimate2 <- MassClimate
MassClimate2$Plot <- "B"
Clim <- rbind(MassClimate, MassClimate2)
Clim2 <- Clim[-which(Clim$Plot == "B" & Clim$Date == "8/05/1966"), ]
expect_error(slidingwin(xvar = list(Clim2$Temp), cdate = Clim2$Date, bdate = Mass$Date,
baseline = lm(Mass ~ 1, data = Mass), range = c(2, 0),
type = "relative",
stat = "max", func = "lin", cmissing = FALSE,
spatial = list(Mass$Plot, Clim2$Plot)))
expect_true(exists("missing"))
rm("missing", envir = .GlobalEnv)
})
# Test cmissing = FALSE with spatial replication (weekly)
test_that("cmissing = FALSE with NAs and spatial replication (weekly)", {
data(Mass, envir = environment())
Mass$Plot <- c(rep(c("A", "B"), 23), "A")
data(MassClimate, envir = environment())
MassClimate$Plot <- "A"
MassClimate2 <- MassClimate
MassClimate2$Plot <- "B"
Clim <- rbind(MassClimate, MassClimate2)
Clim2 <- Clim[-c(18025:18015), ]
expect_error(slidingwin(xvar = list(Clim2$Temp), cdate = Clim2$Date, bdate = Mass$Date,
baseline = lm(Mass ~ 1, data = Mass), range = c(2, 0),
type = "relative",
stat = "max", func = "lin", cmissing = FALSE,
spatial = list(Mass$Plot, Clim2$Plot),
cinterval = "week"))
expect_true(exists("missing"))
rm("missing", envir = .GlobalEnv)
})
# Test cmissing = FALSE with spatial replication (monthly)
test_that("cmissing = FALSE with NAs and spatial replication (monthly)", {
data(Mass, envir = environment())
Mass$Plot <- c(rep(c("A", "B"), 23), "A")
data(MassClimate, envir = environment())
MassClimate$Plot <- "A"
MassClimate2 <- MassClimate
MassClimate2$Plot <- "B"
Clim <- rbind(MassClimate, MassClimate2)
Clim2 <- Clim[-c(18000:18050), ]
expect_error(slidingwin(xvar = list(Clim2$Temp), cdate = Clim2$Date, bdate = Mass$Date,
baseline = lm(Mass ~ 1, data = Mass), range = c(2, 0),
type = "relative",
stat = "max", func = "lin", cmissing = FALSE,
spatial = list(Mass$Plot, Clim2$Plot),
cinterval = "month"))
expect_true(exists("missing"))
rm("missing", envir = .GlobalEnv)
})
# Test when cmissing is method1 and no NA is present #
test_that("No errors return when cmissing method1 and full dataset", {
data(Mass, envir = environment())
data(MassClimate, envir = environment())
test <- slidingwin(xvar = list(MassClimate$Temp), cdate = MassClimate$Date, bdate = Mass$Date,
baseline = lm(Mass ~ 1, data = Mass), range = c(2, 2),
type = "relative", stat = "max", func = "lin", cmissing = "method1")
#Test that slidingwin ran without an error
expect_true(is.list(test))
#Test the values we get out have stayed the same as our last R version
expect_true(round(test[[1]]$Dataset$deltaAICc[1], 1) == -2.7)
expect_true(test[[1]]$Dataset$WindowOpen[1] == 2 & test[[1]]$Dataset$WindowClose[1] == 2)
expect_true(round(test[[1]]$Dataset$ModelBeta[1], 1) == -0.7)
})
# Test when cmissing is method2 and no NA is present #
test_that("No errors return when cmissing method2 and full dataset", {
data(Mass, envir = environment())
data(MassClimate, envir = environment())
test <- slidingwin(xvar = list(MassClimate$Temp), cdate = MassClimate$Date, bdate = Mass$Date,
baseline = lm(Mass ~ 1, data = Mass), range = c(2, 2),
type = "relative", stat = "max", func = "lin", cmissing = "method2")
# Test that slidingwin ran without an error
expect_true(is.list(test))
#Test the values we get out have stayed the same as our last R version
expect_true(round(test[[1]]$Dataset$deltaAICc[1], 1) == -2.7)
expect_true(test[[1]]$Dataset$WindowOpen[1] == 2 & test[[1]]$Dataset$WindowClose[1] == 2)
expect_true(round(test[[1]]$Dataset$ModelBeta[1], 1) == -0.7)
})
# Test when cmissing is method1 and NA is present (daily) #
test_that("No errors return when cmissing method1 with NAs (daily)", {
data(Mass, envir = environment())
data(MassClimate, envir = environment())
MassClimate2 <- MassClimate[-491, ]
test <- slidingwin(xvar = list(MassClimate2$Temp), cdate = MassClimate2$Date, bdate = Mass$Date,
baseline = lm(Mass ~ 1, data = Mass), range = c(2, 0),
type = "relative", stat = "max", func = "lin", cmissing = "method1")
# Test that slidingwin ran without an error
expect_true(is.list(test))
#Test the values we get out have stayed the same as our last R version
expect_true(round(test[[1]]$Dataset$deltaAICc[1], 1) == -2.7)
expect_true(test[[1]]$Dataset$WindowOpen[1] == 2 & test[[1]]$Dataset$WindowClose[1] == 2)
expect_true(round(test[[1]]$Dataset$ModelBeta[1], 1) == -0.7)
})
# Test when cmissing is method2 and NA is present (daily)#
test_that("No errors return when cmissing method2 with NAs (daily)", {
data(Mass, envir = environment())
data(MassClimate, envir = environment())
MassClimate2 <- MassClimate[-491, ]
test <- slidingwin(xvar = list(MassClimate2$Temp), cdate = MassClimate2$Date, bdate = Mass$Date,
baseline = lm(Mass ~ 1, data = Mass), range = c(2, 0),
type = "relative", stat = "max", func = "lin", cmissing = "method2")
# Test that slidingwin ran without an error
expect_true(is.list(test))
#Test the values we get out have stayed the same as our last R version
expect_true(round(test[[1]]$Dataset$deltaAICc[1], 1) == -2.7)
expect_true(test[[1]]$Dataset$WindowOpen[1] == 2 & test[[1]]$Dataset$WindowClose[1] == 2)
expect_true(round(test[[1]]$Dataset$ModelBeta[1], 1) == -0.7)
})
# Test when cmissing is method1 and NA is present (cinterval = "week") #
test_that("No errors returned when cmissing method1 with NAs, cinterval = week", {
data(Mass, envir = environment())
data(MassClimate, envir = environment())
MassClimate2 <- MassClimate[-c(491:505), ]
# Test that an error is returned
test <- slidingwin(xvar = list(MassClimate2$Temp), cdate = MassClimate2$Date, bdate = Mass$Date,
baseline = lm(Mass ~ 1, data = Mass), range = c(2, 0),
type = "relative", stat = "max", func = "lin", cinterval = "week",
cmissing = "method1")
# Test that slidingwin ran without an error
expect_true(is.list(test))
#Test the values we get stay the same as github version (7-9-17).
#N.B. We don't use the old R version because we have changed how we calculate weeks (i.e. use lubridate::week rather than dividing by 7)
expect_true(round(test[[1]]$Dataset$deltaAICc[1], 1) == 0.2)
expect_true(test[[1]]$Dataset$WindowOpen[1] == 1 & test[[1]]$Dataset$WindowClose[1] == 1)
expect_true(round(test[[1]]$Dataset$ModelBeta[1], 1) == -0.6)
})
# Test when cmissing is method2 and NA is present (cinterval = "week") #
test_that("No error returned when cmissing method2 with NAs, cinterval = week", {
data(Mass, envir = environment())
data(MassClimate, envir = environment())
MassClimate2 <- MassClimate[-c(491:505), ]
# Test that an error is returned
test <- slidingwin(xvar = list(MassClimate2$Temp), cdate = MassClimate2$Date, bdate = Mass$Date,
baseline = lm(Mass ~ 1, data = Mass), range = c(2, 0),
type = "relative", stat = "max", func = "lin", cinterval = "week",
cmissing = "method2")
# Test that slidingwin ran without an error
expect_true(is.list(test))
#Test the values we get stay the same as github version (7-9-17).
#N.B. We don't use the old R version because we have changed how we calculate weeks (i.e. use lubridate::week rather than dividing by 7)
expect_true(round(test[[1]]$Dataset$deltaAICc[1], 1) == 0.2)
expect_true(test[[1]]$Dataset$WindowOpen[1] == 1 & test[[1]]$Dataset$WindowClose[1] == 1)
expect_true(round(test[[1]]$Dataset$ModelBeta[1], 1) == -0.6)
})
# Test when cmissing is method1 and NA is present (cinterval = "month") #
test_that("No error returned when cmissing method1 with NAs, cinterval = month", {
data(Mass, envir = environment())
data(MassClimate, envir = environment())
MassClimate2 <- MassClimate[-c(1900:2000), ]
# Test that an error is returned #
test <- slidingwin(xvar = list(MassClimate2$Temp), cdate = MassClimate2$Date, bdate = Mass$Date,
baseline = lm(Mass ~ 1, data = Mass), range = c(1, 0),
type = "relative", stat = "max", func = "lin", cinterval = "month",
cmissing = "method1")
# Test that slidingwin ran without an error
expect_true(is.list(test))
#Test the values we get stay the same as github version (7-9-17).
#N.B. We don't use the old R version because we have changed how we calculate months slightly
expect_true(round(test[[1]]$Dataset$deltaAICc[1], 1) == -3.9)
expect_true(test[[1]]$Dataset$WindowOpen[1] == 1 & test[[1]]$Dataset$WindowClose[1] == 1)
expect_true(round(test[[1]]$Dataset$ModelBeta[1], 1) == -1.8)
})
# Test when cmissing is method2 and NA is present (cinterval = "month") #
test_that("No error returned when cmissing method2 with NAs, cinterval = month", {
data(Mass, envir = environment())
data(MassClimate, envir = environment())
MassClimate2 <- MassClimate[-c(1000:2000), ]
# Test that an error is returned #
test <- slidingwin(xvar = list(MassClimate2$Temp), cdate = MassClimate2$Date, bdate = Mass$Date,
baseline = lm(Mass ~ 1, data = Mass), range = c(1, 0),
type = "relative", stat = "max", func = "lin", cinterval = "month",
cmissing = "method2")
# Test that slidingwin ran without an error
expect_true(is.list(test))
#Test the values we get stay the same as github version (7-9-17).
#N.B. We don't use the old R version because we have changed how we calculate months slightly
expect_true(round(test[[1]]$Dataset$deltaAICc[1], 1) == -1.9)
expect_true(test[[1]]$Dataset$WindowOpen[1] == 1 & test[[1]]$Dataset$WindowClose[1] == 1)
expect_true(round(test[[1]]$Dataset$ModelBeta[1], 1) == -1.6)
})
##########################################################
# Test different types of models #
# Test glm models #
test_that("glm models can run in slidingwin", {
data(Mass, envir = environment())
data(MassClimate, envir = environment())
test <- slidingwin(xvar = list(MassClimate$Temp), cdate = MassClimate$Date, bdate = Mass$Date,
baseline = glm(Mass ~ 1, data = Mass, family = poisson), range = c(2, 0),
type = "relative", stat = "max", func = "lin", cmissing = FALSE)
# Test that slidingwin produced an output
expect_true(is.list(test))
# Test that best model was created
expect_false(is.na((test[[1]]$BestModel)[1]))
# Test that there are no NA values in best model data
expect_equal(length(which(is.na(test[[1]]$BestModelData))), 0)
# Test that there are atleast 2 variables in the best model data
expect_true(ncol(test[[1]]$BestModelData) >= 2)
#Test the values we get out have stayed the same as our last R version
expect_true(round(test[[1]]$Dataset$deltaAICc[1], 1) == 1.3)
expect_true(test[[1]]$Dataset$WindowOpen[1] == 2 & test[[1]]$Dataset$WindowClose[1] == 2)
expect_true(round(test[[1]]$Dataset$ModelBeta[1], 1) == -0.0)
})
# Test mixed effects models (lme4) #
test_that("lmer [lme4] models can run in slidingwin", {
data(Offspring, envir = environment())
data(OffspringClimate, envir = environment())
test <- slidingwin(xvar = list(OffspringClimate$Temp), cdate = OffspringClimate$Date,
bdate = Offspring$Date,
baseline = lmer(Offspring ~ 1 + (1|BirdID), data = Offspring, REML = F),
range = c(2, 0), type = "relative",
stat = "max", func = "lin", cmissing=FALSE)
# Test that slidingwin produced an output
expect_true(is.list(test))
# Test that lmer model produced an intercept
expect_false(is.na(fixef(test[[1]]$BestModel)[1]))
# Test that lmer model produced a climate beta estimate
expect_false(is.na(fixef(test[[1]]$BestModel)[2]))
# Test that best model data doesn't contain NAs
expect_equal(length(which(is.na(test[[1]]$BestModelData))), 0)
# Test that best model data has at least 2 parameters
expect_true(ncol(test[[1]]$BestModelData) >= 2)
#Test the values we get out have stayed the same as our last R version
expect_true(round(test[[1]]$Dataset$deltaAICc[1], 1) == -55.3)
expect_true(test[[1]]$Dataset$WindowOpen[1] == 2 & test[[1]]$Dataset$WindowClose[1] == 2)
expect_true(round(test[[1]]$Dataset$ModelBeta[1], 1) == 0.0)
})
# Test mixed effects models (lme4) #
test_that("lmer [lme4] models can run in slidingwin with cross-validation", {
set.seed(666)
data(Offspring, envir = environment())
data(OffspringClimate, envir = environment())
test <- slidingwin(xvar = list(OffspringClimate$Temp), cdate = OffspringClimate$Date,
bdate = Offspring$Date,
baseline = lmer(Offspring ~ 1 + (1|BirdID), data = Offspring, REML = F),
range = c(2, 1), type = "relative",
stat = "max", func = "lin", cmissing=FALSE, k = 2)
# Test that slidingwin produced an output
expect_true(is.list(test))
# Test that lmer model produced an intercept
expect_false(is.na(fixef(test[[1]]$BestModel)[1]))
# Test that lmer model produced a climate beta estimate
expect_false(is.na(fixef(test[[1]]$BestModel)[2]))
# Test that best model data doesn't contain NAs
expect_equal(length(which(is.na(test[[1]]$BestModelData))), 0)
# Test that best model data has at least 2 parameters
expect_true(ncol(test[[1]]$BestModelData) >= 2)
#Test the values we get out have stayed the same as our last R version
expect_true(round(test[[1]]$Dataset$deltaAICc[1], 1) == -26.3)
expect_true(test[[1]]$Dataset$WindowOpen[1] == 2 & test[[1]]$Dataset$WindowClose[1] == 2)
expect_true(round(test[[1]]$Dataset$ModelBeta[1], 1) == 0.0)
})
# Test glmer models (lme4) #
test_that("glmer [lme4] models can run in slidingwin", {
data(Offspring, envir = environment())
data(OffspringClimate, envir = environment())
# Warnings created due to convergence issues with such a small data set
suppressWarnings(test <- slidingwin(xvar = list(OffspringClimate$Temp), cdate = OffspringClimate$Date,
bdate = Offspring$Date,
baseline = glmer(Offspring ~ 1 + (1|Order), data = Offspring, family = "poisson"),
range = c(1, 0), type = "relative",
stat = "max", func = "lin", cmissing=FALSE))
# Test that slidingwin has produced an output
expect_true(is.list(test))
# Test that glmer model produced an intercept
expect_false(is.na(fixef(test[[1]]$BestModel)[1]))
# Test that glmer model produced a beta estimate for climate
expect_false(is.na(fixef(test[[1]]$BestModel)[2]))
# Test there are no NA values in best model data
expect_equal(length(which(is.na(test[[1]]$BestModelData))), 0)
# Test that best model data has atleast two parameters
expect_true(ncol(test[[1]]$BestModelData) >= 2)
#Test the values we get out have stayed the same as our last R version
expect_true(round(test[[1]]$Dataset$deltaAICc[1], 1) == -14.0)
expect_true(test[[1]]$Dataset$WindowOpen[1] == 1 & test[[1]]$Dataset$WindowClose[1] == 1)
expect_true(round(test[[1]]$Dataset$ModelBeta[1], 1) == 0.0)
})
# Test glmer models (lme4) #
test_that("glmer [lme4] models can run in slidingwin with cross-validation", {
set.seed(666)
data(Offspring, envir = environment())
data(OffspringClimate, envir = environment())
# Warnings created due to convergence issues with such a small data set
suppressWarnings(test <- slidingwin(xvar = list(OffspringClimate$Temp), cdate = OffspringClimate$Date,
bdate = Offspring$Date,
baseline = glmer(Offspring ~ 1 + (1|Order), data = Offspring, family = "poisson"),
range = c(1, 0), type = "relative",
stat = "max", func = "lin", cmissing=FALSE, k = 2))
# Test that slidingwin has produced an output
expect_true(is.list(test))
# Test that glmer model produced an intercept
expect_false(is.na(fixef(test[[1]]$BestModel)[1]))
# Test that glmer model produced a beta estimate for climate
expect_false(is.na(fixef(test[[1]]$BestModel)[2]))
# Test there are no NA values in best model data
expect_equal(length(which(is.na(test[[1]]$BestModelData))), 0)
# Test that best model data has atleast two parameters
expect_true(ncol(test[[1]]$BestModelData) >= 2)
#Test the values we get out have stayed the same as our last R version
expect_true(round(test[[1]]$Dataset$deltaAICc[1], 1) == -6.5)
expect_true(test[[1]]$Dataset$WindowOpen[1] == 1 & test[[1]]$Dataset$WindowClose[1] == 1)
expect_true(round(test[[1]]$Dataset$ModelBeta[1], 1) == 0.0)
})
# Test mixed effects models (nlme) #
test_that("basic lme [nlme] models can run in slidingwin", {
data(Offspring, envir = environment())
data(OffspringClimate, envir = environment())
test <- slidingwin(xvar = list(OffspringClimate$Temp), cdate = OffspringClimate$Date,
bdate = Offspring$Date,
baseline = lme(Offspring ~ 1, random = ~ 1 | BirdID, data = Offspring, method = "ML"),
range = c(2, 0), type = "relative",
stat = "max", func = "lin", cmissing = FALSE)
# Test that slidingwin produced an output
expect_true(is.list(test))
# Test that lmer model produced an intercept
expect_false(is.na(fixef(test[[1]]$BestModel)[1]))
# Test that lmer model produced a climate beta estimate
expect_false(is.na(fixef(test[[1]]$BestModel)[2]))
# Test that best model data doesn't contain NAs
expect_equal(length(which(is.na(test[[1]]$BestModelData))), 0)
# Test that best model data has at least 2 parameters
expect_true(ncol(test[[1]]$BestModelData) >= 2)
#Test the values we get out have stayed the same as github version (7-9-17).
#N.B. Earlier R version didn't have nlme compatability
expect_true(round(test[[1]]$Dataset$deltaAICc[1], 1) == -55.3)
expect_true(test[[1]]$Dataset$WindowOpen[1] == 2 & test[[1]]$Dataset$WindowClose[1] == 2)
expect_true(round(test[[1]]$Dataset$ModelBeta[1], 1) == 0.0)
})
# Test mixed effects models (nlme) #
test_that("lme [nlme] model with VarIdent can run in slidingwin", {
data(Offspring, envir = environment())
data(OffspringClimate, envir = environment())
assign("vI", varIdent(value = 10, form =~ Order), envir=globalenv())
test <- slidingwin(xvar = list(OffspringClimate$Temp), cdate = OffspringClimate$Date,
bdate = Offspring$Date,
baseline = lme(Offspring ~ Order, random = ~ 1 | BirdID, data = Offspring, weights = vI, method = "ML"),
range = c(2, 0), type = "relative",
stat = "max", func = "lin", cmissing = FALSE)
# Test that slidingwin produced an output
expect_true(is.list(test))
# Test that lmer model produced an intercept
expect_false(is.na(fixef(test[[1]]$BestModel)[1]))
# Test that lmer model produced a climate beta estimate
expect_false(is.na(fixef(test[[1]]$BestModel)[2]))
# Test that best model data doesn't contain NAs
expect_equal(length(which(is.na(test[[1]]$BestModelData))), 0)
# Test that best model data has at least 2 parameters
expect_true(ncol(test[[1]]$BestModelData) >= 2)
#Test the values we get out have stayed the same as github version (7-9-17).
#N.B. Earlier R version didn't have nlme compatability
expect_true(round(test[[1]]$Dataset$deltaAICc[1], 1) == -22.7)
expect_true(test[[1]]$Dataset$WindowOpen[1] == 2 & test[[1]]$Dataset$WindowClose[1] == 2)
expect_true(round(test[[1]]$Dataset$ModelBeta[1], 1) == 0.0)
rm("vI", envir = .GlobalEnv)
})
# Test mixed effects models (nlme) #
test_that("lme [nlme] model with VarExp can run in slidingwin", {
data(Offspring, envir = environment())
data(OffspringClimate, envir = environment())
assign("vE", varExp(form =~ Order), envir=globalenv())
test <- slidingwin(xvar = list(OffspringClimate$Temp), cdate = OffspringClimate$Date,
bdate = Offspring$Date,
baseline = lme(Offspring ~ Order, random = ~ 1 | BirdID, data = Offspring, weights = vE, method = "ML"),
range = c(2, 0), type = "relative",
stat = "max", func = "lin", cmissing = FALSE)
# Test that slidingwin produced an output
expect_true(is.list(test))
# Test that lmer model produced an intercept
expect_false(is.na(fixef(test[[1]]$BestModel)[1]))
# Test that lmer model produced a climate beta estimate
expect_false(is.na(fixef(test[[1]]$BestModel)[2]))
# Test that best model data doesn't contain NAs
expect_equal(length(which(is.na(test[[1]]$BestModelData))), 0)
# Test that best model data has at least 2 parameters
expect_true(ncol(test[[1]]$BestModelData) >= 2)
#Test the values we get out have stayed the same as github version (7-9-17).
#N.B. Earlier R version didn't have nlme compatability
expect_true(round(test[[1]]$Dataset$deltaAICc[1], 1) == -23.5)
expect_true(test[[1]]$Dataset$WindowOpen[1] == 2 & test[[1]]$Dataset$WindowClose[1] == 2)
expect_true(round(test[[1]]$Dataset$ModelBeta[1], 1) == 0.0)
rm("vE", envir = .GlobalEnv)
})
### TEST COXPH MODELS!!!!!!!!! STILL NEEDS TO BE DONE! ###
##########################################################
# Test absolute windows #
# Test absolute window #
test_that("absolute window works", {
data(Mass, envir = environment())
data(MassClimate, envir = environment())
test <- slidingwin(xvar = list(MassClimate$Temp), cdate = MassClimate$Date, bdate = Mass$Date,
baseline = lm(Mass ~ 1, data = Mass), range = c(2, 0),
type = "absolute", refday = c(20, 5),
stat = "max", func = "lin", cmissing=FALSE)
# Test that slidingwin has produced an output
expect_true(is.list(test))
# Test that a best model has been fitted
expect_false(is.na((test[[1]]$BestModel)[1]))
# Test there are no NAs in the best model data
expect_equal(length(which(is.na(test[[1]]$BestModelData))), 0)
# Test that the best model data has at least 2 parameters
expect_true(ncol(test[[1]]$BestModelData) >= 2)
#Test the values we get out have stayed the same as our last R version
expect_true(round(test[[1]]$Dataset$deltaAICc[1], 1) == -4.2)
expect_true(test[[1]]$Dataset$WindowOpen[1] == 2 & test[[1]]$Dataset$WindowClose[1] == 1)
expect_true(round(test[[1]]$Dataset$ModelBeta[1], 1) == -0.8)
})
##########################################################
# Test slope stat #
test_that("slope stat work", {
data(Mass, envir = environment())
data(MassClimate, envir = environment())
test <- slidingwin(xvar = list(MassClimate$Temp), cdate = MassClimate$Date, bdate = Mass$Date,
baseline = lm(Mass ~ 1, data = Mass), range = c(2, 0),
type = "relative", stat = "slope", func = "lin", cmissing=FALSE)
# Test that slidingwin produces an output
expect_true(is.list(test))
# Test that a best model is created
expect_false(is.na((test[[1]]$BestModel)[1]))
# Test there are no NAs in best model data
expect_equal(length(which(is.na(test[[1]]$BestModelData))), 0)
# Test that best model data has at least 2 parameters
expect_true(ncol(test[[1]]$BestModelData) >= 2)
#Test the values we get out have stayed the same as github (7-9-17)
#N.B. Don't use original R version because we have reversed the sign of slopes
expect_true(round(test[[1]]$Dataset$deltaAICc[1], 1) == -4.0)
expect_true(test[[1]]$Dataset$WindowOpen[1] == 2 & test[[1]]$Dataset$WindowClose[1] == 0)
expect_true(round(test[[1]]$Dataset$ModelBeta[1], 1) == -1.4)
})
# Test that slope and log stat cannot be used together #
test_that("slope and log return error", {
data(Mass, envir = environment())
data(MassClimate, envir = environment())
# Test that an error is produced
expect_error(slidingwin(xvar = list(MassClimate$Temp), cdate = MassClimate$Date,
bdate = Mass$Date, baseline = lm(Mass ~ 1, data = Mass),
range = c(2, 1), type = "relative", stat = "slope",
func = "log"))
})
# Test that slope and inverse cannot be used together #
test_that("slope and inv return error", {
data(Mass, envir = environment())
data(MassClimate, envir = environment())
# Test that an error is produced
expect_error(slidingwin(xvar = list(MassClimate$Temp), cdate = MassClimate$Date,
bdate = Mass$Date, baseline = lm(Mass ~ 1, data = Mass),
range = c(2, 1), type = "relative", stat = "slope",
func = "inv"))
})
##########################################################
# Test different functions for fitting climate #
# Test quadratic function #
test_that("Quadratic function works", {
data(Mass, envir = environment())
data(MassClimate, envir = environment())
test <- slidingwin(xvar = list(MassClimate$Temp), cdate = MassClimate$Date, bdate = Mass$Date,
baseline = lm(Mass ~ 1, data = Mass), range = c(2, 0),
type = "relative", stat = "max", func = "quad", cmissing=FALSE)
furthest = 2
closest = 0
duration <- (furthest - closest) + 1
maxmodno <- (duration * (duration + 1))/2
# Test that slidingwin produced an output
expect_true(is.list(test))
# Test that a best model was fitted
expect_false(is.na((test[[1]]$BestModel)[1]))
# Test that there are no NAs in the best model data
expect_equal(length(which(is.na(test[[1]]$BestModelData))), 0)
# Test that best model data has at least THREE parameters (i.e. linear and quadratic term)
expect_true(ncol(test[[1]]$BestModelData) >= 3)
# Test there are no NAs in the dataset
expect_equal(length(which(is.na(test[[1]]$Dataset[, 5]))), 0)
# Test that the quad function has been used
expect_true(test[[1]]$Dataset[1, 10] == "quad")
# Test that the dataset is atleast 17 columns (one extra column for quad SE)
expect_true(ncol(test[[1]]$Dataset) == 18)
# Test that the right number of models was fitted
expect_equal(maxmodno, nrow(test[[1]]$Dataset))
# Test that data is not randomised
expect_true((test[[1]]$Dataset["Randomised"])[1, ] == "no")
#Test the values we get out have stayed the same as our last R version
expect_true(round(test[[1]]$Dataset$deltaAICc[1], 1) == -1.0)
expect_true(test[[1]]$Dataset$WindowOpen[1] == 2 & test[[1]]$Dataset$WindowClose[1] == 2)
expect_true(round(test[[1]]$Dataset$ModelBeta[1], 1) == -2.8)
})
# Test cubic function #
test_that("Cubic function works", {
data(Mass, envir = environment())
data(MassClimate, envir = environment())
test <- slidingwin(xvar = list(MassClimate$Temp), cdate = MassClimate$Date, bdate = Mass$Date,
baseline = lm(Mass ~ 1, data = Mass), range = c(2, 0),
type = "relative", stat = "max", func = "cub", cmissing=FALSE)
furthest = 2
closest = 0
duration <- (furthest - closest) + 1
maxmodno <- (duration * (duration + 1))/2
# Test that slidingwin produced an output
expect_true(is.list(test))
# Test that a best model was fitted
expect_false(is.na((test[[1]]$BestModel)[1]))
# Test that there are no NAs in the best model data
expect_equal(length(which(is.na(test[[1]]$BestModelData))), 0)
# Test that best model data has at least FOUR parameters (i.e. linear, quadratic and cubic term)
expect_true(ncol(test[[1]]$BestModelData) >= 4)
# Test there are no NAs in the dataset
expect_equal(length(which(is.na(test[[1]]$Dataset[, 6]))), 0)
# Test that the cub function has been used
expect_true(test[[1]]$Dataset[1, 11] == "cub")
# Test that the dataset is atleast 18 columns (extra columns for quad and cub SE)
expect_true(ncol(test[[1]]$Dataset) == 19)
# Test that the right number of models was fitted
expect_equal(maxmodno, nrow(test[[1]]$Dataset))
# Test that data is not randomised
expect_true((test[[1]]$Dataset["Randomised"])[1, ] == "no")
#Test the values we get out have stayed the same as our last R version
expect_true(round(test[[1]]$Dataset$deltaAICc[1], 1) == 1.3)
expect_true(test[[1]]$Dataset$WindowOpen[1] == 2 & test[[1]]$Dataset$WindowClose[1] == 2)
expect_true(round(test[[1]]$Dataset$ModelBeta[1], 1) == 1.7)
})
# Test log function #
test_that("Log function works", {
data(Mass, envir = environment())
data(MassClimate, envir = environment())
test <- slidingwin(xvar = list(MassClimate$Temp), cdate = MassClimate$Date, bdate = Mass$Date,
baseline = lm(Mass ~ 1, data = Mass), range = c(2, 0),
type = "relative", stat = "max", func = "log", cmissing=FALSE)
furthest = 2
closest = 0
duration <- (furthest - closest) + 1
maxmodno <- (duration * (duration + 1))/2
# Test that slidingwin produced an output
expect_true(is.list(test))
# Test that a best model was fitted
expect_false(is.na((test[[1]]$BestModel)[1]))
# Test that there are no NAs in the best model data
expect_equal(length(which(is.na(test[[1]]$BestModelData))), 0)
# Test that best model data has at least two parameters
expect_true(ncol(test[[1]]$BestModelData) >= 2)
# Test there are no NAs in the dataset
expect_equal(length(which(is.na(test[[1]]$Dataset[, 4]))), 0)
# Test that log function has been used
expect_true(test[[1]]$Dataset[1, 9] == "log")
# Test that the dataset is atleast 16 columns (no extra columns)
expect_true(ncol(test[[1]]$Dataset) == 17)
# Test that the right number of models was fitted
expect_equal(maxmodno, nrow(test[[1]]$Dataset))
# Test that data is not randomised
expect_true((test[[1]]$Dataset["Randomised"])[1, ] == "no")
#Test the values we get out have stayed the same as our last R version
expect_true(round(test[[1]]$Dataset$deltaAICc[1], 1) == -3.1)
expect_true(test[[1]]$Dataset$WindowOpen[1] == 2 & test[[1]]$Dataset$WindowClose[1] == 2)
expect_true(round(test[[1]]$Dataset$ModelBeta[1], 1) == -8.3)
})
# Test inverse function #
test_that("Inverse function works", {
data(Mass, envir = environment())
data(MassClimate, envir = environment())
test <- slidingwin(xvar = list(MassClimate$Temp), cdate = MassClimate$Date, bdate = Mass$Date,
baseline = lm(Mass ~ 1, data = Mass), range = c(2, 0),
type = "relative", stat = "max", func = "inv", cmissing=FALSE)
furthest = 2
closest = 0
duration <- (furthest - closest) + 1
maxmodno <- (duration * (duration + 1))/2
# Test that slidingwin produced an output
expect_true(is.list(test))
# Test that a best model was fitted
expect_false(is.na((test[[1]]$BestModel)[1]))
# Test that there are no NAs in the best model data
expect_equal(length(which(is.na(test[[1]]$BestModelData))), 0)
# Test that best model data has at least two parameters
expect_true(ncol(test[[1]]$BestModelData) >= 2)
# Test there are no NAs in the dataset
expect_equal(length(which(is.na(test[[1]]$Dataset[, 4]))), 0)
# Test that the inv function has been used
expect_true(test[[1]]$Dataset[1, 9] == "inv")
# Test that the dataset is atleast 16 columns (no extra columns)
expect_true(ncol(test[[1]]$Dataset) == 17)
# Test that the right number of models was fitted
expect_equal(maxmodno, nrow(test[[1]]$Dataset))
# Test that data is not randomised
expect_true((test[[1]]$Dataset["Randomised"])[1, ] == "no")
#Test the values we get out have stayed the same as our last R version
expect_true(round(test[[1]]$Dataset$deltaAICc[1], 1) == -3.1)
expect_true(test[[1]]$Dataset$WindowOpen[1] == 2 & test[[1]]$Dataset$WindowClose[1] == 2)
expect_true(round(test[[1]]$Dataset$ModelBeta[1], 1) == 88.7)
})
##########################################################
# Test different cinterval values #
# Test cinterval = week #
test_that("Weekly interval works", {
data(Mass, envir = environment())
data(MassClimate, envir = environment())
test <- slidingwin(xvar = list(MassClimate$Temp), cdate = MassClimate$Date, bdate = Mass$Date,
baseline = lm(Mass ~ 1, data = Mass), range = c(2, 0),
type = "relative", stat = "max", func = "lin",
cmissing=FALSE, cinterval = "week")
# Test that slidingwin produced an output
expect_true(is.list(test))
# Test that a best model was fitted
expect_false(is.na((test[[1]]$BestModel)[1]))
# Test that there are no NAs in the best model data
expect_equal(length(which(is.na(test[[1]]$BestModelData))), 0)
# Test that best model data has at least two parameters
expect_true(ncol(test[[1]]$BestModelData) >= 2)
#Test the values we get stay the same as github version (7-9-17).
#N.B. We don't use the old R version because we have changed how we calculate weeks (i.e. use lubridate::week rather than dividing by 7)
expect_true(round(test[[1]]$Dataset$deltaAICc[1], 1) == 0.1)
expect_true(test[[1]]$Dataset$WindowOpen[1] == 1 & test[[1]]$Dataset$WindowClose[1] == 1)
expect_true(round(test[[1]]$Dataset$ModelBeta[1], 1) == -0.7)
})
# Test cinterval = month #
test_that("Monthly interval works", {
data(Mass, envir = environment())
data(MassClimate, envir = environment())
test <- slidingwin(xvar = list(MassClimate$Temp), cdate = MassClimate$Date, bdate = Mass$Date,
baseline = lm(Mass ~ 1, data = Mass), range = c(2, 0),
type = "relative", stat = "max", func = "lin",
cmissing=FALSE, cinterval = "month")
# Test that slidingwin produced an output
expect_true(is.list(test))
# Test that a best model was fitted
expect_false(is.na((test[[1]]$BestModel)[1]))
# Test that there are no NAs in the best model data
expect_equal(length(which(is.na(test[[1]]$BestModelData))), 0)
# Test that best model data has at least two parameters
expect_true(ncol(test[[1]]$BestModelData) >= 2)
#Test the values we get stay the same as github version (7-9-17).
#N.B. We don't use the old R version because we have changed how we calculate month
expect_true(round(test[[1]]$Dataset$deltaAICc[1], 1) == -8.3)
expect_true(test[[1]]$Dataset$WindowOpen[1] == 2 & test[[1]]$Dataset$WindowClose[1] == 2)
expect_true(round(test[[1]]$Dataset$ModelBeta[1], 1) == -1.8)
})
################################################################
# Error when you have NAs in the biological data #
test_that("slidingwin gives error when NAs are present in biological data", {
data(MassClimate, envir = environment())
Mass <- data.frame(Date = c("01/01/2014", "01/02/2014"), Mass = c(NA, 1))
# Test that an error occurs #
expect_error(slidingwin(xvar = list(MassClimate$Temp), cdate = MassClimate$Date, bdate = Mass$Date,
baseline = lm(Mass ~ 1, data = Mass), range = c(2, 2),
type = "relative", stat = "max", func = "lin",
cmissing = FALSE, cinterval = "day"))
})
################################################################
# Test that cross validation works #
test_that("Does cross validation work?", {
data(Mass, envir = environment())
data(MassClimate, envir = environment())
test <- slidingwin(xvar = list(MassClimate$Temp), cdate = MassClimate$Date, bdate = Mass$Date,
baseline = lm(Mass ~ 1, data = Mass), range = c(2, 0),
type = "relative", stat = "max", func = "lin",
cmissing = FALSE, cinterval = "day", k = 2)
# Test that slidingwin produced an output
expect_true(is.list(test))
# Test that a best model was fitted
expect_false(is.na((test[[1]]$BestModel)[1]))
# Test that there are no NAs in the best model data
expect_equal(length(which(is.na(test[[1]]$BestModelData))), 0)
# Test that best model data has at least two parameters
expect_true(ncol(test[[1]]$BestModelData) >= 2)
# Test that values of k are documented in the dataset
expect_equal(test[[1]]$Dataset$K[1], 2)
})
################################################################
# Test mean centring #
# Test centring with both wgmean and wgdev used #
test_that("Mean centring is functioning", {
data(Offspring, envir = environment())
data(OffspringClimate, envir = environment())
Offspring$Year <- lubridate::year(as.Date(Offspring$Date, format = "%d/%m/%Y"))
test <- slidingwin(xvar = list(OffspringClimate$Temp), cdate = OffspringClimate$Date,
bdate = Offspring$Date, baseline = lm(Offspring ~ 1, data = Offspring), range = c(2, 0),
type = "relative", stat = "max", func = "lin",
cmissing = FALSE, cinterval = "day", centre = list(Offspring$Year, "both"))
# Test that slidingwin produced an output
expect_true(is.list(test))
# Test that a best model was fitted
expect_false(is.na((test[[1]]$BestModel)[1]))
# Test that there are no NAs in the best model data
expect_equal(length(which(is.na(test[[1]]$BestModelData))), 0)
# Test that best model data has at least THREE parameters (i.e. wgdev, wgmean and climate)
expect_true(ncol(test[[1]]$BestModelData) >= 3)
# Test that there are no NAs in wgmean
expect_equal(length(which(is.na(test[[1]]$Dataset[, 4]))), 0)
# Test that there are no NAs in wgdev
expect_equal(length(which(is.na(test[[1]]$Dataset[, 6]))), 0)
# Test that there are 16 columns in the dataset
expect_true(ncol(test[[1]]$Dataset) == 17)
# Test that dataset is not randomised
expect_true((test[[1]]$Dataset["Randomised"])[1, ] == "no")
#Test the values we get out have stayed the same as our last R version
expect_true(round(test[[1]]$Dataset$deltaAICc[1], 1) == -39.0)
expect_true(test[[1]]$Dataset$WindowOpen[1] == 2 & test[[1]]$Dataset$WindowClose[1] == 2)
expect_true(round(test[[1]]$Dataset$WithinGrpMean[1], 1) == 0.0)
expect_true(round(test[[1]]$Dataset$WithinGrpDev[1], 1) == 0.0)
})
# Test centring with only wgmean #
test_that("Mean centring is functioning with only wgmeans", {
data(Offspring, envir = environment())
data(OffspringClimate, envir = environment())
Offspring$Year <- lubridate::year(as.Date(Offspring$Date, format = "%d/%m/%Y"))
test <- slidingwin(xvar = list(OffspringClimate$Temp), cdate = OffspringClimate$Date,
bdate = Offspring$Date, baseline = lm(Offspring ~ 1, data = Offspring), range = c(2, 0),
type = "relative", stat = "max", func = "lin",
cmissing = FALSE, cinterval = "day", centre = list(Offspring$Year, "mean"))
# Test that slidingwin produced an output
expect_true(is.list(test))
# Test that a best model was fitted
expect_false(is.na((test[[1]]$BestModel)[1]))
# Test that there are no NAs in the best model data
expect_equal(length(which(is.na(test[[1]]$BestModelData))), 0)
# Test that best model data has at least two parameters (i.e. wgmean and climate)
expect_true(ncol(test[[1]]$BestModelData) >= 2)
# Test that there are no NAs in wgmean
expect_equal(length(which(is.na(test[[1]]$Dataset[, 4]))), 0)
# Test that there are no NAs in wgdev
expect_equal(length(which(is.na(test[[1]]$Dataset[, 6]))), 0)
# Test that there are 14 columns in the dataset (remove wgdev and SE)
expect_true(ncol(test[[1]]$Dataset) == 15)
# Test that dataset is not randomised
expect_true((test[[1]]$Dataset["Randomised"])[1, ] == "no")
#Test the values we get out have stayed the same as our last R version
expect_true(round(test[[1]]$Dataset$deltaAICc[1], 1) == -2.8)
expect_true(test[[1]]$Dataset$WindowOpen[1] == 2 & test[[1]]$Dataset$WindowClose[1] == 2)
expect_true(round(test[[1]]$Dataset$WithinGrpMean[1], 1) == 0.0)
})
# Test centring with only wgdev #
test_that("Mean centring is functioning with only wgdev", {
data(Offspring, envir = environment())
data(OffspringClimate, envir = environment())
Offspring$Year <- lubridate::year(as.Date(Offspring$Date, format = "%d/%m/%Y"))
test <- slidingwin(xvar = list(OffspringClimate$Temp), cdate = OffspringClimate$Date,
bdate = Offspring$Date, baseline = lm(Offspring ~ 1, data = Offspring), range = c(2, 0),
type = "relative", stat = "max", func = "lin",
cmissing = FALSE, cinterval = "day", centre = list(Offspring$Year, "dev"))
# Test that slidingwin produced an output
expect_true(is.list(test))
# Test that a best model was fitted
expect_false(is.na((test[[1]]$BestModel)[1]))
# Test that there are no NAs in the best model data
expect_equal(length(which(is.na(test[[1]]$BestModelData))), 0)
# Test that best model data has at least two parameters (i.e. wgdev and climate)
expect_true(ncol(test[[1]]$BestModelData) >= 2)
# Test that there are no NAs in wgmean
expect_equal(length(which(is.na(test[[1]]$Dataset[, 4]))), 0)
# Test that there are no NAs in wgdev
expect_equal(length(which(is.na(test[[1]]$Dataset[, 6]))), 0)
# Test that there are 14 columns in the dataset (remove wgmean and SE)
expect_true(ncol(test[[1]]$Dataset) == 15)
# Test that dataset is not randomised
expect_true((test[[1]]$Dataset["Randomised"])[1, ] == "no")
#Test the values we get out have stayed the same as our last R version
expect_true(round(test[[1]]$Dataset$deltaAICc[1], 1) == -36.1)
expect_true(test[[1]]$Dataset$WindowOpen[1] == 2 & test[[1]]$Dataset$WindowClose[1] == 2)
expect_true(round(test[[1]]$Dataset$WithinGrpDev[1], 1) == 1.3)
})
################################################################
# Test cohort parameter #
test_that("absolute window works with a cohort parameter", {
data(Mass, envir = environment())
Mass$Plot <- c(rep(c("A", "B"), 23), "A")
data(MassClimate, envir = environment())
test <- slidingwin(xvar = list(MassClimate$Temp), cdate = MassClimate$Date, bdate = Mass$Date,
baseline = lm(Mass ~ 1, data = Mass), range = c(2, 0),
type = "absolute", refday = c(20, 5),
stat = "max", func = "lin", cmissing = FALSE,
cohort = Mass$Plot)
# Test that slidingwin has produced an output
expect_true(is.list(test))
# Test that a best model has been fitted
expect_false(is.na((test[[1]]$BestModel)[1]))
# Test there are no NAs in the best model data
expect_equal(length(which(is.na(test[[1]]$BestModelData))), 0)
# Test that the best model data has at least 2 parameters
expect_true(ncol(test[[1]]$BestModelData) >= 2)
#Test the values we get out have stayed the same as our last R version
expect_true(round(test[[1]]$Dataset$deltaAICc[1], 1) == 2.3)
#expect_true(test[[1]]$Dataset$WindowOpen[1] == 1 & test[[1]]$Dataset$WindowClose[1] == 1)
#expect_true(round(test[[1]]$Dataset$ModelBeta[1], 1) == 1.6)
})
###############################################################
# Test spatial replication
test_that("spatial replication works in slidingwin", {
data(Mass, envir = environment())
Mass$Plot <- c(rep(c("A", "B"), 23), "A")
data(MassClimate, envir = environment())
MassClimate$Plot <- "A"
MassClimate2 <- MassClimate
MassClimate2$Plot <- "B"
Clim <- rbind(MassClimate, MassClimate2)
test <- slidingwin(xvar = list(Clim$Temp), cdate = Clim$Date, bdate = Mass$Date,
baseline = lm(Mass ~ 1, data = Mass), range = c(2, 0),
type = "absolute", refday = c(20, 5),
stat = "max", func = "lin", cmissing = FALSE,
spatial = list(Mass$Plot, Clim$Plot))
# Test that slidingwin has produced an output
expect_true(is.list(test))
# Test that a best model has been fitted
expect_false(is.na((test[[1]]$BestModel)[1]))
# Test there are no NAs in the best model data
expect_equal(length(which(is.na(test[[1]]$BestModelData))), 0)
# Test that the best model data has at least 2 parameters
expect_true(ncol(test[[1]]$BestModelData) >= 2)
#Test the values we get out have stayed the same as our last R version
expect_true(round(test[[1]]$Dataset$deltaAICc[1], 1) == -4.2)
expect_true(test[[1]]$Dataset$WindowOpen[1] == 2 & test[[1]]$Dataset$WindowClose[1] == 1)
expect_true(round(test[[1]]$Dataset$ModelBeta[1], 1) == -0.8)
})
test_that("spatial replication works in slidingwin with week", {
data(Mass, envir = environment())
Mass$Plot <- c(rep(c("A", "B"), 23), "A")
data(MassClimate, envir = environment())
MassClimate$Plot <- "A"
MassClimate2 <- MassClimate
MassClimate2$Plot <- "B"
Clim <- rbind(MassClimate, MassClimate2)
test <- slidingwin(xvar = list(Clim$Temp), cdate = Clim$Date, bdate = Mass$Date,
baseline = lm(Mass ~ 1, data = Mass), range = c(2, 0),
type = "absolute", refday = c(20, 5),
cinterval = "week",
stat = "max", func = "lin", cmissing=FALSE,
spatial = list(Mass$Plot, Clim$Plot))
# Test that slidingwin has produced an output
expect_true(is.list(test))
# Test that a best model has been fitted
expect_false(is.na((test[[1]]$BestModel)[1]))
# Test there are no NAs in the best model data
expect_equal(length(which(is.na(test[[1]]$BestModelData))), 0)
# Test that the best model data has at least 2 parameters
expect_true(ncol(test[[1]]$BestModelData) >= 2)
#Test the values we get out have stayed the same as github (7-9-17)
#Don't use old R because we changed how we estimate week slightly
expect_true(round(test[[1]]$Dataset$deltaAICc[1], 1) == -8)
expect_true(test[[1]]$Dataset$WindowOpen[1] == 2 & test[[1]]$Dataset$WindowClose[1] == 2)
expect_true(round(test[[1]]$Dataset$ModelBeta[1], 1) == -0.9)
})
test_that("spatial replication works in slidingwin with month", {
data(Mass, envir = environment())
Mass$Plot <- c(rep(c("A", "B"), 23), "A")
data(MassClimate, envir = environment())
MassClimate$Plot <- "A"
MassClimate2 <- MassClimate
MassClimate2$Plot <- "B"
Clim <- rbind(MassClimate, MassClimate2)
test <- slidingwin(xvar = list(Clim$Temp), cdate = Clim$Date, bdate = Mass$Date,
baseline = lm(Mass ~ 1, data = Mass), range = c(2, 0),
type = "absolute", refday = c(20, 5),
cinterval = "month",
stat = "max", func = "lin", cmissing=FALSE,
spatial = list(Mass$Plot, Clim$Plot))
# Test that slidingwin has produced an output
expect_true(is.list(test))
# Test that a best model has been fitted
expect_false(is.na((test[[1]]$BestModel)[1]))
# Test there are no NAs in the best model data
expect_equal(length(which(is.na(test[[1]]$BestModelData))), 0)
# Test that the best model data has at least 2 parameters
expect_true(ncol(test[[1]]$BestModelData) >= 2)
#Test the values we get out have stayed the same as github (7-9-17)
#Don't use old R because we changed how we estimate month slightly
expect_true(round(test[[1]]$Dataset$deltaAICc[1], 1) == -32.5)
expect_true(test[[1]]$Dataset$WindowOpen[1] == 2 & test[[1]]$Dataset$WindowClose[1] == 1)
expect_true(round(test[[1]]$Dataset$ModelBeta[1], 1) == -3.2)
})
test_that("spatial replication works in slidingwin with upper", {
data(Mass, envir = environment())
Mass$Plot <- c(rep(c("A", "B"), 23), "A")
data(MassClimate, envir = environment())
MassClimate$Plot <- "A"
MassClimate2 <- MassClimate
MassClimate2$Plot <- "B"
Clim <- rbind(MassClimate, MassClimate2)
test <- slidingwin(xvar = list(Clim$Temp), cdate = Clim$Date, bdate = Mass$Date,
baseline = lm(Mass ~ 1, data = Mass), range = c(2, 0),
type = "absolute", refday = c(20, 5),
cinterval = "day", upper = 15,
stat = "max", func = "lin", cmissing=FALSE,
spatial = list(Mass$Plot, Clim$Plot))
# Test that slidingwin has produced an output
expect_true(is.list(test))
# Test that a best model has been fitted
expect_false(is.na((test[[1]]$BestModel)[1]))
# Test there are no NAs in the best model data
expect_equal(length(which(is.na(test[[1]]$BestModelData))), 0)
# Test that the best model data has at least 2 parameters
expect_true(ncol(test[[1]]$BestModelData) >= 2)
#Test the values we get out have stayed the same as our last R version
expect_true(round(test[[1]]$Dataset$deltaAICc[1], 1) == -0.0)
expect_true(test[[1]]$Dataset$WindowOpen[1] == 2 & test[[1]]$Dataset$WindowClose[1] == 0)
expect_true(round(test[[1]]$Dataset$ModelBeta[1], 1) == -0.2)
})
test_that("spatial replication with slidingwin returns an error with NAs and cmissing FALSE", {
data(Mass, envir = environment())
Mass$Plot <- c(rep(c("A", "B"), 23), "A")
data(MassClimate, envir = environment())
MassClimate$Plot <- "A"
MassClimate2 <- MassClimate
MassClimate2$Plot <- "B"
Clim <- rbind(MassClimate, MassClimate2)
Clim <- Clim[-which(Clim$Date == "20/05/1979"), ]
expect_error(slidingwin(xvar = list(Clim$Temp), cdate = Clim$Date, bdate = Mass$Date,
baseline = lm(Mass ~ 1, data = Mass), range = c(1, 0),
type = "absolute", refday = c(20, 5),
cinterval = "day",
stat = "max", func = "lin", cmissing = FALSE,
spatial = list(Mass$Plot, Clim$Plot)))
expect_true(exists("missing"))
rm("missing", envir = .GlobalEnv)
})
test_that("spatial replication works with slidingwin with NAs and cmissing method1", {
data(Mass, envir = environment())
Mass$Plot <- c(rep(c("A", "B"), 23), "A")
data(MassClimate, envir = environment())
MassClimate$Plot <- "A"
MassClimate2 <- MassClimate
MassClimate2$Plot <- "B"
Clim <- rbind(MassClimate, MassClimate2)
Clim <- Clim[-which(Clim$Date == "20/05/1979"), ]
test <- slidingwin(xvar = list(Clim$Temp), cdate = Clim$Date, bdate = Mass$Date,
baseline = lm(Mass ~ 1, data = Mass), range = c(2, 0),
type = "absolute", refday = c(20, 5),
cinterval = "day",
stat = "max", func = "lin", cmissing = "method1",
spatial = list(Mass$Plot, Clim$Plot))
# Test that slidingwin has produced an output
expect_true(is.list(test))
# Test that a best model has been fitted
expect_false(is.na((test[[1]]$BestModel)[1]))
# Test there are no NAs in the best model data
expect_equal(length(which(is.na(test[[1]]$BestModelData))), 0)
# Test that the best model data has at least 2 parameters
expect_true(ncol(test[[1]]$BestModelData) >= 2)
#Test the values we get out have stayed the same as our last R version
expect_true(round(test[[1]]$Dataset$deltaAICc[1], 1) == -4.2)
expect_true(test[[1]]$Dataset$WindowOpen[1] == 2 & test[[1]]$Dataset$WindowClose[1] == 1)
expect_true(round(test[[1]]$Dataset$ModelBeta[1], 1) == -0.8)
})
test_that("spatial replication works with slidingwin with NAs and cmissing method2", {
data(Mass, envir = environment())
Mass$Plot <- c(rep(c("A", "B"), 23), "A")
data(MassClimate, envir = environment())
MassClimate$Plot <- "A"
MassClimate2 <- MassClimate
MassClimate2$Plot <- "B"
Clim <- rbind(MassClimate, MassClimate2)
Clim <- Clim[-which(Clim$Date == "20/05/1979"), ]
test <- slidingwin(xvar = list(Clim$Temp), cdate = Clim$Date, bdate = Mass$Date,
baseline = lm(Mass ~ 1, data = Mass), range = c(2, 0),
type = "absolute", refday = c(20, 5),
cinterval = "day",
stat = "max", func = "lin", cmissing = "method2",
spatial = list(Mass$Plot, Clim$Plot))
# Test that slidingwin has produced an output
expect_true(is.list(test))
# Test that a best model has been fitted
expect_false(is.na((test[[1]]$BestModel)[1]))
# Test there are no NAs in the best model data
expect_equal(length(which(is.na(test[[1]]$BestModelData))), 0)
# Test that the best model data has at least 2 parameters
expect_true(ncol(test[[1]]$BestModelData) >= 2)
#Test the values we get out have stayed the same as our last R version
expect_true(round(test[[1]]$Dataset$deltaAICc[1], 1) == -4.2)
expect_true(test[[1]]$Dataset$WindowOpen[1] == 2 & test[[1]]$Dataset$WindowClose[1] == 1)
expect_true(round(test[[1]]$Dataset$ModelBeta[1], 1) == -0.8)
})
##################################################################
#Test that code works with climate in a monthly format
test_that("slidingwin produces the right output with monthly climate data", {
data(Mass, envir = environment())
data(Monthly_data, envir = environment())
furthest = 2
closest = 0
test <- slidingwin(xvar = list(Monthly_data$Temp), cdate = Monthly_data$Date, bdate = Mass$Date,
baseline = lm(Mass ~ 1, data = Mass), range = c(2, 0),
type = "relative", stat = "max", func = "lin", cmissing = FALSE,
cinterval = "month")
duration <- (furthest - closest) + 1
maxmodno <- (duration * (duration + 1))/2
# Test that a list has been produced
expect_true(is.list(test))
# Test that a best model was returned
expect_false(is.na((test[[1]]$BestModel)[1]))
# Test that there are no NAs in the best model data
expect_equal(length(which(is.na(test[[1]]$BestModelData))), 0)
# Test that the best model data has at least 2 columns
expect_true(ncol(test[[1]]$BestModelData) >= 2)
# Test that there are no NAs in the output dataset
expect_equal(length(which(is.na(test[[1]]$Dataset[, 4]))), 0)
# Test that all columns were created in the dataset
expect_true(ncol(test[[1]]$Dataset) == 17)
# Test that the correct number of models were recorded in the dataset
expect_equal(maxmodno, nrow(test[[1]]$Dataset))
# Test that data was not randomised
expect_true((test[[1]]$Dataset["Randomised"])[1, ] == "no")
#Test the values we get out have stayed the same as our last R version
expect_true(round(test[[1]]$Dataset$deltaAICc[1], 1) == -0.7)
expect_true(test[[1]]$Dataset$WindowOpen[1] == 2 & test[[1]]$Dataset$WindowClose[1] == 2)
expect_true(round(test[[1]]$Dataset$ModelBeta[1], 1) == -0.3)
})
##############################################################
#Test that code works with weighted linear model
test_that("slidingwin produces the right output when using weights in model", {
data("Offspring", envir = environment())
data("OffspringClimate", envir = environment())
furthest = 2
closest = 0
test <- slidingwin(xvar = list(OffspringClimate$Temp), cdate = OffspringClimate$Date, bdate = Offspring$Date,
baseline = lm(Offspring ~ 1, data = Offspring, weights = Order), range = c(2, 0),
type = "relative", stat = "max", func = "lin", cmissing = FALSE,
cinterval = "month")
duration <- (furthest - closest) + 1
maxmodno <- (duration * (duration + 1))/2
# Test that a list has been produced
expect_true(is.list(test))
# Test that a best model was returned
expect_false(is.na((test[[1]]$BestModel)[1]))
# Test that there are no NAs in the best model data
expect_equal(length(which(is.na(test[[1]]$BestModelData))), 0)
# Test that the best model data has at least 2 columns
expect_true(ncol(test[[1]]$BestModelData) >= 2)
# Test that there are no NAs in the output dataset
expect_equal(length(which(is.na(test[[1]]$Dataset[, 4]))), 0)
# Test that all columns were created in the dataset
expect_true(ncol(test[[1]]$Dataset) == 17)
# Test that the correct number of models were recorded in the dataset
expect_equal(maxmodno, nrow(test[[1]]$Dataset))
# Test that data was not randomised
expect_true((test[[1]]$Dataset["Randomised"])[1, ] == "no")
#Test the values we get out have stayed the same as our last R version
expect_true(round(test[[1]]$Dataset$deltaAICc[1], 1) == -88.6)
expect_true(test[[1]]$Dataset$WindowOpen[1] == 2 & test[[1]]$Dataset$WindowClose[1] == 2)
expect_true(round(test[[1]]$Dataset$ModelBeta[1], 1) == 0.1)
})
test_that("slidingwin produces the right output when using equal weights in model", {
data("Offspring", envir = environment())
data("OffspringClimate", envir = environment())
Offspring$weight <- 1
furthest = 2
closest = 0
test <- slidingwin(xvar = list(OffspringClimate$Temp), cdate = OffspringClimate$Date, bdate = Offspring$Date,
baseline = lm(Offspring ~ 1, data = Offspring, weights = weight), range = c(2, 0),
type = "relative", stat = "max", func = "lin", cmissing = FALSE,
cinterval = "month")
duration <- (furthest - closest) + 1
maxmodno <- (duration * (duration + 1))/2
# Test that a list has been produced
expect_true(is.list(test))
# Test that a best model was returned
expect_false(is.na((test[[1]]$BestModel)[1]))
# Test that there are no NAs in the best model data
expect_equal(length(which(is.na(test[[1]]$BestModelData))), 0)
# Test that the best model data has at least 2 columns
expect_true(ncol(test[[1]]$BestModelData) >= 2)
# Test that there are no NAs in the output dataset
expect_equal(length(which(is.na(test[[1]]$Dataset[, 4]))), 0)
# Test that all columns were created in the dataset
expect_true(ncol(test[[1]]$Dataset) == 17)
# Test that the correct number of models were recorded in the dataset
expect_equal(maxmodno, nrow(test[[1]]$Dataset))
# Test that data was not randomised
expect_true((test[[1]]$Dataset["Randomised"])[1, ] == "no")
#Test the values we get out have stayed the same as our last R version
expect_true(round(test[[1]]$Dataset$deltaAICc[1], 1) == -88.7)
expect_true(test[[1]]$Dataset$WindowOpen[1] == 2 & test[[1]]$Dataset$WindowClose[1] == 2)
expect_true(round(test[[1]]$Dataset$ModelBeta[1], 1) == 0.1)
})
##############################################################
#Test that code works when climate data reaches exactly to the refday (i.e. max(cdate) == max(bdate))
test_that("slidingwin works when cmax(cdate) == max(bdate)", {
data("Offspring", envir = environment())
data("OffspringClimate", envir = environment())
furthest = 2
closest = 0
test <- slidingwin(xvar = list(OffspringClimate$Temp), cdate = OffspringClimate$Date, bdate = Offspring$Date,
baseline = lm(Offspring ~ 1, data = Offspring, weights = Order), range = c(2, 0),
type = "absolute", refday = c(31, 01), stat = "max", func = "lin", cmissing = FALSE,
cinterval = "day")
duration <- (furthest - closest) + 1
maxmodno <- (duration * (duration + 1))/2
# Test that a list has been produced
expect_true(is.list(test))
# Test that a best model was returned
expect_false(is.na((test[[1]]$BestModel)[1]))
# Test that there are no NAs in the best model data
expect_equal(length(which(is.na(test[[1]]$BestModelData))), 0)
# Test that the best model data has at least 2 columns
expect_true(ncol(test[[1]]$BestModelData) >= 2)
# Test that there are no NAs in the output dataset
expect_equal(length(which(is.na(test[[1]]$Dataset[, 4]))), 0)
# Test that all columns were created in the dataset
expect_true(ncol(test[[1]]$Dataset) == 19)
# Test that the correct number of models were recorded in the dataset
expect_equal(maxmodno, nrow(test[[1]]$Dataset))
# Test that data was not randomised
expect_true((test[[1]]$Dataset["Randomised"])[1, ] == "no")
#Test the values we get out have stayed the same as our last R version
expect_true(round(test[[1]]$Dataset$deltaAICc[1], 1) == -12.7)
expect_true(test[[1]]$Dataset$WindowOpen[1] == 2 & test[[1]]$Dataset$WindowClose[1] == 2)
expect_true(round(test[[1]]$Dataset$ModelBeta[1], 1) == 0)
})
##############################################################
#Test that an error is returned if there are duplicate climate records but no spatial argument.
test_that("Duplicate climate data returns an error (without spatial)", {
data("Mass", envir = environment())
data("MassClimate", envir = environment())
MassClimate <- rbind(MassClimate, MassClimate)
expect_error(slidingwin(xvar = list(MassClimate$Temp), cdate = MassClimate$Date, bdate = Mass$Date,
baseline = lm(Mass ~ 1, data = Mass), range = c(2, 0),
type = "absolute", refday = c(31, 01), stat = "max", func = "lin", cmissing = FALSE,
cinterval = "day"))
})
Try the climwin package in your browser
Any scripts or data that you put into this service are public.
climwin documentation built on July 1, 2020, 7:04 p.m.
R Package Documentation
Browse R Packages
We want your feedback!
Note that we can't provide technical support on individual packages. You should contact the package authors for that.
# Test the outcomes of slidingwin #
#Need to vary:
# baseline model type: glm, lme4, glmer
# cinterval: day, week, month
# stat: mean, min, max, slope
# func: lin, quad, cub, inv, log
# upper: range
# lower: range
# binary: TRUE or FALSE
# k: 0 and >1
# centre: value
##########################################################
# Test regular output #
test_that("slidingwin produces the right output", {
data(Mass, envir = environment())
data(MassClimate, envir = environment())
furthest = 2
closest = 0
test <- slidingwin(xvar = list(MassClimate$Temp), cdate = MassClimate$Date, bdate = Mass$Date,
baseline = lm(Mass ~ 1, data = Mass), range = c(2, 0),
type = "relative", stat = "max", func = "lin", cmissing = FALSE)
duration <- (furthest - closest) + 1
maxmodno <- (duration * (duration + 1))/2
# Test that a list has been produced
expect_true(is.list(test))
# Test that a best model was returned
expect_false(is.na((test[[1]]$BestModel)[1]))
# Test that there are no NAs in the best model data
expect_equal(length(which(is.na(test[[1]]$BestModelData))), 0)
# Test that the best model data has at least 2 columns
expect_true(ncol(test[[1]]$BestModelData) >= 2)
# Test that there are no NAs in the output dataset
expect_equal(length(which(is.na(test[[1]]$Dataset[, 4]))), 0)
# Test that all columns were created in the dataset
expect_true(ncol(test[[1]]$Dataset) == 17)
# Test that the correct number of models were recorded in the dataset
expect_equal(maxmodno, nrow(test[[1]]$Dataset))
# Test that data was not randomised
expect_true((test[[1]]$Dataset["Randomised"])[1, ] == "no")
#Test the values we get out have stayed the same as our last R version
expect_true(round(test[[1]]$Dataset$deltaAICc[1], 1) == -2.7)
expect_true(test[[1]]$Dataset$WindowOpen[1] == 2 & test[[1]]$Dataset$WindowClose[1] == 2)
expect_true(round(test[[1]]$Dataset$ModelBeta[1], 1) == -0.7)
})
# Test output with multiple combos #
test_that("slidingwin produces multiple combos", {
data(Mass, envir = environment())
data(MassClimate, envir = environment())
furthest = 1
closest = 0
test <- slidingwin(xvar = list(Temp = MassClimate$Temp, Rain = MassClimate$Rain), cdate = MassClimate$Date, bdate = Mass$Date,
baseline = lm(Mass ~ 1, data = Mass), range = c(1, 0),
type = "relative", stat = c("max", "min"), func = c("lin", "quad"), cmissing = FALSE)
# Test that all combos of stat, func and xvar were created
expect_equal(nrow(test$combos), 8)
})
##########################################################
# Test that upper and lower work #
# Test with upper and binary:
test_that("slidingwin produces binary values with upper and binary = TRUE", {
data(Mass, envir = environment())
data(MassClimate, envir = environment())
furthest = 1
closest = 0
test <- slidingwin(xvar = list(Temp = MassClimate$Temp), cdate = MassClimate$Date, bdate = Mass$Date,
baseline = lm(Mass ~ 1, data = Mass), range = c(1, 0),
type = "relative", stat = "max", func = "lin", cmissing = FALSE,
upper = 10, binary = TRUE)
# Test that the minimum value of climate was set at 0
expect_equal(min(test[[1]]$BestModelData$climate), 0)
# Test that the maximum value of climate was set at 1
expect_equal(max(test[[1]]$BestModelData$climate), 1)
#Test the values we get out have stayed the same as our last R version
expect_true(round(test[[1]]$Dataset$deltaAICc[1], 1) == 1.2)
expect_true(test[[1]]$Dataset$WindowOpen[1] == 1 & test[[1]]$Dataset$WindowClose[1] == 0)
expect_true(round(test[[1]]$Dataset$ModelBeta[1], 1) == 1.9)
})
# Test with upper and without binary
test_that("slidingwin produces non-binary values with upper and binary = FALSE", {
data(Mass, envir = environment())
data(MassClimate, envir = environment())
furthest = 1
closest = 0
test <- slidingwin(xvar = list(Temp = MassClimate$Temp), cdate = MassClimate$Date, bdate = Mass$Date,
baseline = lm(Mass ~ 1, data = Mass), range = c(1, 0),
type = "relative", stat = "max", func = "lin", cmissing = FALSE,
upper = 10, binary = FALSE)
# Test that the minimum value of climate was set at 0
expect_equal(min(test[[1]]$BestModelData$climate), 0)
# Test that the maximum value of climate in greater than 1
expect_true(max(test[[1]]$BestModelData$climate) > 1)
#Test the values we get out have stayed the same as our last R version
expect_true(round(test[[1]]$Dataset$deltaAICc[1], 1) == 1.7)
expect_true(test[[1]]$Dataset$WindowOpen[1] == 1 & test[[1]]$Dataset$WindowClose[1] == 1)
expect_true(round(test[[1]]$Dataset$ModelBeta[1], 1) == -0.1)
})
# Test with lower and without binary
test_that("slidingwin produces non-binary values with lower and binary = FALSE", {
data(Mass, envir = environment())
data(MassClimate, envir = environment())
furthest = 1
closest = 0
test <- slidingwin(xvar = list(Temp = MassClimate$Temp), cdate = MassClimate$Date, bdate = Mass$Date,
baseline = lm(Mass ~ 1, data = Mass), range = c(1, 0),
type = "relative", stat = "max", func = "lin", cmissing = FALSE,
lower = 10, binary = FALSE)
# Test that the minumum value of climate is set at 0
expect_equal(min(test[[1]]$BestModelData$climate), 0)
# Test that the maximum value of climate is greater than 1
expect_true(max(test[[1]]$BestModelData$climate) > 1)
#Test the values we get out have stayed the same as our last R version
expect_true(round(test[[1]]$Dataset$deltaAICc[1], 1) == 1.5)
expect_true(test[[1]]$Dataset$WindowOpen[1] == 1 & test[[1]]$Dataset$WindowClose[1] == 0)
expect_true(round(test[[1]]$Dataset$ModelBeta[1], 1) == 0.1)
})
# With lower and binary
test_that("slidingwin produces binary values with lower and binary = TRUE", {
data(Mass, envir = environment())
data(MassClimate, envir = environment())
furthest = 1
closest = 0
test <- slidingwin(xvar = list(Temp = MassClimate$Temp), cdate = MassClimate$Date, bdate = Mass$Date,
baseline = lm(Mass ~ 1, data = Mass), range = c(1, 0),
type = "relative", stat = "max", func = "lin", cmissing = FALSE,
lower = 10, binary = TRUE)
# Test that the minimum value of climate is set at 0
expect_equal(min(test[[1]]$BestModelData$climate), 0)
# Test that the maximum value of climate is set at 1
expect_equal(max(test[[1]]$BestModelData$climate), 1)
#Test the values we get out have stayed the same as our last R version
expect_true(round(test[[1]]$Dataset$deltaAICc[1], 1) == 1.7)
expect_true(test[[1]]$Dataset$WindowOpen[1] == 1 & test[[1]]$Dataset$WindowClose[1] == 0)
expect_true(round(test[[1]]$Dataset$ModelBeta[1], 1) == 1.1)
})
# Test with upper, lower and binary
test_that("slidingwin produces binary values with lower/upper and binary = TRUE", {
data(Mass, envir = environment())
data(MassClimate, envir = environment())
furthest = 1
closest = 0
test <- slidingwin(xvar = list(Temp = MassClimate$Temp), cdate = MassClimate$Date, bdate = Mass$Date,
baseline = lm(Mass ~ 1, data = Mass), range = c(1, 0),
type = "relative", stat = "max", func = "lin", cmissing = FALSE,
lower = 10, upper = 15, binary = TRUE)
# Test that the minimum value of climate is set at 0
expect_equal(min(test[[1]]$BestModelData$climate), 0)
# Test that the maximum value of climate is set at 1
expect_equal(max(test[[1]]$BestModelData$climate), 1)
#Test the values we get out have stayed the same as our last R version
expect_true(round(test[[1]]$Dataset$deltaAICc[1], 1) == 0.7)
expect_true(test[[1]]$Dataset$WindowOpen[1] == 1 & test[[1]]$Dataset$WindowClose[1] == 0)
expect_true(round(test[[1]]$Dataset$ModelBeta[1], 1) == 2.2)
})
# With upper and lower but without binary
test_that("slidingwin produces non-binary values with lower/upper and binary = FALSE", {
data(Mass, envir = environment())
data(MassClimate, envir = environment())
furthest = 1
closest = 0
test <- slidingwin(xvar = list(Temp = MassClimate$Temp), cdate = MassClimate$Date, bdate = Mass$Date,
baseline = lm(Mass ~ 1, data = Mass), range = c(1, 0),
type = "relative", stat = "max", func = "lin", cmissing = FALSE,
lower = 10, upper = 15, binary = FALSE)
# Test that the minimum value of climate is set at 0
expect_equal(min(test[[1]]$BestModelData$climate), 0)
# Test that the maximum value of climate is greater than 1
expect_true(max(test[[1]]$BestModelData$climate) > 1)
#Test the values we get out have stayed the same as our last R version
expect_true(round(test[[1]]$Dataset$deltaAICc[1], 1) == 1.6)
expect_true(test[[1]]$Dataset$WindowOpen[1] == 1 & test[[1]]$Dataset$WindowClose[1] == 1)
expect_true(round(test[[1]]$Dataset$ModelBeta[1], 1) == -0.4)
})
##########################################################
# Test different settings of cmissing #
# Test when cmissing is FALSE and NAs are present (daily)#
test_that("Errors return when cmissing FALSE and NA present at a daily scale", {
data(Mass, envir = environment())
data(MassClimate, envir = environment())
MassClimate2 <- MassClimate[-491, ]
expect_error(slidingwin(xvar = list(MassClimate2$Temp), cdate = MassClimate2$Date, bdate = Mass$Date,
baseline = lm(Mass ~ 1, data = Mass), range = c(2, 0),
type = "relative", stat = "max", func = "lin", cmissing = FALSE))
expect_true(exists("missing"))
rm("missing", envir = .GlobalEnv)
})
# Test when cmissing is FALSE and NAs are present (weekly)#
test_that("Errors return when cmissing FALSE and NA present at a weekly scale", {
data(Mass, envir = environment())
data(MassClimate, envir = environment())
MassClimate2 <- MassClimate[-c(491:505), ]
expect_error(slidingwin(xvar = list(MassClimate2$Temp), cdate = MassClimate2$Date, bdate = Mass$Date,
baseline = lm(Mass ~ 1, data = Mass), range = c(2, 0),
type = "relative", stat = "max", func = "lin", cmissing = FALSE,
cinterval = "week"))
expect_true(exists("missing"))
rm("missing", envir = .GlobalEnv)
})
# Test when cmissing is FALSE and NAs are present (monthly)#
test_that("Errors return when cmissing FALSE and NA present at a monthly scale", {
data(Mass, envir = environment())
data(MassClimate, envir = environment())
MassClimate2 <- MassClimate[-c(480:520), ]
expect_error(slidingwin(xvar = list(MassClimate2$Temp), cdate = MassClimate2$Date, bdate = Mass$Date,
baseline = lm(Mass ~ 1, data = Mass), range = c(2, 0),
type = "relative", stat = "max", func = "lin", cmissing = FALSE,
cinterval = "month"))
expect_true(exists("missing"))
rm("missing", envir = .GlobalEnv)
})
# Test cmissing = FALSE with spatial replication (daily)
test_that("cmissing = FALSE with NAs and spatial replication (daily)", {
data(Mass, envir = environment())
Mass$Plot <- c(rep(c("A", "B"), 23), "A")
data(MassClimate, envir = environment())
MassClimate$Plot <- "A"
MassClimate2 <- MassClimate
MassClimate2$Plot <- "B"
Clim <- rbind(MassClimate, MassClimate2)
Clim2 <- Clim[-which(Clim$Plot == "B" & Clim$Date == "8/05/1966"), ]
expect_error(slidingwin(xvar = list(Clim2$Temp), cdate = Clim2$Date, bdate = Mass$Date,
baseline = lm(Mass ~ 1, data = Mass), range = c(2, 0),
type = "relative",
stat = "max", func = "lin", cmissing = FALSE,
spatial = list(Mass$Plot, Clim2$Plot)))
expect_true(exists("missing"))
rm("missing", envir = .GlobalEnv)
})
# Test cmissing = FALSE with spatial replication (weekly)
test_that("cmissing = FALSE with NAs and spatial replication (weekly)", {
data(Mass, envir = environment())
Mass$Plot <- c(rep(c("A", "B"), 23), "A")
data(MassClimate, envir = environment())
MassClimate$Plot <- "A"
MassClimate2 <- MassClimate
MassClimate2$Plot <- "B"
Clim <- rbind(MassClimate, MassClimate2)
Clim2 <- Clim[-c(18025:18015), ]
expect_error(slidingwin(xvar = list(Clim2$Temp), cdate = Clim2$Date, bdate = Mass$Date,
baseline = lm(Mass ~ 1, data = Mass), range = c(2, 0),
type = "relative",
stat = "max", func = "lin", cmissing = FALSE,
spatial = list(Mass$Plot, Clim2$Plot),
cinterval = "week"))
expect_true(exists("missing"))
rm("missing", envir = .GlobalEnv)
})
# Test cmissing = FALSE with spatial replication (monthly)
test_that("cmissing = FALSE with NAs and spatial replication (monthly)", {
data(Mass, envir = environment())
Mass$Plot <- c(rep(c("A", "B"), 23), "A")
data(MassClimate, envir = environment())
MassClimate$Plot <- "A"
MassClimate2 <- MassClimate
MassClimate2$Plot <- "B"
Clim <- rbind(MassClimate, MassClimate2)
Clim2 <- Clim[-c(18000:18050), ]
expect_error(slidingwin(xvar = list(Clim2$Temp), cdate = Clim2$Date, bdate = Mass$Date,
baseline = lm(Mass ~ 1, data = Mass), range = c(2, 0),
type = "relative",
stat = "max", func = "lin", cmissing = FALSE,
spatial = list(Mass$Plot, Clim2$Plot),
cinterval = "month"))
expect_true(exists("missing"))
rm("missing", envir = .GlobalEnv)
})
# Test when cmissing is method1 and no NA is present #
test_that("No errors return when cmissing method1 and full dataset", {
data(Mass, envir = environment())
data(MassClimate, envir = environment())
test <- slidingwin(xvar = list(MassClimate$Temp), cdate = MassClimate$Date, bdate = Mass$Date,
baseline = lm(Mass ~ 1, data = Mass), range = c(2, 2),
type = "relative", stat = "max", func = "lin", cmissing = "method1")
#Test that slidingwin ran without an error
expect_true(is.list(test))
#Test the values we get out have stayed the same as our last R version
expect_true(round(test[[1]]$Dataset$deltaAICc[1], 1) == -2.7)
expect_true(test[[1]]$Dataset$WindowOpen[1] == 2 & test[[1]]$Dataset$WindowClose[1] == 2)
expect_true(round(test[[1]]$Dataset$ModelBeta[1], 1) == -0.7)
})
# Test when cmissing is method2 and no NA is present #
test_that("No errors return when cmissing method2 and full dataset", {
data(Mass, envir = environment())
data(MassClimate, envir = environment())
test <- slidingwin(xvar = list(MassClimate$Temp), cdate = MassClimate$Date, bdate = Mass$Date,
baseline = lm(Mass ~ 1, data = Mass), range = c(2, 2),
type = "relative", stat = "max", func = "lin", cmissing = "method2")
# Test that slidingwin ran without an error
expect_true(is.list(test))
#Test the values we get out have stayed the same as our last R version
expect_true(round(test[[1]]$Dataset$deltaAICc[1], 1) == -2.7)
expect_true(test[[1]]$Dataset$WindowOpen[1] == 2 & test[[1]]$Dataset$WindowClose[1] == 2)
expect_true(round(test[[1]]$Dataset$ModelBeta[1], 1) == -0.7)
})
# Test when cmissing is method1 and NA is present (daily) #
test_that("No errors return when cmissing method1 with NAs (daily)", {
data(Mass, envir = environment())
data(MassClimate, envir = environment())
MassClimate2 <- MassClimate[-491, ]
test <- slidingwin(xvar = list(MassClimate2$Temp), cdate = MassClimate2$Date, bdate = Mass$Date,
baseline = lm(Mass ~ 1, data = Mass), range = c(2, 0),
type = "relative", stat = "max", func = "lin", cmissing = "method1")
# Test that slidingwin ran without an error
expect_true(is.list(test))
#Test the values we get out have stayed the same as our last R version
expect_true(round(test[[1]]$Dataset$deltaAICc[1], 1) == -2.7)
expect_true(test[[1]]$Dataset$WindowOpen[1] == 2 & test[[1]]$Dataset$WindowClose[1] == 2)
expect_true(round(test[[1]]$Dataset$ModelBeta[1], 1) == -0.7)
})
# Test when cmissing is method2 and NA is present (daily)#
test_that("No errors return when cmissing method2 with NAs (daily)", {
data(Mass, envir = environment())
data(MassClimate, envir = environment())
MassClimate2 <- MassClimate[-491, ]
test <- slidingwin(xvar = list(MassClimate2$Temp), cdate = MassClimate2$Date, bdate = Mass$Date,
baseline = lm(Mass ~ 1, data = Mass), range = c(2, 0),
type = "relative", stat = "max", func = "lin", cmissing = "method2")
# Test that slidingwin ran without an error
expect_true(is.list(test))
#Test the values we get out have stayed the same as our last R version
expect_true(round(test[[1]]$Dataset$deltaAICc[1], 1) == -2.7)
expect_true(test[[1]]$Dataset$WindowOpen[1] == 2 & test[[1]]$Dataset$WindowClose[1] == 2)
expect_true(round(test[[1]]$Dataset$ModelBeta[1], 1) == -0.7)
})
# Test when cmissing is method1 and NA is present (cinterval = "week") #
test_that("No errors returned when cmissing method1 with NAs, cinterval = week", {
data(Mass, envir = environment())
data(MassClimate, envir = environment())
MassClimate2 <- MassClimate[-c(491:505), ]
# Test that an error is returned
test <- slidingwin(xvar = list(MassClimate2$Temp), cdate = MassClimate2$Date, bdate = Mass$Date,
baseline = lm(Mass ~ 1, data = Mass), range = c(2, 0),
type = "relative", stat = "max", func = "lin", cinterval = "week",
cmissing = "method1")
# Test that slidingwin ran without an error
expect_true(is.list(test))
#Test the values we get stay the same as github version (7-9-17).
#N.B. We don't use the old R version because we have changed how we calculate weeks (i.e. use lubridate::week rather than dividing by 7)
expect_true(round(test[[1]]$Dataset$deltaAICc[1], 1) == 0.2)
expect_true(test[[1]]$Dataset$WindowOpen[1] == 1 & test[[1]]$Dataset$WindowClose[1] == 1)
expect_true(round(test[[1]]$Dataset$ModelBeta[1], 1) == -0.6)
})
# Test when cmissing is method2 and NA is present (cinterval = "week") #
test_that("No error returned when cmissing method2 with NAs, cinterval = week", {
data(Mass, envir = environment())
data(MassClimate, envir = environment())
MassClimate2 <- MassClimate[-c(491:505), ]
# Test that an error is returned
test <- slidingwin(xvar = list(MassClimate2$Temp), cdate = MassClimate2$Date, bdate = Mass$Date,
baseline = lm(Mass ~ 1, data = Mass), range = c(2, 0),
type = "relative", stat = "max", func = "lin", cinterval = "week",
cmissing = "method2")
# Test that slidingwin ran without an error
expect_true(is.list(test))
#Test the values we get stay the same as github version (7-9-17).
#N.B. We don't use the old R version because we have changed how we calculate weeks (i.e. use lubridate::week rather than dividing by 7)
expect_true(round(test[[1]]$Dataset$deltaAICc[1], 1) == 0.2)
expect_true(test[[1]]$Dataset$WindowOpen[1] == 1 & test[[1]]$Dataset$WindowClose[1] == 1)
expect_true(round(test[[1]]$Dataset$ModelBeta[1], 1) == -0.6)
})
# Test when cmissing is method1 and NA is present (cinterval = "month") #
test_that("No error returned when cmissing method1 with NAs, cinterval = month", {
data(Mass, envir = environment())
data(MassClimate, envir = environment())
MassClimate2 <- MassClimate[-c(1900:2000), ]
# Test that an error is returned #
test <- slidingwin(xvar = list(MassClimate2$Temp), cdate = MassClimate2$Date, bdate = Mass$Date,
baseline = lm(Mass ~ 1, data = Mass), range = c(1, 0),
type = "relative", stat = "max", func = "lin", cinterval = "month",
cmissing = "method1")
# Test that slidingwin ran without an error
expect_true(is.list(test))
#Test the values we get stay the same as github version (7-9-17).
#N.B. We don't use the old R version because we have changed how we calculate months slightly
expect_true(round(test[[1]]$Dataset$deltaAICc[1], 1) == -3.9)
expect_true(test[[1]]$Dataset$WindowOpen[1] == 1 & test[[1]]$Dataset$WindowClose[1] == 1)
expect_true(round(test[[1]]$Dataset$ModelBeta[1], 1) == -1.8)
})
# Test when cmissing is method2 and NA is present (cinterval = "month") #
test_that("No error returned when cmissing method2 with NAs, cinterval = month", {
data(Mass, envir = environment())
data(MassClimate, envir = environment())
MassClimate2 <- MassClimate[-c(1000:2000), ]
# Test that an error is returned #
test <- slidingwin(xvar = list(MassClimate2$Temp), cdate = MassClimate2$Date, bdate = Mass$Date,
baseline = lm(Mass ~ 1, data = Mass), range = c(1, 0),
type = "relative", stat = "max", func = "lin", cinterval = "month",
cmissing = "method2")
# Test that slidingwin ran without an error
expect_true(is.list(test))
#Test the values we get stay the same as github version (7-9-17).
#N.B. We don't use the old R version because we have changed how we calculate months slightly
expect_true(round(test[[1]]$Dataset$deltaAICc[1], 1) == -1.9)
expect_true(test[[1]]$Dataset$WindowOpen[1] == 1 & test[[1]]$Dataset$WindowClose[1] == 1)
expect_true(round(test[[1]]$Dataset$ModelBeta[1], 1) == -1.6)
})
##########################################################
# Test different types of models #
# Test glm models #
test_that("glm models can run in slidingwin", {
data(Mass, envir = environment())
data(MassClimate, envir = environment())
test <- slidingwin(xvar = list(MassClimate$Temp), cdate = MassClimate$Date, bdate = Mass$Date,
baseline = glm(Mass ~ 1, data = Mass, family = poisson), range = c(2, 0),
type = "relative", stat = "max", func = "lin", cmissing = FALSE)
# Test that slidingwin produced an output
expect_true(is.list(test))
# Test that best model was created
expect_false(is.na((test[[1]]$BestModel)[1]))
# Test that there are no NA values in best model data
expect_equal(length(which(is.na(test[[1]]$BestModelData))), 0)
# Test that there are atleast 2 variables in the best model data
expect_true(ncol(test[[1]]$BestModelData) >= 2)
#Test the values we get out have stayed the same as our last R version
expect_true(round(test[[1]]$Dataset$deltaAICc[1], 1) == 1.3)
expect_true(test[[1]]$Dataset$WindowOpen[1] == 2 & test[[1]]$Dataset$WindowClose[1] == 2)
expect_true(round(test[[1]]$Dataset$ModelBeta[1], 1) == -0.0)
})
# Test mixed effects models (lme4) #
test_that("lmer [lme4] models can run in slidingwin", {
data(Offspring, envir = environment())
data(OffspringClimate, envir = environment())
test <- slidingwin(xvar = list(OffspringClimate$Temp), cdate = OffspringClimate$Date,
bdate = Offspring$Date,
baseline = lmer(Offspring ~ 1 + (1|BirdID), data = Offspring, REML = F),
range = c(2, 0), type = "relative",
stat = "max", func = "lin", cmissing=FALSE)
# Test that slidingwin produced an output
expect_true(is.list(test))
# Test that lmer model produced an intercept
expect_false(is.na(fixef(test[[1]]$BestModel)[1]))
# Test that lmer model produced a climate beta estimate
expect_false(is.na(fixef(test[[1]]$BestModel)[2]))
# Test that best model data doesn't contain NAs
expect_equal(length(which(is.na(test[[1]]$BestModelData))), 0)
# Test that best model data has at least 2 parameters
expect_true(ncol(test[[1]]$BestModelData) >= 2)
#Test the values we get out have stayed the same as our last R version
expect_true(round(test[[1]]$Dataset$deltaAICc[1], 1) == -55.3)
expect_true(test[[1]]$Dataset$WindowOpen[1] == 2 & test[[1]]$Dataset$WindowClose[1] == 2)
expect_true(round(test[[1]]$Dataset$ModelBeta[1], 1) == 0.0)
})
# Test mixed effects models (lme4) #
test_that("lmer [lme4] models can run in slidingwin with cross-validation", {
set.seed(666)
data(Offspring, envir = environment())
data(OffspringClimate, envir = environment())
test <- slidingwin(xvar = list(OffspringClimate$Temp), cdate = OffspringClimate$Date,
bdate = Offspring$Date,
baseline = lmer(Offspring ~ 1 + (1|BirdID), data = Offspring, REML = F),
range = c(2, 1), type = "relative",
stat = "max", func = "lin", cmissing=FALSE, k = 2)
# Test that slidingwin produced an output
expect_true(is.list(test))
# Test that lmer model produced an intercept
expect_false(is.na(fixef(test[[1]]$BestModel)[1]))
# Test that lmer model produced a climate beta estimate
expect_false(is.na(fixef(test[[1]]$BestModel)[2]))
# Test that best model data doesn't contain NAs
expect_equal(length(which(is.na(test[[1]]$BestModelData))), 0)
# Test that best model data has at least 2 parameters
expect_true(ncol(test[[1]]$BestModelData) >= 2)
#Test the values we get out have stayed the same as our last R version
expect_true(round(test[[1]]$Dataset$deltaAICc[1], 1) == -26.3)
expect_true(test[[1]]$Dataset$WindowOpen[1] == 2 & test[[1]]$Dataset$WindowClose[1] == 2)
expect_true(round(test[[1]]$Dataset$ModelBeta[1], 1) == 0.0)
})
# Test glmer models (lme4) #
test_that("glmer [lme4] models can run in slidingwin", {
data(Offspring, envir = environment())
data(OffspringClimate, envir = environment())
# Warnings created due to convergence issues with such a small data set
suppressWarnings(test <- slidingwin(xvar = list(OffspringClimate$Temp), cdate = OffspringClimate$Date,
bdate = Offspring$Date,
baseline = glmer(Offspring ~ 1 + (1|Order), data = Offspring, family = "poisson"),
range = c(1, 0), type = "relative",
stat = "max", func = "lin", cmissing=FALSE))
# Test that slidingwin has produced an output
expect_true(is.list(test))
# Test that glmer model produced an intercept
expect_false(is.na(fixef(test[[1]]$BestModel)[1]))
# Test that glmer model produced a beta estimate for climate
expect_false(is.na(fixef(test[[1]]$BestModel)[2]))
# Test there are no NA values in best model data
expect_equal(length(which(is.na(test[[1]]$BestModelData))), 0)
# Test that best model data has atleast two parameters
expect_true(ncol(test[[1]]$BestModelData) >= 2)
#Test the values we get out have stayed the same as our last R version
expect_true(round(test[[1]]$Dataset$deltaAICc[1], 1) == -14.0)
expect_true(test[[1]]$Dataset$WindowOpen[1] == 1 & test[[1]]$Dataset$WindowClose[1] == 1)
expect_true(round(test[[1]]$Dataset$ModelBeta[1], 1) == 0.0)
})
# Test glmer models (lme4) #
test_that("glmer [lme4] models can run in slidingwin with cross-validation", {
set.seed(666)
data(Offspring, envir = environment())
data(OffspringClimate, envir = environment())
# Warnings created due to convergence issues with such a small data set
suppressWarnings(test <- slidingwin(xvar = list(OffspringClimate$Temp), cdate = OffspringClimate$Date,
bdate = Offspring$Date,
baseline = glmer(Offspring ~ 1 + (1|Order), data = Offspring, family = "poisson"),
range = c(1, 0), type = "relative",
stat = "max", func = "lin", cmissing=FALSE, k = 2))
# Test that slidingwin has produced an output
expect_true(is.list(test))
# Test that glmer model produced an intercept
expect_false(is.na(fixef(test[[1]]$BestModel)[1]))
# Test that glmer model produced a beta estimate for climate
expect_false(is.na(fixef(test[[1]]$BestModel)[2]))
# Test there are no NA values in best model data
expect_equal(length(which(is.na(test[[1]]$BestModelData))), 0)
# Test that best model data has atleast two parameters
expect_true(ncol(test[[1]]$BestModelData) >= 2)
#Test the values we get out have stayed the same as our last R version
expect_true(round(test[[1]]$Dataset$deltaAICc[1], 1) == -6.5)
expect_true(test[[1]]$Dataset$WindowOpen[1] == 1 & test[[1]]$Dataset$WindowClose[1] == 1)
expect_true(round(test[[1]]$Dataset$ModelBeta[1], 1) == 0.0)
})
# Test mixed effects models (nlme) #
test_that("basic lme [nlme] models can run in slidingwin", {
data(Offspring, envir = environment())
data(OffspringClimate, envir = environment())
test <- slidingwin(xvar = list(OffspringClimate$Temp), cdate = OffspringClimate$Date,
bdate = Offspring$Date,
baseline = lme(Offspring ~ 1, random = ~ 1 | BirdID, data = Offspring, method = "ML"),
range = c(2, 0), type = "relative",
stat = "max", func = "lin", cmissing = FALSE)
# Test that slidingwin produced an output
expect_true(is.list(test))
# Test that lmer model produced an intercept
expect_false(is.na(fixef(test[[1]]$BestModel)[1]))
# Test that lmer model produced a climate beta estimate
expect_false(is.na(fixef(test[[1]]$BestModel)[2]))
# Test that best model data doesn't contain NAs
expect_equal(length(which(is.na(test[[1]]$BestModelData))), 0)
# Test that best model data has at least 2 parameters
expect_true(ncol(test[[1]]$BestModelData) >= 2)
#Test the values we get out have stayed the same as github version (7-9-17).
#N.B. Earlier R version didn't have nlme compatability
expect_true(round(test[[1]]$Dataset$deltaAICc[1], 1) == -55.3)
expect_true(test[[1]]$Dataset$WindowOpen[1] == 2 & test[[1]]$Dataset$WindowClose[1] == 2)
expect_true(round(test[[1]]$Dataset$ModelBeta[1], 1) == 0.0)
})
# Test mixed effects models (nlme) #
test_that("lme [nlme] model with VarIdent can run in slidingwin", {
data(Offspring, envir = environment())
data(OffspringClimate, envir = environment())
assign("vI", varIdent(value = 10, form =~ Order), envir=globalenv())
test <- slidingwin(xvar = list(OffspringClimate$Temp), cdate = OffspringClimate$Date,
bdate = Offspring$Date,
baseline = lme(Offspring ~ Order, random = ~ 1 | BirdID, data = Offspring, weights = vI, method = "ML"),
range = c(2, 0), type = "relative",
stat = "max", func = "lin", cmissing = FALSE)
# Test that slidingwin produced an output
expect_true(is.list(test))
# Test that lmer model produced an intercept
expect_false(is.na(fixef(test[[1]]$BestModel)[1]))
# Test that lmer model produced a climate beta estimate
expect_false(is.na(fixef(test[[1]]$BestModel)[2]))
# Test that best model data doesn't contain NAs
expect_equal(length(which(is.na(test[[1]]$BestModelData))), 0)
# Test that best model data has at least 2 parameters
expect_true(ncol(test[[1]]$BestModelData) >= 2)
#Test the values we get out have stayed the same as github version (7-9-17).
#N.B. Earlier R version didn't have nlme compatability
expect_true(round(test[[1]]$Dataset$deltaAICc[1], 1) == -22.7)
expect_true(test[[1]]$Dataset$WindowOpen[1] == 2 & test[[1]]$Dataset$WindowClose[1] == 2)
expect_true(round(test[[1]]$Dataset$ModelBeta[1], 1) == 0.0)
rm("vI", envir = .GlobalEnv)
})
# Test mixed effects models (nlme) #
test_that("lme [nlme] model with VarExp can run in slidingwin", {
data(Offspring, envir = environment())
data(OffspringClimate, envir = environment())
assign("vE", varExp(form =~ Order), envir=globalenv())
test <- slidingwin(xvar = list(OffspringClimate$Temp), cdate = OffspringClimate$Date,
bdate = Offspring$Date,
baseline = lme(Offspring ~ Order, random = ~ 1 | BirdID, data = Offspring, weights = vE, method = "ML"),
range = c(2, 0), type = "relative",
stat = "max", func = "lin", cmissing = FALSE)
# Test that slidingwin produced an output
expect_true(is.list(test))
# Test that lmer model produced an intercept
expect_false(is.na(fixef(test[[1]]$BestModel)[1]))
# Test that lmer model produced a climate beta estimate
expect_false(is.na(fixef(test[[1]]$BestModel)[2]))
# Test that best model data doesn't contain NAs
expect_equal(length(which(is.na(test[[1]]$BestModelData))), 0)
# Test that best model data has at least 2 parameters
expect_true(ncol(test[[1]]$BestModelData) >= 2)
#Test the values we get out have stayed the same as github version (7-9-17).
#N.B. Earlier R version didn't have nlme compatability
expect_true(round(test[[1]]$Dataset$deltaAICc[1], 1) == -23.5)
expect_true(test[[1]]$Dataset$WindowOpen[1] == 2 & test[[1]]$Dataset$WindowClose[1] == 2)
expect_true(round(test[[1]]$Dataset$ModelBeta[1], 1) == 0.0)
rm("vE", envir = .GlobalEnv)
})
### TEST COXPH MODELS!!!!!!!!! STILL NEEDS TO BE DONE! ###
##########################################################
# Test absolute windows #
# Test absolute window #
test_that("absolute window works", {
data(Mass, envir = environment())
data(MassClimate, envir = environment())
test <- slidingwin(xvar = list(MassClimate$Temp), cdate = MassClimate$Date, bdate = Mass$Date,
baseline = lm(Mass ~ 1, data = Mass), range = c(2, 0),
type = "absolute", refday = c(20, 5),
stat = "max", func = "lin", cmissing=FALSE)
# Test that slidingwin has produced an output
expect_true(is.list(test))
# Test that a best model has been fitted
expect_false(is.na((test[[1]]$BestModel)[1]))
# Test there are no NAs in the best model data
expect_equal(length(which(is.na(test[[1]]$BestModelData))), 0)
# Test that the best model data has at least 2 parameters
expect_true(ncol(test[[1]]$BestModelData) >= 2)
#Test the values we get out have stayed the same as our last R version
expect_true(round(test[[1]]$Dataset$deltaAICc[1], 1) == -4.2)
expect_true(test[[1]]$Dataset$WindowOpen[1] == 2 & test[[1]]$Dataset$WindowClose[1] == 1)
expect_true(round(test[[1]]$Dataset$ModelBeta[1], 1) == -0.8)
})
##########################################################
# Test slope stat #
test_that("slope stat work", {
data(Mass, envir = environment())
data(MassClimate, envir = environment())
test <- slidingwin(xvar = list(MassClimate$Temp), cdate = MassClimate$Date, bdate = Mass$Date,
baseline = lm(Mass ~ 1, data = Mass), range = c(2, 0),
type = "relative", stat = "slope", func = "lin", cmissing=FALSE)
# Test that slidingwin produces an output
expect_true(is.list(test))
# Test that a best model is created
expect_false(is.na((test[[1]]$BestModel)[1]))
# Test there are no NAs in best model data
expect_equal(length(which(is.na(test[[1]]$BestModelData))), 0)
# Test that best model data has at least 2 parameters
expect_true(ncol(test[[1]]$BestModelData) >= 2)
#Test the values we get out have stayed the same as github (7-9-17)
#N.B. Don't use original R version because we have reversed the sign of slopes
expect_true(round(test[[1]]$Dataset$deltaAICc[1], 1) == -4.0)
expect_true(test[[1]]$Dataset$WindowOpen[1] == 2 & test[[1]]$Dataset$WindowClose[1] == 0)
expect_true(round(test[[1]]$Dataset$ModelBeta[1], 1) == -1.4)
})
# Test that slope and log stat cannot be used together #
test_that("slope and log return error", {
data(Mass, envir = environment())
data(MassClimate, envir = environment())
# Test that an error is produced
expect_error(slidingwin(xvar = list(MassClimate$Temp), cdate = MassClimate$Date,
bdate = Mass$Date, baseline = lm(Mass ~ 1, data = Mass),
range = c(2, 1), type = "relative", stat = "slope",
func = "log"))
})
# Test that slope and inverse cannot be used together #
test_that("slope and inv return error", {
data(Mass, envir = environment())
data(MassClimate, envir = environment())
# Test that an error is produced
expect_error(slidingwin(xvar = list(MassClimate$Temp), cdate = MassClimate$Date,
bdate = Mass$Date, baseline = lm(Mass ~ 1, data = Mass),
range = c(2, 1), type = "relative", stat = "slope",
func = "inv"))
})
##########################################################
# Test different functions for fitting climate #
# Test quadratic function #
test_that("Quadratic function works", {
data(Mass, envir = environment())
data(MassClimate, envir = environment())
test <- slidingwin(xvar = list(MassClimate$Temp), cdate = MassClimate$Date, bdate = Mass$Date,
baseline = lm(Mass ~ 1, data = Mass), range = c(2, 0),
type = "relative", stat = "max", func = "quad", cmissing=FALSE)
furthest = 2
closest = 0
duration <- (furthest - closest) + 1
maxmodno <- (duration * (duration + 1))/2
# Test that slidingwin produced an output
expect_true(is.list(test))
# Test that a best model was fitted
expect_false(is.na((test[[1]]$BestModel)[1]))
# Test that there are no NAs in the best model data
expect_equal(length(which(is.na(test[[1]]$BestModelData))), 0)
# Test that best model data has at least THREE parameters (i.e. linear and quadratic term)
expect_true(ncol(test[[1]]$BestModelData) >= 3)
# Test there are no NAs in the dataset
expect_equal(length(which(is.na(test[[1]]$Dataset[, 5]))), 0)
# Test that the quad function has been used
expect_true(test[[1]]$Dataset[1, 10] == "quad")
# Test that the dataset is atleast 17 columns (one extra column for quad SE)
expect_true(ncol(test[[1]]$Dataset) == 18)
# Test that the right number of models was fitted
expect_equal(maxmodno, nrow(test[[1]]$Dataset))
# Test that data is not randomised
expect_true((test[[1]]$Dataset["Randomised"])[1, ] == "no")
#Test the values we get out have stayed the same as our last R version
expect_true(round(test[[1]]$Dataset$deltaAICc[1], 1) == -1.0)
expect_true(test[[1]]$Dataset$WindowOpen[1] == 2 & test[[1]]$Dataset$WindowClose[1] == 2)
expect_true(round(test[[1]]$Dataset$ModelBeta[1], 1) == -2.8)
})
# Test cubic function #
test_that("Cubic function works", {
data(Mass, envir = environment())
data(MassClimate, envir = environment())
test <- slidingwin(xvar = list(MassClimate$Temp), cdate = MassClimate$Date, bdate = Mass$Date,
baseline = lm(Mass ~ 1, data = Mass), range = c(2, 0),
type = "relative", stat = "max", func = "cub", cmissing=FALSE)
furthest = 2
closest = 0
duration <- (furthest - closest) + 1
maxmodno <- (duration * (duration + 1))/2
# Test that slidingwin produced an output
expect_true(is.list(test))
# Test that a best model was fitted
expect_false(is.na((test[[1]]$BestModel)[1]))
# Test that there are no NAs in the best model data
expect_equal(length(which(is.na(test[[1]]$BestModelData))), 0)
# Test that best model data has at least FOUR parameters (i.e. linear, quadratic and cubic term)
expect_true(ncol(test[[1]]$BestModelData) >= 4)
# Test there are no NAs in the dataset
expect_equal(length(which(is.na(test[[1]]$Dataset[, 6]))), 0)
# Test that the cub function has been used
expect_true(test[[1]]$Dataset[1, 11] == "cub")
# Test that the dataset is atleast 18 columns (extra columns for quad and cub SE)
expect_true(ncol(test[[1]]$Dataset) == 19)
# Test that the right number of models was fitted
expect_equal(maxmodno, nrow(test[[1]]$Dataset))
# Test that data is not randomised
expect_true((test[[1]]$Dataset["Randomised"])[1, ] == "no")
#Test the values we get out have stayed the same as our last R version
expect_true(round(test[[1]]$Dataset$deltaAICc[1], 1) == 1.3)
expect_true(test[[1]]$Dataset$WindowOpen[1] == 2 & test[[1]]$Dataset$WindowClose[1] == 2)
expect_true(round(test[[1]]$Dataset$ModelBeta[1], 1) == 1.7)
})
# Test log function #
test_that("Log function works", {
data(Mass, envir = environment())
data(MassClimate, envir = environment())
test <- slidingwin(xvar = list(MassClimate$Temp), cdate = MassClimate$Date, bdate = Mass$Date,
baseline = lm(Mass ~ 1, data = Mass), range = c(2, 0),
type = "relative", stat = "max", func = "log", cmissing=FALSE)
furthest = 2
closest = 0
duration <- (furthest - closest) + 1
maxmodno <- (duration * (duration + 1))/2
# Test that slidingwin produced an output
expect_true(is.list(test))
# Test that a best model was fitted
expect_false(is.na((test[[1]]$BestModel)[1]))
# Test that there are no NAs in the best model data
expect_equal(length(which(is.na(test[[1]]$BestModelData))), 0)
# Test that best model data has at least two parameters
expect_true(ncol(test[[1]]$BestModelData) >= 2)
# Test there are no NAs in the dataset
expect_equal(length(which(is.na(test[[1]]$Dataset[, 4]))), 0)
# Test that log function has been used
expect_true(test[[1]]$Dataset[1, 9] == "log")
# Test that the dataset is atleast 16 columns (no extra columns)
expect_true(ncol(test[[1]]$Dataset) == 17)
# Test that the right number of models was fitted
expect_equal(maxmodno, nrow(test[[1]]$Dataset))
# Test that data is not randomised
expect_true((test[[1]]$Dataset["Randomised"])[1, ] == "no")
#Test the values we get out have stayed the same as our last R version
expect_true(round(test[[1]]$Dataset$deltaAICc[1], 1) == -3.1)
expect_true(test[[1]]$Dataset$WindowOpen[1] == 2 & test[[1]]$Dataset$WindowClose[1] == 2)
expect_true(round(test[[1]]$Dataset$ModelBeta[1], 1) == -8.3)
})
# Test inverse function #
test_that("Inverse function works", {
data(Mass, envir = environment())
data(MassClimate, envir = environment())
test <- slidingwin(xvar = list(MassClimate$Temp), cdate = MassClimate$Date, bdate = Mass$Date,
baseline = lm(Mass ~ 1, data = Mass), range = c(2, 0),
type = "relative", stat = "max", func = "inv", cmissing=FALSE)
furthest = 2
closest = 0
duration <- (furthest - closest) + 1
maxmodno <- (duration * (duration + 1))/2
# Test that slidingwin produced an output
expect_true(is.list(test))
# Test that a best model was fitted
expect_false(is.na((test[[1]]$BestModel)[1]))
# Test that there are no NAs in the best model data
expect_equal(length(which(is.na(test[[1]]$BestModelData))), 0)
# Test that best model data has at least two parameters
expect_true(ncol(test[[1]]$BestModelData) >= 2)
# Test there are no NAs in the dataset
expect_equal(length(which(is.na(test[[1]]$Dataset[, 4]))), 0)
# Test that the inv function has been used
expect_true(test[[1]]$Dataset[1, 9] == "inv")
# Test that the dataset is atleast 16 columns (no extra columns)
expect_true(ncol(test[[1]]$Dataset) == 17)
# Test that the right number of models was fitted
expect_equal(maxmodno, nrow(test[[1]]$Dataset))
# Test that data is not randomised
expect_true((test[[1]]$Dataset["Randomised"])[1, ] == "no")
#Test the values we get out have stayed the same as our last R version
expect_true(round(test[[1]]$Dataset$deltaAICc[1], 1) == -3.1)
expect_true(test[[1]]$Dataset$WindowOpen[1] == 2 & test[[1]]$Dataset$WindowClose[1] == 2)
expect_true(round(test[[1]]$Dataset$ModelBeta[1], 1) == 88.7)
})
##########################################################
# Test different cinterval values #
# Test cinterval = week #
test_that("Weekly interval works", {
data(Mass, envir = environment())
data(MassClimate, envir = environment())
test <- slidingwin(xvar = list(MassClimate$Temp), cdate = MassClimate$Date, bdate = Mass$Date,
baseline = lm(Mass ~ 1, data = Mass), range = c(2, 0),
type = "relative", stat = "max", func = "lin",
cmissing=FALSE, cinterval = "week")
# Test that slidingwin produced an output
expect_true(is.list(test))
# Test that a best model was fitted
expect_false(is.na((test[[1]]$BestModel)[1]))
# Test that there are no NAs in the best model data
expect_equal(length(which(is.na(test[[1]]$BestModelData))), 0)
# Test that best model data has at least two parameters
expect_true(ncol(test[[1]]$BestModelData) >= 2)
#Test the values we get stay the same as github version (7-9-17).
#N.B. We don't use the old R version because we have changed how we calculate weeks (i.e. use lubridate::week rather than dividing by 7)
expect_true(round(test[[1]]$Dataset$deltaAICc[1], 1) == 0.1)
expect_true(test[[1]]$Dataset$WindowOpen[1] == 1 & test[[1]]$Dataset$WindowClose[1] == 1)
expect_true(round(test[[1]]$Dataset$ModelBeta[1], 1) == -0.7)
})
# Test cinterval = month #
test_that("Monthly interval works", {
data(Mass, envir = environment())
data(MassClimate, envir = environment())
test <- slidingwin(xvar = list(MassClimate$Temp), cdate = MassClimate$Date, bdate = Mass$Date,
baseline = lm(Mass ~ 1, data = Mass), range = c(2, 0),
type = "relative", stat = "max", func = "lin",
cmissing=FALSE, cinterval = "month")
# Test that slidingwin produced an output
expect_true(is.list(test))
# Test that a best model was fitted
expect_false(is.na((test[[1]]$BestModel)[1]))
# Test that there are no NAs in the best model data
expect_equal(length(which(is.na(test[[1]]$BestModelData))), 0)
# Test that best model data has at least two parameters
expect_true(ncol(test[[1]]$BestModelData) >= 2)
#Test the values we get stay the same as github version (7-9-17).
#N.B. We don't use the old R version because we have changed how we calculate month
expect_true(round(test[[1]]$Dataset$deltaAICc[1], 1) == -8.3)
expect_true(test[[1]]$Dataset$WindowOpen[1] == 2 & test[[1]]$Dataset$WindowClose[1] == 2)
expect_true(round(test[[1]]$Dataset$ModelBeta[1], 1) == -1.8)
})
################################################################
# Error when you have NAs in the biological data #
test_that("slidingwin gives error when NAs are present in biological data", {
data(MassClimate, envir = environment())
Mass <- data.frame(Date = c("01/01/2014", "01/02/2014"), Mass = c(NA, 1))
# Test that an error occurs #
expect_error(slidingwin(xvar = list(MassClimate$Temp), cdate = MassClimate$Date, bdate = Mass$Date,
baseline = lm(Mass ~ 1, data = Mass), range = c(2, 2),
type = "relative", stat = "max", func = "lin",
cmissing = FALSE, cinterval = "day"))
})
################################################################
# Test that cross validation works #
test_that("Does cross validation work?", {
data(Mass, envir = environment())
data(MassClimate, envir = environment())
test <- slidingwin(xvar = list(MassClimate$Temp), cdate = MassClimate$Date, bdate = Mass$Date,
baseline = lm(Mass ~ 1, data = Mass), range = c(2, 0),
type = "relative", stat = "max", func = "lin",
cmissing = FALSE, cinterval = "day", k = 2)
# Test that slidingwin produced an output
expect_true(is.list(test))
# Test that a best model was fitted
expect_false(is.na((test[[1]]$BestModel)[1]))
# Test that there are no NAs in the best model data
expect_equal(length(which(is.na(test[[1]]$BestModelData))), 0)
# Test that best model data has at least two parameters
expect_true(ncol(test[[1]]$BestModelData) >= 2)
# Test that values of k are documented in the dataset
expect_equal(test[[1]]$Dataset$K[1], 2)
})
################################################################
# Test mean centring #
# Test centring with both wgmean and wgdev used #
test_that("Mean centring is functioning", {
data(Offspring, envir = environment())
data(OffspringClimate, envir = environment())
Offspring$Year <- lubridate::year(as.Date(Offspring$Date, format = "%d/%m/%Y"))
test <- slidingwin(xvar = list(OffspringClimate$Temp), cdate = OffspringClimate$Date,
bdate = Offspring$Date, baseline = lm(Offspring ~ 1, data = Offspring), range = c(2, 0),
type = "relative", stat = "max", func = "lin",
cmissing = FALSE, cinterval = "day", centre = list(Offspring$Year, "both"))
# Test that slidingwin produced an output
expect_true(is.list(test))
# Test that a best model was fitted
expect_false(is.na((test[[1]]$BestModel)[1]))
# Test that there are no NAs in the best model data
expect_equal(length(which(is.na(test[[1]]$BestModelData))), 0)
# Test that best model data has at least THREE parameters (i.e. wgdev, wgmean and climate)
expect_true(ncol(test[[1]]$BestModelData) >= 3)
# Test that there are no NAs in wgmean
expect_equal(length(which(is.na(test[[1]]$Dataset[, 4]))), 0)
# Test that there are no NAs in wgdev
expect_equal(length(which(is.na(test[[1]]$Dataset[, 6]))), 0)
# Test that there are 16 columns in the dataset
expect_true(ncol(test[[1]]$Dataset) == 17)
# Test that dataset is not randomised
expect_true((test[[1]]$Dataset["Randomised"])[1, ] == "no")
#Test the values we get out have stayed the same as our last R version
expect_true(round(test[[1]]$Dataset$deltaAICc[1], 1) == -39.0)
expect_true(test[[1]]$Dataset$WindowOpen[1] == 2 & test[[1]]$Dataset$WindowClose[1] == 2)
expect_true(round(test[[1]]$Dataset$WithinGrpMean[1], 1) == 0.0)
expect_true(round(test[[1]]$Dataset$WithinGrpDev[1], 1) == 0.0)
})
# Test centring with only wgmean #
test_that("Mean centring is functioning with only wgmeans", {
data(Offspring, envir = environment())
data(OffspringClimate, envir = environment())
Offspring$Year <- lubridate::year(as.Date(Offspring$Date, format = "%d/%m/%Y"))
test <- slidingwin(xvar = list(OffspringClimate$Temp), cdate = OffspringClimate$Date,
bdate = Offspring$Date, baseline = lm(Offspring ~ 1, data = Offspring), range = c(2, 0),
type = "relative", stat = "max", func = "lin",
cmissing = FALSE, cinterval = "day", centre = list(Offspring$Year, "mean"))
# Test that slidingwin produced an output
expect_true(is.list(test))
# Test that a best model was fitted
expect_false(is.na((test[[1]]$BestModel)[1]))
# Test that there are no NAs in the best model data
expect_equal(length(which(is.na(test[[1]]$BestModelData))), 0)
# Test that best model data has at least two parameters (i.e. wgmean and climate)
expect_true(ncol(test[[1]]$BestModelData) >= 2)
# Test that there are no NAs in wgmean
expect_equal(length(which(is.na(test[[1]]$Dataset[, 4]))), 0)
# Test that there are no NAs in wgdev
expect_equal(length(which(is.na(test[[1]]$Dataset[, 6]))), 0)
# Test that there are 14 columns in the dataset (remove wgdev and SE)
expect_true(ncol(test[[1]]$Dataset) == 15)
# Test that dataset is not randomised
expect_true((test[[1]]$Dataset["Randomised"])[1, ] == "no")
#Test the values we get out have stayed the same as our last R version
expect_true(round(test[[1]]$Dataset$deltaAICc[1], 1) == -2.8)
expect_true(test[[1]]$Dataset$WindowOpen[1] == 2 & test[[1]]$Dataset$WindowClose[1] == 2)
expect_true(round(test[[1]]$Dataset$WithinGrpMean[1], 1) == 0.0)
})
# Test centring with only wgdev #
test_that("Mean centring is functioning with only wgdev", {
data(Offspring, envir = environment())
data(OffspringClimate, envir = environment())
Offspring$Year <- lubridate::year(as.Date(Offspring$Date, format = "%d/%m/%Y"))
test <- slidingwin(xvar = list(OffspringClimate$Temp), cdate = OffspringClimate$Date,
bdate = Offspring$Date, baseline = lm(Offspring ~ 1, data = Offspring), range = c(2, 0),
type = "relative", stat = "max", func = "lin",
cmissing = FALSE, cinterval = "day", centre = list(Offspring$Year, "dev"))
# Test that slidingwin produced an output
expect_true(is.list(test))
# Test that a best model was fitted
expect_false(is.na((test[[1]]$BestModel)[1]))
# Test that there are no NAs in the best model data
expect_equal(length(which(is.na(test[[1]]$BestModelData))), 0)
# Test that best model data has at least two parameters (i.e. wgdev and climate)
expect_true(ncol(test[[1]]$BestModelData) >= 2)
# Test that there are no NAs in wgmean
expect_equal(length(which(is.na(test[[1]]$Dataset[, 4]))), 0)
# Test that there are no NAs in wgdev
expect_equal(length(which(is.na(test[[1]]$Dataset[, 6]))), 0)
# Test that there are 14 columns in the dataset (remove wgmean and SE)
expect_true(ncol(test[[1]]$Dataset) == 15)
# Test that dataset is not randomised
expect_true((test[[1]]$Dataset["Randomised"])[1, ] == "no")
#Test the values we get out have stayed the same as our last R version
expect_true(round(test[[1]]$Dataset$deltaAICc[1], 1) == -36.1)
expect_true(test[[1]]$Dataset$WindowOpen[1] == 2 & test[[1]]$Dataset$WindowClose[1] == 2)
expect_true(round(test[[1]]$Dataset$WithinGrpDev[1], 1) == 1.3)
})
################################################################
# Test cohort parameter #
test_that("absolute window works with a cohort parameter", {
data(Mass, envir = environment())
Mass$Plot <- c(rep(c("A", "B"), 23), "A")
data(MassClimate, envir = environment())
test <- slidingwin(xvar = list(MassClimate$Temp), cdate = MassClimate$Date, bdate = Mass$Date,
baseline = lm(Mass ~ 1, data = Mass), range = c(2, 0),
type = "absolute", refday = c(20, 5),
stat = "max", func = "lin", cmissing = FALSE,
cohort = Mass$Plot)
# Test that slidingwin has produced an output
expect_true(is.list(test))
# Test that a best model has been fitted
expect_false(is.na((test[[1]]$BestModel)[1]))
# Test there are no NAs in the best model data
expect_equal(length(which(is.na(test[[1]]$BestModelData))), 0)
# Test that the best model data has at least 2 parameters
expect_true(ncol(test[[1]]$BestModelData) >= 2)
#Test the values we get out have stayed the same as our last R version
expect_true(round(test[[1]]$Dataset$deltaAICc[1], 1) == 2.3)
#expect_true(test[[1]]$Dataset$WindowOpen[1] == 1 & test[[1]]$Dataset$WindowClose[1] == 1)
#expect_true(round(test[[1]]$Dataset$ModelBeta[1], 1) == 1.6)
})
###############################################################
# Test spatial replication
test_that("spatial replication works in slidingwin", {
data(Mass, envir = environment())
Mass$Plot <- c(rep(c("A", "B"), 23), "A")
data(MassClimate, envir = environment())
MassClimate$Plot <- "A"
MassClimate2 <- MassClimate
MassClimate2$Plot <- "B"
Clim <- rbind(MassClimate, MassClimate2)
test <- slidingwin(xvar = list(Clim$Temp), cdate = Clim$Date, bdate = Mass$Date,
baseline = lm(Mass ~ 1, data = Mass), range = c(2, 0),
type = "absolute", refday = c(20, 5),
stat = "max", func = "lin", cmissing = FALSE,
spatial = list(Mass$Plot, Clim$Plot))
# Test that slidingwin has produced an output
expect_true(is.list(test))
# Test that a best model has been fitted
expect_false(is.na((test[[1]]$BestModel)[1]))
# Test there are no NAs in the best model data
expect_equal(length(which(is.na(test[[1]]$BestModelData))), 0)
# Test that the best model data has at least 2 parameters
expect_true(ncol(test[[1]]$BestModelData) >= 2)
#Test the values we get out have stayed the same as our last R version
expect_true(round(test[[1]]$Dataset$deltaAICc[1], 1) == -4.2)
expect_true(test[[1]]$Dataset$WindowOpen[1] == 2 & test[[1]]$Dataset$WindowClose[1] == 1)
expect_true(round(test[[1]]$Dataset$ModelBeta[1], 1) == -0.8)
})
test_that("spatial replication works in slidingwin with week", {
data(Mass, envir = environment())
Mass$Plot <- c(rep(c("A", "B"), 23), "A")
data(MassClimate, envir = environment())
MassClimate$Plot <- "A"
MassClimate2 <- MassClimate
MassClimate2$Plot <- "B"
Clim <- rbind(MassClimate, MassClimate2)
test <- slidingwin(xvar = list(Clim$Temp), cdate = Clim$Date, bdate = Mass$Date,
baseline = lm(Mass ~ 1, data = Mass), range = c(2, 0),
type = "absolute", refday = c(20, 5),
cinterval = "week",
stat = "max", func = "lin", cmissing=FALSE,
spatial = list(Mass$Plot, Clim$Plot))
# Test that slidingwin has produced an output
expect_true(is.list(test))
# Test that a best model has been fitted
expect_false(is.na((test[[1]]$BestModel)[1]))
# Test there are no NAs in the best model data
expect_equal(length(which(is.na(test[[1]]$BestModelData))), 0)
# Test that the best model data has at least 2 parameters
expect_true(ncol(test[[1]]$BestModelData) >= 2)
#Test the values we get out have stayed the same as github (7-9-17)
#Don't use old R because we changed how we estimate week slightly
expect_true(round(test[[1]]$Dataset$deltaAICc[1], 1) == -8)
expect_true(test[[1]]$Dataset$WindowOpen[1] == 2 & test[[1]]$Dataset$WindowClose[1] == 2)
expect_true(round(test[[1]]$Dataset$ModelBeta[1], 1) == -0.9)
})
test_that("spatial replication works in slidingwin with month", {
data(Mass, envir = environment())
Mass$Plot <- c(rep(c("A", "B"), 23), "A")
data(MassClimate, envir = environment())
MassClimate$Plot <- "A"
MassClimate2 <- MassClimate
MassClimate2$Plot <- "B"
Clim <- rbind(MassClimate, MassClimate2)
test <- slidingwin(xvar = list(Clim$Temp), cdate = Clim$Date, bdate = Mass$Date,
baseline = lm(Mass ~ 1, data = Mass), range = c(2, 0),
type = "absolute", refday = c(20, 5),
cinterval = "month",
stat = "max", func = "lin", cmissing=FALSE,
spatial = list(Mass$Plot, Clim$Plot))
# Test that slidingwin has produced an output
expect_true(is.list(test))
# Test that a best model has been fitted
expect_false(is.na((test[[1]]$BestModel)[1]))
# Test there are no NAs in the best model data
expect_equal(length(which(is.na(test[[1]]$BestModelData))), 0)
# Test that the best model data has at least 2 parameters
expect_true(ncol(test[[1]]$BestModelData) >= 2)
#Test the values we get out have stayed the same as github (7-9-17)
#Don't use old R because we changed how we estimate month slightly
expect_true(round(test[[1]]$Dataset$deltaAICc[1], 1) == -32.5)
expect_true(test[[1]]$Dataset$WindowOpen[1] == 2 & test[[1]]$Dataset$WindowClose[1] == 1)
expect_true(round(test[[1]]$Dataset$ModelBeta[1], 1) == -3.2)
})
test_that("spatial replication works in slidingwin with upper", {
data(Mass, envir = environment())
Mass$Plot <- c(rep(c("A", "B"), 23), "A")
data(MassClimate, envir = environment())
MassClimate$Plot <- "A"
MassClimate2 <- MassClimate
MassClimate2$Plot <- "B"
Clim <- rbind(MassClimate, MassClimate2)
test <- slidingwin(xvar = list(Clim$Temp), cdate = Clim$Date, bdate = Mass$Date,
baseline = lm(Mass ~ 1, data = Mass), range = c(2, 0),
type = "absolute", refday = c(20, 5),
cinterval = "day", upper = 15,
stat = "max", func = "lin", cmissing=FALSE,
spatial = list(Mass$Plot, Clim$Plot))
# Test that slidingwin has produced an output
expect_true(is.list(test))
# Test that a best model has been fitted
expect_false(is.na((test[[1]]$BestModel)[1]))
# Test there are no NAs in the best model data
expect_equal(length(which(is.na(test[[1]]$BestModelData))), 0)
# Test that the best model data has at least 2 parameters
expect_true(ncol(test[[1]]$BestModelData) >= 2)
#Test the values we get out have stayed the same as our last R version
expect_true(round(test[[1]]$Dataset$deltaAICc[1], 1) == -0.0)
expect_true(test[[1]]$Dataset$WindowOpen[1] == 2 & test[[1]]$Dataset$WindowClose[1] == 0)
expect_true(round(test[[1]]$Dataset$ModelBeta[1], 1) == -0.2)
})
test_that("spatial replication with slidingwin returns an error with NAs and cmissing FALSE", {
data(Mass, envir = environment())
Mass$Plot <- c(rep(c("A", "B"), 23), "A")
data(MassClimate, envir = environment())
MassClimate$Plot <- "A"
MassClimate2 <- MassClimate
MassClimate2$Plot <- "B"
Clim <- rbind(MassClimate, MassClimate2)
Clim <- Clim[-which(Clim$Date == "20/05/1979"), ]
expect_error(slidingwin(xvar = list(Clim$Temp), cdate = Clim$Date, bdate = Mass$Date,
baseline = lm(Mass ~ 1, data = Mass), range = c(1, 0),
type = "absolute", refday = c(20, 5),
cinterval = "day",
stat = "max", func = "lin", cmissing = FALSE,
spatial = list(Mass$Plot, Clim$Plot)))
expect_true(exists("missing"))
rm("missing", envir = .GlobalEnv)
})
test_that("spatial replication works with slidingwin with NAs and cmissing method1", {
data(Mass, envir = environment())
Mass$Plot <- c(rep(c("A", "B"), 23), "A")
data(MassClimate, envir = environment())
MassClimate$Plot <- "A"
MassClimate2 <- MassClimate
MassClimate2$Plot <- "B"
Clim <- rbind(MassClimate, MassClimate2)
Clim <- Clim[-which(Clim$Date == "20/05/1979"), ]
test <- slidingwin(xvar = list(Clim$Temp), cdate = Clim$Date, bdate = Mass$Date,
baseline = lm(Mass ~ 1, data = Mass), range = c(2, 0),
type = "absolute", refday = c(20, 5),
cinterval = "day",
stat = "max", func = "lin", cmissing = "method1",
spatial = list(Mass$Plot, Clim$Plot))
# Test that slidingwin has produced an output
expect_true(is.list(test))
# Test that a best model has been fitted
expect_false(is.na((test[[1]]$BestModel)[1]))
# Test there are no NAs in the best model data
expect_equal(length(which(is.na(test[[1]]$BestModelData))), 0)
# Test that the best model data has at least 2 parameters
expect_true(ncol(test[[1]]$BestModelData) >= 2)
#Test the values we get out have stayed the same as our last R version
expect_true(round(test[[1]]$Dataset$deltaAICc[1], 1) == -4.2)
expect_true(test[[1]]$Dataset$WindowOpen[1] == 2 & test[[1]]$Dataset$WindowClose[1] == 1)
expect_true(round(test[[1]]$Dataset$ModelBeta[1], 1) == -0.8)
})
test_that("spatial replication works with slidingwin with NAs and cmissing method2", {
data(Mass, envir = environment())
Mass$Plot <- c(rep(c("A", "B"), 23), "A")
data(MassClimate, envir = environment())
MassClimate$Plot <- "A"
MassClimate2 <- MassClimate
MassClimate2$Plot <- "B"
Clim <- rbind(MassClimate, MassClimate2)
Clim <- Clim[-which(Clim$Date == "20/05/1979"), ]
test <- slidingwin(xvar = list(Clim$Temp), cdate = Clim$Date, bdate = Mass$Date,
baseline = lm(Mass ~ 1, data = Mass), range = c(2, 0),
type = "absolute", refday = c(20, 5),
cinterval = "day",
stat = "max", func = "lin", cmissing = "method2",
spatial = list(Mass$Plot, Clim$Plot))
# Test that slidingwin has produced an output
expect_true(is.list(test))
# Test that a best model has been fitted
expect_false(is.na((test[[1]]$BestModel)[1]))
# Test there are no NAs in the best model data
expect_equal(length(which(is.na(test[[1]]$BestModelData))), 0)
# Test that the best model data has at least 2 parameters
expect_true(ncol(test[[1]]$BestModelData) >= 2)
#Test the values we get out have stayed the same as our last R version
expect_true(round(test[[1]]$Dataset$deltaAICc[1], 1) == -4.2)
expect_true(test[[1]]$Dataset$WindowOpen[1] == 2 & test[[1]]$Dataset$WindowClose[1] == 1)
expect_true(round(test[[1]]$Dataset$ModelBeta[1], 1) == -0.8)
})
##################################################################
#Test that code works with climate in a monthly format
test_that("slidingwin produces the right output with monthly climate data", {
data(Mass, envir = environment())
data(Monthly_data, envir = environment())
furthest = 2
closest = 0
test <- slidingwin(xvar = list(Monthly_data$Temp), cdate = Monthly_data$Date, bdate = Mass$Date,
baseline = lm(Mass ~ 1, data = Mass), range = c(2, 0),
type = "relative", stat = "max", func = "lin", cmissing = FALSE,
cinterval = "month")
duration <- (furthest - closest) + 1
maxmodno <- (duration * (duration + 1))/2
# Test that a list has been produced
expect_true(is.list(test))
# Test that a best model was returned
expect_false(is.na((test[[1]]$BestModel)[1]))
# Test that there are no NAs in the best model data
expect_equal(length(which(is.na(test[[1]]$BestModelData))), 0)
# Test that the best model data has at least 2 columns
expect_true(ncol(test[[1]]$BestModelData) >= 2)
# Test that there are no NAs in the output dataset
expect_equal(length(which(is.na(test[[1]]$Dataset[, 4]))), 0)
# Test that all columns were created in the dataset
expect_true(ncol(test[[1]]$Dataset) == 17)
# Test that the correct number of models were recorded in the dataset
expect_equal(maxmodno, nrow(test[[1]]$Dataset))
# Test that data was not randomised
expect_true((test[[1]]$Dataset["Randomised"])[1, ] == "no")
#Test the values we get out have stayed the same as our last R version
expect_true(round(test[[1]]$Dataset$deltaAICc[1], 1) == -0.7)
expect_true(test[[1]]$Dataset$WindowOpen[1] == 2 & test[[1]]$Dataset$WindowClose[1] == 2)
expect_true(round(test[[1]]$Dataset$ModelBeta[1], 1) == -0.3)
})
##############################################################
#Test that code works with weighted linear model
test_that("slidingwin produces the right output when using weights in model", {
data("Offspring", envir = environment())
data("OffspringClimate", envir = environment())
furthest = 2
closest = 0
test <- slidingwin(xvar = list(OffspringClimate$Temp), cdate = OffspringClimate$Date, bdate = Offspring$Date,
baseline = lm(Offspring ~ 1, data = Offspring, weights = Order), range = c(2, 0),
type = "relative", stat = "max", func = "lin", cmissing = FALSE,
cinterval = "month")
duration <- (furthest - closest) + 1
maxmodno <- (duration * (duration + 1))/2
# Test that a list has been produced
expect_true(is.list(test))
# Test that a best model was returned
expect_false(is.na((test[[1]]$BestModel)[1]))
# Test that there are no NAs in the best model data
expect_equal(length(which(is.na(test[[1]]$BestModelData))), 0)
# Test that the best model data has at least 2 columns
expect_true(ncol(test[[1]]$BestModelData) >= 2)
# Test that there are no NAs in the output dataset
expect_equal(length(which(is.na(test[[1]]$Dataset[, 4]))), 0)
# Test that all columns were created in the dataset
expect_true(ncol(test[[1]]$Dataset) == 17)
# Test that the correct number of models were recorded in the dataset
expect_equal(maxmodno, nrow(test[[1]]$Dataset))
# Test that data was not randomised
expect_true((test[[1]]$Dataset["Randomised"])[1, ] == "no")
#Test the values we get out have stayed the same as our last R version
expect_true(round(test[[1]]$Dataset$deltaAICc[1], 1) == -88.6)
expect_true(test[[1]]$Dataset$WindowOpen[1] == 2 & test[[1]]$Dataset$WindowClose[1] == 2)
expect_true(round(test[[1]]$Dataset$ModelBeta[1], 1) == 0.1)
})
test_that("slidingwin produces the right output when using equal weights in model", {
data("Offspring", envir = environment())
data("OffspringClimate", envir = environment())
Offspring$weight <- 1
furthest = 2
closest = 0
test <- slidingwin(xvar = list(OffspringClimate$Temp), cdate = OffspringClimate$Date, bdate = Offspring$Date,
baseline = lm(Offspring ~ 1, data = Offspring, weights = weight), range = c(2, 0),
type = "relative", stat = "max", func = "lin", cmissing = FALSE,
cinterval = "month")
duration <- (furthest - closest) + 1
maxmodno <- (duration * (duration + 1))/2
# Test that a list has been produced
expect_true(is.list(test))
# Test that a best model was returned
expect_false(is.na((test[[1]]$BestModel)[1]))
# Test that there are no NAs in the best model data
expect_equal(length(which(is.na(test[[1]]$BestModelData))), 0)
# Test that the best model data has at least 2 columns
expect_true(ncol(test[[1]]$BestModelData) >= 2)
# Test that there are no NAs in the output dataset
expect_equal(length(which(is.na(test[[1]]$Dataset[, 4]))), 0)
# Test that all columns were created in the dataset
expect_true(ncol(test[[1]]$Dataset) == 17)
# Test that the correct number of models were recorded in the dataset
expect_equal(maxmodno, nrow(test[[1]]$Dataset))
# Test that data was not randomised
expect_true((test[[1]]$Dataset["Randomised"])[1, ] == "no")
#Test the values we get out have stayed the same as our last R version
expect_true(round(test[[1]]$Dataset$deltaAICc[1], 1) == -88.7)
expect_true(test[[1]]$Dataset$WindowOpen[1] == 2 & test[[1]]$Dataset$WindowClose[1] == 2)
expect_true(round(test[[1]]$Dataset$ModelBeta[1], 1) == 0.1)
})
##############################################################
#Test that code works when climate data reaches exactly to the refday (i.e. max(cdate) == max(bdate))
test_that("slidingwin works when cmax(cdate) == max(bdate)", {
data("Offspring", envir = environment())
data("OffspringClimate", envir = environment())
furthest = 2
closest = 0
test <- slidingwin(xvar = list(OffspringClimate$Temp), cdate = OffspringClimate$Date, bdate = Offspring$Date,
baseline = lm(Offspring ~ 1, data = Offspring, weights = Order), range = c(2, 0),
type = "absolute", refday = c(31, 01), stat = "max", func = "lin", cmissing = FALSE,
cinterval = "day")
duration <- (furthest - closest) + 1
maxmodno <- (duration * (duration + 1))/2
# Test that a list has been produced
expect_true(is.list(test))
# Test that a best model was returned
expect_false(is.na((test[[1]]$BestModel)[1]))
# Test that there are no NAs in the best model data
expect_equal(length(which(is.na(test[[1]]$BestModelData))), 0)
# Test that the best model data has at least 2 columns
expect_true(ncol(test[[1]]$BestModelData) >= 2)
# Test that there are no NAs in the output dataset
expect_equal(length(which(is.na(test[[1]]$Dataset[, 4]))), 0)
# Test that all columns were created in the dataset
expect_true(ncol(test[[1]]$Dataset) == 19)
# Test that the correct number of models were recorded in the dataset
expect_equal(maxmodno, nrow(test[[1]]$Dataset))
# Test that data was not randomised
expect_true((test[[1]]$Dataset["Randomised"])[1, ] == "no")
#Test the values we get out have stayed the same as our last R version
expect_true(round(test[[1]]$Dataset$deltaAICc[1], 1) == -12.7)
expect_true(test[[1]]$Dataset$WindowOpen[1] == 2 & test[[1]]$Dataset$WindowClose[1] == 2)
expect_true(round(test[[1]]$Dataset$ModelBeta[1], 1) == 0)
})
##############################################################
#Test that an error is returned if there are duplicate climate records but no spatial argument.
test_that("Duplicate climate data returns an error (without spatial)", {
data("Mass", envir = environment())
data("MassClimate", envir = environment())
MassClimate <- rbind(MassClimate, MassClimate)
expect_error(slidingwin(xvar = list(MassClimate$Temp), cdate = MassClimate$Date, bdate = Mass$Date,
baseline = lm(Mass ~ 1, data = Mass), range = c(2, 0),
type = "absolute", refday = c(31, 01), stat = "max", func = "lin", cmissing = FALSE,
cinterval = "day"))
})
Try the climwin package in your browser
Any scripts or data that you put into this service are public.
R Package Documentation
Browse R Packages
We want your feedback!
Note that we can't provide technical support on individual packages. You should contact the package authors for that.
Embedding an R snippet on your website
Add the following code to your website.
For more information on customizing the embed code, read Embedding Snippets.