CRAN Package Check Results for Package Causata

Last updated on 2020-04-09 09:48:04 CEST.

Flavor	Version	T_install	T_check	T_total	Status
r-devel-linux-x86_64-debian-clang	4.2-0	14.47	272.83	287.30	ERROR
r-devel-linux-x86_64-debian-gcc	4.2-0	11.88	203.23	215.11	ERROR
r-devel-linux-x86_64-fedora-clang	4.2-0			332.02	ERROR
r-devel-linux-x86_64-fedora-gcc	4.2-0			347.92	ERROR
r-devel-windows-ix86+x86_64	4.2-0	31.00	265.00	296.00	ERROR
r-devel-windows-ix86+x86_64-gcc8	4.2-0	30.00	255.00	285.00	ERROR
r-patched-linux-x86_64	4.2-0	13.97	260.47	274.44	ERROR
r-patched-osx-x86_64	4.2-0				ERROR
r-patched-solaris-x86	4.2-0			589.00	ERROR
r-release-linux-x86_64	4.2-0	11.57	239.68	251.25	NOTE
r-release-windows-ix86+x86_64	4.2-0	27.00	339.00	366.00	NOTE
r-release-osx-x86_64	4.2-0				NOTE
r-oldrel-windows-ix86+x86_64	4.2-0	25.00	341.00	366.00	NOTE
r-oldrel-osx-x86_64	4.2-0				NOTE

Check Details

Version: 4.2-0
Check: DESCRIPTION meta-information
Result: NOTE
Malformed Title field: should not end in a period.
Flavors: r-devel-linux-x86_64-debian-clang, r-devel-linux-x86_64-debian-gcc, r-devel-linux-x86_64-fedora-clang, r-devel-linux-x86_64-fedora-gcc, r-devel-windows-ix86+x86_64, r-devel-windows-ix86+x86_64-gcc8, r-patched-linux-x86_64, r-patched-osx-x86_64, r-patched-solaris-x86, r-release-linux-x86_64, r-release-windows-ix86+x86_64, r-release-osx-x86_64, r-oldrel-windows-ix86+x86_64, r-oldrel-osx-x86_64

Version: 4.2-0
Check: top-level files
Result: NOTE
Non-standard file/directory found at top level:
'integration_tests'
Flavors: r-devel-linux-x86_64-debian-clang, r-devel-linux-x86_64-debian-gcc, r-devel-linux-x86_64-fedora-clang, r-devel-linux-x86_64-fedora-gcc, r-patched-linux-x86_64, r-release-linux-x86_64

Version: 4.2-0
Check: R code for possible problems
Result: NOTE
    BinaryCut: no visible global function definition for 'quantile'
    CleanNaFromContinuousFunction: no visible global function definition
     for 'median'
    CleanNaFromContinuousFunction: no visible global function definition
     for 'na.omit'
    GetMetadata.Connect: no visible global function definition for
     'dbGetQuery'
    GetRawData.Connect: no visible global function definition for
     'dbGetQuery'
    Linearity: no visible global function definition for 'median'
    PredictivePowerCv: no visible global function definition for 'sd'
    ReadCausataCsv: no visible global function definition for 'read.csv'
    ToPmml.GlmnetModelDefinition: no visible global function definition for
     'coef'
    ToPmml.GlmnetModelDefinition: no visible global function definition for
     'terms.formula'
    ValidateModel: no visible global function definition for 'predict'
    predict.GlmnetModelDefinition: no visible global function definition
     for 'model.matrix'
    predict.GlmnetModelDefinition: no visible binding for global variable
     'contrasts'
    predict.GlmnetModelDefinition: no visible global function definition
     for 'predict'
    Undefined global functions or variables:
     coef contrasts dbGetQuery median model.matrix na.omit predict
     quantile read.csv sd terms.formula
    Consider adding
     importFrom("stats", "coef", "contrasts", "median", "model.matrix",
     "na.omit", "predict", "quantile", "sd", "terms.formula")
     importFrom("utils", "read.csv")
    to your NAMESPACE file.
