From 8959a15d2236df5742025f6bf7949ee5688d77c0 Mon Sep 17 00:00:00 2001 From: Justin Yap Date: Wed, 5 Nov 2025 11:16:08 +1100 Subject: [PATCH 1/6] Fix --- R/mergedatasetsbyvariable.R | 2 +- R/mergingandstackingutilities.R | 113 ++++++++++++++------------------ R/stacking.R | 17 +++-- 3 files changed, 58 insertions(+), 74 deletions(-) diff --git a/R/mergedatasetsbyvariable.R b/R/mergedatasetsbyvariable.R index 360996b..d2a1a5e 100644 --- a/R/mergedatasetsbyvariable.R +++ b/R/mergedatasetsbyvariable.R @@ -454,7 +454,7 @@ mergedDataSetVariableNames <- function(input.data.sets.metadata, for (i in seq_len(n.data.sets)) for (nm in included.variable.names.list[[i]]) merged.data.set.var.names <- c(merged.data.set.var.names, - uniqueName(nm, merged.data.set.var.names, delimiter = "_")) + makeValidNameForSpss(nm, merged.data.set.var.names, delimiter = "_")) merged.data.set.var.names <- sanitizeSPSSVariableNames(merged.data.set.var.names) attr(merged.data.set.var.names, "included.variable.names.list") <- included.variable.names.list attr(merged.data.set.var.names, "omitted.variable.names.list") <- omitted.var.names.list diff --git a/R/mergingandstackingutilities.R b/R/mergingandstackingutilities.R index 35ffcf6..95e6d52 100644 --- a/R/mergingandstackingutilities.R +++ b/R/mergingandstackingutilities.R @@ -517,6 +517,49 @@ uniqueName <- function(new.name, existing.names, delimiter = "") } } +makeValidNameForSpss <- function(input.name, existing.names, delimiter = "") +{ + name <- removeInvalidStartingCharacters(input.name) + name <- removeWhitespace(name) + + repeat { + previous.name <- name + name <- trimPeriods(name) + name <- defaultNameIfEmpty(name) + name <- replaceReservedKeywords(name) + name <- uniqueName(name, existing.names, delimiter) + if (name == previous.name) { + return(name) + } + } +} + +removeWhitespace <- function(name) +{ + gsub("\\s+", "", name) +} + +removeInvalidStartingCharacters <- function(name) +{ + gsub("^[^a-zA-Z@]+", "", name) +} + +trimPeriods <- function(name) +{ + gsub("^\\.+|\\.+$", "", name) +} + +defaultNameIfEmpty <- function(name) +{ + ifelse(name == "", "VAR", name) +} + +replaceReservedKeywords <- function(name) +{ + reserved.keywords <- c("ALL", "AND", "BY", "EQ", "GE", "GT", "LE", "LT", "NE", "NOT", "OR", "TO", "WITH") + ifelse(name %in% reserved.keywords, paste0(name, "_r"), name) +} + #' @description Return variable name matches to wildcard.text. Throw error if no matches #' found and error.if.not.found == TRUE. #' @param wildcard.text Character scalar of the wildcard pattern to match for. @@ -546,73 +589,15 @@ parseVariableWildcardForMerging <- function(wildcard.text, variable.names, } sanitizeSPSSVariableNames <- function(variable.names) { - variable.names <- trimPeriods(variable.names) - variable.names <- replaceReservedKeywords(variable.names) - variable.names <- truncateVariableNames(variable.names) - - # Extra call to trimPeriods in case truncateVariableNames - # results in trailling periods - variable.names <- trimPeriods(variable.names) - - variable.names <- deduplicateVariableNames(variable.names) - variable.names -} - -trimPeriods <- function(variable.names) -{ - # Can't begin with or end with a period - starts.or.ends.with.period <- startsWith(variable.names, ".") | endsWith(variable.names, ".") - if (any(starts.or.ends.with.period)) { - warning("Cannot save variables names which begin or end with '.'. Some variables have had '.' removed from their names: ", - paste0(variable.names[starts.or.ends.with.period], collapse = ", ")) - variable.names[starts.or.ends.with.period] <- gsub("^\\.+", "", gsub("\\.+$", "", variable.names[starts.or.ends.with.period])) - } - variable.names -} - -replaceReservedKeywords <- function(variable.names) -{ - # SPSS variable names can't be reserved keywords - reserved.keywords <- c("ALL", "AND", "BY", "EQ", "GE", "GT", "LE", "LT", "NE", "NOT", "OR", "TO", "WITH") - forbidden.keywords <- variable.names %in% reserved.keywords - if (any(forbidden.keywords)) { - warning("Cannot save variables whose names are SPSS reserved keywords. The following variables have had '_r' added to their names:", - paste0(variable.names[forbidden.keywords], collapse = ", ")) - variable.names[forbidden.keywords] <- paste0(variable.names[forbidden.keywords], "_r") + sanitized.names <- character(length(variable.names)) + for (i in seq_along(variable.names)) { + sanitized.names[i] <- makeValidNameForSpss(variable.names[i], + existing.names = sanitized.names[seq_len(i - 1)], + delimiter = "_") } - variable.names + sanitized.names } -truncateVariableNames <- function(variable.names) -{ - # SPSS variable names can't be longer than 64 bytes - bad.length <- nchar(variable.names, type = "bytes") > 64 - if (any(bad.length)) { - warning("Some variable names were too long and have been truncated: ", - paste0(variable.names[bad.length], collapse = ", ")) - variable.names[bad.length] <- vapply(variable.names[bad.length], - FUN = addSuffixFittingByteLimit, - FUN.VALUE = character(1)) - } - variable.names -} - -deduplicateVariableNames <- function(variable.names) -{ - # SPSS variable names must be unique - dupes <- duplicated(tolower(variable.names)) - if (any(dupes)) { - dupe.ind <- which(dupes) - for (i in dupe.ind) { - variable.names[i] <- uniqueName(variable.names[i], - existing.names = variable.names, - delimiter = "_") - } - } - variable.names -} - - addSuffixFittingByteLimit <- function(string, suffix = "", byte.limit = 64) { new.string <- paste0(string, suffix) size <- nchar(new.string, type = "bytes") diff --git a/R/stacking.R b/R/stacking.R index 8db387d..251c4f5 100644 --- a/R/stacking.R +++ b/R/stacking.R @@ -1126,7 +1126,7 @@ stackedDataSet <- function(input.data.set, input.data.set.metadata, attr(v, "is.manually.stacked") <- is.manually.stacked[ind] attr(v, "stacking.input.variable.names") <- input.v.names[group.ind] attr(v, "stacking.input.variable.labels") <- input.v.labels[group.ind] - attr(v, "label") <- stackedVariableLabel(group.ind, input.v.labels, nm) + attr(v, "label") <- stackedVariableLabel(group.ind, input.v.labels) val.attr <- stackedValueAttributes(group.ind, input.data.set.metadata$variable.value.attributes) if (!is.null(val.attr)) @@ -1167,7 +1167,7 @@ stackedDataSet <- function(input.data.set, input.data.set.metadata, attr(v, "labels") <- val.attr class(v) <- c(class(v), "haven_labelled") } - nm <- uniqueName(input.v.names[i], names(stacked.data.set)) + nm <- makeValidNameForSpss(input.v.names[i], names(stacked.data.set)) stacked.data.set[[nm]] <- v } } @@ -1179,8 +1179,8 @@ stackedDataSet <- function(input.data.set, input.data.set.metadata, attr(original.case, "is.stacked") <- FALSE attr(original.case, "is.manually.stacked") <- NA attr(original.case, "is.original.case") <- TRUE - stacked.data.set[[uniqueName("original_case", - names(stacked.data.set))]] <- original.case + nm <- makeValidNameForSpss("original_case", names(stacked.data.set)) + stacked.data.set[[nm]] <- original.case } if (include.observation.variable && has.stacking) @@ -1199,9 +1199,8 @@ stackedDataSet <- function(input.data.set, input.data.set.metadata, attr(observation, "is.stacked") <- FALSE attr(observation, "is.manually.stacked") <- NA attr(observation, "is.observation") <- TRUE - - stacked.data.set[[uniqueName("observation", - names(stacked.data.set))]] <- observation + nm <- makeValidNameForSpss("observation", names(stacked.data.set)) + stacked.data.set[[nm]] <- observation } stacked.data.set <- data.frame(stacked.data.set, check.names = FALSE) @@ -1219,10 +1218,10 @@ stackedVariableName <- function(group.ind, input.variable.names, taken.names) if (candidate == "") candidate <- "stacked_var" - uniqueName(candidate, taken.names, "_") + makeValidNameForSpss(candidate, taken.names, "_") } -stackedVariableLabel <- function(group.ind, input.variable.labels, stacked.variable.name) +stackedVariableLabel <- function(group.ind, input.variable.labels) { ind <- removeNA(group.ind) lbl <- input.variable.labels[ind] From ef44a887b26840afd6bc68fa00a2b1e799ea035d Mon Sep 17 00:00:00 2001 From: Justin Yap Date: Wed, 5 Nov 2025 11:41:56 +1100 Subject: [PATCH 2/6] Tests, fixes and refactor --- R/mergedatasetsbyvariable.R | 7 +----- R/mergingandstackingutilities.R | 6 +++++ R/stacking.R | 4 +--- .../test-mergingandstackingutilities.R | 22 ++++++------------- 4 files changed, 15 insertions(+), 24 deletions(-) diff --git a/R/mergedatasetsbyvariable.R b/R/mergedatasetsbyvariable.R index d2a1a5e..ff56563 100644 --- a/R/mergedatasetsbyvariable.R +++ b/R/mergedatasetsbyvariable.R @@ -450,12 +450,7 @@ mergedDataSetVariableNames <- function(input.data.sets.metadata, v.names.list[[data.set.ind]]) } - merged.data.set.var.names <- character(0) - for (i in seq_len(n.data.sets)) - for (nm in included.variable.names.list[[i]]) - merged.data.set.var.names <- c(merged.data.set.var.names, - makeValidNameForSpss(nm, merged.data.set.var.names, delimiter = "_")) - merged.data.set.var.names <- sanitizeSPSSVariableNames(merged.data.set.var.names) + merged.data.set.var.names <- sanitizeSPSSVariableNames(unlist(included.variable.names.list)) attr(merged.data.set.var.names, "included.variable.names.list") <- included.variable.names.list attr(merged.data.set.var.names, "omitted.variable.names.list") <- omitted.var.names.list diff --git a/R/mergingandstackingutilities.R b/R/mergingandstackingutilities.R index 95e6d52..6ce0e68 100644 --- a/R/mergingandstackingutilities.R +++ b/R/mergingandstackingutilities.R @@ -527,6 +527,7 @@ makeValidNameForSpss <- function(input.name, existing.names, delimiter = "") name <- trimPeriods(name) name <- defaultNameIfEmpty(name) name <- replaceReservedKeywords(name) + name <- truncateNameToByteLimit(name) name <- uniqueName(name, existing.names, delimiter) if (name == previous.name) { return(name) @@ -560,6 +561,11 @@ replaceReservedKeywords <- function(name) ifelse(name %in% reserved.keywords, paste0(name, "_r"), name) } +truncateNameToByteLimit <- function(name) +{ + addSuffixFittingByteLimit(name) +} + #' @description Return variable name matches to wildcard.text. Throw error if no matches #' found and error.if.not.found == TRUE. #' @param wildcard.text Character scalar of the wildcard pattern to match for. diff --git a/R/stacking.R b/R/stacking.R index 251c4f5..1bc3a30 100644 --- a/R/stacking.R +++ b/R/stacking.R @@ -1203,9 +1203,7 @@ stackedDataSet <- function(input.data.set, input.data.set.metadata, stacked.data.set[[nm]] <- observation } - stacked.data.set <- data.frame(stacked.data.set, check.names = FALSE) - colnames(stacked.data.set) <- sanitizeSPSSVariableNames(colnames(stacked.data.set)) - stacked.data.set + data.frame(stacked.data.set, check.names = FALSE) } stackedVariableName <- function(group.ind, input.variable.names, taken.names) diff --git a/tests/testthat/test-mergingandstackingutilities.R b/tests/testthat/test-mergingandstackingutilities.R index f98b090..f626a37 100644 --- a/tests/testthat/test-mergingandstackingutilities.R +++ b/tests/testthat/test-mergingandstackingutilities.R @@ -126,26 +126,22 @@ test_that("DS-4210: SPSS variable names sanitized before attempting to save", { # Period at beginning bad.names <- c(".A", ".B", ".C") - expect_warning(z <- sanitizeSPSSVariableNames(bad.names), - "Cannot save variables names which begin or end with '.'") + z <- sanitizeSPSSVariableNames(bad.names) expect_equal(z, c("A", "B", "C")) # Period at end bad.names <- c("A.", "B.", "C.") - expect_warning(z <- sanitizeSPSSVariableNames(bad.names), - "Cannot save variables names which begin or end with '.'") + z <- sanitizeSPSSVariableNames(bad.names) expect_equal(z, c("A", "B", "C")) # Multiple periods bad.names <- c("..A...", "..B...", "..C...") - expect_warning(z <- sanitizeSPSSVariableNames(bad.names), - "Cannot save variables names which begin or end with '.'") + z <- sanitizeSPSSVariableNames(bad.names) expect_equal(z, c("A", "B", "C")) # Restricted names bad.names <- c("A", "B", "WITH") - expect_warning(z <- sanitizeSPSSVariableNames(bad.names), - "Cannot save variables whose names are SPSS reserved keywords.") + z <- sanitizeSPSSVariableNames(bad.names) expect_equal(z, c("A", "B", "WITH_r")) # Too long @@ -154,22 +150,18 @@ test_that("DS-4210: SPSS variable names sanitized before attempting to save", { 'L2LeisureActivitiesConsideration_OtherpleasespecifyL2LeisureActivitiesConsideration_Otherpleasespecify', 'L2LeisureActivitiesConsideration_Otherpleasespecify_0L2LeisureActivitiesConsideration_Otherpleasespecify_0', 'PQ4a_OtherwithchildrenathomepleasespecifyPQ4a_Otherwithchildrenathomepleasespecify') - expect_warning(z <- sanitizeSPSSVariableNames(bad.names), - "Some variable names were too long and have been truncated: ") + z <- sanitizeSPSSVariableNames(bad.names) expect_true(all(nchar(z, type = 'bytes') <= 64)) # Too long, not ascii bad.names <- c("トム・クルーズが嫌いな理由を10語以内で教えてください", "春に訪れたい日本で一番好きな都市はどこですか") - - expect_warning(z <- sanitizeSPSSVariableNames(bad.names), - "Some variable names were too long and have been truncated: ") + z <- sanitizeSPSSVariableNames(bad.names) expect_true(all(nchar(z, type = 'bytes') <= 64)) # Prevent duplicates bad.names <- c("A", "B", "WITH", "A", "B", "WITH") - expect_warning(z <- sanitizeSPSSVariableNames(bad.names), - "Cannot save variables whose names are SPSS reserved keywords") + z <- sanitizeSPSSVariableNames(bad.names) expect_equal(z, c("A", "B", "WITH_r", "A_1", "B_1", "WITH_r_1")) }) From b8be7550ee06bd25696fea0f9910d48d7a4c0af2 Mon Sep 17 00:00:00 2001 From: Justin Yap Date: Wed, 5 Nov 2025 11:56:54 +1100 Subject: [PATCH 3/6] Update test-stacking.R --- tests/testthat/test-stacking.R | 21 +++++++++++++-------- 1 file changed, 13 insertions(+), 8 deletions(-) diff --git a/tests/testthat/test-stacking.R b/tests/testthat/test-stacking.R index e55dc6c..ffca84b 100644 --- a/tests/testthat/test-stacking.R +++ b/tests/testthat/test-stacking.R @@ -329,14 +329,19 @@ test_that("stackWithCommonLabels", { val.attr <- 1:3 names(val.attr) <- letters[1:3] v.val.attr <- rep(list(val.attr), length(v.names)) - expect_warning(stacking.groups <- stackWithCommonLabels(common.labels.list, - list(variable.names = v.names, - variable.labels = v.labels, - variable.types = v.types, - variable.value.attributes = v.val.attr)), - "Some variables could not be stacked due to mismatching ", - "variable types or value attributes. See Notes section in ", - "output for more details.") + # expect_warning(stacking.groups <- stackWithCommonLabels(common.labels.list, + # list(variable.names = v.names, + # variable.labels = v.labels, + # variable.types = v.types, + # variable.value.attributes = v.val.attr)), + # "Some variables could not be stacked due to mismatching ", + # "variable types or value attributes. See Notes section in ", + # "output for more details.") + stackWithCommonLabels(common.labels.list, + list(variable.names = v.names, + variable.labels = v.labels, + variable.types = v.types, + variable.value.attributes = v.val.attr)) expect_equal(stacking.groups, structure(integer(0), .Dim = c(0L, 3L), unstackable.names = list(c("Q2_A", "Q2_B", "Q2_C")))) From 6f986b2ee1847810810bccfa72322da323537c0e Mon Sep 17 00:00:00 2001 From: Justin Yap Date: Wed, 5 Nov 2025 12:04:15 +1100 Subject: [PATCH 4/6] Fix --- tests/testthat/test-stacking.R | 25 ++++++++++--------------- 1 file changed, 10 insertions(+), 15 deletions(-) diff --git a/tests/testthat/test-stacking.R b/tests/testthat/test-stacking.R index ffca84b..8eb70c1 100644 --- a/tests/testthat/test-stacking.R +++ b/tests/testthat/test-stacking.R @@ -329,19 +329,14 @@ test_that("stackWithCommonLabels", { val.attr <- 1:3 names(val.attr) <- letters[1:3] v.val.attr <- rep(list(val.attr), length(v.names)) - # expect_warning(stacking.groups <- stackWithCommonLabels(common.labels.list, - # list(variable.names = v.names, - # variable.labels = v.labels, - # variable.types = v.types, - # variable.value.attributes = v.val.attr)), - # "Some variables could not be stacked due to mismatching ", - # "variable types or value attributes. See Notes section in ", - # "output for more details.") - stackWithCommonLabels(common.labels.list, - list(variable.names = v.names, - variable.labels = v.labels, - variable.types = v.types, - variable.value.attributes = v.val.attr)) + stacking.groups <- expect_warning(stackWithCommonLabels(common.labels.list, + list(variable.names = v.names, + variable.labels = v.labels, + variable.types = v.types, + variable.value.attributes = v.val.attr)), + "Some variables could not be stacked due to mismatching ", + "variable types or value attributes. See Notes section in ", + "output for more details.") expect_equal(stacking.groups, structure(integer(0), .Dim = c(0L, 3L), unstackable.names = list(c("Q2_A", "Q2_B", "Q2_C")))) @@ -350,7 +345,7 @@ test_that("stackWithCommonLabels", { val.attr.2 <- 4:6 names(val.attr.2) <- letters[4:6] v.val.attr <- list(val.attr, val.attr, val.attr.2) - expect_warning(stacking.groups <- stackWithCommonLabels(common.labels.list, + stacking.groups <- expect_warning(stackWithCommonLabels(common.labels.list, list(variable.names = v.names, variable.labels = v.labels, variable.types = v.types, @@ -480,7 +475,7 @@ test_that("stackingSpecifiedByVariable", { names(val.attr.2) <- letters[1:3] v.val.attr.2 <- v.val.attr v.val.attr.2[[2]] <- val.attr.2 - + ## DS-4405: No longer a warning when some labels have duplicate attr. names { expect_warning( stacking.groups <- stackingSpecifiedByVariable( From b330d6b368f976e9c0097389f1ebc14e8f361f8a Mon Sep 17 00:00:00 2001 From: Justin Yap Date: Wed, 5 Nov 2025 12:56:07 +1100 Subject: [PATCH 5/6] Fix --- tests/testthat/test-stacking.R | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/tests/testthat/test-stacking.R b/tests/testthat/test-stacking.R index 8eb70c1..f5f1be4 100644 --- a/tests/testthat/test-stacking.R +++ b/tests/testthat/test-stacking.R @@ -329,14 +329,14 @@ test_that("stackWithCommonLabels", { val.attr <- 1:3 names(val.attr) <- letters[1:3] v.val.attr <- rep(list(val.attr), length(v.names)) - stacking.groups <- expect_warning(stackWithCommonLabels(common.labels.list, + expect_warning(stacking.groups <- stackWithCommonLabels(common.labels.list, list(variable.names = v.names, variable.labels = v.labels, variable.types = v.types, variable.value.attributes = v.val.attr)), - "Some variables could not be stacked due to mismatching ", + paste0("Some variables could not be stacked due to mismatching ", "variable types or value attributes. See Notes section in ", - "output for more details.") + "output for more details.")) expect_equal(stacking.groups, structure(integer(0), .Dim = c(0L, 3L), unstackable.names = list(c("Q2_A", "Q2_B", "Q2_C")))) @@ -345,14 +345,14 @@ test_that("stackWithCommonLabels", { val.attr.2 <- 4:6 names(val.attr.2) <- letters[4:6] v.val.attr <- list(val.attr, val.attr, val.attr.2) - stacking.groups <- expect_warning(stackWithCommonLabels(common.labels.list, + expect_warning(stacking.groups <- stackWithCommonLabels(common.labels.list, list(variable.names = v.names, variable.labels = v.labels, variable.types = v.types, variable.value.attributes = v.val.attr)), - "Some variables could not be stacked due to mismatching ", + paste0("Some variables could not be stacked due to mismatching ", "variable types or value attributes. See Notes section in ", - "output for more details.") + "output for more details.")) expect_equal(stacking.groups, structure(integer(0), .Dim = c(0L, 3L), unstackable.names = list(c("Q2_A", "Q2_B", "Q2_C")))) From 36ed77e4a838c75c8de3a28c90f8eb99098e8b75 Mon Sep 17 00:00:00 2001 From: Justin Yap Date: Wed, 5 Nov 2025 14:07:41 +1100 Subject: [PATCH 6/6] Refactor and add more tests --- R/mergingandstackingutilities.R | 26 +++++++------------ .../test-mergingandstackingutilities.R | 26 ++++++++++++++++++- 2 files changed, 35 insertions(+), 17 deletions(-) diff --git a/R/mergingandstackingutilities.R b/R/mergingandstackingutilities.R index 6ce0e68..57a78bc 100644 --- a/R/mergingandstackingutilities.R +++ b/R/mergingandstackingutilities.R @@ -519,20 +519,14 @@ uniqueName <- function(new.name, existing.names, delimiter = "") makeValidNameForSpss <- function(input.name, existing.names, delimiter = "") { - name <- removeInvalidStartingCharacters(input.name) - name <- removeWhitespace(name) - - repeat { - previous.name <- name - name <- trimPeriods(name) - name <- defaultNameIfEmpty(name) - name <- replaceReservedKeywords(name) - name <- truncateNameToByteLimit(name) - name <- uniqueName(name, existing.names, delimiter) - if (name == previous.name) { - return(name) - } - } + input.name |> + removeWhitespace() |> + removeInvalidStartingCharacters() |> + truncateNameToByteLimit() |> + trimTrailingPeriods() |> + defaultNameIfEmpty() |> + replaceReservedKeywords() |> + uniqueName(existing.names, delimiter) } removeWhitespace <- function(name) @@ -545,9 +539,9 @@ removeInvalidStartingCharacters <- function(name) gsub("^[^a-zA-Z@]+", "", name) } -trimPeriods <- function(name) +trimTrailingPeriods <- function(name) { - gsub("^\\.+|\\.+$", "", name) + gsub("\\.+$", "", name) } defaultNameIfEmpty <- function(name) diff --git a/tests/testthat/test-mergingandstackingutilities.R b/tests/testthat/test-mergingandstackingutilities.R index f626a37..cea2ae7 100644 --- a/tests/testthat/test-mergingandstackingutilities.R +++ b/tests/testthat/test-mergingandstackingutilities.R @@ -159,9 +159,33 @@ test_that("DS-4210: SPSS variable names sanitized before attempting to save", { z <- sanitizeSPSSVariableNames(bad.names) expect_true(all(nchar(z, type = 'bytes') <= 64)) - # Prevent duplicates bad.names <- c("A", "B", "WITH", "A", "B", "WITH") z <- sanitizeSPSSVariableNames(bad.names) expect_equal(z, c("A", "B", "WITH_r", "A_1", "B_1", "WITH_r_1")) + + # Invalid starting characters + bad.names <- c("_A", "??B") + z <- sanitizeSPSSVariableNames(bad.names) + expect_equal(z, c("A", "B")) + + # Spaces + bad.names <- c(" A \n B ") + z <- sanitizeSPSSVariableNames(bad.names) + expect_equal(z, c("AB")) + + # Edge cases + bad.names <- c(" _.WITH.", + "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaab.a", # 65 bytes long + "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabaa", + "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabaa", + "_.", + "__.") + z <- sanitizeSPSSVariableNames(bad.names) + expect_equal(z, c("WITH_r", + "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaab", + "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaba", + "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa_1", + "VAR", + "VAR_1")) })