Flavors: r-devel-linux-x86_64-debian-clang, r-devel-linux-x86_64-debian-gcc, r-devel-linux-x86_64-fedora-clang, r-devel-linux-x86_64-fedora-gcc, r-devel-windows-ix86+x86_64, r-devel-windows-ix86+x86_64-gcc8, r-patched-linux-x86_64, r-patched-osx-x86_64, r-patched-solaris-x86, r-release-linux-x86_64, r-release-windows-ix86+x86_64, r-release-osx-x86_64, r-oldrel-windows-ix86+x86_64, r-oldrel-osx-x86_64

Version: 4.2-0
Check: tests
Result: ERROR
     Running 'testBinaryCut.R' [4s/5s]
     Running 'testBinaryPredictor.R' [5s/6s]
     Running 'testCleanNaFromContinuous.R' [4s/5s]
     Running 'testCleanNaFromFactor.R' [4s/5s]
     Running 'testDiscretize.R' [4s/6s]
     Running 'testFocalPointQuery.R' [4s/6s]
     Running 'testGetStratifiedSample.R' [4s/6s]
     Running 'testMergeLevels.R' [5s/5s]
     Running 'testModelDefinition.R' [5s/6s]
     Running 'testPredictivePower.R' [4s/5s]
     Running 'testPreprocess.R' [4s/5s]
     Running 'testQuery.R' [4s/5s]
     Running 'testQueryFunctions.R' [4s/5s]
     Running 'testReliableModelCreation.R' [4s/5s]
     Running 'testReliableVariableCreation.R' [4s/5s]
     Running 'testToPmml.R' [7s/8s]
     Running 'testTransformationReplay.R' [4s/5s]
     Running 'testUploadGlmnetModel.R' [5s/5s]
     Running 'testWoe.R' [4s/5s]
     Running 'utils.R' [0s/1s]
    Running the tests in 'tests/testTransformationReplay.R' failed.
    Complete output:
     > # Test variable transformation replay
     > # Author: David Barker
     > ###############################################################################
     > library(testthat)
     > library(Causata)
     >
     > source("utils.R")
     > equals <- testthat::equals
     >
     > context("TransformationReplay")
     >
     > test_that("Applying MergeLevels can be replayed", {
     + max.levels <- 3
     +
     + df <- data.frame(var__AP=c("a", "a", "a", "b", "b", "c", "d", "e", NA))
     + cdata <- CausataData(df, rep(0,nrow(df)))
     + cdata <- MergeLevels(cdata, max.levels=max.levels)
     + transformer <- GetTransforms(cdata)
     +
     + # First, let's be sure that the merging has done what we expect.
     + #expect_that(cdata$df$var__AP, is_identical_to(factor(c("a", "a", "a", "b", "b", "Other", "Other", "Other", NA))))
     + f1 <- cdata$df$var__AP
     + f2 <- factor(c("a", "a", "a", "b", "b", "Other", "Other", "Other", NA))
     + expect_that(f1, is_equivalent_to(f2))
     +
     + # Now, create a new data.frame and apply the same transformation to it. Any values in the factor we have
     + # that is not "a", or "b" should be replaced with "Other"
     + #
     + new.df <- data.frame(var__AP=c("a", "b", "c", "c", "c", "d", "a", NA))
     + transformed <- transformer(new.df)
     + expect_that(transformed$var__AP, is_equivalent_to(factor(c("a", "b", "Other", "Other", "Other", "Other", "a", NA))))
     + })
     Error: Test failed: 'Applying MergeLevels can be replayed'
     * `x` not equivalent to `expected`.
     Types not compatible: character is not integer
     * `x` not equivalent to `expected`.
     Types not compatible: character is not integer
     Execution halted
Flavor: r-devel-linux-x86_64-debian-clang

Version: 4.2-0
Check: tests
Result: ERROR
     Running ‘testBinaryCut.R’ [3s/5s]
     Running ‘testBinaryPredictor.R’ [4s/6s]
     Running ‘testCleanNaFromContinuous.R’ [3s/5s]
     Running ‘testCleanNaFromFactor.R’ [3s/5s]
     Running ‘testDiscretize.R’ [3s/5s]
     Running ‘testFocalPointQuery.R’ [3s/6s]
     Running ‘testGetStratifiedSample.R’ [3s/6s]
     Running ‘testMergeLevels.R’ [3s/6s]
     Running ‘testModelDefinition.R’ [3s/5s]
     Running ‘testPredictivePower.R’ [3s/5s]
     Running ‘testPreprocess.R’ [3s/5s]
     Running ‘testQuery.R’ [3s/6s]
     Running ‘testQueryFunctions.R’ [3s/6s]
     Running ‘testReliableModelCreation.R’ [3s/6s]
     Running ‘testReliableVariableCreation.R’ [3s/4s]
     Running ‘testToPmml.R’ [5s/8s]
     Running ‘testTransformationReplay.R’ [3s/6s]
     Running ‘testUploadGlmnetModel.R’ [3s/5s]
     Running ‘testWoe.R’ [3s/6s]
     Running ‘utils.R’ [0s/1s]
    Running the tests in ‘tests/testTransformationReplay.R’ failed.
    Complete output:
     > # Test variable transformation replay
     > # Author: David Barker
     > ###############################################################################
     > library(testthat)
     > library(Causata)
     >
     > source("utils.R")
     > equals <- testthat::equals
     >
     > context("TransformationReplay")
     >
     > test_that("Applying MergeLevels can be replayed", {
     + max.levels <- 3
     +
     + df <- data.frame(var__AP=c("a", "a", "a", "b", "b", "c", "d", "e", NA))
     + cdata <- CausataData(df, rep(0,nrow(df)))
     + cdata <- MergeLevels(cdata, max.levels=max.levels)
     + transformer <- GetTransforms(cdata)
     +
     + # First, let's be sure that the merging has done what we expect.
     + #expect_that(cdata$df$var__AP, is_identical_to(factor(c("a", "a", "a", "b", "b", "Other", "Other", "Other", NA))))
     + f1 <- cdata$df$var__AP
     + f2 <- factor(c("a", "a", "a", "b", "b", "Other", "Other", "Other", NA))
     + expect_that(f1, is_equivalent_to(f2))
     +
     + # Now, create a new data.frame and apply the same transformation to it. Any values in the factor we have
     + # that is not "a", or "b" should be replaced with "Other"
     + #
     + new.df <- data.frame(var__AP=c("a", "b", "c", "c", "c", "d", "a", NA))
     + transformed <- transformer(new.df)
     + expect_that(transformed$var__AP, is_equivalent_to(factor(c("a", "b", "Other", "Other", "Other", "Other", "a", NA))))
     + })
     Error: Test failed: 'Applying MergeLevels can be replayed'
     * `x` not equivalent to `expected`.
     Types not compatible: character is not integer
     * `x` not equivalent to `expected`.
     Types not compatible: character is not integer
     Execution halted
Flavor: r-devel-linux-x86_64-debian-gcc

Version: 4.2-0
Check: tests
Result: ERROR
     Running ‘testBinaryCut.R’
     Running ‘testBinaryPredictor.R’
     Running ‘testCleanNaFromContinuous.R’
     Running ‘testCleanNaFromFactor.R’
     Running ‘testDiscretize.R’
     Running ‘testFocalPointQuery.R’
     Running ‘testGetStratifiedSample.R’
     Running ‘testMergeLevels.R’
     Running ‘testModelDefinition.R’
     Running ‘testPredictivePower.R’
     Running ‘testPreprocess.R’
     Running ‘testQuery.R’
     Running ‘testQueryFunctions.R’
     Running ‘testReliableModelCreation.R’
     Running ‘testReliableVariableCreation.R’
     Running ‘testToPmml.R’ [8s/11s]
     Running ‘testTransformationReplay.R’
     Running ‘testUploadGlmnetModel.R’
     Running ‘testWoe.R’
     Running ‘utils.R’
    Running the tests in ‘tests/testTransformationReplay.R’ failed.
    Complete output:
     > # Test variable transformation replay
     > # Author: David Barker
     > ###############################################################################
     > library(testthat)
     > library(Causata)
     >
     > source("utils.R")
     > equals <- testthat::equals
     >
     > context("TransformationReplay")
     >
     > test_that("Applying MergeLevels can be replayed", {
     + max.levels <- 3
     +
     + df <- data.frame(var__AP=c("a", "a", "a", "b", "b", "c", "d", "e", NA))
     + cdata <- CausataData(df, rep(0,nrow(df)))
     + cdata <- MergeLevels(cdata, max.levels=max.levels)
     + transformer <- GetTransforms(cdata)
     +
     + # First, let's be sure that the merging has done what we expect.
     + #expect_that(cdata$df$var__AP, is_identical_to(factor(c("a", "a", "a", "b", "b", "Other", "Other", "Other", NA))))
     + f1 <- cdata$df$var__AP
     + f2 <- factor(c("a", "a", "a", "b", "b", "Other", "Other", "Other", NA))
     + expect_that(f1, is_equivalent_to(f2))
     +
     + # Now, create a new data.frame and apply the same transformation to it. Any values in the factor we have
     + # that is not "a", or "b" should be replaced with "Other"
     + #
     + new.df <- data.frame(var__AP=c("a", "b", "c", "c", "c", "d", "a", NA))
     + transformed <- transformer(new.df)
     + expect_that(transformed$var__AP, is_equivalent_to(factor(c("a", "b", "Other", "Other", "Other", "Other", "a", NA))))
     + })
     Error: Test failed: 'Applying MergeLevels can be replayed'
     * `x` not equivalent to `expected`.
     Types not compatible: character is not integer
     * `x` not equivalent to `expected`.
     Types not compatible: character is not integer
     Execution halted
Flavor: r-devel-linux-x86_64-fedora-clang

Version: 4.2-0
Check: tests
Result: ERROR
     Running ‘testBinaryCut.R’
     Running ‘testBinaryPredictor.R’
     Running ‘testCleanNaFromContinuous.R’
     Running ‘testCleanNaFromFactor.R’
     Running ‘testDiscretize.R’
     Running ‘testFocalPointQuery.R’
     Running ‘testGetStratifiedSample.R’
     Running ‘testMergeLevels.R’
     Running ‘testModelDefinition.R’
     Running ‘testPredictivePower.R’
     Running ‘testPreprocess.R’
     Running ‘testQuery.R’
     Running ‘testQueryFunctions.R’
     Running ‘testReliableModelCreation.R’
     Running ‘testReliableVariableCreation.R’
     Running ‘testToPmml.R’
     Running ‘testTransformationReplay.R’
     Running ‘testUploadGlmnetModel.R’
     Running ‘testWoe.R’
     Running ‘utils.R’
    Running the tests in ‘tests/testTransformationReplay.R’ failed.
    Complete output:
     > # Test variable transformation replay
     > # Author: David Barker
     > ###############################################################################
     > library(testthat)
     > library(Causata)
     >
     > source("utils.R")
     > equals <- testthat::equals
     >
     > context("TransformationReplay")
     >
     > test_that("Applying MergeLevels can be replayed", {
     + max.levels <- 3
     +
     + df <- data.frame(var__AP=c("a", "a", "a", "b", "b", "c", "d", "e", NA))
     + cdata <- CausataData(df, rep(0,nrow(df)))
     + cdata <- MergeLevels(cdata, max.levels=max.levels)
     + transformer <- GetTransforms(cdata)
     +
     + # First, let's be sure that the merging has done what we expect.
     + #expect_that(cdata$df$var__AP, is_identical_to(factor(c("a", "a", "a", "b", "b", "Other", "Other", "Other", NA))))
     + f1 <- cdata$df$var__AP
     + f2 <- factor(c("a", "a", "a", "b", "b", "Other", "Other", "Other", NA))
     + expect_that(f1, is_equivalent_to(f2))
     +
     + # Now, create a new data.frame and apply the same transformation to it. Any values in the factor we have
     + # that is not "a", or "b" should be replaced with "Other"
     + #
     + new.df <- data.frame(var__AP=c("a", "b", "c", "c", "c", "d", "a", NA))
     + transformed <- transformer(new.df)
     + expect_that(transformed$var__AP, is_equivalent_to(factor(c("a", "b", "Other", "Other", "Other", "Other", "a", NA))))
     + })
     Error: Test failed: 'Applying MergeLevels can be replayed'
     * `x` not equivalent to `expected`.
     Types not compatible: character is not integer
     * `x` not equivalent to `expected`.
     Types not compatible: character is not integer
     Execution halted
Flavor: r-devel-linux-x86_64-fedora-gcc

Version: 4.2-0
Check: package dependencies
Result: NOTE
Package suggested but not available for checking: 'doMC'
Flavors: r-devel-windows-ix86+x86_64, r-devel-windows-ix86+x86_64-gcc8, r-release-windows-ix86+x86_64, r-oldrel-windows-ix86+x86_64

Version: 4.2-0
Check: tests
Result: ERROR
     Running 'testBinaryCut.R' [4s]
     Running 'testBinaryPredictor.R' [4s]
     Running 'testCleanNaFromContinuous.R' [4s]
     Running 'testCleanNaFromFactor.R' [5s]
     Running 'testDiscretize.R' [4s]
     Running 'testFocalPointQuery.R' [5s]
     Running 'testGetStratifiedSample.R' [4s]
     Running 'testMergeLevels.R' [5s]
     Running 'testModelDefinition.R' [4s]
     Running 'testPredictivePower.R' [4s]
     Running 'testPreprocess.R' [4s]
     Running 'testQuery.R' [4s]
     Running 'testQueryFunctions.R' [4s]
     Running 'testReliableModelCreation.R' [4s]
     Running 'testReliableVariableCreation.R' [4s]
     Running 'testToPmml.R' [6s]
     Running 'testTransformationReplay.R' [3s]
     Running 'testUploadGlmnetModel.R' [4s]
     Running 'testWoe.R' [4s]
     Running 'utils.R' [0s]
    Running the tests in 'tests/testTransformationReplay.R' failed.
    Complete output:
     > # Test variable transformation replay
     > # Author: David Barker
     > ###############################################################################
     > library(testthat)
     > library(Causata)
     >
     > source("utils.R")
     > equals <- testthat::equals
     >
     > context("TransformationReplay")
     >
     > test_that("Applying MergeLevels can be replayed", {
     + max.levels <- 3
     +
     + df <- data.frame(var__AP=c("a", "a", "a", "b", "b", "c", "d", "e", NA))
     + cdata <- CausataData(df, rep(0,nrow(df)))
     + cdata <- MergeLevels(cdata, max.levels=max.levels)
     + transformer <- GetTransforms(cdata)
     +
     + # First, let's be sure that the merging has done what we expect.
     + #expect_that(cdata$df$var__AP, is_identical_to(factor(c("a", "a", "a", "b", "b", "Other", "Other", "Other", NA))))
     + f1 <- cdata$df$var__AP
     + f2 <- factor(c("a", "a", "a", "b", "b", "Other", "Other", "Other", NA))
     + expect_that(f1, is_equivalent_to(f2))
     +
     + # Now, create a new data.frame and apply the same transformation to it. Any values in the factor we have
     + # that is not "a", or "b" should be replaced with "Other"
     + #
     + new.df <- data.frame(var__AP=c("a", "b", "c", "c", "c", "d", "a", NA))
     + transformed <- transformer(new.df)
     + expect_that(transformed$var__AP, is_equivalent_to(factor(c("a", "b", "Other", "Other", "Other", "Other", "a", NA))))
     + })
     Error: Test failed: 'Applying MergeLevels can be replayed'
     * `x` not equivalent to `expected`.
     Types not compatible: character is not integer
     * `x` not equivalent to `expected`.
     Types not compatible: character is not integer
     Execution halted
Flavor: r-devel-windows-ix86+x86_64

Version: 4.2-0
Check: tests
Result: ERROR
     Running 'testBinaryCut.R' [5s]
     Running 'testBinaryPredictor.R' [4s]
     Running 'testCleanNaFromContinuous.R' [4s]
     Running 'testCleanNaFromFactor.R' [3s]
     Running 'testDiscretize.R' [3s]
     Running 'testFocalPointQuery.R' [3s]
     Running 'testGetStratifiedSample.R' [4s]
     Running 'testMergeLevels.R' [4s]
     Running 'testModelDefinition.R' [4s]
     Running 'testPredictivePower.R' [3s]
     Running 'testPreprocess.R' [4s]
     Running 'testQuery.R' [3s]
     Running 'testQueryFunctions.R' [4s]
     Running 'testReliableModelCreation.R' [4s]
     Running 'testReliableVariableCreation.R' [4s]
     Running 'testToPmml.R' [6s]
     Running 'testTransformationReplay.R' [3s]
     Running 'testUploadGlmnetModel.R' [4s]
     Running 'testWoe.R' [4s]
     Running 'utils.R' [0s]
    Running the tests in 'tests/testTransformationReplay.R' failed.
    Complete output:
     > # Test variable transformation replay
     > # Author: David Barker
     > ###############################################################################
     > library(testthat)
     > library(Causata)
     >
     > source("utils.R")
     > equals <- testthat::equals
     >
     > context("TransformationReplay")
     >
     > test_that("Applying MergeLevels can be replayed", {
     + max.levels <- 3
     +
     + df <- data.frame(var__AP=c("a", "a", "a", "b", "b", "c", "d", "e", NA))
     + cdata <- CausataData(df, rep(0,nrow(df)))
     + cdata <- MergeLevels(cdata, max.levels=max.levels)
     + transformer <- GetTransforms(cdata)
     +
     + # First, let's be sure that the merging has done what we expect.
     + #expect_that(cdata$df$var__AP, is_identical_to(factor(c("a", "a", "a", "b", "b", "Other", "Other", "Other", NA))))
     + f1 <- cdata$df$var__AP
     + f2 <- factor(c("a", "a", "a", "b", "b", "Other", "Other", "Other", NA))
     + expect_that(f1, is_equivalent_to(f2))
     +
     + # Now, create a new data.frame and apply the same transformation to it. Any values in the factor we have
     + # that is not "a", or "b" should be replaced with "Other"
     + #
     + new.df <- data.frame(var__AP=c("a", "b", "c", "c", "c", "d", "a", NA))
     + transformed <- transformer(new.df)
     + expect_that(transformed$var__AP, is_equivalent_to(factor(c("a", "b", "Other", "Other", "Other", "Other", "a", NA))))
     + })
     Error: Test failed: 'Applying MergeLevels can be replayed'
     * `x` not equivalent to `expected`.
     Types not compatible: character is not integer
     * `x` not equivalent to `expected`.
     Types not compatible: character is not integer
     Execution halted
Flavor: r-devel-windows-ix86+x86_64-gcc8

Version: 4.2-0
Check: tests
Result: ERROR
     Running ‘testBinaryCut.R’ [4s/5s]
     Running ‘testBinaryPredictor.R’ [5s/6s]
     Running ‘testCleanNaFromContinuous.R’ [4s/5s]
     Running ‘testCleanNaFromFactor.R’ [4s/5s]
     Running ‘testDiscretize.R’ [4s/5s]
     Running ‘testFocalPointQuery.R’ [4s/5s]
     Running ‘testGetStratifiedSample.R’ [4s/5s]
     Running ‘testMergeLevels.R’ [4s/5s]
     Running ‘testModelDefinition.R’ [4s/5s]
     Running ‘testPredictivePower.R’ [4s/5s]
     Running ‘testPreprocess.R’ [4s/5s]
     Running ‘testQuery.R’ [4s/5s]
     Running ‘testQueryFunctions.R’ [4s/5s]
     Running ‘testReliableModelCreation.R’ [4s/5s]
     Running ‘testReliableVariableCreation.R’ [4s/5s]
     Running ‘testToPmml.R’ [6s/7s]
     Running ‘testTransformationReplay.R’ [4s/5s]
     Running ‘testUploadGlmnetModel.R’ [4s/5s]
     Running ‘testWoe.R’ [4s/5s]
     Running ‘utils.R’ [0s/1s]
    Running the tests in ‘tests/testTransformationReplay.R’ failed.
    Complete output:
     > # Test variable transformation replay
     > # Author: David Barker
     > ###############################################################################
     > library(testthat)
     > library(Causata)
     >
     > source("utils.R")
     > equals <- testthat::equals
     >
     > context("TransformationReplay")
     >
     > test_that("Applying MergeLevels can be replayed", {
     + max.levels <- 3
     +
     + df <- data.frame(var__AP=c("a", "a", "a", "b", "b", "c", "d", "e", NA))
     + cdata <- CausataData(df, rep(0,nrow(df)))
     + cdata <- MergeLevels(cdata, max.levels=max.levels)
     + transformer <- GetTransforms(cdata)
     +
     + # First, let's be sure that the merging has done what we expect.
     + #expect_that(cdata$df$var__AP, is_identical_to(factor(c("a", "a", "a", "b", "b", "Other", "Other", "Other", NA))))
     + f1 <- cdata$df$var__AP
     + f2 <- factor(c("a", "a", "a", "b", "b", "Other", "Other", "Other", NA))
     + expect_that(f1, is_equivalent_to(f2))
     +
     + # Now, create a new data.frame and apply the same transformation to it. Any values in the factor we have
     + # that is not "a", or "b" should be replaced with "Other"
     + #
     + new.df <- data.frame(var__AP=c("a", "b", "c", "c", "c", "d", "a", NA))
     + transformed <- transformer(new.df)
     + expect_that(transformed$var__AP, is_equivalent_to(factor(c("a", "b", "Other", "Other", "Other", "Other", "a", NA))))
     + })
     Error: Test failed: 'Applying MergeLevels can be replayed'
     * `x` not equivalent to `expected`.
     Types not compatible: character is not integer
     * `x` not equivalent to `expected`.
     Types not compatible: character is not integer
     Execution halted
Flavor: r-patched-linux-x86_64

Version: 4.2-0
Check: tests
Result: ERROR
     Running ‘testBinaryCut.R’ [3s/4s]
     Running ‘testBinaryPredictor.R’ [3s/4s]
     Running ‘testCleanNaFromContinuous.R’ [3s/4s]
     Running ‘testCleanNaFromFactor.R’ [3s/4s]
     Running ‘testDiscretize.R’ [3s/4s]
     Running ‘testFocalPointQuery.R’ [3s/3s]
     Running ‘testGetStratifiedSample.R’ [3s/4s]
     Running ‘testMergeLevels.R’ [3s/4s]
     Running ‘testModelDefinition.R’ [3s/4s]
     Running ‘testPredictivePower.R’ [2s/3s]
     Running ‘testPreprocess.R’ [2s/3s]
     Running ‘testQuery.R’ [2s/3s]
     Running ‘testQueryFunctions.R’ [3s/4s]
     Running ‘testReliableModelCreation.R’ [3s/4s]
     Running ‘testReliableVariableCreation.R’ [3s/4s]
     Running ‘testToPmml.R’ [4s/6s]
     Running ‘testTransformationReplay.R’ [3s/3s]
    Running the tests in ‘tests/testTransformationReplay.R’ failed.
    Last 13 lines of output:
     + expect_that(f1, is_equivalent_to(f2))
     +
     + # Now, create a new data.frame and apply the same transformation to it. Any values in the factor we have
     + # that is not "a", or "b" should be replaced with "Other"
     + #
     + new.df <- data.frame(var__AP=c("a", "b", "c", "c", "c", "d", "a", NA))
     + transformed <- transformer(new.df)
     + expect_that(transformed$var__AP, is_equivalent_to(factor(c("a", "b", "Other", "Other", "Other", "Other", "a", NA))))
     + })
     Error: Test failed: 'Applying MergeLevels can be replayed'
     * `x` not equivalent to `expected`.
     Types not compatible: character is not integer
     * `x` not equivalent to `expected`.
     Types not compatible: character is not integer
     Execution halted
Flavor: r-patched-osx-x86_64

Version: 4.2-0
Check: tests
Result: ERROR
     Running ‘testBinaryCut.R’
     Running ‘testBinaryPredictor.R’
     Running ‘testCleanNaFromContinuous.R’
     Running ‘testCleanNaFromFactor.R’
     Running ‘testDiscretize.R’
     Running ‘testFocalPointQuery.R’
     Running ‘testGetStratifiedSample.R’
     Running ‘testMergeLevels.R’
     Running ‘testModelDefinition.R’
     Running ‘testPredictivePower.R’
     Running ‘testPreprocess.R’
     Running ‘testQuery.R’
     Running ‘testQueryFunctions.R’
     Running ‘testReliableModelCreation.R’
     Running ‘testReliableVariableCreation.R’
     Running ‘testToPmml.R’ [13s/18s]
     Running ‘testTransformationReplay.R’
     Running ‘testUploadGlmnetModel.R’
     Running ‘testWoe.R’
     Running ‘utils.R’
    Running the tests in ‘tests/testTransformationReplay.R’ failed.
    Complete output:
     > # Test variable transformation replay
     > # Author: David Barker
     > ###############################################################################
     > library(testthat)
     > library(Causata)
     >
     > source("utils.R")
     > equals <- testthat::equals
     >
     > context("TransformationReplay")
     >
     > test_that("Applying MergeLevels can be replayed", {
     + max.levels <- 3
     +
     + df <- data.frame(var__AP=c("a", "a", "a", "b", "b", "c", "d", "e", NA))
     + cdata <- CausataData(df, rep(0,nrow(df)))
     + cdata <- MergeLevels(cdata, max.levels=max.levels)
     + transformer <- GetTransforms(cdata)
     +
     + # First, let's be sure that the merging has done what we expect.
     + #expect_that(cdata$df$var__AP, is_identical_to(factor(c("a", "a", "a", "b", "b", "Other", "Other", "Other", NA))))
     + f1 <- cdata$df$var__AP
     + f2 <- factor(c("a", "a", "a", "b", "b", "Other", "Other", "Other", NA))
     + expect_that(f1, is_equivalent_to(f2))
     +
     + # Now, create a new data.frame and apply the same transformation to it. Any values in the factor we have
     + # that is not "a", or "b" should be replaced with "Other"
     + #
     + new.df <- data.frame(var__AP=c("a", "b", "c", "c", "c", "d", "a", NA))
     + transformed <- transformer(new.df)
     + expect_that(transformed$var__AP, is_equivalent_to(factor(c("a", "b", "Other", "Other", "Other", "Other", "a", NA))))
     + })
     Error: Test failed: 'Applying MergeLevels can be replayed'
     * `x` not equivalent to `expected`.
     Types not compatible: character is not integer
     * `x` not equivalent to `expected`.
     Types not compatible: character is not integer
     Execution halted
Flavor: r-patched-solaris-x86