diff --git a/ufos/rust/ufos_c/src/lib.rs b/ufos/rust/ufos_c/src/lib.rs index d344c59..f535c94 100644 --- a/ufos/rust/ufos_c/src/lib.rs +++ b/ufos/rust/ufos_c/src/lib.rs @@ -116,7 +116,7 @@ impl UfoCore { .and_then(|core| { let ufo = core .get_ufo_by_address(ptr as usize) - .expect("UFO lookup failed"); + .ok()?; // okay if this fails, we just return "none" Some(UfoObj::wrap(ufo)) }) .unwrap_or_else(UfoObj::none) diff --git a/ufovectors/..Rcheck/tests/csv/test.c b/ufovectors/..Rcheck/tests/csv/test.c new file mode 100644 index 0000000..7d1d9f5 --- /dev/null +++ b/ufovectors/..Rcheck/tests/csv/test.c @@ -0,0 +1,217 @@ +#include +#include +#include +#include + +#include "../../src/csv/token.h" +#include "../../src/csv/tokenizer.h" +#include "../../src/csv/reader.h" +#include "../../src/csv/string_set.h" + +/* + * gcc -o test -I../src/csv/ ../../src/csv/reader.c ../../src/csv/tokenizer.c ../../src/csv/token.c ../../src/csv/string_vector.c ../../src/csv/string_set.c test.c -g -O0 -Wall + */ + +void test_file(char* path) { + tokenizer_t tokenizer = csv_tokenizer(); + tokenizer_state_t *state = tokenizer_state_init(path, 0, 10, 10); + tokenizer_start(&tokenizer, state); + tokenizer_token_t *token; + + while (true) { + int result = tokenizer_next(&tokenizer, state, &token, false); + + printf("Token: [size: %li, start: %li, end: %li, string: <%s>], %s\n", + token->size, token->position_start, token->position_end, token->string, + tokenizer_result_to_string(result)); + + if (result == TOKENIZER_END_OF_FILE || result == TOKENIZER_ERROR || result == TOKENIZER_PARSE_ERROR) { + break; + } + } + + tokenizer_close(&tokenizer, state); +}; + +void test_initial_scan(char* path, bool headers) { + //tokenizer_t tokenizer = csv_tokenizer(); + scan_results_t *results = ufo_csv_perform_initial_scan(path, 5, headers); + + printf("After initial scan of %s: \n\n", path); + printf(" rows: %li\n", results->rows); + printf(" cols: %li\n", results->columns); + + printf(" column_names:\n\n"); + for (size_t i = 0; i < results->columns; i++) { + printf(" [%li]: %s\n", i, results->column_names[i]); + } + printf("\n"); + + printf(" column_types:\n\n"); + for (size_t i = 0; i < results->columns; i++) { + printf(" [%li]: %s/%i\n", + i, token_type_to_string(results->column_types[i]), + results->column_types[i]); + } + printf("\n"); + + printf(" row_offsets:\n\n"); + for (size_t i = 0; i < results->row_offsets->size; i++) { + printf(" [%li] (row #%li): %li\n", + i, offset_record_human_readable_key(results->row_offsets, i), + results->row_offsets->offsets[i]); + } + printf("\n"); +}; + + + +void test_read_individual_columns(char* path, bool headers) { + //tokenizer_t tokenizer = csv_tokenizer(); + scan_results_t *results = ufo_csv_perform_initial_scan(path, 3, headers); + + printf("After initial scan of %s: \n\n", path); + printf(" rows: %li\n", results->rows); + printf(" cols: %li\n", results->columns); + + printf(" column_names:\n\n"); + for (size_t i = 0; i < results->columns; i++) { + printf(" [%li]: %s\n", i, results->column_names[i]); + } + printf("\n"); + + printf(" column_types:\n\n"); + for (size_t i = 0; i < results->columns; i++) { + printf(" [%li]: %s/%i\n", + i, token_type_to_string(results->column_types[i]), + results->column_types[i]); + } + printf("\n"); + + printf(" row_offsets:\n\n"); + for (size_t i = 0; i < results->row_offsets->size; i++) { + printf(" [%li] (row #%li): %li\n", + i, offset_record_human_readable_key(results->row_offsets, i), + results->row_offsets->offsets[i]); + } + printf("\n"); + + size_t start = 4; + size_t end = 5; + + for (size_t column = 0; column <= results->columns; column++) { + read_results_t column_tokens = ufo_csv_read_column(path, column, results, start, end); + + printf("After reading column %li of %s/%li from row %li to row %li (inclusive): \n\n", + column, path, column_tokens.size, start, end); + + + for (size_t row = 0; row < column_tokens.size; row++) { + printf(" [%li+%li]: %s\n", start, row, column_tokens.tokens[row]->string); + } + printf("\n"); + } +} + +void test_read_typed_columns(char* path, bool headers) { + //tokenizer_t tokenizer = csv_tokenizer(); + scan_results_t *results = ufo_csv_perform_initial_scan(path, 3, headers); + + printf("After initial scan of %s: \n\n", path); + printf(" rows: %li\n", results->rows); + printf(" cols: %li\n", results->columns); + + printf(" column_names:\n\n"); + for (size_t i = 0; i < results->columns; i++) { + printf(" [%li]: %s\n", i, results->column_names[i]); + } + printf("\n"); + + printf(" column_types:\n\n"); + for (size_t i = 0; i < results->columns; i++) { + printf(" [%li]: %s/%i\n", + i, token_type_to_string(results->column_types[i]), + results->column_types[i]); + } + printf("\n"); + + printf(" row_offsets:\n\n"); + for (size_t i = 0; i < results->row_offsets->size; i++) { + printf(" [%li] (row #%li): %li\n", + i, offset_record_human_readable_key(results->row_offsets, i), + results->row_offsets->offsets[i]); + } + printf("\n"); + + for (size_t column = 0; column <= results->columns; column++) { + read_results_t column_tokens = ufo_csv_read_column(path, column, results, 0L, 0L); + + printf("After reading column %li of %s/%li from row %li to row %li (inclusive): \n\n", + column, path, column_tokens.size, 0L, 0L); + + for (size_t row = 0; row < column_tokens.size; row++) { + switch (results->column_types[column]) { + case TOKEN_NOTHING: + printf(" [%li]: \n", row); + break; + case TOKEN_EMPTY: { + printf(" [%li]: \n", row); + break; + } + case TOKEN_NA: { + printf(" [%li]: \n", row); + break; + } + case TOKEN_BOOLEAN: { + trinary_t value = token_to_logical(column_tokens.tokens[row]); + printf(" [%li]: %s\n", row, (value == TRUE ? "true" : (value == FALSE ? "false" : "NA"))); + break; + } + case TOKEN_INTEGER: { + int value = token_to_integer(column_tokens.tokens[row]); + if (value != NA_INTEGER) { + printf(" [%li]: %i\n", row, value); + } else { + printf(" [%li]: \n", row); + } + break; + } + case TOKEN_DOUBLE: { + double value = token_to_numeric(column_tokens.tokens[row]); + printf(" [%li]: %f\n", row, value); + break; + } + case TOKEN_STRING: { + printf(" [%li]: %s\n", row, column_tokens.tokens[row]->string); + break; + } + } + } + printf("\n"); + } + + for (size_t column = 0; column <= results->columns; column++) { + string_set_t *tokens = ufo_csv_read_column_unique_values(path, column, results); + + printf("Column %li of %s has the following unique values: \n\n", column, path); + + for (size_t i = 0; i < tokens->size; i++) { + printf(" [%li]: %s\n", i, tokens->strings[i]); + } + + printf("\n"); + } +} + +int main (int argc, char *argv[]) { + //test_file("test.csv"); + + //test_initial_scan("test.csv"); + //test_read_individual_columns("test.csv"); + + //test_initial_scan("test2.csv", true); + test_read_individual_columns("test3.csv", true); + //test_read_typ`ed_columns("test2.csv", true); + test_read_typed_columns("test3.csv", true); + return 0; +} \ No newline at end of file diff --git a/ufovectors/..Rcheck/tests/testthat.R b/ufovectors/..Rcheck/tests/testthat.R new file mode 100644 index 0000000..d42458f --- /dev/null +++ b/ufovectors/..Rcheck/tests/testthat.R @@ -0,0 +1,4 @@ +library(testthat) +library(ufovectors) + +test_check("ufovectors") diff --git a/ufovectors/..Rcheck/tests/testthat/test-assign.R b/ufovectors/..Rcheck/tests/testthat/test-assign.R new file mode 100644 index 0000000..72c39b4 --- /dev/null +++ b/ufovectors/..Rcheck/tests/testthat/test-assign.R @@ -0,0 +1,229 @@ +context("UFO vector assignment") + +test_ufo_assign <- function (data, subscript, ufo_constructor) { + new_data_length <- length(data[subscript]) + set.seed(42) + new_data <- sample(data, new_data_length, replace=TRUE) + + ufo <- ufo_constructor(length(data)) + #ufo[seq_len(length(data))] <- data + + ufo[subscript] <- new_data + #ufo[ufo_subscript(ufo, subscript)] <- new_data + + reference_vector <- vector(typeof(ufo), length(data)) + reference_vector[subscript] <- new_data + + expect_equal(ufo, reference_vector) + expect_equal(is_ufo(ufo), TRUE) +} + +test_that("ufo integer assign: NULL", {test_ufo_assign(data=as.integer(1:100000), subscript=NULL, ufo_integer)}) +test_that("ufo numeric assign: NULL", {test_ufo_assign(data=as.numeric(1:100000), subscript=NULL, ufo_numeric)}) +test_that("ufo raw assign: NULL", {test_ufo_assign(data=as.raw(1:100000), subscript=NULL, ufo_raw)}) +test_that("ufo logical assign: NULL", {test_ufo_assign(data=as.logical(1:100000), subscript=NULL, ufo_logical)}) +test_that("ufo complex assign: NULL", {test_ufo_assign(data=as.complex(1:100000), subscript=NULL, ufo_complex)}) +test_that("ufo integer assign: num 0", {test_ufo_assign(data=as.integer(1:100000), subscript=0, ufo_integer)}) +test_that("ufo integer assign: num 1", {test_ufo_assign(data=as.integer(1:100000), subscript=1, ufo_integer)}) +test_that("ufo integer assign: num N/2", {test_ufo_assign(data=as.integer(1:100000), subscript=50000, ufo_integer)}) +test_that("ufo integer assign: num N", {test_ufo_assign(data=as.integer(1:100000), subscript=100000, ufo_integer)}) +test_that("ufo integer assign: num 1:10", {test_ufo_assign(data=as.integer(1:100000), subscript=1:10, ufo_integer)}) +test_that("ufo integer assign: num 1:1000", {test_ufo_assign(data=as.integer(1:100000), subscript=1:1000, ufo_integer)}) +test_that("ufo integer assign: num 1:N", {test_ufo_assign(data=as.integer(1:100000), subscript=1:100000, ufo_integer)}) +test_that("ufo integer assign: num N/2:N", {test_ufo_assign(data=as.integer(1:100000), subscript=50000:100000, ufo_integer)}) +test_that("ufo integer assign: num 2*(2:N/2)", {test_ufo_assign(data=as.integer(1:100000), subscript=2*(1:50000), ufo_integer)}) +test_that("ufo integer assign: num -1", {test_ufo_assign(data=as.integer(1:100000), subscript=-1, ufo_integer)}) +test_that("ufo integer assign: num -(N/2)", {test_ufo_assign(data=as.integer(1:100000), subscript=-50000, ufo_integer)}) +test_that("ufo integer assign: num -N", {test_ufo_assign(data=as.integer(1:100000), subscript=-100000, ufo_integer)}) +test_that("ufo integer assign: num -(1:10)", {test_ufo_assign(data=as.integer(1:100000), subscript=-(1:10), ufo_integer)}) +test_that("ufo integer assign: num -(1:1000)", {test_ufo_assign(data=as.integer(1:100000), subscript=-(1:1000), ufo_integer)}) +test_that("ufo integer assign: num -(1:N)", {test_ufo_assign(data=as.integer(1:100000), subscript=-(1:100000), ufo_integer)}) +test_that("ufo integer assign: num -(N/2:N)", {test_ufo_assign(data=as.integer(1:100000), subscript=-(50000:100000), ufo_integer)}) +test_that("ufo integer assign: num -2*(2:N/2)", {test_ufo_assign(data=as.integer(1:100000), subscript=-2*(1:50000), ufo_integer)}) +test_that("ufo numeric assign: num 0", {test_ufo_assign(data=as.numeric(1:100000), subscript=0, ufo_numeric)}) +test_that("ufo numeric assign: num 1", {test_ufo_assign(data=as.numeric(1:100000), subscript=1, ufo_numeric)}) +test_that("ufo numeric assign: num N/2", {test_ufo_assign(data=as.numeric(1:100000), subscript=50000, ufo_numeric)}) +test_that("ufo numeric assign: num N", {test_ufo_assign(data=as.numeric(1:100000), subscript=100000, ufo_numeric)}) +test_that("ufo numeric assign: num 1:10", {test_ufo_assign(data=as.numeric(1:100000), subscript=1:10, ufo_numeric)}) +test_that("ufo numeric assign: num 1:1000", {test_ufo_assign(data=as.numeric(1:100000), subscript=1:1000, ufo_numeric)}) +test_that("ufo numeric assign: num 1:N", {test_ufo_assign(data=as.numeric(1:100000), subscript=1:100000, ufo_numeric)}) +test_that("ufo numeric assign: num N/2:N", {test_ufo_assign(data=as.numeric(1:100000), subscript=50000:100000, ufo_numeric)}) +test_that("ufo numeric assign: num 2*(2:N/2)", {test_ufo_assign(data=as.numeric(1:100000), subscript=2*(1:50000), ufo_numeric)}) +test_that("ufo numeric assign: num -1", {test_ufo_assign(data=as.numeric(1:100000), subscript=-1, ufo_numeric)}) +test_that("ufo numeric assign: num -(N/2)", {test_ufo_assign(data=as.numeric(1:100000), subscript=-50000, ufo_numeric)}) +test_that("ufo numeric assign: num -N", {test_ufo_assign(data=as.numeric(1:100000), subscript=-100000, ufo_numeric)}) +test_that("ufo numeric assign: num -(1:10)", {test_ufo_assign(data=as.numeric(1:100000), subscript=-(1:10), ufo_numeric)}) +test_that("ufo numeric assign: num -(1:1000)", {test_ufo_assign(data=as.numeric(1:100000), subscript=-(1:1000), ufo_numeric)}) +test_that("ufo numeric assign: num -(1:N)", {test_ufo_assign(data=as.numeric(1:100000), subscript=-(1:100000), ufo_numeric)}) +test_that("ufo numeric assign: num -(N/2:N)", {test_ufo_assign(data=as.numeric(1:100000), subscript=-(50000:100000), ufo_numeric)}) +test_that("ufo numeric assign: num -2*(2:N/2)", {test_ufo_assign(data=as.numeric(1:100000), subscript=-2*(1:50000), ufo_numeric)}) +test_that("ufo complex assign: num 0", {test_ufo_assign(data=as.complex(1:100000), subscript=0, ufo_complex)}) +test_that("ufo complex assign: num 1", {test_ufo_assign(data=as.complex(1:100000), subscript=1, ufo_complex)}) +test_that("ufo complex assign: num N/2", {test_ufo_assign(data=as.complex(1:100000), subscript=50000, ufo_complex)}) +test_that("ufo complex assign: num N", {test_ufo_assign(data=as.complex(1:100000), subscript=100000, ufo_complex)}) +test_that("ufo complex assign: num 1:10", {test_ufo_assign(data=as.complex(1:100000), subscript=1:10, ufo_complex)}) +test_that("ufo complex assign: num 1:1000", {test_ufo_assign(data=as.complex(1:100000), subscript=1:1000, ufo_complex)}) +test_that("ufo complex assign: num 1:N", {test_ufo_assign(data=as.complex(1:100000), subscript=1:100000, ufo_complex)}) +test_that("ufo complex assign: num N/2:N", {test_ufo_assign(data=as.complex(1:100000), subscript=50000:100000, ufo_complex)}) +test_that("ufo complex assign: num 2*(2:N/2)", {test_ufo_assign(data=as.complex(1:100000), subscript=2*(1:50000), ufo_complex)}) +test_that("ufo complex assign: num -1", {test_ufo_assign(data=as.complex(1:100000), subscript=-1, ufo_complex)}) +test_that("ufo complex assign: num -(N/2)", {test_ufo_assign(data=as.complex(1:100000), subscript=-50000, ufo_complex)}) +test_that("ufo complex assign: num -N", {test_ufo_assign(data=as.complex(1:100000), subscript=-100000, ufo_complex)}) +test_that("ufo complex assign: num -(1:10)", {test_ufo_assign(data=as.complex(1:100000), subscript=-(1:10), ufo_complex)}) +test_that("ufo complex assign: num -(1:1000)", {test_ufo_assign(data=as.complex(1:100000), subscript=-(1:1000), ufo_complex)}) +test_that("ufo complex assign: num -(1:N)", {test_ufo_assign(data=as.complex(1:100000), subscript=-(1:100000), ufo_complex)}) +test_that("ufo complex assign: num -(N/2:N)", {test_ufo_assign(data=as.complex(1:100000), subscript=-(50000:100000), ufo_complex)}) +test_that("ufo complex assign: num -2*(2:N/2)", {test_ufo_assign(data=as.complex(1:100000), subscript=-2*(1:50000), ufo_complex)}) +test_that("ufo raw assign: num 0", {test_ufo_assign(data=as.raw(1:100000), subscript=0, ufo_raw)}) +test_that("ufo raw assign: num 1", {test_ufo_assign(data=as.raw(1:100000), subscript=1, ufo_raw)}) +test_that("ufo raw assign: num N/2", {test_ufo_assign(data=as.raw(1:100000), subscript=50000, ufo_raw)}) +test_that("ufo raw assign: num N", {test_ufo_assign(data=as.raw(1:100000), subscript=100000, ufo_raw)}) +test_that("ufo raw assign: num 1:10", {test_ufo_assign(data=as.raw(1:100000), subscript=1:10, ufo_raw)}) +test_that("ufo raw assign: num 1:1000", {test_ufo_assign(data=as.raw(1:100000), subscript=1:1000, ufo_raw)}) +test_that("ufo raw assign: num 1:N", {test_ufo_assign(data=as.raw(1:100000), subscript=1:100000, ufo_raw)}) +test_that("ufo raw assign: num N/2:N", {test_ufo_assign(data=as.raw(1:100000), subscript=50000:100000, ufo_raw)}) +test_that("ufo raw assign: num 2*(2:N/2)", {test_ufo_assign(data=as.raw(1:100000), subscript=2*(1:50000), ufo_raw)}) +test_that("ufo raw assign: num -1", {test_ufo_assign(data=as.raw(1:100000), subscript=-1, ufo_raw)}) +test_that("ufo raw assign: num -(N/2)", {test_ufo_assign(data=as.raw(1:100000), subscript=-50000, ufo_raw)}) +test_that("ufo raw assign: num -N", {test_ufo_assign(data=as.raw(1:100000), subscript=-100000, ufo_raw)}) +test_that("ufo raw assign: num -(1:10)", {test_ufo_assign(data=as.raw(1:100000), subscript=-(1:10), ufo_raw)}) +test_that("ufo raw assign: num -(1:1000)", {test_ufo_assign(data=as.raw(1:100000), subscript=-(1:1000), ufo_raw)}) +test_that("ufo raw assign: num -(1:N)", {test_ufo_assign(data=as.raw(1:100000), subscript=-(1:100000), ufo_raw)}) +test_that("ufo raw assign: num -(N/2:N)", {test_ufo_assign(data=as.raw(1:100000), subscript=-(50000:100000), ufo_raw)}) +test_that("ufo raw assign: num -2*(2:N/2)", {test_ufo_assign(data=as.raw(1:100000), subscript=-2*(1:50000), ufo_raw)}) +test_that("ufo logical assign: num 0", {test_ufo_assign(data=as.logical(1:100000), subscript=0, ufo_logical)}) +test_that("ufo logical assign: num 1", {test_ufo_assign(data=as.logical(1:100000), subscript=1, ufo_logical)}) +test_that("ufo logical assign: num N/2", {test_ufo_assign(data=as.logical(1:100000), subscript=50000, ufo_logical)}) +test_that("ufo logical assign: num N", {test_ufo_assign(data=as.logical(1:100000), subscript=100000, ufo_logical)}) +test_that("ufo logical assign: num 1:10", {test_ufo_assign(data=as.logical(1:100000), subscript=1:10, ufo_logical)}) +test_that("ufo logical assign: num 1:1000", {test_ufo_assign(data=as.logical(1:100000), subscript=1:1000, ufo_logical)}) +test_that("ufo logical assign: num 1:N", {test_ufo_assign(data=as.logical(1:100000), subscript=1:100000, ufo_logical)}) +test_that("ufo logical assign: num N/2:N", {test_ufo_assign(data=as.logical(1:100000), subscript=50000:100000, ufo_logical)}) +test_that("ufo logical assign: num 2*(2:N/2)", {test_ufo_assign(data=as.logical(1:100000), subscript=2*(1:50000), ufo_logical)}) +test_that("ufo logical assign: num -1", {test_ufo_assign(data=as.logical(1:100000), subscript=-1, ufo_logical)}) +test_that("ufo logical assign: num -(N/2)", {test_ufo_assign(data=as.logical(1:100000), subscript=-50000, ufo_logical)}) +test_that("ufo logical assign: num -N", {test_ufo_assign(data=as.logical(1:100000), subscript=-100000, ufo_logical)}) +test_that("ufo logical assign: num -(1:10)", {test_ufo_assign(data=as.logical(1:100000), subscript=-(1:10), ufo_logical)}) +test_that("ufo logical assign: num -(1:1000)", {test_ufo_assign(data=as.logical(1:100000), subscript=-(1:1000), ufo_logical)}) +test_that("ufo logical assign: num -(1:N)", {test_ufo_assign(data=as.logical(1:100000), subscript=-(1:100000), ufo_logical)}) +test_that("ufo logical assign: num -(N/2:N)", {test_ufo_assign(data=as.logical(1:100000), subscript=-(50000:100000), ufo_logical)}) +test_that("ufo logical assign: num -2*(2:N/2)", {test_ufo_assign(data=as.logical(1:100000), subscript=-2*(1:50000), ufo_logical)}) +test_that("ufo string assign: num 0", {test_ufo_assign(data=as.character(1:100000), subscript=0, ufo_character)}) +test_that("ufo string assign: num 1", {test_ufo_assign(data=as.character(1:100000), subscript=1, ufo_character)}) +test_that("ufo string assign: num N/2", {test_ufo_assign(data=as.character(1:100000), subscript=50000, ufo_character)}) +test_that("ufo string assign: num N", {test_ufo_assign(data=as.character(1:100000), subscript=100000, ufo_character)}) +test_that("ufo string assign: num 1:10", {test_ufo_assign(data=as.character(1:100000), subscript=1:10, ufo_character)}) +test_that("ufo string assign: num 1:1000", {test_ufo_assign(data=as.character(1:100000), subscript=1:1000, ufo_character)}) +test_that("ufo string assign: num 1:N", {test_ufo_assign(data=as.character(1:100000), subscript=1:100000, ufo_character)}) +test_that("ufo string assign: num N/2:N", {test_ufo_assign(data=as.character(1:100000), subscript=50000:100000, ufo_character)}) +test_that("ufo string assign: num 2*(2:N/2)", {test_ufo_assign(data=as.character(1:100000), subscript=2*(1:50000), ufo_character)}) +test_that("ufo string assign: num -1", {test_ufo_assign(data=as.character(1:100000), subscript=-1, ufo_character)}) +test_that("ufo string assign: num -(N/2)", {test_ufo_assign(data=as.character(1:100000), subscript=-50000, ufo_character)}) +test_that("ufo string assign: num -N", {test_ufo_assign(data=as.character(1:100000), subscript=-100000, ufo_character)}) +test_that("ufo string assign: num -(1:10)", {test_ufo_assign(data=as.character(1:100000), subscript=-(1:10), ufo_character)}) +test_that("ufo string assign: num -(1:1000)", {test_ufo_assign(data=as.character(1:100000), subscript=-(1:1000), ufo_character)}) +test_that("ufo string assign: num -(1:N)", {test_ufo_assign(data=as.character(1:100000), subscript=-(1:100000), ufo_character)}) +test_that("ufo string assign: num -(N/2:N)", {test_ufo_assign(data=as.character(1:100000), subscript=-(50000:100000), ufo_character)}) +test_that("ufo string assign: num -2*(2:N/2)", {test_ufo_assign(data=as.character(1:100000), subscript=-2*(1:50000), ufo_character)}) +test_that("ufo integer assign: int 0", {test_ufo_assign(data=as.integer(1:100000), subscript=as.integer(0), ufo_integer)}) +test_that("ufo integer assign: int 1", {test_ufo_assign(data=as.integer(1:100000), subscript=as.integer(1), ufo_integer)}) +test_that("ufo integer assign: int N/2", {test_ufo_assign(data=as.integer(1:100000), subscript=as.integer(50000), ufo_integer)}) +test_that("ufo integer assign: int N", {test_ufo_assign(data=as.integer(1:100000), subscript=as.integer(100000), ufo_integer)}) +test_that("ufo integer assign: int 1:10", {test_ufo_assign(data=as.integer(1:100000), subscript=as.integer(1:10), ufo_integer)}) +test_that("ufo integer assign: int 1:1000", {test_ufo_assign(data=as.integer(1:100000), subscript=as.integer(1:1000), ufo_integer)}) +test_that("ufo integer assign: int 1:N", {test_ufo_assign(data=as.integer(1:100000), subscript=as.integer(1:100000), ufo_integer)}) +test_that("ufo integer assign: int N/2:N", {test_ufo_assign(data=as.integer(1:100000), subscript=as.integer(50000:100000), ufo_integer)}) +test_that("ufo integer assign: int 2*(2:N/2)", {test_ufo_assign(data=as.integer(1:100000), subscript=as.integer(2*(1:50000)), ufo_integer)}) +test_that("ufo integer assign: int -1", {test_ufo_assign(data=as.integer(1:100000), subscript=as.integer(-1), ufo_integer)}) +test_that("ufo integer assign: int -(N/2)", {test_ufo_assign(data=as.integer(1:100000), subscript=as.integer(-50000), ufo_integer)}) +test_that("ufo integer assign: int -N", {test_ufo_assign(data=as.integer(1:100000), subscript=as.integer(-100000), ufo_integer)}) +test_that("ufo integer assign: int -(1:10)", {test_ufo_assign(data=as.integer(1:100000), subscript=as.integer(-(1:10)), ufo_integer)}) +test_that("ufo integer assign: int -(1:1000)", {test_ufo_assign(data=as.integer(1:100000), subscript=as.integer(-(1:1000)), ufo_integer)}) +test_that("ufo integer assign: int -(1:N)", {test_ufo_assign(data=as.integer(1:100000), subscript=as.integer(-(1:100000)), ufo_integer)}) +test_that("ufo integer assign: int -(N/2:N)", {test_ufo_assign(data=as.integer(1:100000), subscript=as.integer(-(50000:100000)), ufo_integer)}) +test_that("ufo integer assign: int -2*(2:N/2)", {test_ufo_assign(data=as.integer(1:100000), subscript=as.integer(-2*(1:50000)), ufo_integer)}) +test_that("ufo numeric assign: int 0", {test_ufo_assign(data=as.numeric(1:100000), subscript=as.integer(0), ufo_numeric)}) +test_that("ufo numeric assign: int 1", {test_ufo_assign(data=as.numeric(1:100000), subscript=as.integer(1), ufo_numeric)}) +test_that("ufo numeric assign: int N/2", {test_ufo_assign(data=as.numeric(1:100000), subscript=as.integer(50000), ufo_numeric)}) +test_that("ufo numeric assign: int N", {test_ufo_assign(data=as.numeric(1:100000), subscript=as.integer(100000), ufo_numeric)}) +test_that("ufo numeric assign: int 1:10", {test_ufo_assign(data=as.numeric(1:100000), subscript=as.integer(1:10), ufo_numeric)}) +test_that("ufo numeric assign: int 1:1000", {test_ufo_assign(data=as.numeric(1:100000), subscript=as.integer(1:1000), ufo_numeric)}) +test_that("ufo numeric assign: int 1:N", {test_ufo_assign(data=as.numeric(1:100000), subscript=as.integer(1:100000), ufo_numeric)}) +test_that("ufo numeric assign: int N/2:N", {test_ufo_assign(data=as.numeric(1:100000), subscript=as.integer(50000:100000), ufo_numeric)}) +test_that("ufo numeric assign: int 2*(2:N/2)", {test_ufo_assign(data=as.numeric(1:100000), subscript=as.integer(2*(1:50000)), ufo_numeric)}) +test_that("ufo numeric assign: int -1", {test_ufo_assign(data=as.numeric(1:100000), subscript=as.integer(-1), ufo_numeric)}) +test_that("ufo numeric assign: int -(N/2)", {test_ufo_assign(data=as.numeric(1:100000), subscript=as.integer(-50000), ufo_numeric)}) +test_that("ufo numeric assign: int -N", {test_ufo_assign(data=as.numeric(1:100000), subscript=as.integer(-100000), ufo_numeric)}) +test_that("ufo numeric assign: int -(1:10)", {test_ufo_assign(data=as.numeric(1:100000), subscript=as.integer(-(1:10)), ufo_numeric)}) +test_that("ufo numeric assign: int -(1:1000)", {test_ufo_assign(data=as.numeric(1:100000), subscript=as.integer(-(1:1000)), ufo_numeric)}) +test_that("ufo numeric assign: int -(1:N)", {test_ufo_assign(data=as.numeric(1:100000), subscript=as.integer(-(1:100000)), ufo_numeric)}) +test_that("ufo numeric assign: int -(N/2:N)", {test_ufo_assign(data=as.numeric(1:100000), subscript=as.integer(-(50000:100000)), ufo_numeric)}) +test_that("ufo numeric assign: int -2*(2:N/2)", {test_ufo_assign(data=as.numeric(1:100000), subscript=as.integer(-2*(1:50000)), ufo_numeric)}) +test_that("ufo complex assign: int 0", {test_ufo_assign(data=as.complex(1:100000), subscript=as.integer(0), ufo_complex)}) +test_that("ufo complex assign: int 1", {test_ufo_assign(data=as.complex(1:100000), subscript=as.integer(1), ufo_complex)}) +test_that("ufo complex assign: int N/2", {test_ufo_assign(data=as.complex(1:100000), subscript=as.integer(50000), ufo_complex)}) +test_that("ufo complex assign: int N", {test_ufo_assign(data=as.complex(1:100000), subscript=as.integer(100000), ufo_complex)}) +test_that("ufo complex assign: int 1:10", {test_ufo_assign(data=as.complex(1:100000), subscript=as.integer(1:10), ufo_complex)}) +test_that("ufo complex assign: int 1:1000", {test_ufo_assign(data=as.complex(1:100000), subscript=as.integer(1:1000), ufo_complex)}) +test_that("ufo complex assign: int 1:N", {test_ufo_assign(data=as.complex(1:100000), subscript=as.integer(1:100000), ufo_complex)}) +test_that("ufo complex assign: int N/2:N", {test_ufo_assign(data=as.complex(1:100000), subscript=as.integer(50000:100000), ufo_complex)}) +test_that("ufo complex assign: int 2*(2:N/2)", {test_ufo_assign(data=as.complex(1:100000), subscript=as.integer(2*(1:50000)), ufo_complex)}) +test_that("ufo complex assign: int -1", {test_ufo_assign(data=as.complex(1:100000), subscript=as.integer(-1), ufo_complex)}) +test_that("ufo complex assign: int -(N/2)", {test_ufo_assign(data=as.complex(1:100000), subscript=as.integer(-50000), ufo_complex)}) +test_that("ufo complex assign: int -N", {test_ufo_assign(data=as.complex(1:100000), subscript=as.integer(-100000), ufo_complex)}) +test_that("ufo complex assign: int -(1:10)", {test_ufo_assign(data=as.complex(1:100000), subscript=as.integer(-(1:10)), ufo_complex)}) +test_that("ufo complex assign: int -(1:1000)", {test_ufo_assign(data=as.complex(1:100000), subscript=as.integer(-(1:1000)), ufo_complex)}) +test_that("ufo complex assign: int -(1:N)", {test_ufo_assign(data=as.complex(1:100000), subscript=as.integer(-(1:100000)), ufo_complex)}) +test_that("ufo complex assign: int -(N/2:N)", {test_ufo_assign(data=as.complex(1:100000), subscript=as.integer(-(50000:100000)), ufo_complex)}) +test_that("ufo complex assign: int -2*(2:N/2)", {test_ufo_assign(data=as.complex(1:100000), subscript=as.integer(-2*(1:50000)), ufo_complex)}) +test_that("ufo raw assign: int 0", {test_ufo_assign(data=as.raw(1:100000), subscript=as.integer(0), ufo_raw)}) +test_that("ufo raw assign: int 1", {test_ufo_assign(data=as.raw(1:100000), subscript=as.integer(1), ufo_raw)}) +test_that("ufo raw assign: int N/2", {test_ufo_assign(data=as.raw(1:100000), subscript=as.integer(50000), ufo_raw)}) +test_that("ufo raw assign: int N", {test_ufo_assign(data=as.raw(1:100000), subscript=as.integer(100000), ufo_raw)}) +test_that("ufo raw assign: int 1:10", {test_ufo_assign(data=as.raw(1:100000), subscript=as.integer(1:10), ufo_raw)}) +test_that("ufo raw assign: int 1:1000", {test_ufo_assign(data=as.raw(1:100000), subscript=as.integer(1:1000), ufo_raw)}) +test_that("ufo raw assign: int 1:N", {test_ufo_assign(data=as.raw(1:100000), subscript=as.integer(1:100000), ufo_raw)}) +test_that("ufo raw assign: int N/2:N", {test_ufo_assign(data=as.raw(1:100000), subscript=as.integer(50000:100000), ufo_raw)}) +test_that("ufo raw assign: int 2*(2:N/2)", {test_ufo_assign(data=as.raw(1:100000), subscript=as.integer(2*(1:50000)), ufo_raw)}) +test_that("ufo raw assign: int -1", {test_ufo_assign(data=as.raw(1:100000), subscript=as.integer(-1), ufo_raw)}) +test_that("ufo raw assign: int -(N/2)", {test_ufo_assign(data=as.raw(1:100000), subscript=as.integer(-50000), ufo_raw)}) +test_that("ufo raw assign: int -N", {test_ufo_assign(data=as.raw(1:100000), subscript=as.integer(-100000), ufo_raw)}) +test_that("ufo raw assign: int -(1:10)", {test_ufo_assign(data=as.raw(1:100000), subscript=as.integer(-(1:10)), ufo_raw)}) +test_that("ufo raw assign: int -(1:1000)", {test_ufo_assign(data=as.raw(1:100000), subscript=as.integer(-(1:1000)), ufo_raw)}) +test_that("ufo raw assign: int -(1:N)", {test_ufo_assign(data=as.raw(1:100000), subscript=as.integer(-(1:100000)), ufo_raw)}) +test_that("ufo raw assign: int -(N/2:N)", {test_ufo_assign(data=as.raw(1:100000), subscript=as.integer(-(50000:100000)), ufo_raw)}) +test_that("ufo raw assign: int -2*(2:N/2)", {test_ufo_assign(data=as.raw(1:100000), subscript=as.integer(-2*(1:50000)), ufo_raw)}) +test_that("ufo logical assign: int 0", {test_ufo_assign(data=as.logical(1:100000), subscript=as.integer(0), ufo_logical)}) +test_that("ufo logical assign: int 1", {test_ufo_assign(data=as.logical(1:100000), subscript=as.integer(1), ufo_logical)}) +test_that("ufo logical assign: int N/2", {test_ufo_assign(data=as.logical(1:100000), subscript=as.integer(50000), ufo_logical)}) +test_that("ufo logical assign: int N", {test_ufo_assign(data=as.logical(1:100000), subscript=as.integer(100000), ufo_logical)}) +test_that("ufo logical assign: int 1:10", {test_ufo_assign(data=as.logical(1:100000), subscript=as.integer(1:10), ufo_logical)}) +test_that("ufo logical assign: int 1:1000", {test_ufo_assign(data=as.logical(1:100000), subscript=as.integer(1:1000), ufo_logical)}) +test_that("ufo logical assign: int 1:N", {test_ufo_assign(data=as.logical(1:100000), subscript=as.integer(1:100000), ufo_logical)}) +test_that("ufo logical assign: int N/2:N", {test_ufo_assign(data=as.logical(1:100000), subscript=as.integer(50000:100000), ufo_logical)}) +test_that("ufo logical assign: int 2*(2:N/2)", {test_ufo_assign(data=as.logical(1:100000), subscript=as.integer(2*(1:50000)), ufo_logical)}) +test_that("ufo logical assign: int -1", {test_ufo_assign(data=as.logical(1:100000), subscript=as.integer(-1), ufo_logical)}) +test_that("ufo logical assign: int -(N/2)", {test_ufo_assign(data=as.logical(1:100000), subscript=as.integer(-50000), ufo_logical)}) +test_that("ufo logical assign: int -N", {test_ufo_assign(data=as.logical(1:100000), subscript=as.integer(-100000), ufo_logical)}) +test_that("ufo logical assign: int -(1:10)", {test_ufo_assign(data=as.logical(1:100000), subscript=as.integer(-(1:10)), ufo_logical)}) +test_that("ufo logical assign: int -(1:1000)", {test_ufo_assign(data=as.logical(1:100000), subscript=as.integer(-(1:1000)), ufo_logical)}) +test_that("ufo logical assign: int -(1:N)", {test_ufo_assign(data=as.logical(1:100000), subscript=as.integer(-(1:100000)), ufo_logical)}) +test_that("ufo logical assign: int -(N/2:N)", {test_ufo_assign(data=as.logical(1:100000), subscript=as.integer(-(50000:100000)), ufo_logical)}) +test_that("ufo logical assign: int -2*(2:N/2)", {test_ufo_assign(data=as.logical(1:100000), subscript=as.integer(-2*(1:50000)), ufo_logical)}) +test_that("ufo string assign: int 0", {test_ufo_assign(data=as.character(1:100000), subscript=as.integer(0), ufo_character)}) +test_that("ufo string assign: int 1", {test_ufo_assign(data=as.character(1:100000), subscript=as.integer(1), ufo_character)}) +test_that("ufo string assign: int N/2", {test_ufo_assign(data=as.character(1:100000), subscript=as.integer(50000), ufo_character)}) +test_that("ufo string assign: int N", {test_ufo_assign(data=as.character(1:100000), subscript=as.integer(100000), ufo_character)}) +test_that("ufo string assign: int 1:10", {test_ufo_assign(data=as.character(1:100000), subscript=as.integer(1:10), ufo_character)}) +test_that("ufo string assign: int 1:1000", {test_ufo_assign(data=as.character(1:100000), subscript=as.integer(1:1000), ufo_character)}) +test_that("ufo string assign: int 1:N", {test_ufo_assign(data=as.character(1:100000), subscript=as.integer(1:100000), ufo_character)}) +test_that("ufo string assign: int N/2:N", {test_ufo_assign(data=as.character(1:100000), subscript=as.integer(50000:100000), ufo_character)}) +test_that("ufo string assign: int 2*(2:N/2)", {test_ufo_assign(data=as.character(1:100000), subscript=as.integer(2*(1:50000)), ufo_character)}) +test_that("ufo string assign: int -1", {test_ufo_assign(data=as.character(1:100000), subscript=as.integer(-1), ufo_character)}) +test_that("ufo string assign: int -(N/2)", {test_ufo_assign(data=as.character(1:100000), subscript=as.integer(-50000), ufo_character)}) +test_that("ufo string assign: int -N", {test_ufo_assign(data=as.character(1:100000), subscript=as.integer(-100000), ufo_character)}) +test_that("ufo string assign: int -(1:10)", {test_ufo_assign(data=as.character(1:100000), subscript=as.integer(-(1:10)), ufo_character)}) +test_that("ufo string assign: int -(1:1000)", {test_ufo_assign(data=as.character(1:100000), subscript=as.integer(-(1:1000)), ufo_character)}) +test_that("ufo string assign: int -(1:N)", {test_ufo_assign(data=as.character(1:100000), subscript=as.integer(-(1:100000)), ufo_character)}) +test_that("ufo string assign: int -(N/2:N)", {test_ufo_assign(data=as.character(1:100000), subscript=as.integer(-(50000:100000)), ufo_character)}) +test_that("ufo string assign: int -2*(2:N/2)", {test_ufo_assign(data=as.character(1:100000), subscript=as.integer(-2*(1:50000)), ufo_character)}) \ No newline at end of file diff --git a/ufovectors/..Rcheck/tests/testthat/test-chunking.R b/ufovectors/..Rcheck/tests/testthat/test-chunking.R new file mode 100644 index 0000000..e63076a --- /dev/null +++ b/ufovectors/..Rcheck/tests/testthat/test-chunking.R @@ -0,0 +1,24 @@ +context("Vector ufo apply") + +test_apply <- function (f, ..., chunk_size) { + ufo_result <- ufo_apply(FUN=f, ..., chunk_size=chunk_size) + reference_result <- mapply(FUN=f, ..., SIMPLIFY=TRUE) + expect_equal(ufo_result, reference_result) + expect_equal(is_ufo(ufo_result), TRUE) +} + +test_that("ufo_apply 1 input tiny chunks", test_apply(function(x) x + 1, 1:10000, chunk_size=1)) +test_that("ufo_apply 2 inputs tiny chunks", test_apply(function(x, y) x + y + 1, 1:10000, 1:1000, chunk_size=1)) +test_that("ufo_apply 3 inputs tiny chunks", test_apply(function(x, y, z) x + y + z + 1, 1:10000, 1:1000, 1:100, chunk_size=1)) +test_that("ufo_apply 1 input small chunks", test_apply(function(x) x + 1, 1:10000, chunk_size=100)) +test_that("ufo_apply 2 inputs small chunks", test_apply(function(x, y) x + y + 1, 1:10000, 1:1000, chunk_size=100)) +test_that("ufo_apply 3 inputs small chunks", test_apply(function(x, y, z) x + y + z + 1, 1:10000, 1:1000, 1:100, chunk_size=100)) +test_that("ufo_apply 1 input medium chunks", test_apply(function(x) x + 1, 1:10000, chunk_size=1000)) +test_that("ufo_apply 2 inputs medium chunks", test_apply(function(x, y) x + y + 1, 1:10000, 1:1000, chunk_size=1000)) +test_that("ufo_apply 3 inputs medium chunks", test_apply(function(x, y, z) x + y + z + 1, 1:10000, 1:1000, 1:100, chunk_size=1000)) +test_that("ufo_apply 1 input big chunks", test_apply(function(x) x + 1, 1:10000, chunk_size=10000)) +test_that("ufo_apply 2 inputs big chunks", test_apply(function(x, y) x + y + 1, 1:10000, 1:1000, chunk_size=10000)) +test_that("ufo_apply 3 inputs big chunks", test_apply(function(x, y, z) x + y + z + 1, 1:10000, 1:1000, 1:100, chunk_size=10000)) +test_that("ufo_apply 1 input hugenormous chunks", test_apply(function(x) x + 1, 1:10000, chunk_size=100000)) +test_that("ufo_apply 2 inputs hugenormous chunks", test_apply(function(x, y) x + y + 1, 1:10000, 1:1000, chunk_size=100000)) +test_that("ufo_apply 3 inputs hugenormous chunks", test_apply(function(x, y, z) x + y + z + 1, 1:10000, 1:1000, 1:100, chunk_size=100000)) \ No newline at end of file diff --git a/ufovectors/..Rcheck/tests/testthat/test-empty-vectors.R b/ufovectors/..Rcheck/tests/testthat/test-empty-vectors.R new file mode 100644 index 0000000..7cb4bdb --- /dev/null +++ b/ufovectors/..Rcheck/tests/testthat/test-empty-vectors.R @@ -0,0 +1,37 @@ +context("Empty UFO vectors") + +test_that("empty integer vector", { + ufo <- ufo_integer(1000000); + ordinary <- integer(1000000); + expect_equal(ufo, ordinary); +}) + +test_that("empty numeric vector", { + ufo <- ufo_numeric(1000000); + ordinary <- numeric(1000000); + expect_equal(ufo, ordinary); +}) + +test_that("empty logical vector", { + ufo <- ufo_logical(1000000); + ordinary <- logical(1000000); + expect_equal(ufo, ordinary); +}) + +test_that("empty complex vector", { + ufo <- ufo_complex(1000000); + ordinary <- complex(1000000); + expect_equal(ufo, ordinary); +}) + +test_that("empty raw vector", { + ufo <- ufo_raw(1000000); + ordinary <- raw(1000000); + expect_equal(ufo, ordinary); +}) + +#test_that("empty character vector", { + #ufo <- ufo_character(1000000); + #ordinary <- character(1000000); + #expect_equal(ufo, ordinary); +#}) \ No newline at end of file diff --git a/ufovectors/..Rcheck/tests/testthat/test-file-backed-add-1.R b/ufovectors/..Rcheck/tests/testthat/test-file-backed-add-1.R new file mode 100644 index 0000000..be7daed --- /dev/null +++ b/ufovectors/..Rcheck/tests/testthat/test-file-backed-add-1.R @@ -0,0 +1,18 @@ +context("Vector operations on file-backed integer vectors") + +dir <- "../../data" + +# test_that("sum 1K ones", { +# path <- paste(dir, "1K_ones_int.bin", sep="/") +# expect_equal(sum(ufo_integer_bin(path) + 1), 2 * 1000) +# }) + +#test_that("sum 1M ones", { +# path <- paste(dir, "1M_ones_int.bin", sep="/") +# expect_equal(sum(ufo_integer_bin(path) + 1), 2 * 1000000) +#}) + +#test_that("sum 1G ones", { +# path <- paste(dir, "1G_ones_int.bin", sep="/") +# expect_equal(sum(ufo_integer_bin(path) + 1), 2 * 1000000000) +#}) \ No newline at end of file diff --git a/ufovectors/..Rcheck/tests/testthat/test-file-backed-sum.R b/ufovectors/..Rcheck/tests/testthat/test-file-backed-sum.R new file mode 100644 index 0000000..59e9fe9 --- /dev/null +++ b/ufovectors/..Rcheck/tests/testthat/test-file-backed-sum.R @@ -0,0 +1,34 @@ +context("Make segfault") + +#create_bin_file <- function(name, template, repeats = 1) { +# path <- tempfile(name) +# handle <- file(path, "wb") +# for (i in 1:repeats) { writeBin(template, handle) } +# close(handle) +# path +#} + +#destroy_bin_file <- function(path) { +# unlink(path) +#} + +#test_that("sum 1K int ones", { +# path <- create_bin_file(name="ufo1K", template=as.integer(rep(1,1000)), repeats=1) +# expect_equal(sum(ufo_integer_bin(path)), 1000) +# destroy_bin_file(path) +#}) + +#test_that("sum 1M int ones", { +# path <- create_bin_file(name="ufo1M", template=as.integer(rep(1,1000000)), repeats=1) +# expect_equal(sum(ufo_integer_bin(path)), 1000000) +# destroy_bin_file(path) +#}) + +test_that("sum 1G int ones", { + a <- ufo_integer(100000000) + rm(a); + + v <- ufo_integer(1000000) + s <- sum(v) + expect_equal(s, 0) +}) \ No newline at end of file diff --git a/ufovectors/..Rcheck/tests/testthat/test-operators.R b/ufovectors/..Rcheck/tests/testthat/test-operators.R new file mode 100644 index 0000000..4669b26 --- /dev/null +++ b/ufovectors/..Rcheck/tests/testthat/test-operators.R @@ -0,0 +1,235 @@ +context("UFO vector operators") + +test_that("ufo binary +", { + ufo <- ufo_integer(100000); + ufo[1:100000] <- 1:100000 + reference <- 1:100000 + argument <- 1:100000 + + result_ufo <- ufo_add(ufo, argument) + result_reference <- reference + argument + + expect_equal(result_ufo, result_reference) + expect_true(is_ufo(result_ufo)) +}) + +test_that("ufo binary -", { + ufo <- ufo_integer(100000); + ufo[1:100000] <- 1:100000 + reference <- 1:100000 + argument <- 1:100000 + + result_ufo <- ufo_subtract(ufo, argument) + result_reference <- reference - argument + + expect_equal(result_ufo, result_reference) + expect_true(is_ufo(result_ufo)) +}) + +test_that("ufo binary *", { + ufo <- ufo_integer(100000); + ufo[1:100000] <- 1:100000 + reference <- 1:100000 + argument <- 1:100000 + + result_ufo <- ufo_multiply(ufo, argument) + result_reference <- reference * argument + + expect_equal(result_ufo, result_reference) + expect_true(is_ufo(result_ufo)) +}) + +test_that("ufo binary /", { + ufo <- ufo_integer(100000); + ufo[1:100000] <- 1:100000 + reference <- 1:100000 + argument <- 1:100000 + + result_ufo <- ufo_divide(ufo, argument) + result_reference <- reference / argument + + expect_equal(result_ufo, result_reference) + expect_true(is_ufo(result_ufo)) +}) + +test_that("ufo binary ^", { + ufo <- ufo_integer(100000); + ufo[1:100000] <- 1:100000 + reference <- 1:100000 + argument <- 1:100000 + + result_ufo <- ufo_power(ufo, argument) + result_reference <- reference ^ argument + + expect_equal(result_ufo, result_reference) + expect_true(is_ufo(result_ufo)) +}) + +test_that("ufo binary %%", { + ufo <- ufo_integer(100000); + ufo[1:100000] <- 1:100000 + reference <- 1:100000 + argument <- 1:100000 + + result_ufo <- ufo_modulo(ufo, argument) + result_reference <- reference %% argument + + expect_equal(result_ufo, result_reference) + expect_true(is_ufo(result_ufo)) +}) + +test_that("ufo binary %/%", { + ufo <- ufo_integer(100000); + ufo[1:100000] <- 1:100000 + reference <- 1:100000 + argument <- 1:100000 + + result_ufo <- ufo_int_divide(ufo, argument) + result_reference <- reference %/% argument + + expect_equal(result_ufo, result_reference) + expect_true(is_ufo(result_ufo)) +}) + +test_that("ufo binary <", { + ufo <- ufo_integer(100000); + ufo[1:100000] <- 1:100000 + reference <- 1:100000 + argument <- 1:100000 + + result_ufo <- ufo_less(ufo, argument) + result_reference <- reference < argument + + expect_equal(result_ufo, result_reference) + expect_true(is_ufo(result_ufo)) +}) + +test_that("ufo binary >", { + ufo <- ufo_integer(100000); + ufo[1:100000] <- 1:100000 + reference <- 1:100000 + argument <- 1:100000 + + result_ufo <- ufo_greater(ufo, argument) + result_reference <- reference > argument + + expect_equal(result_ufo, result_reference) + expect_true(is_ufo(result_ufo)) +}) + +test_that("ufo binary <=", { + ufo <- ufo_integer(100000); + ufo[1:100000] <- 1:100000 + reference <- 1:100000 + argument <- 1:100000 + + result_ufo <- ufo_less_equal(ufo, argument) + result_reference <- reference <= argument + + expect_equal(result_ufo, result_reference) + expect_true(is_ufo(result_ufo)) +}) + +test_that("ufo binary >=", { + ufo <- ufo_integer(100000); + ufo[1:100000] <- 1:100000 + reference <- 1:100000 + argument <- 1:100000 + + result_ufo <- ufo_greater_equal(ufo, argument) + result_reference <- reference >= argument + + expect_equal(result_ufo, result_reference) + expect_true(is_ufo(result_ufo)) +}) + +test_that("ufo binary ==", { + ufo <- ufo_integer(100000); + ufo[1:100000] <- 1:100000 + reference <- 1:100000 + argument <- 1:100000 + + result_ufo <- ufo_equal(ufo, argument) + result_reference <- reference == argument + + expect_equal(result_ufo, result_reference) + expect_true(is_ufo(result_ufo)) +}) + +test_that("ufo binary !=", { + ufo <- ufo_integer(100000); + ufo[1:100000] <- 1:100000 + reference <- 1:100000 + argument <- 1:100000 + + result_ufo <- ufo_unequal(ufo, argument) + result_reference <- reference != argument + + expect_equal(result_ufo, result_reference) + expect_true(is_ufo(result_ufo)) +}) + +test_that("ufo binary |", { + ufo <- ufo_integer(100000); + ufo[1:100000] <- 1:100000 + reference <- 1:100000 + argument <- 1:100000 + + result_ufo <- ufo_or(ufo, argument) + result_reference <- reference | argument + + expect_equal(result_ufo, result_reference) + expect_true(is_ufo(result_ufo)) +}) + +test_that("ufo binary &", { + ufo <- ufo_integer(100000); + ufo[1:100000] <- 1:100000 + reference <- 1:100000 + argument <- 1:100000 + + result_ufo <- ufo_and(ufo, argument) + result_reference <- reference & argument + + expect_equal(result_ufo, result_reference) + expect_true(is_ufo(result_ufo)) +}) + +test_that("ufo unary !", { + ufo <- ufo_logical(100000); + reference <- logical(100000); + + ufo[1:100000] <- c(TRUE, FALSE, NA, FALSE) + reference[1:100000]<-c(TRUE, FALSE, NA, FALSE) + + result_ufo <- ufo_not(ufo) + result_reference <- !reference + + expect_equal(result_ufo, result_reference) + expect_true(is_ufo(result_ufo)) +}) + +test_that("ufo unary +", { + ufo <- ufo_integer(100000); + ufo[1:100000] <- 1:100000 + reference <- 1:100000 + + result_ufo <- ufo_add(ufo) + result_reference <- +reference + + expect_equal(result_ufo, result_reference) + expect_true(is_ufo(result_ufo)) +}) + +test_that("ufo unary -", { + ufo <- ufo_integer(100000); + ufo[1:100000] <- 1:100000 + reference <- 1:100000 + argument <- 1:100000 + + result_ufo <- ufo_subtract(ufo) + result_reference <- -reference + + expect_equal(result_ufo, result_reference) + expect_true(is_ufo(result_ufo)) +}) \ No newline at end of file diff --git a/ufovectors/..Rcheck/tests/testthat/test-subscripting.R b/ufovectors/..Rcheck/tests/testthat/test-subscripting.R new file mode 100644 index 0000000..a0ed9cd --- /dev/null +++ b/ufovectors/..Rcheck/tests/testthat/test-subscripting.R @@ -0,0 +1,975 @@ +context("UFO vector subscripting") + +#context <- function(n) n +#test_that <- function(name, code) code +#expect_equal <- function(x, y) ifelse(x == y, T, F) + +test_ufo_subscript <- function (n, subscript, ufo_constructor, named=FALSE, index_type=as.integer) { + ufo <- ufo_constructor(n) + data <- index_type(1:n) + if (named) { + ufo <- setNames(ufo, as.character(1:n)) + data <- setNames(data, as.character(1:n)) + } + result <- ufovectors::ufo_subscript(ufo, subscript) + expected <- data[subscript] + if (named) { + # subscripting does not return names, so remove those from expected + expected <- setNames(expected, NULL) + } + expect_equal(result, expected) +} + +test_that("ufo integer subscript: null", {test_ufo_subscript(n=100000, NULL, ufo_integer )}) +test_that("ufo integer subscript: logical(0)", {test_ufo_subscript(n=100000, logical(0), ufo_integer )}) +test_that("ufo integer subscript: F", {test_ufo_subscript(n=100000, c(T), ufo_integer )}) +test_that("ufo integer subscript: T", {test_ufo_subscript(n=100000, c(F), ufo_integer )}) +test_that("ufo integer subscript: logical(NA)", {test_ufo_subscript(n=100000, as.logical(NA), ufo_integer )}) +test_that("ufo integer subscript: F,F", {test_ufo_subscript(n=100000, c(F, F), ufo_integer )}) +test_that("ufo integer subscript: F,T", {test_ufo_subscript(n=100000, c(F, T), ufo_integer )}) +test_that("ufo integer subscript: T,F", {test_ufo_subscript(n=100000, c(T, F), ufo_integer )}) +test_that("ufo integer subscript: T,T", {test_ufo_subscript(n=100000, c(T, T), ufo_integer )}) +test_that("ufo integer subscript: F,NA", {test_ufo_subscript(n=100000, c(F, NA), ufo_integer )}) +test_that("ufo integer subscript: NA,F", {test_ufo_subscript(n=100000, c(NA, F), ufo_integer )}) +test_that("ufo integer subscript: NA,T", {test_ufo_subscript(n=100000, c(NA, T), ufo_integer )}) +test_that("ufo integer subscript: T,NA", {test_ufo_subscript(n=100000, c(T, NA), ufo_integer )}) +test_that("ufo integer subscript: F,F,F", {test_ufo_subscript(n=100000, c(F, F, F), ufo_integer )}) +test_that("ufo integer subscript: F,F,T", {test_ufo_subscript(n=100000, c(F, F, T), ufo_integer )}) +test_that("ufo integer subscript: F,T,F", {test_ufo_subscript(n=100000, c(F, T, F), ufo_integer )}) +test_that("ufo integer subscript: F,T,T", {test_ufo_subscript(n=100000, c(F, T, T), ufo_integer )}) +test_that("ufo integer subscript: T,F,F", {test_ufo_subscript(n=100000, c(T, F, F), ufo_integer )}) +test_that("ufo integer subscript: T,F,T", {test_ufo_subscript(n=100000, c(T, F, T), ufo_integer )}) +test_that("ufo integer subscript: T,T,F", {test_ufo_subscript(n=100000, c(T, T, F), ufo_integer )}) +test_that("ufo integer subscript: T,T,T", {test_ufo_subscript(n=100000, c(T, T, T), ufo_integer )}) +test_that("ufo integer subscript: F,F,NA", {test_ufo_subscript(n=100000, c(F, F, NA), ufo_integer )}) +test_that("ufo integer subscript: F,NA,F", {test_ufo_subscript(n=100000, c(F, NA, F), ufo_integer )}) +test_that("ufo integer subscript: F,NA,NA", {test_ufo_subscript(n=100000, c(F, NA, NA), ufo_integer )}) +test_that("ufo integer subscript: NA,F,F", {test_ufo_subscript(n=100000, c(NA, F, F), ufo_integer )}) +test_that("ufo integer subscript: NA,F,NA", {test_ufo_subscript(n=100000, c(NA, F, NA), ufo_integer )}) +test_that("ufo integer subscript: NA,NA,F", {test_ufo_subscript(n=100000, c(NA, NA, F), ufo_integer )}) +test_that("ufo integer subscript: F,F,T", {test_ufo_subscript(n=100000, c(F, F, T), ufo_integer )}) +test_that("ufo integer subscript: F,NA,T", {test_ufo_subscript(n=100000, c(F, NA, T), ufo_integer )}) +test_that("ufo integer subscript: NA,F,T", {test_ufo_subscript(n=100000, c(NA, F, T), ufo_integer )}) +test_that("ufo integer subscript: NA,NA,T", {test_ufo_subscript(n=100000, c(NA, NA, T), ufo_integer )}) +test_that("ufo integer subscript: F,T,NA", {test_ufo_subscript(n=100000, c(F, T, NA), ufo_integer )}) +test_that("ufo integer subscript: NA,T,F", {test_ufo_subscript(n=100000, c(NA, T, F), ufo_integer )}) +test_that("ufo integer subscript: NA,T,NA", {test_ufo_subscript(n=100000, c(NA, T, NA), ufo_integer )}) +test_that("ufo integer subscript: F,NA,T", {test_ufo_subscript(n=100000, c(F, NA, T), ufo_integer )}) +test_that("ufo integer subscript: NA,T,T", {test_ufo_subscript(n=100000, c(NA, T, T), ufo_integer )}) +test_that("ufo integer subscript: T,F,NA", {test_ufo_subscript(n=100000, c(T, F, NA), ufo_integer )}) +test_that("ufo integer subscript: T,NA,F", {test_ufo_subscript(n=100000, c(T, NA, F), ufo_integer )}) +test_that("ufo integer subscript: T,NA,NA", {test_ufo_subscript(n=100000, c(T, NA, NA), ufo_integer )}) +test_that("ufo integer subscript: T,NA,T", {test_ufo_subscript(n=100000, c(T, NA, T), ufo_integer )}) +test_that("ufo integer subscript: T,T,NA", {test_ufo_subscript(n=100000, c(T, T, NA), ufo_integer )}) +test_that("ufo integer subscript: T,NA,NA", {test_ufo_subscript(n=100000, c(T, NA, NA), ufo_integer )}) +test_that("ufo integer subscript: T..", {test_ufo_subscript(n=100000, rep(T, 100000), ufo_integer )}) +test_that("ufo integer subscript: F..", {test_ufo_subscript(n=100000, rep(F, 100000), ufo_integer )}) +test_that("ufo integer subscript: T,F..", {test_ufo_subscript(n=100000, rep(c(T,F), 100000), ufo_integer )}) +test_that("ufo integer subscript: F,T..", {test_ufo_subscript(n=100000, rep(c(F,T), 100000), ufo_integer )}) +test_that("ufo integer subscript: int integer(0)", {test_ufo_subscript(n=100000, integer(0), ufo_integer )}) +test_that("ufo integer subscript: int 0", {test_ufo_subscript(n=100000, as.integer(0), ufo_integer )}) +test_that("ufo integer subscript: int 1", {test_ufo_subscript(n=100000, as.integer(1), ufo_integer )}) +test_that("ufo integer subscript: int 10", {test_ufo_subscript(n=100000, as.integer(10), ufo_integer )}) +test_that("ufo integer subscript: int 42", {test_ufo_subscript(n=100000, as.integer(42), ufo_integer )}) +test_that("ufo integer subscript: int N+1", {test_ufo_subscript(n=100000, as.integer(100001), ufo_integer )}) +test_that("ufo integer subscript: int 0,0", {test_ufo_subscript(n=100000, as.integer(c(0, 0)), ufo_integer )}) +test_that("ufo integer subscript: int 0,1,0,N,0", {test_ufo_subscript(n=100000, as.integer(c(0, 1, 0, 100000, 0)), ufo_integer )}) +test_that("ufo integer subscript: int 1,10,100,1000,100", {test_ufo_subscript(n=100000, as.integer(c(1, 10, 100, 1000, 100)), ufo_integer )}) +test_that("ufo integer subscript: int -1", {test_ufo_subscript(n=100000, as.integer(-1), ufo_integer )}) +test_that("ufo integer subscript: int -10", {test_ufo_subscript(n=100000, as.integer(-10), ufo_integer )}) +test_that("ufo integer subscript: int -42", {test_ufo_subscript(n=100000, as.integer(-42), ufo_integer )}) +test_that("ufo integer subscript: int -1,-10,-100,-1000,-100", {test_ufo_subscript(n=100000, as.integer(-c(1, 10, 100, 1000, 100)), ufo_integer )}) +test_that("ufo integer subscript: int few", {test_ufo_subscript(n=100000, as.integer(c(4, 10, 7, 100)), ufo_integer )}) +test_that("ufo integer subscript: int many", {test_ufo_subscript(n=100000, as.integer(c(1:1000, 2000:5000, 10:1000, 6000:10000)), ufo_integer )}) +test_that("ufo integer subscript: int all", {test_ufo_subscript(n=100000, as.integer(1:100000), ufo_integer )}) +test_that("ufo integer subscript: int few with NAs", {test_ufo_subscript(n=100000, as.integer(c(4, 10, NA, 7, NA, 100, NA)), ufo_integer )}) +test_that("ufo integer subscript: int many with NAs", {test_ufo_subscript(n=100000, as.integer(c(1:1000, NA, 2000:5000, NA, 10:1000, NA, 6000:10000)), ufo_integer )}) +test_that("ufo integer subscript: int all with NAs", {test_ufo_subscript(n=100000, as.integer(c(1:100000, NA)), ufo_integer )}) +test_that("ufo integer subscript: int few negative", {test_ufo_subscript(n=100000, as.integer(-c(4, 10, 7, 100)), ufo_integer )}) +test_that("ufo integer subscript: int many negative", {test_ufo_subscript(n=100000, as.integer(-c(1:1000, 2000:5000, 10:1000, 6000:10000)), ufo_integer )}) +test_that("ufo integer subscript: int all negative", {test_ufo_subscript(n=100000, as.integer(-(1:100000)), ufo_integer )}) +test_that("ufo integer subscript: num integer(0)", {test_ufo_subscript(n=100000, numeric(0), ufo_integer )}) +test_that("ufo integer subscript: num 0", {test_ufo_subscript(n=100000, as.numeric(0), ufo_integer )}) +test_that("ufo integer subscript: num 1", {test_ufo_subscript(n=100000, as.numeric(1), ufo_integer )}) +test_that("ufo integer subscript: num 10", {test_ufo_subscript(n=100000, as.numeric(10), ufo_integer )}) +test_that("ufo integer subscript: num 42", {test_ufo_subscript(n=100000, as.numeric(42), ufo_integer )}) +test_that("ufo integer subscript: num N+1", {test_ufo_subscript(n=100000, as.numeric(100001), ufo_integer )}) +test_that("ufo integer subscript: num 0,0", {test_ufo_subscript(n=100000, as.numeric(c(0, 0)), ufo_integer )}) +test_that("ufo integer subscript: num 0,1,0,N,0", {test_ufo_subscript(n=100000, as.numeric(c(0, 1, 0, 100000, 0)), ufo_integer )}) +test_that("ufo integer subscript: num 1,10,100,1000,100", {test_ufo_subscript(n=100000, as.numeric(c(1, 10, 100, 1000, 100)), ufo_integer )}) +test_that("ufo integer subscript: num -1", {test_ufo_subscript(n=100000, as.numeric(-1), ufo_integer )}) +test_that("ufo integer subscript: num -10", {test_ufo_subscript(n=100000, as.numeric(-10), ufo_integer )}) +test_that("ufo integer subscript: num -42", {test_ufo_subscript(n=100000, as.numeric(-42), ufo_integer )}) +test_that("ufo integer subscript: num -1,-10,-100,-1000,-100", {test_ufo_subscript(n=100000, as.numeric(-c(1, 10, 100, 1000, 100)), ufo_integer )}) +test_that("ufo integer subscript: num few", {test_ufo_subscript(n=100000, as.numeric(c(4, 10, 7, 100)), ufo_integer )}) +test_that("ufo integer subscript: num many", {test_ufo_subscript(n=100000, as.numeric(c(1:1000, 2000:5000, 10:1000, 6000:10000)), ufo_integer )}) +test_that("ufo integer subscript: num all", {test_ufo_subscript(n=100000, as.numeric(1:100000), ufo_integer )}) +test_that("ufo integer subscript: num few with NAs", {test_ufo_subscript(n=100000, as.numeric(c(4, 10, NA, 7, NA, 100, NA)), ufo_integer )}) +test_that("ufo integer subscript: num many with NAs", {test_ufo_subscript(n=100000, as.numeric(c(1:1000, NA, 2000:5000, NA, 10:1000, NA, 6000:10000)), ufo_integer )}) +test_that("ufo integer subscript: num all with NAs", {test_ufo_subscript(n=100000, as.numeric(c(1:100000, NA)), ufo_integer )}) +test_that("ufo integer subscript: num few negative", {test_ufo_subscript(n=100000, as.numeric(-c(4, 10, 7, 100)), ufo_integer )}) +test_that("ufo integer subscript: num many negative", {test_ufo_subscript(n=100000, as.numeric(-c(1:1000, 2000:5000, 10:1000, 6000:10000)), ufo_integer )}) +test_that("ufo integer subscript: num all negative", {test_ufo_subscript(n=100000, as.numeric(-(1:100000)), ufo_integer )}) +test_that("ufo integer subscript: num 0.1", {test_ufo_subscript(n=100000, as.numeric(0.1), ufo_integer )}) +test_that("ufo integer subscript: num 1.1", {test_ufo_subscript(n=100000, as.numeric(1.1), ufo_integer )}) +test_that("ufo integer subscript: num 10.5", {test_ufo_subscript(n=100000, as.numeric(10.5), ufo_integer )}) +test_that("ufo integer subscript: num 42.9", {test_ufo_subscript(n=100000, as.numeric(42.9), ufo_integer )}) +test_that("ufo integer subscript: num -0.1", {test_ufo_subscript(n=100000, as.numeric(-0.1), ufo_integer )}) +test_that("ufo integer subscript: num -1.1", {test_ufo_subscript(n=100000, as.numeric(-1.1), ufo_integer )}) +test_that("ufo integer subscript: num -10.5", {test_ufo_subscript(n=100000, as.numeric(-10.5), ufo_integer )}) +test_that("ufo integer subscript: num -42.9", {test_ufo_subscript(n=100000, as.numeric(-42.9), ufo_integer )}) +test_that("ufo integer subscript: hash str character(0)", {test_ufo_subscript(n=100000, character(0), ufo_integer )}) +test_that("ufo integer subscript: hash str 0", {test_ufo_subscript(n=100000, as.character(0), ufo_integer )}) +test_that("ufo integer subscript: hash str 1", {test_ufo_subscript(n=100000, as.character(1), ufo_integer )}) +test_that("ufo integer subscript: hash str 10", {test_ufo_subscript(n=100000, as.character(10), ufo_integer )}) +test_that("ufo integer subscript: hash str 42", {test_ufo_subscript(n=100000, as.character(42), ufo_integer )}) +test_that("ufo integer subscript: hash str N+1", {test_ufo_subscript(n=100000, as.character(100001), ufo_integer )}) +test_that("ufo integer subscript: hash str 0,0", {test_ufo_subscript(n=100000, as.character(c(0, 0)), ufo_integer )}) +test_that("ufo integer subscript: hash str 0,1,0,N,0", {test_ufo_subscript(n=100000, as.character(c(0, 1, 0, 100000, 0)), ufo_integer )}) +test_that("ufo integer subscript: hash str 1,10,100,1000,100", {test_ufo_subscript(n=100000, as.character(c(1, 10, 100, 1000, 100)), ufo_integer )}) +test_that("ufo integer subscript: hash str few", {test_ufo_subscript(n=100000, as.character(c(4, 10, 7, 100)), ufo_integer )}) +test_that("ufo integer subscript: hash str many", {test_ufo_subscript(n=100000, as.character(c(1:1000, 2000:5000, 10:1000, 6000:10000)), ufo_integer )}) +test_that("ufo integer subscript: hash str all", {test_ufo_subscript(n=100000, as.character(1:100000), ufo_integer )}) +test_that("ufo integer subscript: hash str few with NAs", {test_ufo_subscript(n=100000, as.character(c(4, 10, NA, 7, NA, 100, NA)), ufo_integer )}) +test_that("ufo integer subscript: hash str many with NAs", {test_ufo_subscript(n=100000, as.character(c(1:1000, NA, 2000:5000, NA, 10:1000, NA, 6000:10000)), ufo_integer )}) +test_that("ufo integer subscript: hash str all with NAs", {test_ufo_subscript(n=100000, as.character(c(1:100000, NA)), ufo_integer )}) +test_that("ufo integer subscript: loop str character(0)", {test_ufo_subscript(n=10, character(0), ufo_integer )}) +test_that("ufo integer subscript: loop str 0", {test_ufo_subscript(n=10, as.character(0), ufo_integer )}) +test_that("ufo integer subscript: loop str 1", {test_ufo_subscript(n=10, as.character(1), ufo_integer )}) +test_that("ufo integer subscript: loop str 10", {test_ufo_subscript(n=10, as.character(10), ufo_integer )}) +test_that("ufo integer subscript: loop str 42", {test_ufo_subscript(n=10, as.character(42), ufo_integer )}) +test_that("ufo integer subscript: loop str N+1", {test_ufo_subscript(n=10, as.character(11), ufo_integer )}) +test_that("ufo integer subscript: loop str 0,0", {test_ufo_subscript(n=10, as.character(c(0, 0)), ufo_integer )}) +test_that("ufo integer subscript: loop str 0,1,0,N,0", {test_ufo_subscript(n=10, as.character(c(0, 1, 0, 10, 0)), ufo_integer )}) +test_that("ufo integer subscript: loop str 1,10,100,1000,100", {test_ufo_subscript(n=10, as.character(c(1, 10, 100, 1000, 100)), ufo_integer )}) +test_that("ufo integer subscript: loop str few", {test_ufo_subscript(n=10, as.character(c(4, 10, 7, 100)), ufo_integer )}) +test_that("ufo integer subscript: loop str many", {test_ufo_subscript(n=10, as.character(c(1:1000, 2000:5000, 10:1000, 6000:10000)), ufo_integer )}) +test_that("ufo integer subscript: loop str all", {test_ufo_subscript(n=10, as.character(1:100000), ufo_integer )}) +test_that("ufo integer subscript: loop str few with NAs", {test_ufo_subscript(n=10, as.character(c(4, 10, NA, 7, NA, 100, NA)), ufo_integer )}) +test_that("ufo integer subscript: loop str many with NAs", {test_ufo_subscript(n=10, as.character(c(1:1000, NA, 2000:5000, NA, 10:1000, NA, 6000:10000)), ufo_integer )}) +test_that("ufo integer subscript: loop str all with NAs", {test_ufo_subscript(n=10, as.character(c(1:100000, NA)), ufo_integer )}) +test_that("ufo integer+names subscript: hash str character(0)", {test_ufo_subscript(n=100000, character(0), ufo_integer, named=T)}) +test_that("ufo integer+names subscript: hash str 0", {test_ufo_subscript(n=100000, as.character(0), ufo_integer, named=T)}) +test_that("ufo integer+names subscript: hash str 1", {test_ufo_subscript(n=100000, as.character(1), ufo_integer, named=T)}) +test_that("ufo integer+names subscript: hash str 10", {test_ufo_subscript(n=100000, as.character(10), ufo_integer, named=T)}) +test_that("ufo integer+names subscript: hash str 42", {test_ufo_subscript(n=100000, as.character(42), ufo_integer, named=T)}) +test_that("ufo integer+names subscript: hash str N+1", {test_ufo_subscript(n=100000, as.character(100001), ufo_integer, named=T)}) +test_that("ufo integer+names subscript: hash str 0,0", {test_ufo_subscript(n=100000, as.character(c(0, 0)), ufo_integer, named=T)}) +test_that("ufo integer+names subscript: hash str 0,1,0,N,0", {test_ufo_subscript(n=100000, as.character(c(0, 1, 0, 100000, 0)), ufo_integer, named=T)}) +test_that("ufo integer+names subscript: hash str 1,10,100,1000,100", {test_ufo_subscript(n=100000, as.character(c(1, 10, 100, 1000, 100)), ufo_integer, named=T)}) +test_that("ufo integer+names subscript: hash str few", {test_ufo_subscript(n=100000, as.character(c(4, 10, 7, 100)), ufo_integer, named=T)}) +test_that("ufo integer+names subscript: hash str many", {test_ufo_subscript(n=100000, as.character(c(1:1000, 2000:5000, 10:1000, 6000:10000)), ufo_integer, named=T)}) +test_that("ufo integer+names subscript: hash str all", {test_ufo_subscript(n=100000, as.character(1:100000), ufo_integer, named=T)}) +test_that("ufo integer+names subscript: hash str few with NAs", {test_ufo_subscript(n=100000, as.character(c(4, 10, NA, 7, NA, 100, NA)), ufo_integer, named=T)}) +test_that("ufo integer+names subscript: hash str many with NAs", {test_ufo_subscript(n=100000, as.character(c(1:1000, NA, 2000:5000, NA, 10:1000, NA, 6000:10000)), ufo_integer, named=T)}) +test_that("ufo integer+names subscript: hash str all with NAs", {test_ufo_subscript(n=100000, as.character(c(1:100000, NA)), ufo_integer, named=T)}) +test_that("ufo integer+names subscript: loop str character(0)", {test_ufo_subscript(n=10, character(0), ufo_integer, named=T)}) +test_that("ufo integer+names subscript: loop str 0", {test_ufo_subscript(n=10, as.character(0), ufo_integer, named=T)}) +test_that("ufo integer+names subscript: loop str 1", {test_ufo_subscript(n=10, as.character(1), ufo_integer, named=T)}) +test_that("ufo integer+names subscript: loop str 10", {test_ufo_subscript(n=10, as.character(10), ufo_integer, named=T)}) +test_that("ufo integer+names subscript: loop str 42", {test_ufo_subscript(n=10, as.character(42), ufo_integer, named=T)}) +test_that("ufo integer+names subscript: loop str N+1", {test_ufo_subscript(n=10, as.character(11), ufo_integer, named=T)}) +test_that("ufo integer+names subscript: loop str 0,0", {test_ufo_subscript(n=10, as.character(c(0, 0)), ufo_integer, named=T)}) +test_that("ufo integer+names subscript: loop str 0,1,0,N,0", {test_ufo_subscript(n=10, as.character(c(0, 1, 0, 10, 0)), ufo_integer, named=T)}) +test_that("ufo integer+names subscript: loop str 1,10,100,1000,100", {test_ufo_subscript(n=10, as.character(c(1, 10, 100, 1000, 100)), ufo_integer, named=T)}) +test_that("ufo integer+names subscript: loop str few", {test_ufo_subscript(n=10, as.character(c(4, 10, 7, 100)), ufo_integer, named=T)}) +test_that("ufo integer+names subscript: loop str many", {test_ufo_subscript(n=10, as.character(c(1:1000, 2000:5000, 10:1000, 6000:10000)), ufo_integer, named=T)}) +test_that("ufo integer+names subscript: loop str all", {test_ufo_subscript(n=10, as.character(1:100000), ufo_integer, named=T)}) +test_that("ufo integer+names subscript: loop str few with NAs", {test_ufo_subscript(n=10, as.character(c(4, 10, NA, 7, NA, 100, NA)), ufo_integer, named=T)}) +test_that("ufo integer+names subscript: loop str many with NAs", {test_ufo_subscript(n=10, as.character(c(1:1000, NA, 2000:5000, NA, 10:1000, NA, 6000:10000)), ufo_integer, named=T)}) +test_that("ufo integer+names subscript: loop str all with NAs", {test_ufo_subscript(n=10, as.character(c(1:100000, NA)), ufo_integer, named=T)}) + +test_that("ufo numeric subscript: null", {test_ufo_subscript(n=10, NULL, ufo_numeric )}) +test_that("ufo numeric subscript: logical(0)", {test_ufo_subscript(n=100000, logical(0), ufo_numeric )}) +test_that("ufo numeric subscript: F", {test_ufo_subscript(n=100000, c(T), ufo_numeric )}) +test_that("ufo numeric subscript: T", {test_ufo_subscript(n=100000, c(F), ufo_numeric )}) +test_that("ufo numeric subscript: logical(NA)", {test_ufo_subscript(n=100000, as.logical(NA), ufo_numeric )}) +test_that("ufo numeric subscript: F,F", {test_ufo_subscript(n=100000, c(F, F), ufo_numeric )}) +test_that("ufo numeric subscript: F,T", {test_ufo_subscript(n=100000, c(F, T), ufo_numeric )}) +test_that("ufo numeric subscript: T,F", {test_ufo_subscript(n=100000, c(T, F), ufo_numeric )}) +test_that("ufo numeric subscript: T,T", {test_ufo_subscript(n=100000, c(T, T), ufo_numeric )}) +test_that("ufo numeric subscript: F,NA", {test_ufo_subscript(n=100000, c(F, NA), ufo_numeric )}) +test_that("ufo numeric subscript: NA,F", {test_ufo_subscript(n=100000, c(NA, F), ufo_numeric )}) +test_that("ufo numeric subscript: NA,T", {test_ufo_subscript(n=100000, c(NA, T), ufo_numeric )}) +test_that("ufo numeric subscript: T,NA", {test_ufo_subscript(n=100000, c(T, NA), ufo_numeric )}) +test_that("ufo numeric subscript: F,F,F", {test_ufo_subscript(n=100000, c(F, F, F), ufo_numeric )}) +test_that("ufo numeric subscript: F,F,T", {test_ufo_subscript(n=100000, c(F, F, T), ufo_numeric )}) +test_that("ufo numeric subscript: F,T,F", {test_ufo_subscript(n=100000, c(F, T, F), ufo_numeric )}) +test_that("ufo numeric subscript: F,T,T", {test_ufo_subscript(n=100000, c(F, T, T), ufo_numeric )}) +test_that("ufo numeric subscript: T,F,F", {test_ufo_subscript(n=100000, c(T, F, F), ufo_numeric )}) +test_that("ufo numeric subscript: T,F,T", {test_ufo_subscript(n=100000, c(T, F, T), ufo_numeric )}) +test_that("ufo numeric subscript: T,T,F", {test_ufo_subscript(n=100000, c(T, T, F), ufo_numeric )}) +test_that("ufo numeric subscript: T,T,T", {test_ufo_subscript(n=100000, c(T, T, T), ufo_numeric )}) +test_that("ufo numeric subscript: F,F,NA", {test_ufo_subscript(n=100000, c(F, F, NA), ufo_numeric )}) +test_that("ufo numeric subscript: F,NA,F", {test_ufo_subscript(n=100000, c(F, NA, F), ufo_numeric )}) +test_that("ufo numeric subscript: F,NA,NA", {test_ufo_subscript(n=100000, c(F, NA, NA), ufo_numeric )}) +test_that("ufo numeric subscript: NA,F,F", {test_ufo_subscript(n=100000, c(NA, F, F), ufo_numeric )}) +test_that("ufo numeric subscript: NA,F,NA", {test_ufo_subscript(n=100000, c(NA, F, NA), ufo_numeric )}) +test_that("ufo numeric subscript: NA,NA,F", {test_ufo_subscript(n=100000, c(NA, NA, F), ufo_numeric )}) +test_that("ufo numeric subscript: F,F,T", {test_ufo_subscript(n=100000, c(F, F, T), ufo_numeric )}) +test_that("ufo numeric subscript: F,NA,T", {test_ufo_subscript(n=100000, c(F, NA, T), ufo_numeric )}) +test_that("ufo numeric subscript: NA,F,T", {test_ufo_subscript(n=100000, c(NA, F, T), ufo_numeric )}) +test_that("ufo numeric subscript: NA,NA,T", {test_ufo_subscript(n=100000, c(NA, NA, T), ufo_numeric )}) +test_that("ufo numeric subscript: F,T,NA", {test_ufo_subscript(n=100000, c(F, T, NA), ufo_numeric )}) +test_that("ufo numeric subscript: NA,T,F", {test_ufo_subscript(n=100000, c(NA, T, F), ufo_numeric )}) +test_that("ufo numeric subscript: NA,T,NA", {test_ufo_subscript(n=100000, c(NA, T, NA), ufo_numeric )}) +test_that("ufo numeric subscript: F,NA,T", {test_ufo_subscript(n=100000, c(F, NA, T), ufo_numeric )}) +test_that("ufo numeric subscript: NA,T,T", {test_ufo_subscript(n=100000, c(NA, T, T), ufo_numeric )}) +test_that("ufo numeric subscript: T,F,NA", {test_ufo_subscript(n=100000, c(T, F, NA), ufo_numeric )}) +test_that("ufo numeric subscript: T,NA,F", {test_ufo_subscript(n=100000, c(T, NA, F), ufo_numeric )}) +test_that("ufo numeric subscript: T,NA,NA", {test_ufo_subscript(n=100000, c(T, NA, NA), ufo_numeric )}) +test_that("ufo numeric subscript: T,NA,T", {test_ufo_subscript(n=100000, c(T, NA, T), ufo_numeric )}) +test_that("ufo numeric subscript: T,T,NA", {test_ufo_subscript(n=100000, c(T, T, NA), ufo_numeric )}) +test_that("ufo numeric subscript: T,NA,NA", {test_ufo_subscript(n=100000, c(T, NA, NA), ufo_numeric )}) +test_that("ufo numeric subscript: T..", {test_ufo_subscript(n=100000, rep(T, 100000), ufo_numeric )}) +test_that("ufo numeric subscript: F..", {test_ufo_subscript(n=100000, rep(F, 100000), ufo_numeric )}) +test_that("ufo numeric subscript: T,F..", {test_ufo_subscript(n=100000, rep(c(T,F), 100000), ufo_numeric )}) +test_that("ufo numeric subscript: F,T..", {test_ufo_subscript(n=100000, rep(c(F,T), 100000), ufo_numeric )}) +test_that("ufo numeric subscript: int integer(0)", {test_ufo_subscript(n=100000, integer(0), ufo_numeric )}) +test_that("ufo numeric subscript: int 0", {test_ufo_subscript(n=100000, as.integer(0), ufo_numeric )}) +test_that("ufo numeric subscript: int 1", {test_ufo_subscript(n=100000, as.integer(1), ufo_numeric )}) +test_that("ufo numeric subscript: int 10", {test_ufo_subscript(n=100000, as.integer(10), ufo_numeric )}) +test_that("ufo numeric subscript: int 42", {test_ufo_subscript(n=100000, as.integer(42), ufo_numeric )}) +test_that("ufo numeric subscript: int N+1", {test_ufo_subscript(n=100000, as.integer(100001), ufo_numeric )}) +test_that("ufo numeric subscript: int 0,0", {test_ufo_subscript(n=100000, as.integer(c(0, 0)), ufo_numeric )}) +test_that("ufo numeric subscript: int 0,1,0,N,0", {test_ufo_subscript(n=100000, as.integer(c(0, 1, 0, 100000, 0)), ufo_numeric )}) +test_that("ufo numeric subscript: int 1,10,100,1000,100", {test_ufo_subscript(n=100000, as.integer(c(1, 10, 100, 1000, 100)), ufo_numeric )}) +test_that("ufo numeric subscript: int -1", {test_ufo_subscript(n=100000, as.integer(-1), ufo_numeric )}) +test_that("ufo numeric subscript: int -10", {test_ufo_subscript(n=100000, as.integer(-10), ufo_numeric )}) +test_that("ufo numeric subscript: int -42", {test_ufo_subscript(n=100000, as.integer(-42), ufo_numeric )}) +test_that("ufo numeric subscript: int -1,-10,-100,-1000,-100", {test_ufo_subscript(n=100000, as.integer(-c(1, 10, 100, 1000, 100)), ufo_numeric )}) +test_that("ufo numeric subscript: int few", {test_ufo_subscript(n=100000, as.integer(c(4, 10, 7, 100)), ufo_numeric )}) +test_that("ufo numeric subscript: int many", {test_ufo_subscript(n=100000, as.integer(c(1:1000, 2000:5000, 10:1000, 6000:10000)), ufo_numeric )}) +test_that("ufo numeric subscript: int all", {test_ufo_subscript(n=100000, as.integer(1:100000), ufo_numeric )}) +test_that("ufo numeric subscript: int few with NAs", {test_ufo_subscript(n=100000, as.integer(c(4, 10, NA, 7, NA, 100, NA)), ufo_numeric )}) +test_that("ufo numeric subscript: int many with NAs", {test_ufo_subscript(n=100000, as.integer(c(1:1000, NA, 2000:5000, NA, 10:1000, NA, 6000:10000)), ufo_numeric )}) +test_that("ufo numeric subscript: int all with NAs", {test_ufo_subscript(n=100000, as.integer(c(1:100000, NA)), ufo_numeric )}) +test_that("ufo numeric subscript: int few negative", {test_ufo_subscript(n=100000, as.integer(-c(4, 10, 7, 100)), ufo_numeric )}) +test_that("ufo numeric subscript: int many negative", {test_ufo_subscript(n=100000, as.integer(-c(1:1000, 2000:5000, 10:1000, 6000:10000)), ufo_numeric )}) +test_that("ufo numeric subscript: int all negative", {test_ufo_subscript(n=100000, as.integer(-(1:100000)), ufo_numeric )}) +test_that("ufo numeric subscript: num integer(0)", {test_ufo_subscript(n=100000, numeric(0), ufo_numeric )}) +test_that("ufo numeric subscript: num 0", {test_ufo_subscript(n=100000, as.numeric(0), ufo_numeric )}) +test_that("ufo numeric subscript: num 1", {test_ufo_subscript(n=100000, as.numeric(1), ufo_numeric )}) +test_that("ufo numeric subscript: num 10", {test_ufo_subscript(n=100000, as.numeric(10), ufo_numeric )}) +test_that("ufo numeric subscript: num 42", {test_ufo_subscript(n=100000, as.numeric(42), ufo_numeric )}) +test_that("ufo numeric subscript: num N+1", {test_ufo_subscript(n=100000, as.numeric(100001), ufo_numeric )}) +test_that("ufo numeric subscript: num 0,0", {test_ufo_subscript(n=100000, as.numeric(c(0, 0)), ufo_numeric )}) +test_that("ufo numeric subscript: num 0,1,0,N,0", {test_ufo_subscript(n=100000, as.numeric(c(0, 1, 0, 100000, 0)), ufo_numeric )}) +test_that("ufo numeric subscript: num 1,10,100,1000,100", {test_ufo_subscript(n=100000, as.numeric(c(1, 10, 100, 1000, 100)), ufo_numeric )}) +test_that("ufo numeric subscript: num -1", {test_ufo_subscript(n=100000, as.numeric(-1), ufo_numeric )}) +test_that("ufo numeric subscript: num -10", {test_ufo_subscript(n=100000, as.numeric(-10), ufo_numeric )}) +test_that("ufo numeric subscript: num -42", {test_ufo_subscript(n=100000, as.numeric(-42), ufo_numeric )}) +test_that("ufo numeric subscript: num -1,-10,-100,-1000,-100", {test_ufo_subscript(n=100000, as.numeric(-c(1, 10, 100, 1000, 100)), ufo_numeric )}) +test_that("ufo numeric subscript: num few", {test_ufo_subscript(n=100000, as.numeric(c(4, 10, 7, 100)), ufo_numeric )}) +test_that("ufo numeric subscript: num many", {test_ufo_subscript(n=100000, as.numeric(c(1:1000, 2000:5000, 10:1000, 6000:10000)), ufo_numeric )}) +test_that("ufo numeric subscript: num all", {test_ufo_subscript(n=100000, as.numeric(1:100000), ufo_numeric )}) +test_that("ufo numeric subscript: num few with NAs", {test_ufo_subscript(n=100000, as.numeric(c(4, 10, NA, 7, NA, 100, NA)), ufo_numeric )}) +test_that("ufo numeric subscript: num many with NAs", {test_ufo_subscript(n=100000, as.numeric(c(1:1000, NA, 2000:5000, NA, 10:1000, NA, 6000:10000)), ufo_numeric )}) +test_that("ufo numeric subscript: num all with NAs", {test_ufo_subscript(n=100000, as.numeric(c(1:100000, NA)), ufo_numeric )}) +test_that("ufo numeric subscript: num few negative", {test_ufo_subscript(n=100000, as.numeric(-c(4, 10, 7, 100)), ufo_numeric )}) +test_that("ufo numeric subscript: num many negative", {test_ufo_subscript(n=100000, as.numeric(-c(1:1000, 2000:5000, 10:1000, 6000:10000)), ufo_numeric )}) +test_that("ufo numeric subscript: num all negative", {test_ufo_subscript(n=100000, as.numeric(-(1:100000)), ufo_numeric )}) +test_that("ufo numeric subscript: num 0.1", {test_ufo_subscript(n=100000, as.numeric(0.1), ufo_numeric )}) +test_that("ufo numeric subscript: num 1.1", {test_ufo_subscript(n=100000, as.numeric(1.1), ufo_numeric )}) +test_that("ufo numeric subscript: num 10.5", {test_ufo_subscript(n=100000, as.numeric(10.5), ufo_numeric )}) +test_that("ufo numeric subscript: num 42.9", {test_ufo_subscript(n=100000, as.numeric(42.9), ufo_numeric )}) +test_that("ufo numeric subscript: num -0.1", {test_ufo_subscript(n=100000, as.numeric(-0.1), ufo_numeric )}) +test_that("ufo numeric subscript: num -1.1", {test_ufo_subscript(n=100000, as.numeric(-1.1), ufo_numeric )}) +test_that("ufo numeric subscript: num -10.5", {test_ufo_subscript(n=100000, as.numeric(-10.5), ufo_numeric )}) +test_that("ufo numeric subscript: num -42.9", {test_ufo_subscript(n=100000, as.numeric(-42.9), ufo_numeric )}) +test_that("ufo numeric subscript: hash str character(0)", {test_ufo_subscript(n=100000, character(0), ufo_numeric )}) +test_that("ufo numeric subscript: hash str 0", {test_ufo_subscript(n=100000, as.character(0), ufo_numeric )}) +test_that("ufo numeric subscript: hash str 1", {test_ufo_subscript(n=100000, as.character(1), ufo_numeric )}) +test_that("ufo numeric subscript: hash str 10", {test_ufo_subscript(n=100000, as.character(10), ufo_numeric )}) +test_that("ufo numeric subscript: hash str 42", {test_ufo_subscript(n=100000, as.character(42), ufo_numeric )}) +test_that("ufo numeric subscript: hash str N+1", {test_ufo_subscript(n=100000, as.character(100001), ufo_numeric )}) +test_that("ufo numeric subscript: hash str 0,0", {test_ufo_subscript(n=100000, as.character(c(0, 0)), ufo_numeric )}) +test_that("ufo numeric subscript: hash str 0,1,0,N,0", {test_ufo_subscript(n=100000, as.character(c(0, 1, 0, 100000, 0)), ufo_numeric )}) +test_that("ufo numeric subscript: hash str 1,10,100,1000,100", {test_ufo_subscript(n=100000, as.character(c(1, 10, 100, 1000, 100)), ufo_numeric )}) +test_that("ufo numeric subscript: hash str few", {test_ufo_subscript(n=100000, as.character(c(4, 10, 7, 100)), ufo_numeric )}) +test_that("ufo numeric subscript: hash str many", {test_ufo_subscript(n=100000, as.character(c(1:1000, 2000:5000, 10:1000, 6000:10000)), ufo_numeric )}) +test_that("ufo numeric subscript: hash str all", {test_ufo_subscript(n=100000, as.character(1:100000), ufo_numeric )}) +test_that("ufo numeric subscript: hash str few with NAs", {test_ufo_subscript(n=100000, as.character(c(4, 10, NA, 7, NA, 100, NA)), ufo_numeric )}) +test_that("ufo numeric subscript: hash str many with NAs", {test_ufo_subscript(n=100000, as.character(c(1:1000, NA, 2000:5000, NA, 10:1000, NA, 6000:10000)), ufo_numeric )}) +test_that("ufo numeric subscript: hash str all with NAs", {test_ufo_subscript(n=100000, as.character(c(1:100000, NA)), ufo_numeric )}) +test_that("ufo numeric subscript: loop str character(0)", {test_ufo_subscript(n=10, character(0), ufo_numeric )}) +test_that("ufo numeric subscript: loop str 0", {test_ufo_subscript(n=10, as.character(0), ufo_numeric )}) +test_that("ufo numeric subscript: loop str 1", {test_ufo_subscript(n=10, as.character(1), ufo_numeric )}) +test_that("ufo numeric subscript: loop str 10", {test_ufo_subscript(n=10, as.character(10), ufo_numeric )}) +test_that("ufo numeric subscript: loop str 42", {test_ufo_subscript(n=10, as.character(42), ufo_numeric )}) +test_that("ufo numeric subscript: loop str N+1", {test_ufo_subscript(n=10, as.character(11), ufo_numeric )}) +test_that("ufo numeric subscript: loop str 0,0", {test_ufo_subscript(n=10, as.character(c(0, 0)), ufo_numeric )}) +test_that("ufo numeric subscript: loop str 0,1,0,N,0", {test_ufo_subscript(n=10, as.character(c(0, 1, 0, 10, 0)), ufo_numeric )}) +test_that("ufo numeric subscript: loop str 1,10,100,1000,100", {test_ufo_subscript(n=10, as.character(c(1, 10, 100, 1000, 100)), ufo_numeric )}) +test_that("ufo numeric subscript: loop str few", {test_ufo_subscript(n=10, as.character(c(4, 10, 7, 100)), ufo_numeric )}) +test_that("ufo numeric subscript: loop str many", {test_ufo_subscript(n=10, as.character(c(1:1000, 2000:5000, 10:1000, 6000:10000)), ufo_numeric )}) +test_that("ufo numeric subscript: loop str all", {test_ufo_subscript(n=10, as.character(1:100000), ufo_numeric )}) +test_that("ufo numeric subscript: loop str few with NAs", {test_ufo_subscript(n=10, as.character(c(4, 10, NA, 7, NA, 100, NA)), ufo_numeric )}) +test_that("ufo numeric subscript: loop str many with NAs", {test_ufo_subscript(n=10, as.character(c(1:1000, NA, 2000:5000, NA, 10:1000, NA, 6000:10000)), ufo_numeric )}) +test_that("ufo numeric subscript: loop str all with NAs", {test_ufo_subscript(n=10, as.character(c(1:100000, NA)), ufo_numeric )}) +test_that("ufo numeric+names subscript: hash str character(0)", {test_ufo_subscript(n=100000, character(0), ufo_numeric, named=T)}) +test_that("ufo numeric+names subscript: hash str 0", {test_ufo_subscript(n=100000, as.character(0), ufo_numeric, named=T)}) +test_that("ufo numeric+names subscript: hash str 1", {test_ufo_subscript(n=100000, as.character(1), ufo_numeric, named=T)}) +test_that("ufo numeric+names subscript: hash str 10", {test_ufo_subscript(n=100000, as.character(10), ufo_numeric, named=T)}) +test_that("ufo numeric+names subscript: hash str 42", {test_ufo_subscript(n=100000, as.character(42), ufo_numeric, named=T)}) +test_that("ufo numeric+names subscript: hash str N+1", {test_ufo_subscript(n=100000, as.character(100001), ufo_numeric, named=T)}) +test_that("ufo numeric+names subscript: hash str 0,0", {test_ufo_subscript(n=100000, as.character(c(0, 0)), ufo_numeric, named=T)}) +test_that("ufo numeric+names subscript: hash str 0,1,0,N,0", {test_ufo_subscript(n=100000, as.character(c(0, 1, 0, 100000, 0)), ufo_numeric, named=T)}) +test_that("ufo numeric+names subscript: hash str 1,10,100,1000,100", {test_ufo_subscript(n=100000, as.character(c(1, 10, 100, 1000, 100)), ufo_numeric, named=T)}) +test_that("ufo numeric+names subscript: hash str few", {test_ufo_subscript(n=100000, as.character(c(4, 10, 7, 100)), ufo_numeric, named=T)}) +test_that("ufo numeric+names subscript: hash str many", {test_ufo_subscript(n=100000, as.character(c(1:1000, 2000:5000, 10:1000, 6000:10000)), ufo_numeric, named=T)}) +test_that("ufo numeric+names subscript: hash str all", {test_ufo_subscript(n=100000, as.character(1:100000), ufo_numeric, named=T)}) +test_that("ufo numeric+names subscript: hash str few with NAs", {test_ufo_subscript(n=100000, as.character(c(4, 10, NA, 7, NA, 100, NA)), ufo_numeric, named=T)}) +test_that("ufo numeric+names subscript: hash str many with NAs", {test_ufo_subscript(n=100000, as.character(c(1:1000, NA, 2000:5000, NA, 10:1000, NA, 6000:10000)), ufo_numeric, named=T)}) +test_that("ufo numeric+names subscript: hash str all with NAs", {test_ufo_subscript(n=100000, as.character(c(1:100000, NA)), ufo_numeric, named=T)}) +test_that("ufo numeric+names subscript: loop str character(0)", {test_ufo_subscript(n=10, character(0), ufo_numeric, named=T)}) +test_that("ufo numeric+names subscript: loop str 0", {test_ufo_subscript(n=10, as.character(0), ufo_numeric, named=T)}) +test_that("ufo numeric+names subscript: loop str 1", {test_ufo_subscript(n=10, as.character(1), ufo_numeric, named=T)}) +test_that("ufo numeric+names subscript: loop str 10", {test_ufo_subscript(n=10, as.character(10), ufo_numeric, named=T)}) +test_that("ufo numeric+names subscript: loop str 42", {test_ufo_subscript(n=10, as.character(42), ufo_numeric, named=T)}) +test_that("ufo numeric+names subscript: loop str N+1", {test_ufo_subscript(n=10, as.character(11), ufo_numeric, named=T)}) +test_that("ufo numeric+names subscript: loop str 0,0", {test_ufo_subscript(n=10, as.character(c(0, 0)), ufo_numeric, named=T)}) +test_that("ufo numeric+names subscript: loop str 0,1,0,N,0", {test_ufo_subscript(n=10, as.character(c(0, 1, 0, 10, 0)), ufo_numeric, named=T)}) +test_that("ufo numeric+names subscript: loop str 1,10,100,1000,100", {test_ufo_subscript(n=10, as.character(c(1, 10, 100, 1000, 100)), ufo_numeric, named=T)}) +test_that("ufo numeric+names subscript: loop str few", {test_ufo_subscript(n=10, as.character(c(4, 10, 7, 100)), ufo_numeric, named=T)}) +test_that("ufo numeric+names subscript: loop str many", {test_ufo_subscript(n=10, as.character(c(1:1000, 2000:5000, 10:1000, 6000:10000)), ufo_numeric, named=T)}) +test_that("ufo numeric+names subscript: loop str all", {test_ufo_subscript(n=10, as.character(1:100000), ufo_numeric, named=T)}) +test_that("ufo numeric+names subscript: loop str few with NAs", {test_ufo_subscript(n=10, as.character(c(4, 10, NA, 7, NA, 100, NA)), ufo_numeric, named=T)}) +test_that("ufo numeric+names subscript: loop str many with NAs", {test_ufo_subscript(n=10, as.character(c(1:1000, NA, 2000:5000, NA, 10:1000, NA, 6000:10000)), ufo_numeric, named=T)}) +test_that("ufo numeric+names subscript: loop str all with NAs", {test_ufo_subscript(n=10, as.character(c(1:100000, NA)), ufo_numeric, named=T)}) + +test_that("ufo logical subscript: null", {test_ufo_subscript(n=100000, NULL, ufo_logical )}) +test_that("ufo logical subscript: logical(0)", {test_ufo_subscript(n=100000, logical(0), ufo_logical )}) +test_that("ufo logical subscript: F", {test_ufo_subscript(n=100000, c(T), ufo_logical )}) +test_that("ufo logical subscript: T", {test_ufo_subscript(n=100000, c(F), ufo_logical )}) +test_that("ufo logical subscript: logical(NA)", {test_ufo_subscript(n=100000, as.logical(NA), ufo_logical )}) +test_that("ufo logical subscript: F,F", {test_ufo_subscript(n=100000, c(F, F), ufo_logical )}) +test_that("ufo logical subscript: F,T", {test_ufo_subscript(n=100000, c(F, T), ufo_logical )}) +test_that("ufo logical subscript: T,F", {test_ufo_subscript(n=100000, c(T, F), ufo_logical )}) +test_that("ufo logical subscript: T,T", {test_ufo_subscript(n=100000, c(T, T), ufo_logical )}) +test_that("ufo logical subscript: F,NA", {test_ufo_subscript(n=100000, c(F, NA), ufo_logical )}) +test_that("ufo logical subscript: NA,F", {test_ufo_subscript(n=100000, c(NA, F), ufo_logical )}) +test_that("ufo logical subscript: NA,T", {test_ufo_subscript(n=100000, c(NA, T), ufo_logical )}) +test_that("ufo logical subscript: T,NA", {test_ufo_subscript(n=100000, c(T, NA), ufo_logical )}) +test_that("ufo logical subscript: F,F,F", {test_ufo_subscript(n=100000, c(F, F, F), ufo_logical )}) +test_that("ufo logical subscript: F,F,T", {test_ufo_subscript(n=100000, c(F, F, T), ufo_logical )}) +test_that("ufo logical subscript: F,T,F", {test_ufo_subscript(n=100000, c(F, T, F), ufo_logical )}) +test_that("ufo logical subscript: F,T,T", {test_ufo_subscript(n=100000, c(F, T, T), ufo_logical )}) +test_that("ufo logical subscript: T,F,F", {test_ufo_subscript(n=100000, c(T, F, F), ufo_logical )}) +test_that("ufo logical subscript: T,F,T", {test_ufo_subscript(n=100000, c(T, F, T), ufo_logical )}) +test_that("ufo logical subscript: T,T,F", {test_ufo_subscript(n=100000, c(T, T, F), ufo_logical )}) +test_that("ufo logical subscript: T,T,T", {test_ufo_subscript(n=100000, c(T, T, T), ufo_logical )}) +test_that("ufo logical subscript: F,F,NA", {test_ufo_subscript(n=100000, c(F, F, NA), ufo_logical )}) +test_that("ufo logical subscript: F,NA,F", {test_ufo_subscript(n=100000, c(F, NA, F), ufo_logical )}) +test_that("ufo logical subscript: F,NA,NA", {test_ufo_subscript(n=100000, c(F, NA, NA), ufo_logical )}) +test_that("ufo logical subscript: NA,F,F", {test_ufo_subscript(n=100000, c(NA, F, F), ufo_logical )}) +test_that("ufo logical subscript: NA,F,NA", {test_ufo_subscript(n=100000, c(NA, F, NA), ufo_logical )}) +test_that("ufo logical subscript: NA,NA,F", {test_ufo_subscript(n=100000, c(NA, NA, F), ufo_logical )}) +test_that("ufo logical subscript: F,F,T", {test_ufo_subscript(n=100000, c(F, F, T), ufo_logical )}) +test_that("ufo logical subscript: F,NA,T", {test_ufo_subscript(n=100000, c(F, NA, T), ufo_logical )}) +test_that("ufo logical subscript: NA,F,T", {test_ufo_subscript(n=100000, c(NA, F, T), ufo_logical )}) +test_that("ufo logical subscript: NA,NA,T", {test_ufo_subscript(n=100000, c(NA, NA, T), ufo_logical )}) +test_that("ufo logical subscript: F,T,NA", {test_ufo_subscript(n=100000, c(F, T, NA), ufo_logical )}) +test_that("ufo logical subscript: NA,T,F", {test_ufo_subscript(n=100000, c(NA, T, F), ufo_logical )}) +test_that("ufo logical subscript: NA,T,NA", {test_ufo_subscript(n=100000, c(NA, T, NA), ufo_logical )}) +test_that("ufo logical subscript: F,NA,T", {test_ufo_subscript(n=100000, c(F, NA, T), ufo_logical )}) +test_that("ufo logical subscript: NA,T,T", {test_ufo_subscript(n=100000, c(NA, T, T), ufo_logical )}) +test_that("ufo logical subscript: T,F,NA", {test_ufo_subscript(n=100000, c(T, F, NA), ufo_logical )}) +test_that("ufo logical subscript: T,NA,F", {test_ufo_subscript(n=100000, c(T, NA, F), ufo_logical )}) +test_that("ufo logical subscript: T,NA,NA", {test_ufo_subscript(n=100000, c(T, NA, NA), ufo_logical )}) +test_that("ufo logical subscript: T,NA,T", {test_ufo_subscript(n=100000, c(T, NA, T), ufo_logical )}) +test_that("ufo logical subscript: T,T,NA", {test_ufo_subscript(n=100000, c(T, T, NA), ufo_logical )}) +test_that("ufo logical subscript: T,NA,NA", {test_ufo_subscript(n=100000, c(T, NA, NA), ufo_logical )}) +test_that("ufo logical subscript: T..", {test_ufo_subscript(n=100000, rep(T, 100000), ufo_logical )}) +test_that("ufo logical subscript: F..", {test_ufo_subscript(n=100000, rep(F, 100000), ufo_logical )}) +test_that("ufo logical subscript: T,F..", {test_ufo_subscript(n=100000, rep(c(T,F), 100000), ufo_logical )}) +test_that("ufo logical subscript: F,T..", {test_ufo_subscript(n=100000, rep(c(F,T), 100000), ufo_logical )}) +test_that("ufo logical subscript: int integer(0)", {test_ufo_subscript(n=100000, integer(0), ufo_logical )}) +test_that("ufo logical subscript: int 0", {test_ufo_subscript(n=100000, as.integer(0), ufo_logical )}) +test_that("ufo logical subscript: int 1", {test_ufo_subscript(n=100000, as.integer(1), ufo_logical )}) +test_that("ufo logical subscript: int 10", {test_ufo_subscript(n=100000, as.integer(10), ufo_logical )}) +test_that("ufo logical subscript: int 42", {test_ufo_subscript(n=100000, as.integer(42), ufo_logical )}) +test_that("ufo logical subscript: int N+1", {test_ufo_subscript(n=100000, as.integer(100001), ufo_logical )}) +test_that("ufo logical subscript: int 0,0", {test_ufo_subscript(n=100000, as.integer(c(0, 0)), ufo_logical )}) +test_that("ufo logical subscript: int 0,1,0,N,0", {test_ufo_subscript(n=100000, as.integer(c(0, 1, 0, 100000, 0)), ufo_logical )}) +test_that("ufo logical subscript: int 1,10,100,1000,100", {test_ufo_subscript(n=100000, as.integer(c(1, 10, 100, 1000, 100)), ufo_logical )}) +test_that("ufo logical subscript: int -1", {test_ufo_subscript(n=100000, as.integer(-1), ufo_logical )}) +test_that("ufo logical subscript: int -10", {test_ufo_subscript(n=100000, as.integer(-10), ufo_logical )}) +test_that("ufo logical subscript: int -42", {test_ufo_subscript(n=100000, as.integer(-42), ufo_logical )}) +test_that("ufo logical subscript: int -1,-10,-100,-1000,-100", {test_ufo_subscript(n=100000, as.integer(-c(1, 10, 100, 1000, 100)), ufo_logical )}) +test_that("ufo logical subscript: int few", {test_ufo_subscript(n=100000, as.integer(c(4, 10, 7, 100)), ufo_logical )}) +test_that("ufo logical subscript: int many", {test_ufo_subscript(n=100000, as.integer(c(1:1000, 2000:5000, 10:1000, 6000:10000)), ufo_logical )}) +test_that("ufo logical subscript: int all", {test_ufo_subscript(n=100000, as.integer(1:100000), ufo_logical )}) +test_that("ufo logical subscript: int few with NAs", {test_ufo_subscript(n=100000, as.integer(c(4, 10, NA, 7, NA, 100, NA)), ufo_logical )}) +test_that("ufo logical subscript: int many with NAs", {test_ufo_subscript(n=100000, as.integer(c(1:1000, NA, 2000:5000, NA, 10:1000, NA, 6000:10000)), ufo_logical )}) +test_that("ufo logical subscript: int all with NAs", {test_ufo_subscript(n=100000, as.integer(c(1:100000, NA)), ufo_logical )}) +test_that("ufo logical subscript: int few negative", {test_ufo_subscript(n=100000, as.integer(-c(4, 10, 7, 100)), ufo_logical )}) +test_that("ufo logical subscript: int many negative", {test_ufo_subscript(n=100000, as.integer(-c(1:1000, 2000:5000, 10:1000, 6000:10000)), ufo_logical )}) +test_that("ufo logical subscript: int all negative", {test_ufo_subscript(n=100000, as.integer(-(1:100000)), ufo_logical )}) +test_that("ufo logical subscript: num integer(0)", {test_ufo_subscript(n=100000, numeric(0), ufo_logical )}) +test_that("ufo logical subscript: num 0", {test_ufo_subscript(n=100000, as.numeric(0), ufo_logical )}) +test_that("ufo logical subscript: num 1", {test_ufo_subscript(n=100000, as.numeric(1), ufo_logical )}) +test_that("ufo logical subscript: num 10", {test_ufo_subscript(n=100000, as.numeric(10), ufo_logical )}) +test_that("ufo logical subscript: num 42", {test_ufo_subscript(n=100000, as.numeric(42), ufo_logical )}) +test_that("ufo logical subscript: num N+1", {test_ufo_subscript(n=100000, as.numeric(100001), ufo_logical )}) +test_that("ufo logical subscript: num 0,0", {test_ufo_subscript(n=100000, as.numeric(c(0, 0)), ufo_logical )}) +test_that("ufo logical subscript: num 0,1,0,N,0", {test_ufo_subscript(n=100000, as.numeric(c(0, 1, 0, 100000, 0)), ufo_logical )}) +test_that("ufo logical subscript: num 1,10,100,1000,100", {test_ufo_subscript(n=100000, as.numeric(c(1, 10, 100, 1000, 100)), ufo_logical )}) +test_that("ufo logical subscript: num -1", {test_ufo_subscript(n=100000, as.numeric(-1), ufo_logical )}) +test_that("ufo logical subscript: num -10", {test_ufo_subscript(n=100000, as.numeric(-10), ufo_logical )}) +test_that("ufo logical subscript: num -42", {test_ufo_subscript(n=100000, as.numeric(-42), ufo_logical )}) +test_that("ufo logical subscript: num -1,-10,-100,-1000,-100", {test_ufo_subscript(n=100000, as.numeric(-c(1, 10, 100, 1000, 100)), ufo_logical )}) +test_that("ufo logical subscript: num few", {test_ufo_subscript(n=100000, as.numeric(c(4, 10, 7, 100)), ufo_logical )}) +test_that("ufo logical subscript: num many", {test_ufo_subscript(n=100000, as.numeric(c(1:1000, 2000:5000, 10:1000, 6000:10000)), ufo_logical )}) +test_that("ufo logical subscript: num all", {test_ufo_subscript(n=100000, as.numeric(1:100000), ufo_logical )}) +test_that("ufo logical subscript: num few with NAs", {test_ufo_subscript(n=100000, as.numeric(c(4, 10, NA, 7, NA, 100, NA)), ufo_logical )}) +test_that("ufo logical subscript: num many with NAs", {test_ufo_subscript(n=100000, as.numeric(c(1:1000, NA, 2000:5000, NA, 10:1000, NA, 6000:10000)), ufo_logical )}) +test_that("ufo logical subscript: num all with NAs", {test_ufo_subscript(n=100000, as.numeric(c(1:100000, NA)), ufo_logical )}) +test_that("ufo logical subscript: num few negative", {test_ufo_subscript(n=100000, as.numeric(-c(4, 10, 7, 100)), ufo_logical )}) +test_that("ufo logical subscript: num many negative", {test_ufo_subscript(n=100000, as.numeric(-c(1:1000, 2000:5000, 10:1000, 6000:10000)), ufo_logical )}) +test_that("ufo logical subscript: num all negative", {test_ufo_subscript(n=100000, as.numeric(-(1:100000)), ufo_logical )}) +test_that("ufo logical subscript: num 0.1", {test_ufo_subscript(n=100000, as.numeric(0.1), ufo_logical )}) +test_that("ufo logical subscript: num 1.1", {test_ufo_subscript(n=100000, as.numeric(1.1), ufo_logical )}) +test_that("ufo logical subscript: num 10.5", {test_ufo_subscript(n=100000, as.numeric(10.5), ufo_logical )}) +test_that("ufo logical subscript: num 42.9", {test_ufo_subscript(n=100000, as.numeric(42.9), ufo_logical )}) +test_that("ufo logical subscript: num -0.1", {test_ufo_subscript(n=100000, as.numeric(-0.1), ufo_logical )}) +test_that("ufo logical subscript: num -1.1", {test_ufo_subscript(n=100000, as.numeric(-1.1), ufo_logical )}) +test_that("ufo logical subscript: num -10.5", {test_ufo_subscript(n=100000, as.numeric(-10.5), ufo_logical )}) +test_that("ufo logical subscript: num -42.9", {test_ufo_subscript(n=100000, as.numeric(-42.9), ufo_logical )}) +test_that("ufo logical subscript: hash str character(0)", {test_ufo_subscript(n=100000, character(0), ufo_logical )}) +test_that("ufo logical subscript: hash str 0", {test_ufo_subscript(n=100000, as.character(0), ufo_logical )}) +test_that("ufo logical subscript: hash str 1", {test_ufo_subscript(n=100000, as.character(1), ufo_logical )}) +test_that("ufo logical subscript: hash str 10", {test_ufo_subscript(n=100000, as.character(10), ufo_logical )}) +test_that("ufo logical subscript: hash str 42", {test_ufo_subscript(n=100000, as.character(42), ufo_logical )}) +test_that("ufo logical subscript: hash str N+1", {test_ufo_subscript(n=100000, as.character(100001), ufo_logical )}) +test_that("ufo logical subscript: hash str 0,0", {test_ufo_subscript(n=100000, as.character(c(0, 0)), ufo_logical )}) +test_that("ufo logical subscript: hash str 0,1,0,N,0", {test_ufo_subscript(n=100000, as.character(c(0, 1, 0, 100000, 0)), ufo_logical )}) +test_that("ufo logical subscript: hash str 1,10,100,1000,100", {test_ufo_subscript(n=100000, as.character(c(1, 10, 100, 1000, 100)), ufo_logical )}) +test_that("ufo logical subscript: hash str few", {test_ufo_subscript(n=100000, as.character(c(4, 10, 7, 100)), ufo_logical )}) +test_that("ufo logical subscript: hash str many", {test_ufo_subscript(n=100000, as.character(c(1:1000, 2000:5000, 10:1000, 6000:10000)), ufo_logical )}) +test_that("ufo logical subscript: hash str all", {test_ufo_subscript(n=100000, as.character(1:100000), ufo_logical )}) +test_that("ufo logical subscript: hash str few with NAs", {test_ufo_subscript(n=100000, as.character(c(4, 10, NA, 7, NA, 100, NA)), ufo_logical )}) +test_that("ufo logical subscript: hash str many with NAs", {test_ufo_subscript(n=100000, as.character(c(1:1000, NA, 2000:5000, NA, 10:1000, NA, 6000:10000)), ufo_logical )}) +test_that("ufo logical subscript: hash str all with NAs", {test_ufo_subscript(n=100000, as.character(c(1:100000, NA)), ufo_logical )}) +test_that("ufo logical subscript: loop str character(0)", {test_ufo_subscript(n=10, character(0), ufo_logical )}) +test_that("ufo logical subscript: loop str 0", {test_ufo_subscript(n=10, as.character(0), ufo_logical )}) +test_that("ufo logical subscript: loop str 1", {test_ufo_subscript(n=10, as.character(1), ufo_logical )}) +test_that("ufo logical subscript: loop str 10", {test_ufo_subscript(n=10, as.character(10), ufo_logical )}) +test_that("ufo logical subscript: loop str 42", {test_ufo_subscript(n=10, as.character(42), ufo_logical )}) +test_that("ufo logical subscript: loop str N+1", {test_ufo_subscript(n=10, as.character(11), ufo_logical )}) +test_that("ufo logical subscript: loop str 0,0", {test_ufo_subscript(n=10, as.character(c(0, 0)), ufo_logical )}) +test_that("ufo logical subscript: loop str 0,1,0,N,0", {test_ufo_subscript(n=10, as.character(c(0, 1, 0, 10, 0)), ufo_logical )}) +test_that("ufo logical subscript: loop str 1,10,100,1000,100", {test_ufo_subscript(n=10, as.character(c(1, 10, 100, 1000, 100)), ufo_logical )}) +test_that("ufo logical subscript: loop str few", {test_ufo_subscript(n=10, as.character(c(4, 10, 7, 100)), ufo_logical )}) +test_that("ufo logical subscript: loop str many", {test_ufo_subscript(n=10, as.character(c(1:1000, 2000:5000, 10:1000, 6000:10000)), ufo_logical )}) +test_that("ufo logical subscript: loop str all", {test_ufo_subscript(n=10, as.character(1:100000), ufo_logical )}) +test_that("ufo logical subscript: loop str few with NAs", {test_ufo_subscript(n=10, as.character(c(4, 10, NA, 7, NA, 100, NA)), ufo_logical )}) +test_that("ufo logical subscript: loop str many with NAs", {test_ufo_subscript(n=10, as.character(c(1:1000, NA, 2000:5000, NA, 10:1000, NA, 6000:10000)), ufo_logical )}) +test_that("ufo logical subscript: loop str all with NAs", {test_ufo_subscript(n=10, as.character(c(1:100000, NA)), ufo_logical )}) +test_that("ufo logical+names subscript: hash str character(0)", {test_ufo_subscript(n=100000, character(0), ufo_logical, named=T)}) +test_that("ufo logical+names subscript: hash str 0", {test_ufo_subscript(n=100000, as.character(0), ufo_logical, named=T)}) +test_that("ufo logical+names subscript: hash str 1", {test_ufo_subscript(n=100000, as.character(1), ufo_logical, named=T)}) +test_that("ufo logical+names subscript: hash str 10", {test_ufo_subscript(n=100000, as.character(10), ufo_logical, named=T)}) +test_that("ufo logical+names subscript: hash str 42", {test_ufo_subscript(n=100000, as.character(42), ufo_logical, named=T)}) +test_that("ufo logical+names subscript: hash str N+1", {test_ufo_subscript(n=100000, as.character(100001), ufo_logical, named=T)}) +test_that("ufo logical+names subscript: hash str 0,0", {test_ufo_subscript(n=100000, as.character(c(0, 0)), ufo_logical, named=T)}) +test_that("ufo logical+names subscript: hash str 0,1,0,N,0", {test_ufo_subscript(n=100000, as.character(c(0, 1, 0, 100000, 0)), ufo_logical, named=T)}) +test_that("ufo logical+names subscript: hash str 1,10,100,1000,100", {test_ufo_subscript(n=100000, as.character(c(1, 10, 100, 1000, 100)), ufo_logical, named=T)}) +test_that("ufo logical+names subscript: hash str few", {test_ufo_subscript(n=100000, as.character(c(4, 10, 7, 100)), ufo_logical, named=T)}) +test_that("ufo logical+names subscript: hash str many", {test_ufo_subscript(n=100000, as.character(c(1:1000, 2000:5000, 10:1000, 6000:10000)), ufo_logical, named=T)}) +test_that("ufo logical+names subscript: hash str all", {test_ufo_subscript(n=100000, as.character(1:100000), ufo_logical, named=T)}) +test_that("ufo logical+names subscript: hash str few with NAs", {test_ufo_subscript(n=100000, as.character(c(4, 10, NA, 7, NA, 100, NA)), ufo_logical, named=T)}) +test_that("ufo logical+names subscript: hash str many with NAs", {test_ufo_subscript(n=100000, as.character(c(1:1000, NA, 2000:5000, NA, 10:1000, NA, 6000:10000)), ufo_logical, named=T)}) +test_that("ufo logical+names subscript: hash str all with NAs", {test_ufo_subscript(n=100000, as.character(c(1:100000, NA)), ufo_logical, named=T)}) +test_that("ufo logical+names subscript: loop str character(0)", {test_ufo_subscript(n=10, character(0), ufo_logical, named=T)}) +test_that("ufo logical+names subscript: loop str 0", {test_ufo_subscript(n=10, as.character(0), ufo_logical, named=T)}) +test_that("ufo logical+names subscript: loop str 1", {test_ufo_subscript(n=10, as.character(1), ufo_logical, named=T)}) +test_that("ufo logical+names subscript: loop str 10", {test_ufo_subscript(n=10, as.character(10), ufo_logical, named=T)}) +test_that("ufo logical+names subscript: loop str 42", {test_ufo_subscript(n=10, as.character(42), ufo_logical, named=T)}) +test_that("ufo logical+names subscript: loop str N+1", {test_ufo_subscript(n=10, as.character(11), ufo_logical, named=T)}) +test_that("ufo logical+names subscript: loop str 0,0", {test_ufo_subscript(n=10, as.character(c(0, 0)), ufo_logical, named=T)}) +test_that("ufo logical+names subscript: loop str 0,1,0,N,0", {test_ufo_subscript(n=10, as.character(c(0, 1, 0, 10, 0)), ufo_logical, named=T)}) +test_that("ufo logical+names subscript: loop str 1,10,100,1000,100", {test_ufo_subscript(n=10, as.character(c(1, 10, 100, 1000, 100)), ufo_logical, named=T)}) +test_that("ufo logical+names subscript: loop str few", {test_ufo_subscript(n=10, as.character(c(4, 10, 7, 100)), ufo_logical, named=T)}) +test_that("ufo logical+names subscript: loop str many", {test_ufo_subscript(n=10, as.character(c(1:1000, 2000:5000, 10:1000, 6000:10000)), ufo_logical, named=T)}) +test_that("ufo logical+names subscript: loop str all", {test_ufo_subscript(n=10, as.character(1:100000), ufo_logical, named=T)}) +test_that("ufo logical+names subscript: loop str few with NAs", {test_ufo_subscript(n=10, as.character(c(4, 10, NA, 7, NA, 100, NA)), ufo_logical, named=T)}) +test_that("ufo logical+names subscript: loop str many with NAs", {test_ufo_subscript(n=10, as.character(c(1:1000, NA, 2000:5000, NA, 10:1000, NA, 6000:10000)), ufo_logical, named=T)}) +test_that("ufo logical+names subscript: loop str all with NAs", {test_ufo_subscript(n=10, as.character(c(1:100000, NA)), ufo_logical, named=T)}) + +test_that("ufo complex subscript: null", {test_ufo_subscript(n=100000, NULL, ufo_complex )}) +test_that("ufo complex subscript: logical(0)", {test_ufo_subscript(n=100000, logical(0), ufo_complex )}) +test_that("ufo complex subscript: F", {test_ufo_subscript(n=100000, c(T), ufo_complex )}) +test_that("ufo complex subscript: T", {test_ufo_subscript(n=100000, c(F), ufo_complex )}) +test_that("ufo complex subscript: logical(NA)", {test_ufo_subscript(n=100000, as.logical(NA), ufo_complex )}) +test_that("ufo complex subscript: F,F", {test_ufo_subscript(n=100000, c(F, F), ufo_complex )}) +test_that("ufo complex subscript: F,T", {test_ufo_subscript(n=100000, c(F, T), ufo_complex )}) +test_that("ufo complex subscript: T,F", {test_ufo_subscript(n=100000, c(T, F), ufo_complex )}) +test_that("ufo complex subscript: T,T", {test_ufo_subscript(n=100000, c(T, T), ufo_complex )}) +test_that("ufo complex subscript: F,NA", {test_ufo_subscript(n=100000, c(F, NA), ufo_complex )}) +test_that("ufo complex subscript: NA,F", {test_ufo_subscript(n=100000, c(NA, F), ufo_complex )}) +test_that("ufo complex subscript: NA,T", {test_ufo_subscript(n=100000, c(NA, T), ufo_complex )}) +test_that("ufo complex subscript: T,NA", {test_ufo_subscript(n=100000, c(T, NA), ufo_complex )}) +test_that("ufo complex subscript: F,F,F", {test_ufo_subscript(n=100000, c(F, F, F), ufo_complex )}) +test_that("ufo complex subscript: F,F,T", {test_ufo_subscript(n=100000, c(F, F, T), ufo_complex )}) +test_that("ufo complex subscript: F,T,F", {test_ufo_subscript(n=100000, c(F, T, F), ufo_complex )}) +test_that("ufo complex subscript: F,T,T", {test_ufo_subscript(n=100000, c(F, T, T), ufo_complex )}) +test_that("ufo complex subscript: T,F,F", {test_ufo_subscript(n=100000, c(T, F, F), ufo_complex )}) +test_that("ufo complex subscript: T,F,T", {test_ufo_subscript(n=100000, c(T, F, T), ufo_complex )}) +test_that("ufo complex subscript: T,T,F", {test_ufo_subscript(n=100000, c(T, T, F), ufo_complex )}) +test_that("ufo complex subscript: T,T,T", {test_ufo_subscript(n=100000, c(T, T, T), ufo_complex )}) +test_that("ufo complex subscript: F,F,NA", {test_ufo_subscript(n=100000, c(F, F, NA), ufo_complex )}) +test_that("ufo complex subscript: F,NA,F", {test_ufo_subscript(n=100000, c(F, NA, F), ufo_complex )}) +test_that("ufo complex subscript: F,NA,NA", {test_ufo_subscript(n=100000, c(F, NA, NA), ufo_complex )}) +test_that("ufo complex subscript: NA,F,F", {test_ufo_subscript(n=100000, c(NA, F, F), ufo_complex )}) +test_that("ufo complex subscript: NA,F,NA", {test_ufo_subscript(n=100000, c(NA, F, NA), ufo_complex )}) +test_that("ufo complex subscript: NA,NA,F", {test_ufo_subscript(n=100000, c(NA, NA, F), ufo_complex )}) +test_that("ufo complex subscript: F,F,T", {test_ufo_subscript(n=100000, c(F, F, T), ufo_complex )}) +test_that("ufo complex subscript: F,NA,T", {test_ufo_subscript(n=100000, c(F, NA, T), ufo_complex )}) +test_that("ufo complex subscript: NA,F,T", {test_ufo_subscript(n=100000, c(NA, F, T), ufo_complex )}) +test_that("ufo complex subscript: NA,NA,T", {test_ufo_subscript(n=100000, c(NA, NA, T), ufo_complex )}) +test_that("ufo complex subscript: F,T,NA", {test_ufo_subscript(n=100000, c(F, T, NA), ufo_complex )}) +test_that("ufo complex subscript: NA,T,F", {test_ufo_subscript(n=100000, c(NA, T, F), ufo_complex )}) +test_that("ufo complex subscript: NA,T,NA", {test_ufo_subscript(n=100000, c(NA, T, NA), ufo_complex )}) +test_that("ufo complex subscript: F,NA,T", {test_ufo_subscript(n=100000, c(F, NA, T), ufo_complex )}) +test_that("ufo complex subscript: NA,T,T", {test_ufo_subscript(n=100000, c(NA, T, T), ufo_complex )}) +test_that("ufo complex subscript: T,F,NA", {test_ufo_subscript(n=100000, c(T, F, NA), ufo_complex )}) +test_that("ufo complex subscript: T,NA,F", {test_ufo_subscript(n=100000, c(T, NA, F), ufo_complex )}) +test_that("ufo complex subscript: T,NA,NA", {test_ufo_subscript(n=100000, c(T, NA, NA), ufo_complex )}) +test_that("ufo complex subscript: T,NA,T", {test_ufo_subscript(n=100000, c(T, NA, T), ufo_complex )}) +test_that("ufo complex subscript: T,T,NA", {test_ufo_subscript(n=100000, c(T, T, NA), ufo_complex )}) +test_that("ufo complex subscript: T,NA,NA", {test_ufo_subscript(n=100000, c(T, NA, NA), ufo_complex )}) +test_that("ufo complex subscript: T..", {test_ufo_subscript(n=100000, rep(T, 100000), ufo_complex )}) +test_that("ufo complex subscript: F..", {test_ufo_subscript(n=100000, rep(F, 100000), ufo_complex )}) +test_that("ufo complex subscript: T,F..", {test_ufo_subscript(n=100000, rep(c(T,F), 100000), ufo_complex )}) +test_that("ufo complex subscript: F,T..", {test_ufo_subscript(n=100000, rep(c(F,T), 100000), ufo_complex )}) +test_that("ufo complex subscript: int integer(0)", {test_ufo_subscript(n=100000, integer(0), ufo_complex )}) +test_that("ufo complex subscript: int 0", {test_ufo_subscript(n=100000, as.integer(0), ufo_complex )}) +test_that("ufo complex subscript: int 1", {test_ufo_subscript(n=100000, as.integer(1), ufo_complex )}) +test_that("ufo complex subscript: int 10", {test_ufo_subscript(n=100000, as.integer(10), ufo_complex )}) +test_that("ufo complex subscript: int 42", {test_ufo_subscript(n=100000, as.integer(42), ufo_complex )}) +test_that("ufo complex subscript: int N+1", {test_ufo_subscript(n=100000, as.integer(100001), ufo_complex )}) +test_that("ufo complex subscript: int 0,0", {test_ufo_subscript(n=100000, as.integer(c(0, 0)), ufo_complex )}) +test_that("ufo complex subscript: int 0,1,0,N,0", {test_ufo_subscript(n=100000, as.integer(c(0, 1, 0, 100000, 0)), ufo_complex )}) +test_that("ufo complex subscript: int 1,10,100,1000,100", {test_ufo_subscript(n=100000, as.integer(c(1, 10, 100, 1000, 100)), ufo_complex )}) +test_that("ufo complex subscript: int -1", {test_ufo_subscript(n=100000, as.integer(-1), ufo_complex )}) +test_that("ufo complex subscript: int -10", {test_ufo_subscript(n=100000, as.integer(-10), ufo_complex )}) +test_that("ufo complex subscript: int -42", {test_ufo_subscript(n=100000, as.integer(-42), ufo_complex )}) +test_that("ufo complex subscript: int -1,-10,-100,-1000,-100", {test_ufo_subscript(n=100000, as.integer(-c(1, 10, 100, 1000, 100)), ufo_complex )}) +test_that("ufo complex subscript: int few", {test_ufo_subscript(n=100000, as.integer(c(4, 10, 7, 100)), ufo_complex )}) +test_that("ufo complex subscript: int many", {test_ufo_subscript(n=100000, as.integer(c(1:1000, 2000:5000, 10:1000, 6000:10000)), ufo_complex )}) +test_that("ufo complex subscript: int all", {test_ufo_subscript(n=100000, as.integer(1:100000), ufo_complex )}) +test_that("ufo complex subscript: int few with NAs", {test_ufo_subscript(n=100000, as.integer(c(4, 10, NA, 7, NA, 100, NA)), ufo_complex )}) +test_that("ufo complex subscript: int many with NAs", {test_ufo_subscript(n=100000, as.integer(c(1:1000, NA, 2000:5000, NA, 10:1000, NA, 6000:10000)), ufo_complex )}) +test_that("ufo complex subscript: int all with NAs", {test_ufo_subscript(n=100000, as.integer(c(1:100000, NA)), ufo_complex )}) +test_that("ufo complex subscript: int few negative", {test_ufo_subscript(n=100000, as.integer(-c(4, 10, 7, 100)), ufo_complex )}) +test_that("ufo complex subscript: int many negative", {test_ufo_subscript(n=100000, as.integer(-c(1:1000, 2000:5000, 10:1000, 6000:10000)), ufo_complex )}) +test_that("ufo complex subscript: int all negative", {test_ufo_subscript(n=100000, as.integer(-(1:100000)), ufo_complex )}) +test_that("ufo complex subscript: num integer(0)", {test_ufo_subscript(n=100000, numeric(0), ufo_complex )}) +test_that("ufo complex subscript: num 0", {test_ufo_subscript(n=100000, as.numeric(0), ufo_complex )}) +test_that("ufo complex subscript: num 1", {test_ufo_subscript(n=100000, as.numeric(1), ufo_complex )}) +test_that("ufo complex subscript: num 10", {test_ufo_subscript(n=100000, as.numeric(10), ufo_complex )}) +test_that("ufo complex subscript: num 42", {test_ufo_subscript(n=100000, as.numeric(42), ufo_complex )}) +test_that("ufo complex subscript: num N+1", {test_ufo_subscript(n=100000, as.numeric(100001), ufo_complex )}) +test_that("ufo complex subscript: num 0,0", {test_ufo_subscript(n=100000, as.numeric(c(0, 0)), ufo_complex )}) +test_that("ufo complex subscript: num 0,1,0,N,0", {test_ufo_subscript(n=100000, as.numeric(c(0, 1, 0, 100000, 0)), ufo_complex )}) +test_that("ufo complex subscript: num 1,10,100,1000,100", {test_ufo_subscript(n=100000, as.numeric(c(1, 10, 100, 1000, 100)), ufo_complex )}) +test_that("ufo complex subscript: num -1", {test_ufo_subscript(n=100000, as.numeric(-1), ufo_complex )}) +test_that("ufo complex subscript: num -10", {test_ufo_subscript(n=100000, as.numeric(-10), ufo_complex )}) +test_that("ufo complex subscript: num -42", {test_ufo_subscript(n=100000, as.numeric(-42), ufo_complex )}) +test_that("ufo complex subscript: num -1,-10,-100,-1000,-100", {test_ufo_subscript(n=100000, as.numeric(-c(1, 10, 100, 1000, 100)), ufo_complex )}) +test_that("ufo complex subscript: num few", {test_ufo_subscript(n=100000, as.numeric(c(4, 10, 7, 100)), ufo_complex )}) +test_that("ufo complex subscript: num many", {test_ufo_subscript(n=100000, as.numeric(c(1:1000, 2000:5000, 10:1000, 6000:10000)), ufo_complex )}) +test_that("ufo complex subscript: num all", {test_ufo_subscript(n=100000, as.numeric(1:100000), ufo_complex )}) +test_that("ufo complex subscript: num few with NAs", {test_ufo_subscript(n=100000, as.numeric(c(4, 10, NA, 7, NA, 100, NA)), ufo_complex )}) +test_that("ufo complex subscript: num many with NAs", {test_ufo_subscript(n=100000, as.numeric(c(1:1000, NA, 2000:5000, NA, 10:1000, NA, 6000:10000)), ufo_complex )}) +test_that("ufo complex subscript: num all with NAs", {test_ufo_subscript(n=100000, as.numeric(c(1:100000, NA)), ufo_complex )}) +test_that("ufo complex subscript: num few negative", {test_ufo_subscript(n=100000, as.numeric(-c(4, 10, 7, 100)), ufo_complex )}) +test_that("ufo complex subscript: num many negative", {test_ufo_subscript(n=100000, as.numeric(-c(1:1000, 2000:5000, 10:1000, 6000:10000)), ufo_complex )}) +test_that("ufo complex subscript: num all negative", {test_ufo_subscript(n=100000, as.numeric(-(1:100000)), ufo_complex )}) +test_that("ufo complex subscript: num 0.1", {test_ufo_subscript(n=100000, as.numeric(0.1), ufo_complex )}) +test_that("ufo complex subscript: num 1.1", {test_ufo_subscript(n=100000, as.numeric(1.1), ufo_complex )}) +test_that("ufo complex subscript: num 10.5", {test_ufo_subscript(n=100000, as.numeric(10.5), ufo_complex )}) +test_that("ufo complex subscript: num 42.9", {test_ufo_subscript(n=100000, as.numeric(42.9), ufo_complex )}) +test_that("ufo complex subscript: num -0.1", {test_ufo_subscript(n=100000, as.numeric(-0.1), ufo_complex )}) +test_that("ufo complex subscript: num -1.1", {test_ufo_subscript(n=100000, as.numeric(-1.1), ufo_complex )}) +test_that("ufo complex subscript: num -10.5", {test_ufo_subscript(n=100000, as.numeric(-10.5), ufo_complex )}) +test_that("ufo complex subscript: num -42.9", {test_ufo_subscript(n=100000, as.numeric(-42.9), ufo_complex )}) +test_that("ufo complex subscript: hash str character(0)", {test_ufo_subscript(n=100000, character(0), ufo_complex )}) +test_that("ufo complex subscript: hash str 0", {test_ufo_subscript(n=100000, as.character(0), ufo_complex )}) +test_that("ufo complex subscript: hash str 1", {test_ufo_subscript(n=100000, as.character(1), ufo_complex )}) +test_that("ufo complex subscript: hash str 10", {test_ufo_subscript(n=100000, as.character(10), ufo_complex )}) +test_that("ufo complex subscript: hash str 42", {test_ufo_subscript(n=100000, as.character(42), ufo_complex )}) +test_that("ufo complex subscript: hash str N+1", {test_ufo_subscript(n=100000, as.character(100001), ufo_complex )}) +test_that("ufo complex subscript: hash str 0,0", {test_ufo_subscript(n=100000, as.character(c(0, 0)), ufo_complex )}) +test_that("ufo complex subscript: hash str 0,1,0,N,0", {test_ufo_subscript(n=100000, as.character(c(0, 1, 0, 100000, 0)), ufo_complex )}) +test_that("ufo complex subscript: hash str 1,10,100,1000,100", {test_ufo_subscript(n=100000, as.character(c(1, 10, 100, 1000, 100)), ufo_complex )}) +test_that("ufo complex subscript: hash str few", {test_ufo_subscript(n=100000, as.character(c(4, 10, 7, 100)), ufo_complex )}) +test_that("ufo complex subscript: hash str many", {test_ufo_subscript(n=100000, as.character(c(1:1000, 2000:5000, 10:1000, 6000:10000)), ufo_complex )}) +test_that("ufo complex subscript: hash str all", {test_ufo_subscript(n=100000, as.character(1:100000), ufo_complex )}) +test_that("ufo complex subscript: hash str few with NAs", {test_ufo_subscript(n=100000, as.character(c(4, 10, NA, 7, NA, 100, NA)), ufo_complex )}) +test_that("ufo complex subscript: hash str many with NAs", {test_ufo_subscript(n=100000, as.character(c(1:1000, NA, 2000:5000, NA, 10:1000, NA, 6000:10000)), ufo_complex )}) +test_that("ufo complex subscript: hash str all with NAs", {test_ufo_subscript(n=100000, as.character(c(1:100000, NA)), ufo_complex )}) +test_that("ufo complex subscript: loop str character(0)", {test_ufo_subscript(n=10, character(0), ufo_complex )}) +test_that("ufo complex subscript: loop str 0", {test_ufo_subscript(n=10, as.character(0), ufo_complex )}) +test_that("ufo complex subscript: loop str 1", {test_ufo_subscript(n=10, as.character(1), ufo_complex )}) +test_that("ufo complex subscript: loop str 10", {test_ufo_subscript(n=10, as.character(10), ufo_complex )}) +test_that("ufo complex subscript: loop str 42", {test_ufo_subscript(n=10, as.character(42), ufo_complex )}) +test_that("ufo complex subscript: loop str N+1", {test_ufo_subscript(n=10, as.character(11), ufo_complex )}) +test_that("ufo complex subscript: loop str 0,0", {test_ufo_subscript(n=10, as.character(c(0, 0)), ufo_complex )}) +test_that("ufo complex subscript: loop str 0,1,0,N,0", {test_ufo_subscript(n=10, as.character(c(0, 1, 0, 10, 0)), ufo_complex )}) +test_that("ufo complex subscript: loop str 1,10,100,1000,100", {test_ufo_subscript(n=10, as.character(c(1, 10, 100, 1000, 100)), ufo_complex )}) +test_that("ufo complex subscript: loop str few", {test_ufo_subscript(n=10, as.character(c(4, 10, 7, 100)), ufo_complex )}) +test_that("ufo complex subscript: loop str many", {test_ufo_subscript(n=10, as.character(c(1:1000, 2000:5000, 10:1000, 6000:10000)), ufo_complex )}) +test_that("ufo complex subscript: loop str all", {test_ufo_subscript(n=10, as.character(1:100000), ufo_complex )}) +test_that("ufo complex subscript: loop str few with NAs", {test_ufo_subscript(n=10, as.character(c(4, 10, NA, 7, NA, 100, NA)), ufo_complex )}) +test_that("ufo complex subscript: loop str many with NAs", {test_ufo_subscript(n=10, as.character(c(1:1000, NA, 2000:5000, NA, 10:1000, NA, 6000:10000)), ufo_complex )}) +test_that("ufo complex subscript: loop str all with NAs", {test_ufo_subscript(n=10, as.character(c(1:100000, NA)), ufo_complex )}) +test_that("ufo complex+names subscript: hash str character(0)", {test_ufo_subscript(n=100000, character(0), ufo_complex, named=T)}) +test_that("ufo complex+names subscript: hash str 0", {test_ufo_subscript(n=100000, as.character(0), ufo_complex, named=T)}) +test_that("ufo complex+names subscript: hash str 1", {test_ufo_subscript(n=100000, as.character(1), ufo_complex, named=T)}) +test_that("ufo complex+names subscript: hash str 10", {test_ufo_subscript(n=100000, as.character(10), ufo_complex, named=T)}) +test_that("ufo complex+names subscript: hash str 42", {test_ufo_subscript(n=100000, as.character(42), ufo_complex, named=T)}) +test_that("ufo complex+names subscript: hash str N+1", {test_ufo_subscript(n=100000, as.character(100001), ufo_complex, named=T)}) +test_that("ufo complex+names subscript: hash str 0,0", {test_ufo_subscript(n=100000, as.character(c(0, 0)), ufo_complex, named=T)}) +test_that("ufo complex+names subscript: hash str 0,1,0,N,0", {test_ufo_subscript(n=100000, as.character(c(0, 1, 0, 100000, 0)), ufo_complex, named=T)}) +test_that("ufo complex+names subscript: hash str 1,10,100,1000,100", {test_ufo_subscript(n=100000, as.character(c(1, 10, 100, 1000, 100)), ufo_complex, named=T)}) +test_that("ufo complex+names subscript: hash str few", {test_ufo_subscript(n=100000, as.character(c(4, 10, 7, 100)), ufo_complex, named=T)}) +test_that("ufo complex+names subscript: hash str many", {test_ufo_subscript(n=100000, as.character(c(1:1000, 2000:5000, 10:1000, 6000:10000)), ufo_complex, named=T)}) +test_that("ufo complex+names subscript: hash str all", {test_ufo_subscript(n=100000, as.character(1:100000), ufo_complex, named=T)}) +test_that("ufo complex+names subscript: hash str few with NAs", {test_ufo_subscript(n=100000, as.character(c(4, 10, NA, 7, NA, 100, NA)), ufo_complex, named=T)}) +test_that("ufo complex+names subscript: hash str many with NAs", {test_ufo_subscript(n=100000, as.character(c(1:1000, NA, 2000:5000, NA, 10:1000, NA, 6000:10000)), ufo_complex, named=T)}) +test_that("ufo complex+names subscript: hash str all with NAs", {test_ufo_subscript(n=100000, as.character(c(1:100000, NA)), ufo_complex, named=T)}) +test_that("ufo complex+names subscript: loop str character(0)", {test_ufo_subscript(n=10, character(0), ufo_complex, named=T)}) +test_that("ufo complex+names subscript: loop str 0", {test_ufo_subscript(n=10, as.character(0), ufo_complex, named=T)}) +test_that("ufo complex+names subscript: loop str 1", {test_ufo_subscript(n=10, as.character(1), ufo_complex, named=T)}) +test_that("ufo complex+names subscript: loop str 10", {test_ufo_subscript(n=10, as.character(10), ufo_complex, named=T)}) +test_that("ufo complex+names subscript: loop str 42", {test_ufo_subscript(n=10, as.character(42), ufo_complex, named=T)}) +test_that("ufo complex+names subscript: loop str N+1", {test_ufo_subscript(n=10, as.character(11), ufo_complex, named=T)}) +test_that("ufo complex+names subscript: loop str 0,0", {test_ufo_subscript(n=10, as.character(c(0, 0)), ufo_complex, named=T)}) +test_that("ufo complex+names subscript: loop str 0,1,0,N,0", {test_ufo_subscript(n=10, as.character(c(0, 1, 0, 10, 0)), ufo_complex, named=T)}) +test_that("ufo complex+names subscript: loop str 1,10,100,1000,100", {test_ufo_subscript(n=10, as.character(c(1, 10, 100, 1000, 100)), ufo_complex, named=T)}) +test_that("ufo complex+names subscript: loop str few", {test_ufo_subscript(n=10, as.character(c(4, 10, 7, 100)), ufo_complex, named=T)}) +test_that("ufo complex+names subscript: loop str many", {test_ufo_subscript(n=10, as.character(c(1:1000, 2000:5000, 10:1000, 6000:10000)), ufo_complex, named=T)}) +test_that("ufo complex+names subscript: loop str all", {test_ufo_subscript(n=10, as.character(1:100000), ufo_complex, named=T)}) +test_that("ufo complex+names subscript: loop str few with NAs", {test_ufo_subscript(n=10, as.character(c(4, 10, NA, 7, NA, 100, NA)), ufo_complex, named=T)}) +test_that("ufo complex+names subscript: loop str many with NAs", {test_ufo_subscript(n=10, as.character(c(1:1000, NA, 2000:5000, NA, 10:1000, NA, 6000:10000)), ufo_complex, named=T)}) +test_that("ufo complex+names subscript: loop str all with NAs", {test_ufo_subscript(n=10, as.character(c(1:100000, NA)), ufo_complex, named=T)}) + +test_that("ufo raw subscript: null", {test_ufo_subscript(n=100000, NULL, ufo_raw )}) +test_that("ufo raw subscript: logical(0)", {test_ufo_subscript(n=100000, logical(0), ufo_raw )}) +test_that("ufo raw subscript: F", {test_ufo_subscript(n=100000, c(T), ufo_raw )}) +test_that("ufo raw subscript: T", {test_ufo_subscript(n=100000, c(F), ufo_raw )}) +test_that("ufo raw subscript: logical(NA)", {test_ufo_subscript(n=100000, as.logical(NA), ufo_raw )}) +test_that("ufo raw subscript: F,F", {test_ufo_subscript(n=100000, c(F, F), ufo_raw )}) +test_that("ufo raw subscript: F,T", {test_ufo_subscript(n=100000, c(F, T), ufo_raw )}) +test_that("ufo raw subscript: T,F", {test_ufo_subscript(n=100000, c(T, F), ufo_raw )}) +test_that("ufo raw subscript: T,T", {test_ufo_subscript(n=100000, c(T, T), ufo_raw )}) +test_that("ufo raw subscript: F,NA", {test_ufo_subscript(n=100000, c(F, NA), ufo_raw )}) +test_that("ufo raw subscript: NA,F", {test_ufo_subscript(n=100000, c(NA, F), ufo_raw )}) +test_that("ufo raw subscript: NA,T", {test_ufo_subscript(n=100000, c(NA, T), ufo_raw )}) +test_that("ufo raw subscript: T,NA", {test_ufo_subscript(n=100000, c(T, NA), ufo_raw )}) +test_that("ufo raw subscript: F,F,F", {test_ufo_subscript(n=100000, c(F, F, F), ufo_raw )}) +test_that("ufo raw subscript: F,F,T", {test_ufo_subscript(n=100000, c(F, F, T), ufo_raw )}) +test_that("ufo raw subscript: F,T,F", {test_ufo_subscript(n=100000, c(F, T, F), ufo_raw )}) +test_that("ufo raw subscript: F,T,T", {test_ufo_subscript(n=100000, c(F, T, T), ufo_raw )}) +test_that("ufo raw subscript: T,F,F", {test_ufo_subscript(n=100000, c(T, F, F), ufo_raw )}) +test_that("ufo raw subscript: T,F,T", {test_ufo_subscript(n=100000, c(T, F, T), ufo_raw )}) +test_that("ufo raw subscript: T,T,F", {test_ufo_subscript(n=100000, c(T, T, F), ufo_raw )}) +test_that("ufo raw subscript: T,T,T", {test_ufo_subscript(n=100000, c(T, T, T), ufo_raw )}) +test_that("ufo raw subscript: F,F,NA", {test_ufo_subscript(n=100000, c(F, F, NA), ufo_raw )}) +test_that("ufo raw subscript: F,NA,F", {test_ufo_subscript(n=100000, c(F, NA, F), ufo_raw )}) +test_that("ufo raw subscript: F,NA,NA", {test_ufo_subscript(n=100000, c(F, NA, NA), ufo_raw )}) +test_that("ufo raw subscript: NA,F,F", {test_ufo_subscript(n=100000, c(NA, F, F), ufo_raw )}) +test_that("ufo raw subscript: NA,F,NA", {test_ufo_subscript(n=100000, c(NA, F, NA), ufo_raw )}) +test_that("ufo raw subscript: NA,NA,F", {test_ufo_subscript(n=100000, c(NA, NA, F), ufo_raw )}) +test_that("ufo raw subscript: F,F,T", {test_ufo_subscript(n=100000, c(F, F, T), ufo_raw )}) +test_that("ufo raw subscript: F,NA,T", {test_ufo_subscript(n=100000, c(F, NA, T), ufo_raw )}) +test_that("ufo raw subscript: NA,F,T", {test_ufo_subscript(n=100000, c(NA, F, T), ufo_raw )}) +test_that("ufo raw subscript: NA,NA,T", {test_ufo_subscript(n=100000, c(NA, NA, T), ufo_raw )}) +test_that("ufo raw subscript: F,T,NA", {test_ufo_subscript(n=100000, c(F, T, NA), ufo_raw )}) +test_that("ufo raw subscript: NA,T,F", {test_ufo_subscript(n=100000, c(NA, T, F), ufo_raw )}) +test_that("ufo raw subscript: NA,T,NA", {test_ufo_subscript(n=100000, c(NA, T, NA), ufo_raw )}) +test_that("ufo raw subscript: F,NA,T", {test_ufo_subscript(n=100000, c(F, NA, T), ufo_raw )}) +test_that("ufo raw subscript: NA,T,T", {test_ufo_subscript(n=100000, c(NA, T, T), ufo_raw )}) +test_that("ufo raw subscript: T,F,NA", {test_ufo_subscript(n=100000, c(T, F, NA), ufo_raw )}) +test_that("ufo raw subscript: T,NA,F", {test_ufo_subscript(n=100000, c(T, NA, F), ufo_raw )}) +test_that("ufo raw subscript: T,NA,NA", {test_ufo_subscript(n=100000, c(T, NA, NA), ufo_raw )}) +test_that("ufo raw subscript: T,NA,T", {test_ufo_subscript(n=100000, c(T, NA, T), ufo_raw )}) +test_that("ufo raw subscript: T,T,NA", {test_ufo_subscript(n=100000, c(T, T, NA), ufo_raw )}) +test_that("ufo raw subscript: T,NA,NA", {test_ufo_subscript(n=100000, c(T, NA, NA), ufo_raw )}) +test_that("ufo raw subscript: T..", {test_ufo_subscript(n=100000, rep(T, 100000), ufo_raw )}) +test_that("ufo raw subscript: F..", {test_ufo_subscript(n=100000, rep(F, 100000), ufo_raw )}) +test_that("ufo raw subscript: T,F..", {test_ufo_subscript(n=100000, rep(c(T,F), 100000), ufo_raw )}) +test_that("ufo raw subscript: F,T..", {test_ufo_subscript(n=100000, rep(c(F,T), 100000), ufo_raw )}) +test_that("ufo raw subscript: int integer(0)", {test_ufo_subscript(n=100000, integer(0), ufo_raw )}) +test_that("ufo raw subscript: int 0", {test_ufo_subscript(n=100000, as.integer(0), ufo_raw )}) +test_that("ufo raw subscript: int 1", {test_ufo_subscript(n=100000, as.integer(1), ufo_raw )}) +test_that("ufo raw subscript: int 10", {test_ufo_subscript(n=100000, as.integer(10), ufo_raw )}) +test_that("ufo raw subscript: int 42", {test_ufo_subscript(n=100000, as.integer(42), ufo_raw )}) +test_that("ufo raw subscript: int N+1", {test_ufo_subscript(n=100000, as.integer(100001), ufo_raw )}) +test_that("ufo raw subscript: int 0,0", {test_ufo_subscript(n=100000, as.integer(c(0, 0)), ufo_raw )}) +test_that("ufo raw subscript: int 0,1,0,N,0", {test_ufo_subscript(n=100000, as.integer(c(0, 1, 0, 100000, 0)), ufo_raw )}) +test_that("ufo raw subscript: int 1,10,100,1000,100", {test_ufo_subscript(n=100000, as.integer(c(1, 10, 100, 1000, 100)), ufo_raw )}) +test_that("ufo raw subscript: int -1", {test_ufo_subscript(n=100000, as.integer(-1), ufo_raw )}) +test_that("ufo raw subscript: int -10", {test_ufo_subscript(n=100000, as.integer(-10), ufo_raw )}) +test_that("ufo raw subscript: int -42", {test_ufo_subscript(n=100000, as.integer(-42), ufo_raw )}) +test_that("ufo raw subscript: int -1,-10,-100,-1000,-100", {test_ufo_subscript(n=100000, as.integer(-c(1, 10, 100, 1000, 100)), ufo_raw )}) +test_that("ufo raw subscript: int few", {test_ufo_subscript(n=100000, as.integer(c(4, 10, 7, 100)), ufo_raw )}) +test_that("ufo raw subscript: int many", {test_ufo_subscript(n=100000, as.integer(c(1:1000, 2000:5000, 10:1000, 6000:10000)), ufo_raw )}) +test_that("ufo raw subscript: int all", {test_ufo_subscript(n=100000, as.integer(1:100000), ufo_raw )}) +test_that("ufo raw subscript: int few with NAs", {test_ufo_subscript(n=100000, as.integer(c(4, 10, NA, 7, NA, 100, NA)), ufo_raw )}) +test_that("ufo raw subscript: int many with NAs", {test_ufo_subscript(n=100000, as.integer(c(1:1000, NA, 2000:5000, NA, 10:1000, NA, 6000:10000)), ufo_raw )}) +test_that("ufo raw subscript: int all with NAs", {test_ufo_subscript(n=100000, as.integer(c(1:100000, NA)), ufo_raw )}) +test_that("ufo raw subscript: int few negative", {test_ufo_subscript(n=100000, as.integer(-c(4, 10, 7, 100)), ufo_raw )}) +test_that("ufo raw subscript: int many negative", {test_ufo_subscript(n=100000, as.integer(-c(1:1000, 2000:5000, 10:1000, 6000:10000)), ufo_raw )}) +test_that("ufo raw subscript: int all negative", {test_ufo_subscript(n=100000, as.integer(-(1:100000)), ufo_raw )}) +test_that("ufo raw subscript: num integer(0)", {test_ufo_subscript(n=100000, numeric(0), ufo_raw )}) +test_that("ufo raw subscript: num 0", {test_ufo_subscript(n=100000, as.numeric(0), ufo_raw )}) +test_that("ufo raw subscript: num 1", {test_ufo_subscript(n=100000, as.numeric(1), ufo_raw )}) +test_that("ufo raw subscript: num 10", {test_ufo_subscript(n=100000, as.numeric(10), ufo_raw )}) +test_that("ufo raw subscript: num 42", {test_ufo_subscript(n=100000, as.numeric(42), ufo_raw )}) +test_that("ufo raw subscript: num N+1", {test_ufo_subscript(n=100000, as.numeric(100001), ufo_raw )}) +test_that("ufo raw subscript: num 0,0", {test_ufo_subscript(n=100000, as.numeric(c(0, 0)), ufo_raw )}) +test_that("ufo raw subscript: num 0,1,0,N,0", {test_ufo_subscript(n=100000, as.numeric(c(0, 1, 0, 100000, 0)), ufo_raw )}) +test_that("ufo raw subscript: num 1,10,100,1000,100", {test_ufo_subscript(n=100000, as.numeric(c(1, 10, 100, 1000, 100)), ufo_raw )}) +test_that("ufo raw subscript: num -1", {test_ufo_subscript(n=100000, as.numeric(-1), ufo_raw )}) +test_that("ufo raw subscript: num -10", {test_ufo_subscript(n=100000, as.numeric(-10), ufo_raw )}) +test_that("ufo raw subscript: num -42", {test_ufo_subscript(n=100000, as.numeric(-42), ufo_raw )}) +test_that("ufo raw subscript: num -1,-10,-100,-1000,-100", {test_ufo_subscript(n=100000, as.numeric(-c(1, 10, 100, 1000, 100)), ufo_raw )}) +test_that("ufo raw subscript: num few", {test_ufo_subscript(n=100000, as.numeric(c(4, 10, 7, 100)), ufo_raw )}) +test_that("ufo raw subscript: num many", {test_ufo_subscript(n=100000, as.numeric(c(1:1000, 2000:5000, 10:1000, 6000:10000)), ufo_raw )}) +test_that("ufo raw subscript: num all", {test_ufo_subscript(n=100000, as.numeric(1:100000), ufo_raw )}) +test_that("ufo raw subscript: num few with NAs", {test_ufo_subscript(n=100000, as.numeric(c(4, 10, NA, 7, NA, 100, NA)), ufo_raw )}) +test_that("ufo raw subscript: num many with NAs", {test_ufo_subscript(n=100000, as.numeric(c(1:1000, NA, 2000:5000, NA, 10:1000, NA, 6000:10000)), ufo_raw )}) +test_that("ufo raw subscript: num all with NAs", {test_ufo_subscript(n=100000, as.numeric(c(1:100000, NA)), ufo_raw )}) +test_that("ufo raw subscript: num few negative", {test_ufo_subscript(n=100000, as.numeric(-c(4, 10, 7, 100)), ufo_raw )}) +test_that("ufo raw subscript: num many negative", {test_ufo_subscript(n=100000, as.numeric(-c(1:1000, 2000:5000, 10:1000, 6000:10000)), ufo_raw )}) +test_that("ufo raw subscript: num all negative", {test_ufo_subscript(n=100000, as.numeric(-(1:100000)), ufo_raw )}) +test_that("ufo raw subscript: num 0.1", {test_ufo_subscript(n=100000, as.numeric(0.1), ufo_raw )}) +test_that("ufo raw subscript: num 1.1", {test_ufo_subscript(n=100000, as.numeric(1.1), ufo_raw )}) +test_that("ufo raw subscript: num 10.5", {test_ufo_subscript(n=100000, as.numeric(10.5), ufo_raw )}) +test_that("ufo raw subscript: num 42.9", {test_ufo_subscript(n=100000, as.numeric(42.9), ufo_raw )}) +test_that("ufo raw subscript: num -0.1", {test_ufo_subscript(n=100000, as.numeric(-0.1), ufo_raw )}) +test_that("ufo raw subscript: num -1.1", {test_ufo_subscript(n=100000, as.numeric(-1.1), ufo_raw )}) +test_that("ufo raw subscript: num -10.5", {test_ufo_subscript(n=100000, as.numeric(-10.5), ufo_raw )}) +test_that("ufo raw subscript: num -42.9", {test_ufo_subscript(n=100000, as.numeric(-42.9), ufo_raw )}) +test_that("ufo raw subscript: hash str character(0)", {test_ufo_subscript(n=100000, character(0), ufo_raw )}) +test_that("ufo raw subscript: hash str 0", {test_ufo_subscript(n=100000, as.character(0), ufo_raw )}) +test_that("ufo raw subscript: hash str 1", {test_ufo_subscript(n=100000, as.character(1), ufo_raw )}) +test_that("ufo raw subscript: hash str 10", {test_ufo_subscript(n=100000, as.character(10), ufo_raw )}) +test_that("ufo raw subscript: hash str 42", {test_ufo_subscript(n=100000, as.character(42), ufo_raw )}) +test_that("ufo raw subscript: hash str N+1", {test_ufo_subscript(n=100000, as.character(100001), ufo_raw )}) +test_that("ufo raw subscript: hash str 0,0", {test_ufo_subscript(n=100000, as.character(c(0, 0)), ufo_raw )}) +test_that("ufo raw subscript: hash str 0,1,0,N,0", {test_ufo_subscript(n=100000, as.character(c(0, 1, 0, 100000, 0)), ufo_raw )}) +test_that("ufo raw subscript: hash str 1,10,100,1000,100", {test_ufo_subscript(n=100000, as.character(c(1, 10, 100, 1000, 100)), ufo_raw )}) +test_that("ufo raw subscript: hash str few", {test_ufo_subscript(n=100000, as.character(c(4, 10, 7, 100)), ufo_raw )}) +test_that("ufo raw subscript: hash str many", {test_ufo_subscript(n=100000, as.character(c(1:1000, 2000:5000, 10:1000, 6000:10000)), ufo_raw )}) +test_that("ufo raw subscript: hash str all", {test_ufo_subscript(n=100000, as.character(1:100000), ufo_raw )}) +test_that("ufo raw subscript: hash str few with NAs", {test_ufo_subscript(n=100000, as.character(c(4, 10, NA, 7, NA, 100, NA)), ufo_raw )}) +test_that("ufo raw subscript: hash str many with NAs", {test_ufo_subscript(n=100000, as.character(c(1:1000, NA, 2000:5000, NA, 10:1000, NA, 6000:10000)), ufo_raw )}) +test_that("ufo raw subscript: hash str all with NAs", {test_ufo_subscript(n=100000, as.character(c(1:100000, NA)), ufo_raw )}) +test_that("ufo raw subscript: loop str character(0)", {test_ufo_subscript(n=10, character(0), ufo_raw )}) +test_that("ufo raw subscript: loop str 0", {test_ufo_subscript(n=10, as.character(0), ufo_raw )}) +test_that("ufo raw subscript: loop str 1", {test_ufo_subscript(n=10, as.character(1), ufo_raw )}) +test_that("ufo raw subscript: loop str 10", {test_ufo_subscript(n=10, as.character(10), ufo_raw )}) +test_that("ufo raw subscript: loop str 42", {test_ufo_subscript(n=10, as.character(42), ufo_raw )}) +test_that("ufo raw subscript: loop str N+1", {test_ufo_subscript(n=10, as.character(11), ufo_raw )}) +test_that("ufo raw subscript: loop str 0,0", {test_ufo_subscript(n=10, as.character(c(0, 0)), ufo_raw )}) +test_that("ufo raw subscript: loop str 0,1,0,N,0", {test_ufo_subscript(n=10, as.character(c(0, 1, 0, 10, 0)), ufo_raw )}) +test_that("ufo raw subscript: loop str 1,10,100,1000,100", {test_ufo_subscript(n=10, as.character(c(1, 10, 100, 1000, 100)), ufo_raw )}) +test_that("ufo raw subscript: loop str few", {test_ufo_subscript(n=10, as.character(c(4, 10, 7, 100)), ufo_raw )}) +test_that("ufo raw subscript: loop str many", {test_ufo_subscript(n=10, as.character(c(1:1000, 2000:5000, 10:1000, 6000:10000)), ufo_raw )}) +test_that("ufo raw subscript: loop str all", {test_ufo_subscript(n=10, as.character(1:100000), ufo_raw )}) +test_that("ufo raw subscript: loop str few with NAs", {test_ufo_subscript(n=10, as.character(c(4, 10, NA, 7, NA, 100, NA)), ufo_raw )}) +test_that("ufo raw subscript: loop str many with NAs", {test_ufo_subscript(n=10, as.character(c(1:1000, NA, 2000:5000, NA, 10:1000, NA, 6000:10000)), ufo_raw )}) +test_that("ufo raw subscript: loop str all with NAs", {test_ufo_subscript(n=10, as.character(c(1:100000, NA)), ufo_raw )}) +test_that("ufo raw+names subscript: hash str character(0)", {test_ufo_subscript(n=100000, character(0), ufo_raw, named=T)}) +test_that("ufo raw+names subscript: hash str 0", {test_ufo_subscript(n=100000, as.character(0), ufo_raw, named=T)}) +test_that("ufo raw+names subscript: hash str 1", {test_ufo_subscript(n=100000, as.character(1), ufo_raw, named=T)}) +test_that("ufo raw+names subscript: hash str 10", {test_ufo_subscript(n=100000, as.character(10), ufo_raw, named=T)}) +test_that("ufo raw+names subscript: hash str 42", {test_ufo_subscript(n=100000, as.character(42), ufo_raw, named=T)}) +test_that("ufo raw+names subscript: hash str N+1", {test_ufo_subscript(n=100000, as.character(100001), ufo_raw, named=T)}) +test_that("ufo raw+names subscript: hash str 0,0", {test_ufo_subscript(n=100000, as.character(c(0, 0)), ufo_raw, named=T)}) +test_that("ufo raw+names subscript: hash str 0,1,0,N,0", {test_ufo_subscript(n=100000, as.character(c(0, 1, 0, 100000, 0)), ufo_raw, named=T)}) +test_that("ufo raw+names subscript: hash str 1,10,100,1000,100", {test_ufo_subscript(n=100000, as.character(c(1, 10, 100, 1000, 100)), ufo_raw, named=T)}) +test_that("ufo raw+names subscript: hash str few", {test_ufo_subscript(n=100000, as.character(c(4, 10, 7, 100)), ufo_raw, named=T)}) +test_that("ufo raw+names subscript: hash str many", {test_ufo_subscript(n=100000, as.character(c(1:1000, 2000:5000, 10:1000, 6000:10000)), ufo_raw, named=T)}) +test_that("ufo raw+names subscript: hash str all", {test_ufo_subscript(n=100000, as.character(1:100000), ufo_raw, named=T)}) +test_that("ufo raw+names subscript: hash str few with NAs", {test_ufo_subscript(n=100000, as.character(c(4, 10, NA, 7, NA, 100, NA)), ufo_raw, named=T)}) +test_that("ufo raw+names subscript: hash str many with NAs", {test_ufo_subscript(n=100000, as.character(c(1:1000, NA, 2000:5000, NA, 10:1000, NA, 6000:10000)), ufo_raw, named=T)}) +test_that("ufo raw+names subscript: hash str all with NAs", {test_ufo_subscript(n=100000, as.character(c(1:100000, NA)), ufo_raw, named=T)}) +test_that("ufo raw+names subscript: loop str character(0)", {test_ufo_subscript(n=10, character(0), ufo_raw, named=T)}) +test_that("ufo raw+names subscript: loop str 0", {test_ufo_subscript(n=10, as.character(0), ufo_raw, named=T)}) +test_that("ufo raw+names subscript: loop str 1", {test_ufo_subscript(n=10, as.character(1), ufo_raw, named=T)}) +test_that("ufo raw+names subscript: loop str 10", {test_ufo_subscript(n=10, as.character(10), ufo_raw, named=T)}) +test_that("ufo raw+names subscript: loop str 42", {test_ufo_subscript(n=10, as.character(42), ufo_raw, named=T)}) +test_that("ufo raw+names subscript: loop str N+1", {test_ufo_subscript(n=10, as.character(11), ufo_raw, named=T)}) +test_that("ufo raw+names subscript: loop str 0,0", {test_ufo_subscript(n=10, as.character(c(0, 0)), ufo_raw, named=T)}) +test_that("ufo raw+names subscript: loop str 0,1,0,N,0", {test_ufo_subscript(n=10, as.character(c(0, 1, 0, 10, 0)), ufo_raw, named=T)}) +test_that("ufo raw+names subscript: loop str 1,10,100,1000,100", {test_ufo_subscript(n=10, as.character(c(1, 10, 100, 1000, 100)), ufo_raw, named=T)}) +test_that("ufo raw+names subscript: loop str few", {test_ufo_subscript(n=10, as.character(c(4, 10, 7, 100)), ufo_raw, named=T)}) +test_that("ufo raw+names subscript: loop str many", {test_ufo_subscript(n=10, as.character(c(1:1000, 2000:5000, 10:1000, 6000:10000)), ufo_raw, named=T)}) +test_that("ufo raw+names subscript: loop str all", {test_ufo_subscript(n=10, as.character(1:100000), ufo_raw, named=T)}) +test_that("ufo raw+names subscript: loop str few with NAs", {test_ufo_subscript(n=10, as.character(c(4, 10, NA, 7, NA, 100, NA)), ufo_raw, named=T)}) +test_that("ufo raw+names subscript: loop str many with NAs", {test_ufo_subscript(n=10, as.character(c(1:1000, NA, 2000:5000, NA, 10:1000, NA, 6000:10000)), ufo_raw, named=T)}) +test_that("ufo raw+names subscript: loop str all with NAs", {test_ufo_subscript(n=10, as.character(c(1:100000, NA)), ufo_raw, named=T)}) + +test_that("ufo character subscript: null", {test_ufo_subscript(n=100000, NULL, ufo_character )}) +test_that("ufo character subscript: logical(0)", {test_ufo_subscript(n=100000, logical(0), ufo_character )}) +test_that("ufo character subscript: F", {test_ufo_subscript(n=100000, c(T), ufo_character )}) +test_that("ufo character subscript: T", {test_ufo_subscript(n=100000, c(F), ufo_character )}) +test_that("ufo character subscript: logical(NA)", {test_ufo_subscript(n=100000, as.logical(NA), ufo_character )}) +test_that("ufo character subscript: F,F", {test_ufo_subscript(n=100000, c(F, F), ufo_character )}) +test_that("ufo character subscript: F,T", {test_ufo_subscript(n=100000, c(F, T), ufo_character )}) +test_that("ufo character subscript: T,F", {test_ufo_subscript(n=100000, c(T, F), ufo_character )}) +test_that("ufo character subscript: T,T", {test_ufo_subscript(n=100000, c(T, T), ufo_character )}) +test_that("ufo character subscript: F,NA", {test_ufo_subscript(n=100000, c(F, NA), ufo_character )}) +test_that("ufo character subscript: NA,F", {test_ufo_subscript(n=100000, c(NA, F), ufo_character )}) +test_that("ufo character subscript: NA,T", {test_ufo_subscript(n=100000, c(NA, T), ufo_character )}) +test_that("ufo character subscript: T,NA", {test_ufo_subscript(n=100000, c(T, NA), ufo_character )}) +test_that("ufo character subscript: F,F,F", {test_ufo_subscript(n=100000, c(F, F, F), ufo_character )}) +test_that("ufo character subscript: F,F,T", {test_ufo_subscript(n=100000, c(F, F, T), ufo_character )}) +test_that("ufo character subscript: F,T,F", {test_ufo_subscript(n=100000, c(F, T, F), ufo_character )}) +test_that("ufo character subscript: F,T,T", {test_ufo_subscript(n=100000, c(F, T, T), ufo_character )}) +test_that("ufo character subscript: T,F,F", {test_ufo_subscript(n=100000, c(T, F, F), ufo_character )}) +test_that("ufo character subscript: T,F,T", {test_ufo_subscript(n=100000, c(T, F, T), ufo_character )}) +test_that("ufo character subscript: T,T,F", {test_ufo_subscript(n=100000, c(T, T, F), ufo_character )}) +test_that("ufo character subscript: T,T,T", {test_ufo_subscript(n=100000, c(T, T, T), ufo_character )}) +test_that("ufo character subscript: F,F,NA", {test_ufo_subscript(n=100000, c(F, F, NA), ufo_character )}) +test_that("ufo character subscript: F,NA,F", {test_ufo_subscript(n=100000, c(F, NA, F), ufo_character )}) +test_that("ufo character subscript: F,NA,NA", {test_ufo_subscript(n=100000, c(F, NA, NA), ufo_character )}) +test_that("ufo character subscript: NA,F,F", {test_ufo_subscript(n=100000, c(NA, F, F), ufo_character )}) +test_that("ufo character subscript: NA,F,NA", {test_ufo_subscript(n=100000, c(NA, F, NA), ufo_character )}) +test_that("ufo character subscript: NA,NA,F", {test_ufo_subscript(n=100000, c(NA, NA, F), ufo_character )}) +test_that("ufo character subscript: F,F,T", {test_ufo_subscript(n=100000, c(F, F, T), ufo_character )}) +test_that("ufo character subscript: F,NA,T", {test_ufo_subscript(n=100000, c(F, NA, T), ufo_character )}) +test_that("ufo character subscript: NA,F,T", {test_ufo_subscript(n=100000, c(NA, F, T), ufo_character )}) +test_that("ufo character subscript: NA,NA,T", {test_ufo_subscript(n=100000, c(NA, NA, T), ufo_character )}) +test_that("ufo character subscript: F,T,NA", {test_ufo_subscript(n=100000, c(F, T, NA), ufo_character )}) +test_that("ufo character subscript: NA,T,F", {test_ufo_subscript(n=100000, c(NA, T, F), ufo_character )}) +test_that("ufo character subscript: NA,T,NA", {test_ufo_subscript(n=100000, c(NA, T, NA), ufo_character )}) +test_that("ufo character subscript: F,NA,T", {test_ufo_subscript(n=100000, c(F, NA, T), ufo_character )}) +test_that("ufo character subscript: NA,T,T", {test_ufo_subscript(n=100000, c(NA, T, T), ufo_character )}) +test_that("ufo character subscript: T,F,NA", {test_ufo_subscript(n=100000, c(T, F, NA), ufo_character )}) +test_that("ufo character subscript: T,NA,F", {test_ufo_subscript(n=100000, c(T, NA, F), ufo_character )}) +test_that("ufo character subscript: T,NA,NA", {test_ufo_subscript(n=100000, c(T, NA, NA), ufo_character )}) +test_that("ufo character subscript: T,NA,T", {test_ufo_subscript(n=100000, c(T, NA, T), ufo_character )}) +test_that("ufo character subscript: T,T,NA", {test_ufo_subscript(n=100000, c(T, T, NA), ufo_character )}) +test_that("ufo character subscript: T,NA,NA", {test_ufo_subscript(n=100000, c(T, NA, NA), ufo_character )}) +test_that("ufo character subscript: T..", {test_ufo_subscript(n=100000, rep(T, 100000), ufo_character )}) +test_that("ufo character subscript: F..", {test_ufo_subscript(n=100000, rep(F, 100000), ufo_character )}) +test_that("ufo character subscript: T,F..", {test_ufo_subscript(n=100000, rep(c(T,F), 100000), ufo_character )}) +test_that("ufo character subscript: F,T..", {test_ufo_subscript(n=100000, rep(c(F,T), 100000), ufo_character )}) +test_that("ufo character subscript: int integer(0)", {test_ufo_subscript(n=100000, integer(0), ufo_character )}) +test_that("ufo character subscript: int 0", {test_ufo_subscript(n=100000, as.integer(0), ufo_character )}) +test_that("ufo character subscript: int 1", {test_ufo_subscript(n=100000, as.integer(1), ufo_character )}) +test_that("ufo character subscript: int 10", {test_ufo_subscript(n=100000, as.integer(10), ufo_character )}) +test_that("ufo character subscript: int 42", {test_ufo_subscript(n=100000, as.integer(42), ufo_character )}) +test_that("ufo character subscript: int N+1", {test_ufo_subscript(n=100000, as.integer(100001), ufo_character )}) +test_that("ufo character subscript: int 0,0", {test_ufo_subscript(n=100000, as.integer(c(0, 0)), ufo_character )}) +test_that("ufo character subscript: int 0,1,0,N,0", {test_ufo_subscript(n=100000, as.integer(c(0, 1, 0, 100000, 0)), ufo_character )}) +test_that("ufo character subscript: int 1,10,100,1000,100", {test_ufo_subscript(n=100000, as.integer(c(1, 10, 100, 1000, 100)), ufo_character )}) +test_that("ufo character subscript: int -1", {test_ufo_subscript(n=100000, as.integer(-1), ufo_character )}) +test_that("ufo character subscript: int -10", {test_ufo_subscript(n=100000, as.integer(-10), ufo_character )}) +test_that("ufo character subscript: int -42", {test_ufo_subscript(n=100000, as.integer(-42), ufo_character )}) +test_that("ufo character subscript: int -1,-10,-100,-1000,-100", {test_ufo_subscript(n=100000, as.integer(-c(1, 10, 100, 1000, 100)), ufo_character )}) +test_that("ufo character subscript: int few", {test_ufo_subscript(n=100000, as.integer(c(4, 10, 7, 100)), ufo_character )}) +test_that("ufo character subscript: int many", {test_ufo_subscript(n=100000, as.integer(c(1:1000, 2000:5000, 10:1000, 6000:10000)), ufo_character )}) +test_that("ufo character subscript: int all", {test_ufo_subscript(n=100000, as.integer(1:100000), ufo_character )}) +test_that("ufo character subscript: int few with NAs", {test_ufo_subscript(n=100000, as.integer(c(4, 10, NA, 7, NA, 100, NA)), ufo_character )}) +test_that("ufo character subscript: int many with NAs", {test_ufo_subscript(n=100000, as.integer(c(1:1000, NA, 2000:5000, NA, 10:1000, NA, 6000:10000)), ufo_character )}) +test_that("ufo character subscript: int all with NAs", {test_ufo_subscript(n=100000, as.integer(c(1:100000, NA)), ufo_character )}) +test_that("ufo character subscript: int few negative", {test_ufo_subscript(n=100000, as.integer(-c(4, 10, 7, 100)), ufo_character )}) +test_that("ufo character subscript: int many negative", {test_ufo_subscript(n=100000, as.integer(-c(1:1000, 2000:5000, 10:1000, 6000:10000)), ufo_character )}) +test_that("ufo character subscript: int all negative", {test_ufo_subscript(n=100000, as.integer(-(1:100000)), ufo_character )}) +test_that("ufo character subscript: num integer(0)", {test_ufo_subscript(n=100000, numeric(0), ufo_character )}) +test_that("ufo character subscript: num 0", {test_ufo_subscript(n=100000, as.numeric(0), ufo_character )}) +test_that("ufo character subscript: num 1", {test_ufo_subscript(n=100000, as.numeric(1), ufo_character )}) +test_that("ufo character subscript: num 10", {test_ufo_subscript(n=100000, as.numeric(10), ufo_character )}) +test_that("ufo character subscript: num 42", {test_ufo_subscript(n=100000, as.numeric(42), ufo_character )}) +test_that("ufo character subscript: num N+1", {test_ufo_subscript(n=100000, as.numeric(100001), ufo_character )}) +test_that("ufo character subscript: num 0,0", {test_ufo_subscript(n=100000, as.numeric(c(0, 0)), ufo_character )}) +test_that("ufo character subscript: num 0,1,0,N,0", {test_ufo_subscript(n=100000, as.numeric(c(0, 1, 0, 100000, 0)), ufo_character )}) +test_that("ufo character subscript: num 1,10,100,1000,100", {test_ufo_subscript(n=100000, as.numeric(c(1, 10, 100, 1000, 100)), ufo_character )}) +test_that("ufo character subscript: num -1", {test_ufo_subscript(n=100000, as.numeric(-1), ufo_character )}) +test_that("ufo character subscript: num -10", {test_ufo_subscript(n=100000, as.numeric(-10), ufo_character )}) +test_that("ufo character subscript: num -42", {test_ufo_subscript(n=100000, as.numeric(-42), ufo_character )}) +test_that("ufo character subscript: num -1,-10,-100,-1000,-100", {test_ufo_subscript(n=100000, as.numeric(-c(1, 10, 100, 1000, 100)), ufo_character )}) +test_that("ufo character subscript: num few", {test_ufo_subscript(n=100000, as.numeric(c(4, 10, 7, 100)), ufo_character )}) +test_that("ufo character subscript: num many", {test_ufo_subscript(n=100000, as.numeric(c(1:1000, 2000:5000, 10:1000, 6000:10000)), ufo_character )}) +test_that("ufo character subscript: num all", {test_ufo_subscript(n=100000, as.numeric(1:100000), ufo_character )}) +test_that("ufo character subscript: num few with NAs", {test_ufo_subscript(n=100000, as.numeric(c(4, 10, NA, 7, NA, 100, NA)), ufo_character )}) +test_that("ufo character subscript: num many with NAs", {test_ufo_subscript(n=100000, as.numeric(c(1:1000, NA, 2000:5000, NA, 10:1000, NA, 6000:10000)), ufo_character )}) +test_that("ufo character subscript: num all with NAs", {test_ufo_subscript(n=100000, as.numeric(c(1:100000, NA)), ufo_character )}) +test_that("ufo character subscript: num few negative", {test_ufo_subscript(n=100000, as.numeric(-c(4, 10, 7, 100)), ufo_character )}) +test_that("ufo character subscript: num many negative", {test_ufo_subscript(n=100000, as.numeric(-c(1:1000, 2000:5000, 10:1000, 6000:10000)), ufo_character )}) +test_that("ufo character subscript: num all negative", {test_ufo_subscript(n=100000, as.numeric(-(1:100000)), ufo_character )}) +test_that("ufo character subscript: num 0.1", {test_ufo_subscript(n=100000, as.numeric(0.1), ufo_character )}) +test_that("ufo character subscript: num 1.1", {test_ufo_subscript(n=100000, as.numeric(1.1), ufo_character )}) +test_that("ufo character subscript: num 10.5", {test_ufo_subscript(n=100000, as.numeric(10.5), ufo_character )}) +test_that("ufo character subscript: num 42.9", {test_ufo_subscript(n=100000, as.numeric(42.9), ufo_character )}) +test_that("ufo character subscript: num -0.1", {test_ufo_subscript(n=100000, as.numeric(-0.1), ufo_character )}) +test_that("ufo character subscript: num -1.1", {test_ufo_subscript(n=100000, as.numeric(-1.1), ufo_character )}) +test_that("ufo character subscript: num -10.5", {test_ufo_subscript(n=100000, as.numeric(-10.5), ufo_character )}) +test_that("ufo character subscript: num -42.9", {test_ufo_subscript(n=100000, as.numeric(-42.9), ufo_character )}) +test_that("ufo character subscript: hash str character(0)", {test_ufo_subscript(n=100000, character(0), ufo_character )}) +test_that("ufo character subscript: hash str 0", {test_ufo_subscript(n=100000, as.character(0), ufo_character )}) +test_that("ufo character subscript: hash str 1", {test_ufo_subscript(n=100000, as.character(1), ufo_character )}) +test_that("ufo character subscript: hash str 10", {test_ufo_subscript(n=100000, as.character(10), ufo_character )}) +test_that("ufo character subscript: hash str 42", {test_ufo_subscript(n=100000, as.character(42), ufo_character )}) +test_that("ufo character subscript: hash str N+1", {test_ufo_subscript(n=100000, as.character(100001), ufo_character )}) +test_that("ufo character subscript: hash str 0,0", {test_ufo_subscript(n=100000, as.character(c(0, 0)), ufo_character )}) +test_that("ufo character subscript: hash str 0,1,0,N,0", {test_ufo_subscript(n=100000, as.character(c(0, 1, 0, 100000, 0)), ufo_character )}) +test_that("ufo character subscript: hash str 1,10,100,1000,100", {test_ufo_subscript(n=100000, as.character(c(1, 10, 100, 1000, 100)), ufo_character )}) +test_that("ufo character subscript: hash str few", {test_ufo_subscript(n=100000, as.character(c(4, 10, 7, 100)), ufo_character )}) +test_that("ufo character subscript: hash str many", {test_ufo_subscript(n=100000, as.character(c(1:1000, 2000:5000, 10:1000, 6000:10000)), ufo_character )}) +test_that("ufo character subscript: hash str all", {test_ufo_subscript(n=100000, as.character(1:100000), ufo_character )}) +test_that("ufo character subscript: hash str few with NAs", {test_ufo_subscript(n=100000, as.character(c(4, 10, NA, 7, NA, 100, NA)), ufo_character )}) +test_that("ufo character subscript: hash str many with NAs", {test_ufo_subscript(n=100000, as.character(c(1:1000, NA, 2000:5000, NA, 10:1000, NA, 6000:10000)), ufo_character )}) +test_that("ufo character subscript: hash str all with NAs", {test_ufo_subscript(n=100000, as.character(c(1:100000, NA)), ufo_character )}) +test_that("ufo character subscript: loop str character(0)", {test_ufo_subscript(n=10, character(0), ufo_character )}) +test_that("ufo character subscript: loop str 0", {test_ufo_subscript(n=10, as.character(0), ufo_character )}) +test_that("ufo character subscript: loop str 1", {test_ufo_subscript(n=10, as.character(1), ufo_character )}) +test_that("ufo character subscript: loop str 10", {test_ufo_subscript(n=10, as.character(10), ufo_character )}) +test_that("ufo character subscript: loop str 42", {test_ufo_subscript(n=10, as.character(42), ufo_character )}) +test_that("ufo character subscript: loop str N+1", {test_ufo_subscript(n=10, as.character(11), ufo_character )}) +test_that("ufo character subscript: loop str 0,0", {test_ufo_subscript(n=10, as.character(c(0, 0)), ufo_character )}) +test_that("ufo character subscript: loop str 0,1,0,N,0", {test_ufo_subscript(n=10, as.character(c(0, 1, 0, 10, 0)), ufo_character )}) +test_that("ufo character subscript: loop str 1,10,100,1000,100", {test_ufo_subscript(n=10, as.character(c(1, 10, 100, 1000, 100)), ufo_character )}) +test_that("ufo character subscript: loop str few", {test_ufo_subscript(n=10, as.character(c(4, 10, 7, 100)), ufo_character )}) +test_that("ufo character subscript: loop str many", {test_ufo_subscript(n=10, as.character(c(1:1000, 2000:5000, 10:1000, 6000:10000)), ufo_character )}) +test_that("ufo character subscript: loop str all", {test_ufo_subscript(n=10, as.character(1:100000), ufo_character )}) +test_that("ufo character subscript: loop str few with NAs", {test_ufo_subscript(n=10, as.character(c(4, 10, NA, 7, NA, 100, NA)), ufo_character )}) +test_that("ufo character subscript: loop str many with NAs", {test_ufo_subscript(n=10, as.character(c(1:1000, NA, 2000:5000, NA, 10:1000, NA, 6000:10000)), ufo_character )}) +test_that("ufo character subscript: loop str all with NAs", {test_ufo_subscript(n=10, as.character(c(1:100000, NA)), ufo_character )}) +test_that("ufo character+names subscript: hash str character(0)", {test_ufo_subscript(n=100000, character(0), ufo_character, named=T)}) +test_that("ufo character+names subscript: hash str 0", {test_ufo_subscript(n=100000, as.character(0), ufo_character, named=T)}) +test_that("ufo character+names subscript: hash str 1", {test_ufo_subscript(n=100000, as.character(1), ufo_character, named=T)}) +test_that("ufo character+names subscript: hash str 10", {test_ufo_subscript(n=100000, as.character(10), ufo_character, named=T)}) +test_that("ufo character+names subscript: hash str 42", {test_ufo_subscript(n=100000, as.character(42), ufo_character, named=T)}) +test_that("ufo character+names subscript: hash str N+1", {test_ufo_subscript(n=100000, as.character(100001), ufo_character, named=T)}) +test_that("ufo character+names subscript: hash str 0,0", {test_ufo_subscript(n=100000, as.character(c(0, 0)), ufo_character, named=T)}) +test_that("ufo character+names subscript: hash str 0,1,0,N,0", {test_ufo_subscript(n=100000, as.character(c(0, 1, 0, 100000, 0)), ufo_character, named=T)}) +test_that("ufo character+names subscript: hash str 1,10,100,1000,100", {test_ufo_subscript(n=100000, as.character(c(1, 10, 100, 1000, 100)), ufo_character, named=T)}) +test_that("ufo character+names subscript: hash str few", {test_ufo_subscript(n=100000, as.character(c(4, 10, 7, 100)), ufo_character, named=T)}) +test_that("ufo character+names subscript: hash str many", {test_ufo_subscript(n=100000, as.character(c(1:1000, 2000:5000, 10:1000, 6000:10000)), ufo_character, named=T)}) +test_that("ufo character+names subscript: hash str all", {test_ufo_subscript(n=100000, as.character(1:100000), ufo_character, named=T)}) +test_that("ufo character+names subscript: hash str few with NAs", {test_ufo_subscript(n=100000, as.character(c(4, 10, NA, 7, NA, 100, NA)), ufo_character, named=T)}) +test_that("ufo character+names subscript: hash str many with NAs", {test_ufo_subscript(n=100000, as.character(c(1:1000, NA, 2000:5000, NA, 10:1000, NA, 6000:10000)), ufo_character, named=T)}) +test_that("ufo character+names subscript: hash str all with NAs", {test_ufo_subscript(n=100000, as.character(c(1:100000, NA)), ufo_character, named=T)}) +test_that("ufo character+names subscript: loop str character(0)", {test_ufo_subscript(n=10, character(0), ufo_character, named=T)}) +test_that("ufo character+names subscript: loop str 0", {test_ufo_subscript(n=10, as.character(0), ufo_character, named=T)}) +test_that("ufo character+names subscript: loop str 1", {test_ufo_subscript(n=10, as.character(1), ufo_character, named=T)}) +test_that("ufo character+names subscript: loop str 10", {test_ufo_subscript(n=10, as.character(10), ufo_character, named=T)}) +test_that("ufo character+names subscript: loop str 42", {test_ufo_subscript(n=10, as.character(42), ufo_character, named=T)}) +test_that("ufo character+names subscript: loop str N+1", {test_ufo_subscript(n=10, as.character(11), ufo_character, named=T)}) +test_that("ufo character+names subscript: loop str 0,0", {test_ufo_subscript(n=10, as.character(c(0, 0)), ufo_character, named=T)}) +test_that("ufo character+names subscript: loop str 0,1,0,N,0", {test_ufo_subscript(n=10, as.character(c(0, 1, 0, 10, 0)), ufo_character, named=T)}) +test_that("ufo character+names subscript: loop str 1,10,100,1000,100", {test_ufo_subscript(n=10, as.character(c(1, 10, 100, 1000, 100)), ufo_character, named=T)}) +test_that("ufo character+names subscript: loop str few", {test_ufo_subscript(n=10, as.character(c(4, 10, 7, 100)), ufo_character, named=T)}) +test_that("ufo character+names subscript: loop str many", {test_ufo_subscript(n=10, as.character(c(1:1000, 2000:5000, 10:1000, 6000:10000)), ufo_character, named=T)}) +test_that("ufo character+names subscript: loop str all", {test_ufo_subscript(n=10, as.character(1:100000), ufo_character, named=T)}) +test_that("ufo character+names subscript: loop str few with NAs", {test_ufo_subscript(n=10, as.character(c(4, 10, NA, 7, NA, 100, NA)), ufo_character, named=T)}) +test_that("ufo character+names subscript: loop str many with NAs", {test_ufo_subscript(n=10, as.character(c(1:1000, NA, 2000:5000, NA, 10:1000, NA, 6000:10000)), ufo_character, named=T)}) +test_that("ufo character+names subscript: loop str all with NAs", {test_ufo_subscript(n=10, as.character(c(1:100000, NA)), ufo_character, named=T)}) diff --git a/ufovectors/..Rcheck/tests/testthat/test-subsetting.R b/ufovectors/..Rcheck/tests/testthat/test-subsetting.R new file mode 100644 index 0000000..2f88b80 --- /dev/null +++ b/ufovectors/..Rcheck/tests/testthat/test-subsetting.R @@ -0,0 +1,230 @@ +context("UFO vector subsetting") + +test_ufo_subset <- function (data, subscript, ufo_constructor) { + ufo <- ufo_constructor(length(data)) + ufo[seq_len(length(data))] <- data + result <- ufovectors::ufo_subset(ufo, subscript) + expect_equal(result, data[subscript]) +} + +test_that("ufo integer subset: NULL", {test_ufo_subset(data=as.integer(1:100000), subscript=NULL, ufo_integer)}) +test_that("ufo numeric subset: NULL", {test_ufo_subset(data=as.numeric(1:100000), subscript=NULL, ufo_numeric)}) +test_that("ufo raw subset: NULL", {test_ufo_subset(data=as.raw(1:100000), subscript=NULL, ufo_raw)}) +test_that("ufo logical subset: NULL", {test_ufo_subset(data=as.logical(1:100000), subscript=NULL, ufo_logical)}) +test_that("ufo complex subset: NULL", {test_ufo_subset(data=as.complex(1:100000), subscript=NULL, ufo_complex)}) + +test_that("ufo integer subset: num 0", {test_ufo_subset(data=as.integer(1:100000), subscript=0, ufo_integer)}) +test_that("ufo integer subset: num 1", {test_ufo_subset(data=as.integer(1:100000), subscript=1, ufo_integer)}) +test_that("ufo integer subset: num N/2", {test_ufo_subset(data=as.integer(1:100000), subscript=50000, ufo_integer)}) +test_that("ufo integer subset: num N", {test_ufo_subset(data=as.integer(1:100000), subscript=100000, ufo_integer)}) +test_that("ufo integer subset: num 1:10", {test_ufo_subset(data=as.integer(1:100000), subscript=1:10, ufo_integer)}) +test_that("ufo integer subset: num 1:1000", {test_ufo_subset(data=as.integer(1:100000), subscript=1:1000, ufo_integer)}) +test_that("ufo integer subset: num 1:N", {test_ufo_subset(data=as.integer(1:100000), subscript=1:100000, ufo_integer)}) +test_that("ufo integer subset: num N/2:N", {test_ufo_subset(data=as.integer(1:100000), subscript=50000:100000, ufo_integer)}) +test_that("ufo integer subset: num 2*(2:N/2)", {test_ufo_subset(data=as.integer(1:100000), subscript=2*(1:50000), ufo_integer)}) +test_that("ufo integer subset: num -1", {test_ufo_subset(data=as.integer(1:100000), subscript=-1, ufo_integer)}) +test_that("ufo integer subset: num -(N/2)", {test_ufo_subset(data=as.integer(1:100000), subscript=-50000, ufo_integer)}) +test_that("ufo integer subset: num -N", {test_ufo_subset(data=as.integer(1:100000), subscript=-100000, ufo_integer)}) +test_that("ufo integer subset: num -(1:10)", {test_ufo_subset(data=as.integer(1:100000), subscript=-(1:10), ufo_integer)}) +test_that("ufo integer subset: num -(1:1000)", {test_ufo_subset(data=as.integer(1:100000), subscript=-(1:1000), ufo_integer)}) +test_that("ufo integer subset: num -(1:N)", {test_ufo_subset(data=as.integer(1:100000), subscript=-(1:100000), ufo_integer)}) +test_that("ufo integer subset: num -(N/2:N)", {test_ufo_subset(data=as.integer(1:100000), subscript=-(50000:100000), ufo_integer)}) +test_that("ufo integer subset: num -2*(2:N/2)", {test_ufo_subset(data=as.integer(1:100000), subscript=-2*(1:50000), ufo_integer)}) + +test_that("ufo numeric subset: num 0", {test_ufo_subset(data=as.numeric(1:100000), subscript=0, ufo_numeric)}) +test_that("ufo numeric subset: num 1", {test_ufo_subset(data=as.numeric(1:100000), subscript=1, ufo_numeric)}) +test_that("ufo numeric subset: num N/2", {test_ufo_subset(data=as.numeric(1:100000), subscript=50000, ufo_numeric)}) +test_that("ufo numeric subset: num N", {test_ufo_subset(data=as.numeric(1:100000), subscript=100000, ufo_numeric)}) +test_that("ufo numeric subset: num 1:10", {test_ufo_subset(data=as.numeric(1:100000), subscript=1:10, ufo_numeric)}) +test_that("ufo numeric subset: num 1:1000", {test_ufo_subset(data=as.numeric(1:100000), subscript=1:1000, ufo_numeric)}) +test_that("ufo numeric subset: num 1:N", {test_ufo_subset(data=as.numeric(1:100000), subscript=1:100000, ufo_numeric)}) +test_that("ufo numeric subset: num N/2:N", {test_ufo_subset(data=as.numeric(1:100000), subscript=50000:100000, ufo_numeric)}) +test_that("ufo numeric subset: num 2*(2:N/2)", {test_ufo_subset(data=as.numeric(1:100000), subscript=2*(1:50000), ufo_numeric)}) +test_that("ufo numeric subset: num -1", {test_ufo_subset(data=as.numeric(1:100000), subscript=-1, ufo_numeric)}) +test_that("ufo numeric subset: num -(N/2)", {test_ufo_subset(data=as.numeric(1:100000), subscript=-50000, ufo_numeric)}) +test_that("ufo numeric subset: num -N", {test_ufo_subset(data=as.numeric(1:100000), subscript=-100000, ufo_numeric)}) +test_that("ufo numeric subset: num -(1:10)", {test_ufo_subset(data=as.numeric(1:100000), subscript=-(1:10), ufo_numeric)}) +test_that("ufo numeric subset: num -(1:1000)", {test_ufo_subset(data=as.numeric(1:100000), subscript=-(1:1000), ufo_numeric)}) +test_that("ufo numeric subset: num -(1:N)", {test_ufo_subset(data=as.numeric(1:100000), subscript=-(1:100000), ufo_numeric)}) +test_that("ufo numeric subset: num -(N/2:N)", {test_ufo_subset(data=as.numeric(1:100000), subscript=-(50000:100000), ufo_numeric)}) +test_that("ufo numeric subset: num -2*(2:N/2)", {test_ufo_subset(data=as.numeric(1:100000), subscript=-2*(1:50000), ufo_numeric)}) + +test_that("ufo complex subset: num 0", {test_ufo_subset(data=as.complex(1:100000), subscript=0, ufo_complex)}) +test_that("ufo complex subset: num 1", {test_ufo_subset(data=as.complex(1:100000), subscript=1, ufo_complex)}) +test_that("ufo complex subset: num N/2", {test_ufo_subset(data=as.complex(1:100000), subscript=50000, ufo_complex)}) +test_that("ufo complex subset: num N", {test_ufo_subset(data=as.complex(1:100000), subscript=100000, ufo_complex)}) +test_that("ufo complex subset: num 1:10", {test_ufo_subset(data=as.complex(1:100000), subscript=1:10, ufo_complex)}) +test_that("ufo complex subset: num 1:1000", {test_ufo_subset(data=as.complex(1:100000), subscript=1:1000, ufo_complex)}) +test_that("ufo complex subset: num 1:N", {test_ufo_subset(data=as.complex(1:100000), subscript=1:100000, ufo_complex)}) +test_that("ufo complex subset: num N/2:N", {test_ufo_subset(data=as.complex(1:100000), subscript=50000:100000, ufo_complex)}) +test_that("ufo complex subset: num 2*(2:N/2)", {test_ufo_subset(data=as.complex(1:100000), subscript=2*(1:50000), ufo_complex)}) +test_that("ufo complex subset: num -1", {test_ufo_subset(data=as.complex(1:100000), subscript=-1, ufo_complex)}) +test_that("ufo complex subset: num -(N/2)", {test_ufo_subset(data=as.complex(1:100000), subscript=-50000, ufo_complex)}) +test_that("ufo complex subset: num -N", {test_ufo_subset(data=as.complex(1:100000), subscript=-100000, ufo_complex)}) +test_that("ufo complex subset: num -(1:10)", {test_ufo_subset(data=as.complex(1:100000), subscript=-(1:10), ufo_complex)}) +test_that("ufo complex subset: num -(1:1000)", {test_ufo_subset(data=as.complex(1:100000), subscript=-(1:1000), ufo_complex)}) +test_that("ufo complex subset: num -(1:N)", {test_ufo_subset(data=as.complex(1:100000), subscript=-(1:100000), ufo_complex)}) +test_that("ufo complex subset: num -(N/2:N)", {test_ufo_subset(data=as.complex(1:100000), subscript=-(50000:100000), ufo_complex)}) +test_that("ufo complex subset: num -2*(2:N/2)", {test_ufo_subset(data=as.complex(1:100000), subscript=-2*(1:50000), ufo_complex)}) + +test_that("ufo raw subset: num 0", {test_ufo_subset(data=as.raw(1:100000), subscript=0, ufo_raw)}) +test_that("ufo raw subset: num 1", {test_ufo_subset(data=as.raw(1:100000), subscript=1, ufo_raw)}) +test_that("ufo raw subset: num N/2", {test_ufo_subset(data=as.raw(1:100000), subscript=50000, ufo_raw)}) +test_that("ufo raw subset: num N", {test_ufo_subset(data=as.raw(1:100000), subscript=100000, ufo_raw)}) +test_that("ufo raw subset: num 1:10", {test_ufo_subset(data=as.raw(1:100000), subscript=1:10, ufo_raw)}) +test_that("ufo raw subset: num 1:1000", {test_ufo_subset(data=as.raw(1:100000), subscript=1:1000, ufo_raw)}) +test_that("ufo raw subset: num 1:N", {test_ufo_subset(data=as.raw(1:100000), subscript=1:100000, ufo_raw)}) +test_that("ufo raw subset: num N/2:N", {test_ufo_subset(data=as.raw(1:100000), subscript=50000:100000, ufo_raw)}) +test_that("ufo raw subset: num 2*(2:N/2)", {test_ufo_subset(data=as.raw(1:100000), subscript=2*(1:50000), ufo_raw)}) +test_that("ufo raw subset: num -1", {test_ufo_subset(data=as.raw(1:100000), subscript=-1, ufo_raw)}) +test_that("ufo raw subset: num -(N/2)", {test_ufo_subset(data=as.raw(1:100000), subscript=-50000, ufo_raw)}) +test_that("ufo raw subset: num -N", {test_ufo_subset(data=as.raw(1:100000), subscript=-100000, ufo_raw)}) +test_that("ufo raw subset: num -(1:10)", {test_ufo_subset(data=as.raw(1:100000), subscript=-(1:10), ufo_raw)}) +test_that("ufo raw subset: num -(1:1000)", {test_ufo_subset(data=as.raw(1:100000), subscript=-(1:1000), ufo_raw)}) +test_that("ufo raw subset: num -(1:N)", {test_ufo_subset(data=as.raw(1:100000), subscript=-(1:100000), ufo_raw)}) +test_that("ufo raw subset: num -(N/2:N)", {test_ufo_subset(data=as.raw(1:100000), subscript=-(50000:100000), ufo_raw)}) +test_that("ufo raw subset: num -2*(2:N/2)", {test_ufo_subset(data=as.raw(1:100000), subscript=-2*(1:50000), ufo_raw)}) + +test_that("ufo logical subset: num 0", {test_ufo_subset(data=as.logical(1:100000), subscript=0, ufo_logical)}) +test_that("ufo logical subset: num 1", {test_ufo_subset(data=as.logical(1:100000), subscript=1, ufo_logical)}) +test_that("ufo logical subset: num N/2", {test_ufo_subset(data=as.logical(1:100000), subscript=50000, ufo_logical)}) +test_that("ufo logical subset: num N", {test_ufo_subset(data=as.logical(1:100000), subscript=100000, ufo_logical)}) +test_that("ufo logical subset: num 1:10", {test_ufo_subset(data=as.logical(1:100000), subscript=1:10, ufo_logical)}) +test_that("ufo logical subset: num 1:1000", {test_ufo_subset(data=as.logical(1:100000), subscript=1:1000, ufo_logical)}) +test_that("ufo logical subset: num 1:N", {test_ufo_subset(data=as.logical(1:100000), subscript=1:100000, ufo_logical)}) +test_that("ufo logical subset: num N/2:N", {test_ufo_subset(data=as.logical(1:100000), subscript=50000:100000, ufo_logical)}) +test_that("ufo logical subset: num 2*(2:N/2)", {test_ufo_subset(data=as.logical(1:100000), subscript=2*(1:50000), ufo_logical)}) +test_that("ufo logical subset: num -1", {test_ufo_subset(data=as.logical(1:100000), subscript=-1, ufo_logical)}) +test_that("ufo logical subset: num -(N/2)", {test_ufo_subset(data=as.logical(1:100000), subscript=-50000, ufo_logical)}) +test_that("ufo logical subset: num -N", {test_ufo_subset(data=as.logical(1:100000), subscript=-100000, ufo_logical)}) +test_that("ufo logical subset: num -(1:10)", {test_ufo_subset(data=as.logical(1:100000), subscript=-(1:10), ufo_logical)}) +test_that("ufo logical subset: num -(1:1000)", {test_ufo_subset(data=as.logical(1:100000), subscript=-(1:1000), ufo_logical)}) +test_that("ufo logical subset: num -(1:N)", {test_ufo_subset(data=as.logical(1:100000), subscript=-(1:100000), ufo_logical)}) +test_that("ufo logical subset: num -(N/2:N)", {test_ufo_subset(data=as.logical(1:100000), subscript=-(50000:100000), ufo_logical)}) +test_that("ufo logical subset: num -2*(2:N/2)", {test_ufo_subset(data=as.logical(1:100000), subscript=-2*(1:50000), ufo_logical)}) + +test_that("ufo string subset: num 0", {test_ufo_subset(data=as.character(1:100000), subscript=0, ufo_character)}) +test_that("ufo string subset: num 1", {test_ufo_subset(data=as.character(1:100000), subscript=1, ufo_character)}) +test_that("ufo string subset: num N/2", {test_ufo_subset(data=as.character(1:100000), subscript=50000, ufo_character)}) +test_that("ufo string subset: num N", {test_ufo_subset(data=as.character(1:100000), subscript=100000, ufo_character)}) +test_that("ufo string subset: num 1:10", {test_ufo_subset(data=as.character(1:100000), subscript=1:10, ufo_character)}) +test_that("ufo string subset: num 1:1000", {test_ufo_subset(data=as.character(1:100000), subscript=1:1000, ufo_character)}) +test_that("ufo string subset: num 1:N", {test_ufo_subset(data=as.character(1:100000), subscript=1:100000, ufo_character)}) +test_that("ufo string subset: num N/2:N", {test_ufo_subset(data=as.character(1:100000), subscript=50000:100000, ufo_character)}) +test_that("ufo string subset: num 2*(2:N/2)", {test_ufo_subset(data=as.character(1:100000), subscript=2*(1:50000), ufo_character)}) +test_that("ufo string subset: num -1", {test_ufo_subset(data=as.character(1:100000), subscript=-1, ufo_character)}) +test_that("ufo string subset: num -(N/2)", {test_ufo_subset(data=as.character(1:100000), subscript=-50000, ufo_character)}) +test_that("ufo string subset: num -N", {test_ufo_subset(data=as.character(1:100000), subscript=-100000, ufo_character)}) +test_that("ufo string subset: num -(1:10)", {test_ufo_subset(data=as.character(1:100000), subscript=-(1:10), ufo_character)}) +test_that("ufo string subset: num -(1:1000)", {test_ufo_subset(data=as.character(1:100000), subscript=-(1:1000), ufo_character)}) +test_that("ufo string subset: num -(1:N)", {test_ufo_subset(data=as.character(1:100000), subscript=-(1:100000), ufo_character)}) +test_that("ufo string subset: num -(N/2:N)", {test_ufo_subset(data=as.character(1:100000), subscript=-(50000:100000), ufo_character)}) +test_that("ufo string subset: num -2*(2:N/2)", {test_ufo_subset(data=as.character(1:100000), subscript=-2*(1:50000), ufo_character)}) + +test_that("ufo integer subset: int 0", {test_ufo_subset(data=as.integer(1:100000), subscript=as.integer(0), ufo_integer)}) +test_that("ufo integer subset: int 1", {test_ufo_subset(data=as.integer(1:100000), subscript=as.integer(1), ufo_integer)}) +test_that("ufo integer subset: int N/2", {test_ufo_subset(data=as.integer(1:100000), subscript=as.integer(50000), ufo_integer)}) +test_that("ufo integer subset: int N", {test_ufo_subset(data=as.integer(1:100000), subscript=as.integer(100000), ufo_integer)}) +test_that("ufo integer subset: int 1:10", {test_ufo_subset(data=as.integer(1:100000), subscript=as.integer(1:10), ufo_integer)}) +test_that("ufo integer subset: int 1:1000", {test_ufo_subset(data=as.integer(1:100000), subscript=as.integer(1:1000), ufo_integer)}) +test_that("ufo integer subset: int 1:N", {test_ufo_subset(data=as.integer(1:100000), subscript=as.integer(1:100000), ufo_integer)}) +test_that("ufo integer subset: int N/2:N", {test_ufo_subset(data=as.integer(1:100000), subscript=as.integer(50000:100000), ufo_integer)}) +test_that("ufo integer subset: int 2*(2:N/2)", {test_ufo_subset(data=as.integer(1:100000), subscript=as.integer(2*(1:50000)), ufo_integer)}) +test_that("ufo integer subset: int -1", {test_ufo_subset(data=as.integer(1:100000), subscript=as.integer(-1), ufo_integer)}) +test_that("ufo integer subset: int -(N/2)", {test_ufo_subset(data=as.integer(1:100000), subscript=as.integer(-50000), ufo_integer)}) +test_that("ufo integer subset: int -N", {test_ufo_subset(data=as.integer(1:100000), subscript=as.integer(-100000), ufo_integer)}) +test_that("ufo integer subset: int -(1:10)", {test_ufo_subset(data=as.integer(1:100000), subscript=as.integer(-(1:10)), ufo_integer)}) +test_that("ufo integer subset: int -(1:1000)", {test_ufo_subset(data=as.integer(1:100000), subscript=as.integer(-(1:1000)), ufo_integer)}) +test_that("ufo integer subset: int -(1:N)", {test_ufo_subset(data=as.integer(1:100000), subscript=as.integer(-(1:100000)), ufo_integer)}) +test_that("ufo integer subset: int -(N/2:N)", {test_ufo_subset(data=as.integer(1:100000), subscript=as.integer(-(50000:100000)), ufo_integer)}) +test_that("ufo integer subset: int -2*(2:N/2)", {test_ufo_subset(data=as.integer(1:100000), subscript=as.integer(-2*(1:50000)), ufo_integer)}) + +test_that("ufo numeric subset: int 0", {test_ufo_subset(data=as.numeric(1:100000), subscript=as.integer(0), ufo_numeric)}) +test_that("ufo numeric subset: int 1", {test_ufo_subset(data=as.numeric(1:100000), subscript=as.integer(1), ufo_numeric)}) +test_that("ufo numeric subset: int N/2", {test_ufo_subset(data=as.numeric(1:100000), subscript=as.integer(50000), ufo_numeric)}) +test_that("ufo numeric subset: int N", {test_ufo_subset(data=as.numeric(1:100000), subscript=as.integer(100000), ufo_numeric)}) +test_that("ufo numeric subset: int 1:10", {test_ufo_subset(data=as.numeric(1:100000), subscript=as.integer(1:10), ufo_numeric)}) +test_that("ufo numeric subset: int 1:1000", {test_ufo_subset(data=as.numeric(1:100000), subscript=as.integer(1:1000), ufo_numeric)}) +test_that("ufo numeric subset: int 1:N", {test_ufo_subset(data=as.numeric(1:100000), subscript=as.integer(1:100000), ufo_numeric)}) +test_that("ufo numeric subset: int N/2:N", {test_ufo_subset(data=as.numeric(1:100000), subscript=as.integer(50000:100000), ufo_numeric)}) +test_that("ufo numeric subset: int 2*(2:N/2)", {test_ufo_subset(data=as.numeric(1:100000), subscript=as.integer(2*(1:50000)), ufo_numeric)}) +test_that("ufo numeric subset: int -1", {test_ufo_subset(data=as.numeric(1:100000), subscript=as.integer(-1), ufo_numeric)}) +test_that("ufo numeric subset: int -(N/2)", {test_ufo_subset(data=as.numeric(1:100000), subscript=as.integer(-50000), ufo_numeric)}) +test_that("ufo numeric subset: int -N", {test_ufo_subset(data=as.numeric(1:100000), subscript=as.integer(-100000), ufo_numeric)}) +test_that("ufo numeric subset: int -(1:10)", {test_ufo_subset(data=as.numeric(1:100000), subscript=as.integer(-(1:10)), ufo_numeric)}) +test_that("ufo numeric subset: int -(1:1000)", {test_ufo_subset(data=as.numeric(1:100000), subscript=as.integer(-(1:1000)), ufo_numeric)}) +test_that("ufo numeric subset: int -(1:N)", {test_ufo_subset(data=as.numeric(1:100000), subscript=as.integer(-(1:100000)), ufo_numeric)}) +test_that("ufo numeric subset: int -(N/2:N)", {test_ufo_subset(data=as.numeric(1:100000), subscript=as.integer(-(50000:100000)), ufo_numeric)}) +test_that("ufo numeric subset: int -2*(2:N/2)", {test_ufo_subset(data=as.numeric(1:100000), subscript=as.integer(-2*(1:50000)), ufo_numeric)}) + +test_that("ufo complex subset: int 0", {test_ufo_subset(data=as.complex(1:100000), subscript=as.integer(0), ufo_complex)}) +test_that("ufo complex subset: int 1", {test_ufo_subset(data=as.complex(1:100000), subscript=as.integer(1), ufo_complex)}) +test_that("ufo complex subset: int N/2", {test_ufo_subset(data=as.complex(1:100000), subscript=as.integer(50000), ufo_complex)}) +test_that("ufo complex subset: int N", {test_ufo_subset(data=as.complex(1:100000), subscript=as.integer(100000), ufo_complex)}) +test_that("ufo complex subset: int 1:10", {test_ufo_subset(data=as.complex(1:100000), subscript=as.integer(1:10), ufo_complex)}) +test_that("ufo complex subset: int 1:1000", {test_ufo_subset(data=as.complex(1:100000), subscript=as.integer(1:1000), ufo_complex)}) +test_that("ufo complex subset: int 1:N", {test_ufo_subset(data=as.complex(1:100000), subscript=as.integer(1:100000), ufo_complex)}) +test_that("ufo complex subset: int N/2:N", {test_ufo_subset(data=as.complex(1:100000), subscript=as.integer(50000:100000), ufo_complex)}) +test_that("ufo complex subset: int 2*(2:N/2)", {test_ufo_subset(data=as.complex(1:100000), subscript=as.integer(2*(1:50000)), ufo_complex)}) +test_that("ufo complex subset: int -1", {test_ufo_subset(data=as.complex(1:100000), subscript=as.integer(-1), ufo_complex)}) +test_that("ufo complex subset: int -(N/2)", {test_ufo_subset(data=as.complex(1:100000), subscript=as.integer(-50000), ufo_complex)}) +test_that("ufo complex subset: int -N", {test_ufo_subset(data=as.complex(1:100000), subscript=as.integer(-100000), ufo_complex)}) +test_that("ufo complex subset: int -(1:10)", {test_ufo_subset(data=as.complex(1:100000), subscript=as.integer(-(1:10)), ufo_complex)}) +test_that("ufo complex subset: int -(1:1000)", {test_ufo_subset(data=as.complex(1:100000), subscript=as.integer(-(1:1000)), ufo_complex)}) +test_that("ufo complex subset: int -(1:N)", {test_ufo_subset(data=as.complex(1:100000), subscript=as.integer(-(1:100000)), ufo_complex)}) +test_that("ufo complex subset: int -(N/2:N)", {test_ufo_subset(data=as.complex(1:100000), subscript=as.integer(-(50000:100000)), ufo_complex)}) +test_that("ufo complex subset: int -2*(2:N/2)", {test_ufo_subset(data=as.complex(1:100000), subscript=as.integer(-2*(1:50000)), ufo_complex)}) + +test_that("ufo raw subset: int 0", {test_ufo_subset(data=as.raw(1:100000), subscript=as.integer(0), ufo_raw)}) +test_that("ufo raw subset: int 1", {test_ufo_subset(data=as.raw(1:100000), subscript=as.integer(1), ufo_raw)}) +test_that("ufo raw subset: int N/2", {test_ufo_subset(data=as.raw(1:100000), subscript=as.integer(50000), ufo_raw)}) +test_that("ufo raw subset: int N", {test_ufo_subset(data=as.raw(1:100000), subscript=as.integer(100000), ufo_raw)}) +test_that("ufo raw subset: int 1:10", {test_ufo_subset(data=as.raw(1:100000), subscript=as.integer(1:10), ufo_raw)}) +test_that("ufo raw subset: int 1:1000", {test_ufo_subset(data=as.raw(1:100000), subscript=as.integer(1:1000), ufo_raw)}) +test_that("ufo raw subset: int 1:N", {test_ufo_subset(data=as.raw(1:100000), subscript=as.integer(1:100000), ufo_raw)}) +test_that("ufo raw subset: int N/2:N", {test_ufo_subset(data=as.raw(1:100000), subscript=as.integer(50000:100000), ufo_raw)}) +test_that("ufo raw subset: int 2*(2:N/2)", {test_ufo_subset(data=as.raw(1:100000), subscript=as.integer(2*(1:50000)), ufo_raw)}) +test_that("ufo raw subset: int -1", {test_ufo_subset(data=as.raw(1:100000), subscript=as.integer(-1), ufo_raw)}) +test_that("ufo raw subset: int -(N/2)", {test_ufo_subset(data=as.raw(1:100000), subscript=as.integer(-50000), ufo_raw)}) +test_that("ufo raw subset: int -N", {test_ufo_subset(data=as.raw(1:100000), subscript=as.integer(-100000), ufo_raw)}) +test_that("ufo raw subset: int -(1:10)", {test_ufo_subset(data=as.raw(1:100000), subscript=as.integer(-(1:10)), ufo_raw)}) +test_that("ufo raw subset: int -(1:1000)", {test_ufo_subset(data=as.raw(1:100000), subscript=as.integer(-(1:1000)), ufo_raw)}) +test_that("ufo raw subset: int -(1:N)", {test_ufo_subset(data=as.raw(1:100000), subscript=as.integer(-(1:100000)), ufo_raw)}) +test_that("ufo raw subset: int -(N/2:N)", {test_ufo_subset(data=as.raw(1:100000), subscript=as.integer(-(50000:100000)), ufo_raw)}) +test_that("ufo raw subset: int -2*(2:N/2)", {test_ufo_subset(data=as.raw(1:100000), subscript=as.integer(-2*(1:50000)), ufo_raw)}) + +test_that("ufo logical subset: int 0", {test_ufo_subset(data=as.logical(1:100000), subscript=as.integer(0), ufo_logical)}) +test_that("ufo logical subset: int 1", {test_ufo_subset(data=as.logical(1:100000), subscript=as.integer(1), ufo_logical)}) +test_that("ufo logical subset: int N/2", {test_ufo_subset(data=as.logical(1:100000), subscript=as.integer(50000), ufo_logical)}) +test_that("ufo logical subset: int N", {test_ufo_subset(data=as.logical(1:100000), subscript=as.integer(100000), ufo_logical)}) +test_that("ufo logical subset: int 1:10", {test_ufo_subset(data=as.logical(1:100000), subscript=as.integer(1:10), ufo_logical)}) +test_that("ufo logical subset: int 1:1000", {test_ufo_subset(data=as.logical(1:100000), subscript=as.integer(1:1000), ufo_logical)}) +test_that("ufo logical subset: int 1:N", {test_ufo_subset(data=as.logical(1:100000), subscript=as.integer(1:100000), ufo_logical)}) +test_that("ufo logical subset: int N/2:N", {test_ufo_subset(data=as.logical(1:100000), subscript=as.integer(50000:100000), ufo_logical)}) +test_that("ufo logical subset: int 2*(2:N/2)", {test_ufo_subset(data=as.logical(1:100000), subscript=as.integer(2*(1:50000)), ufo_logical)}) +test_that("ufo logical subset: int -1", {test_ufo_subset(data=as.logical(1:100000), subscript=as.integer(-1), ufo_logical)}) +test_that("ufo logical subset: int -(N/2)", {test_ufo_subset(data=as.logical(1:100000), subscript=as.integer(-50000), ufo_logical)}) +test_that("ufo logical subset: int -N", {test_ufo_subset(data=as.logical(1:100000), subscript=as.integer(-100000), ufo_logical)}) +test_that("ufo logical subset: int -(1:10)", {test_ufo_subset(data=as.logical(1:100000), subscript=as.integer(-(1:10)), ufo_logical)}) +test_that("ufo logical subset: int -(1:1000)", {test_ufo_subset(data=as.logical(1:100000), subscript=as.integer(-(1:1000)), ufo_logical)}) +test_that("ufo logical subset: int -(1:N)", {test_ufo_subset(data=as.logical(1:100000), subscript=as.integer(-(1:100000)), ufo_logical)}) +test_that("ufo logical subset: int -(N/2:N)", {test_ufo_subset(data=as.logical(1:100000), subscript=as.integer(-(50000:100000)), ufo_logical)}) +test_that("ufo logical subset: int -2*(2:N/2)", {test_ufo_subset(data=as.logical(1:100000), subscript=as.integer(-2*(1:50000)), ufo_logical)}) + +test_that("ufo string subset: int 0", {test_ufo_subset(data=as.character(1:100000), subscript=as.integer(0), ufo_character)}) +test_that("ufo string subset: int 1", {test_ufo_subset(data=as.character(1:100000), subscript=as.integer(1), ufo_character)}) +test_that("ufo string subset: int N/2", {test_ufo_subset(data=as.character(1:100000), subscript=as.integer(50000), ufo_character)}) +test_that("ufo string subset: int N", {test_ufo_subset(data=as.character(1:100000), subscript=as.integer(100000), ufo_character)}) +test_that("ufo string subset: int 1:10", {test_ufo_subset(data=as.character(1:100000), subscript=as.integer(1:10), ufo_character)}) +test_that("ufo string subset: int 1:1000", {test_ufo_subset(data=as.character(1:100000), subscript=as.integer(1:1000), ufo_character)}) +test_that("ufo string subset: int 1:N", {test_ufo_subset(data=as.character(1:100000), subscript=as.integer(1:100000), ufo_character)}) +test_that("ufo string subset: int N/2:N", {test_ufo_subset(data=as.character(1:100000), subscript=as.integer(50000:100000), ufo_character)}) +test_that("ufo string subset: int 2*(2:N/2)", {test_ufo_subset(data=as.character(1:100000), subscript=as.integer(2*(1:50000)), ufo_character)}) +test_that("ufo string subset: int -1", {test_ufo_subset(data=as.character(1:100000), subscript=as.integer(-1), ufo_character)}) +test_that("ufo string subset: int -(N/2)", {test_ufo_subset(data=as.character(1:100000), subscript=as.integer(-50000), ufo_character)}) +test_that("ufo string subset: int -N", {test_ufo_subset(data=as.character(1:100000), subscript=as.integer(-100000), ufo_character)}) +test_that("ufo string subset: int -(1:10)", {test_ufo_subset(data=as.character(1:100000), subscript=as.integer(-(1:10)), ufo_character)}) +test_that("ufo string subset: int -(1:1000)", {test_ufo_subset(data=as.character(1:100000), subscript=as.integer(-(1:1000)), ufo_character)}) +test_that("ufo string subset: int -(1:N)", {test_ufo_subset(data=as.character(1:100000), subscript=as.integer(-(1:100000)), ufo_character)}) +test_that("ufo string subset: int -(N/2:N)", {test_ufo_subset(data=as.character(1:100000), subscript=as.integer(-(50000:100000)), ufo_character)}) +test_that("ufo string subset: int -2*(2:N/2)", {test_ufo_subset(data=as.character(1:100000), subscript=as.integer(-2*(1:50000)), ufo_character)}) \ No newline at end of file diff --git a/ufovectors/..Rcheck/ufovectors/DESCRIPTION b/ufovectors/..Rcheck/ufovectors/DESCRIPTION new file mode 100644 index 0000000..4759b9c --- /dev/null +++ b/ufovectors/..Rcheck/ufovectors/DESCRIPTION @@ -0,0 +1,21 @@ +Package: ufovectors +Type: Package +Title: Implementation of R vectors using UserFault Objects +Description: Example implementation of R vectors using UserFault Objects to + materialize data on demand from file sources. +Version: 0.1.0 +Author: Konrad Siek +Authors@R: c(person(given = "Colette", family = "Kerr", role = c("aut"), + email = "colette.m.y.kerr@gmail.com"), + person(given = "Konrad", family = "Siek", role = c("aut", "cre"), + email = "siekkonr@fit.cvut.cz")) +Maintainer: Konrad Siek +License: GPL-2 | GPL-3 +Encoding: UTF-8 +LazyData: true +Depends: ufos, viewports +LinkingTo: ufos, viewports +NeedsCompilation: yes +Suggests: knitr, rmarkdown, testthat +VignetteBuilder: knitr +Built: R 4.0.4; x86_64-pc-linux-gnu; 2021-08-16 16:27:05 UTC; unix diff --git a/ufovectors/..Rcheck/ufovectors/NAMESPACE b/ufovectors/..Rcheck/ufovectors/NAMESPACE new file mode 100644 index 0000000..2dad349 --- /dev/null +++ b/ufovectors/..Rcheck/ufovectors/NAMESPACE @@ -0,0 +1,107 @@ +useDynLib(ufovectors, .registration = TRUE, .fixes = "") + +export(ufo_set_debug_mode) + +export(ufo_integer) +export(ufo_numeric) +export(ufo_complex) +export(ufo_logical) +export(ufo_raw) +export(ufo_character) +export(ufo_vector) + +export(ufo_integer_bin) +export(ufo_numeric_bin) +export(ufo_complex_bin) +export(ufo_logical_bin) +export(ufo_raw_bin) +export(ufo_vector_bin) + +export(ufo_matrix_integer_bin) +export(ufo_matrix_numeric_bin) +export(ufo_matrix_complex_bin) +export(ufo_matrix_logical_bin) +export(ufo_matrix_raw_bin) +export(ufo_matrix_bin) + +export(ufo_integer_seq) +export(ufo_numeric_seq) + +export(ufo_csv) + +# Chunking functions +export(ufo_apply) + +# Operators as custom functions +export(ufo_add) +export(ufo_subtract) +export(ufo_multiply) +export(ufo_divide) +export(ufo_power) +export(ufo_modulo) +export(ufo_int_divide) +export(ufo_less) +export(ufo_less_equal) +export(ufo_greater) +export(ufo_greater_equal) +export(ufo_equal) +export(ufo_unequal) +export(ufo_or) +export(ufo_and) +export(ufo_not) +#export(`[.ufo`) +#export(`[<-.ufo`) + +# Operators as S3 +if (isTRUE(getOption("ufovectors.add_class"))) { + S3method(`+`, ufo) + S3method(`-`, ufo) + S3method(`*`, ufo) + S3method(`/`, ufo) + S3method(`%%`, ufo) + S3method(`%/%`, ufo) + S3method(`^`, ufo) + S3method(`<`, ufo) + S3method(`>`, ufo) + S3method(`<=`, ufo) + S3method(`>=`, ufo) + S3method(`==`, ufo) + S3method(`!=`, ufo) + S3method(`|`, ufo) + S3method(`&`, ufo) + S3method(`!`, ufo) + #S3method(`[`, ufo) + #S3method(`[<-`, ufo) +} + +# Operators overloaded +# XXX could not get it to work, went with onLoad + eval +#if (isTRUE(getOption("ufovectors.overload_operators"))) { + #export(`+`) + #export(`-`) + #export(`*`) + #export(`/`) + #export(`%%`) + #export(`%/%`) + #export(`^`) + #export(`<`) + #export(`>`) + #export(`<=`) + #export(`>=`) + #export(`==`) + #export(`!=`) + #export(`|`) + #export(`&`) + #export(`!`) + #export(`[`) + #export(`[<-`) +#} + +export(ufo_subscript) +export(ufo_subset) + +# Mutate is buggy. TODO: fix and make available +#export(ufo_mutate) + +# Helpers +export(ufo_store_bin) diff --git a/ufovectors/..Rcheck/ufovectors/data/gen.c b/ufovectors/..Rcheck/ufovectors/data/gen.c new file mode 100644 index 0000000..78ecc00 --- /dev/null +++ b/ufovectors/..Rcheck/ufovectors/data/gen.c @@ -0,0 +1,20 @@ +#include +#include +#include + +int main (int argc,char *argv[]) { + if (argc != 4) { + printf("usage: gen FILE N_ITEMS VALUE"); + exit(1); + } + + char *path = argv[1]; + size_t n = atoi(argv[2]); + uint32_t v = atoi(argv[3]); + + FILE *fp = fopen(path, "w"); + for (size_t i = 0; i < n; i++) { + fwrite(&v, sizeof(uint32_t), 1, fp); + } + fclose(fp); +} diff --git a/ufovectors/NAMESPACE b/ufovectors/NAMESPACE index 2dad349..356b18c 100644 --- a/ufovectors/NAMESPACE +++ b/ufovectors/NAMESPACE @@ -1,4 +1,4 @@ -useDynLib(ufovectors, .registration = TRUE, .fixes = "") +useDynLib(ufovectors, .registration = TRUE, .fixes = "UFO_C_") export(ufo_set_debug_mode) diff --git a/ufovectors/R/operators.R b/ufovectors/R/operators.R index 038b748..a5fd3e5 100644 --- a/ufovectors/R/operators.R +++ b/ufovectors/R/operators.R @@ -3,25 +3,25 @@ #----------------------------------------------------------------------------- ufo_add <- function(x, y) - if(missing(y)) .ufo_unary (.base_add, "ufo_neg_result", x) else - .ufo_binary(.base_add, "ufo_fit_result", x, y) + if(missing(y)) .ufo_unary (.base_add, UFO_C_neg_result, x) else + .ufo_binary(.base_add, UFO_C_fit_result, x, y) ufo_subtract <- function(x, y) - if(missing(y)) .ufo_unary (.base_subtract, "ufo_neg_result", x) else - .ufo_binary(.base_subtract, "ufo_fit_result", x, y) -ufo_multiply <- function(x, y) .ufo_binary(.base_multiply, "ufo_fit_result", x, y) -ufo_divide <- function(x, y) .ufo_binary(.base_divide, "ufo_div_result", x, y) -ufo_int_divide <- function(x, y) .ufo_binary(.base_int_divide, "ufo_mod_result", x, y) -ufo_power <- function(x, y) .ufo_binary(.base_power, "ufo_div_result", x, y) -ufo_modulo <- function(x, y) .ufo_binary(.base_modulo, "ufo_mod_result", x, y) -ufo_less <- function(x, y) .ufo_binary(.base_less, "ufo_rel_result", x, y) -ufo_less_equal <- function(x, y) .ufo_binary(.base_less_equal, "ufo_rel_result", x, y) -ufo_greater <- function(x, y) .ufo_binary(.base_greater, "ufo_rel_result", x, y) -ufo_greater_equal <- function(x, y) .ufo_binary(.base_greater_equal, "ufo_rel_result", x, y) -ufo_equal <- function(x, y) .ufo_binary(.base_equal, "ufo_log_result", x, y) -ufo_unequal <- function(x, y) .ufo_binary(.base_unequal, "ufo_log_result", x, y) -ufo_or <- function(x, y) .ufo_binary(.base_or, "ufo_log_result", x, y) -ufo_and <- function(x, y) .ufo_binary(.base_and, "ufo_log_result", x, y) -ufo_not <- function(x) .ufo_unary (.base_not, "ufo_neg_result", x) + if(missing(y)) .ufo_unary (.base_subtract, UFO_C_neg_result, x) else + .ufo_binary(.base_subtract, UFO_C_fit_result, x, y) +ufo_multiply <- function(x, y) .ufo_binary(.base_multiply, UFO_C_fit_result, x, y) +ufo_divide <- function(x, y) .ufo_binary(.base_divide, UFO_C_div_result, x, y) +ufo_int_divide <- function(x, y) .ufo_binary(.base_int_divide, UFO_C_mod_result, x, y) +ufo_power <- function(x, y) .ufo_binary(.base_power, UFO_C_div_result, x, y) +ufo_modulo <- function(x, y) .ufo_binary(.base_modulo, UFO_C_mod_result, x, y) +ufo_less <- function(x, y) .ufo_binary(.base_less, UFO_C_rel_result, x, y) +ufo_less_equal <- function(x, y) .ufo_binary(.base_less_equal, UFO_C_rel_result, x, y) +ufo_greater <- function(x, y) .ufo_binary(.base_greater, UFO_C_rel_result, x, y) +ufo_greater_equal <- function(x, y) .ufo_binary(.base_greater_equal, UFO_C_rel_result, x, y) +ufo_equal <- function(x, y) .ufo_binary(.base_equal, UFO_C_log_result, x, y) +ufo_unequal <- function(x, y) .ufo_binary(.base_unequal, UFO_C_log_result, x, y) +ufo_or <- function(x, y) .ufo_binary(.base_or, UFO_C_log_result, x, y) +ufo_and <- function(x, y) .ufo_binary(.base_and, UFO_C_log_result, x, y) +ufo_not <- function(x) .ufo_unary (.base_not, UFO_C_neg_result, x) #----------------------------------------------------------------------------- @@ -30,16 +30,16 @@ ufo_not <- function(x) .ufo_unary (.base_not, "ufo_neg_ ufo_subset <- function(x, subscript, ..., drop=FALSE, min_load_count=0) { # drop ignored for ordinary vectors, it seems? # choice of output type goes here? or inside - .Call("ufo_subset", x, subscript, as.integer(min_load_count)) + .Call(UFO_C_subset, x, subscript, as.integer(min_load_count)) } # ufo_subset_assign <- function(x, subscript, values, ..., drop=FALSE, min_load_count=0) { # drop ignored for ordinary vectors, it seems? # # choice of output type goes here? or inside -# .Call("ufo_subset_assign", x, subscript, values, as.integer(min_load_count)) +# .Call(UFO_C_subset_assign, x, subscript, values, as.integer(min_load_count)) # } ufo_subscript <- function(x, subscript, min_load_count=0) { - .Call("ufo_subscript", x, subscript, as.integer(min_load_count)) + .Call(UFO_C_subscript, x, subscript, as.integer(min_load_count)) } # We can't really do subset_assign equivalent, without triggering copy-on-write @@ -52,7 +52,7 @@ ufo_subscript <- function(x, subscript, min_load_count=0) { # Warnign: buggy. ufo_mutate <- function(x, subscript, values, ..., drop=FALSE, min_load_count=0) { # drop ignored for ordinary vectors, it seems? - .Call("ufo_subset_assign", x, subscript, values, as.integer(min_load_count)) + .Call(UFO_C_subset_assign, x, subscript, values, as.integer(min_load_count)) } #----------------------------------------------------------------------------- @@ -108,7 +108,7 @@ ufo_apply <- function(FUN, ..., MoreArgs = NULL, USE.NAMES = TRUE, chunk_size=10 # - [[2]] c, d # - [[3]] x, y input_chunks <- Map(function(input_vector) { - .Call("ufo_get_chunk", input_vector, + .Call(UFO_C_get_chunk, input_vector, chunk, chunk_size, return_vector_length) }, input_vectors) @@ -184,8 +184,8 @@ ufo_apply <- function(FUN, ..., MoreArgs = NULL, USE.NAMES = TRUE, chunk_size=10 number_of_chunks <- ceiling(result_size / chunk_size) for (chunk in 0:(.base_subtract(number_of_chunks, 1))) { - x_chunk <- .Call("ufo_get_chunk", x, chunk, chunk_size, result_size) - y_chunk <- .Call("ufo_get_chunk", y, chunk, chunk_size, result_size) + x_chunk <- .Call(UFO_C_get_chunk, x, chunk, chunk_size, result_size) + y_chunk <- .Call(UFO_C_get_chunk, y, chunk, chunk_size, result_size) result[attr(x_chunk, 'start_index'):attr(x_chunk, 'end_index')] <- operation(x_chunk, y_chunk) } @@ -202,7 +202,7 @@ ufo_apply <- function(FUN, ..., MoreArgs = NULL, USE.NAMES = TRUE, chunk_size=10 number_of_chunks <- ceiling(result_size / chunk_size) for (chunk in 0:(.base_subtract(number_of_chunks, 1))) { - x_chunk <- .Call("ufo_get_chunk", x, chunk, chunk_size, result_size) + x_chunk <- .Call(UFO_C_get_chunk, x, chunk, chunk_size, result_size) result[attr(x_chunk, 'start_index'):attr(x_chunk, 'end_index')] <- operation(x_chunk) } diff --git a/ufovectors/R/ufovectors.R b/ufovectors/R/ufovectors.R index 92974bb..2405ab5 100644 --- a/ufovectors/R/ufovectors.R +++ b/ufovectors/R/ufovectors.R @@ -1,5 +1,5 @@ ufo_set_debug_mode <- function(debug=TRUE) { - invisible(.Call("ufo_vectors_set_debug_mode", .expect_exactly_one(.expect_type(debug, "logical")))) + invisible(.Call(UFO_C_vectors_set_debug_mode, .expect_exactly_one(.expect_type(debug, "logical")))) } .check_path <- function(path) { @@ -56,7 +56,7 @@ ufo_set_debug_mode <- function(debug=TRUE) { .check_add_class <- function () isTRUE(getOption("ufovectors.add_class")) ufo_integer_seq <- function(from, to, by = 1, read_only = FALSE, min_load_count = 0, add_class = .check_add_class()) { - .add_class(.Call("ufo_intsxp_seq", + .add_class(.Call(UFO_C_intsxp_seq, as.integer(from), as.integer(to), as.integer(by), as.logical(.expect_exactly_one(read_only)), as.integer(.expect_exactly_one(min_load_count))), @@ -64,7 +64,7 @@ ufo_integer_seq <- function(from, to, by = 1, read_only = FALSE, min_load_count } ufo_numeric_seq <- function(from, to, by = 1, read_only = FALSE, min_load_count = 0, add_class = .check_add_class()) { - .add_class(.Call("ufo_realsxp_seq", + .add_class(.Call(UFO_C_realsxp_seq, as.integer(from), as.integer(to), as.integer(by), as.logical(.expect_exactly_one(read_only)), as.integer(.expect_exactly_one(min_load_count))), @@ -72,7 +72,7 @@ ufo_numeric_seq <- function(from, to, by = 1, read_only = FALSE, min_load_count } ufo_integer_bin <- function(path, read_only = FALSE, min_load_count = 0, add_class = .check_add_class()) { - .add_class(.Call("ufo_vectors_intsxp_bin", + .add_class(.Call(UFO_C_vectors_intsxp_bin, path.expand(.check_path(.expect_exactly_one(path))), as.logical(.expect_exactly_one(read_only)), as.integer(.expect_exactly_one(min_load_count))), @@ -80,7 +80,7 @@ ufo_integer_bin <- function(path, read_only = FALSE, min_load_count = 0, add_cla } ufo_numeric_bin <- function(path, read_only = FALSE, min_load_count = 0, add_class = .check_add_class()) { - .add_class(.Call("ufo_vectors_realsxp_bin", + .add_class(.Call(UFO_C_vectors_realsxp_bin, path.expand(.check_path(.expect_exactly_one(path))), as.logical(.expect_exactly_one(read_only)), as.integer(.expect_exactly_one(min_load_count))), @@ -88,7 +88,7 @@ ufo_numeric_bin <- function(path, read_only = FALSE, min_load_count = 0, add_cla } ufo_complex_bin <- function(path, read_only = FALSE, min_load_count = 0, add_class = .check_add_class()) { - .add_class(.Call("ufo_vectors_cplxsxp_bin", + .add_class(.Call(UFO_C_vectors_cplxsxp_bin, path.expand(.check_path(.expect_exactly_one(path))), as.logical(.expect_exactly_one(read_only)), as.integer(.expect_exactly_one(min_load_count))), @@ -96,7 +96,7 @@ ufo_complex_bin <- function(path, read_only = FALSE, min_load_count = 0, add_cla } ufo_logical_bin <- function(path, read_only = FALSE, min_load_count = 0, add_class = .check_add_class()) { - .add_class(.Call("ufo_vectors_lglsxp_bin", + .add_class(.Call(UFO_C_vectors_lglsxp_bin, path.expand(.check_path(.expect_exactly_one(path))), as.logical(.expect_exactly_one(read_only)), as.integer(.expect_exactly_one(min_load_count))), @@ -104,7 +104,7 @@ ufo_logical_bin <- function(path, read_only = FALSE, min_load_count = 0, add_cla } ufo_raw_bin <- function(path, read_only = FALSE, min_load_count = 0, add_class = .check_add_class()) { - .add_class(.Call("ufo_vectors_rawsxp_bin", + .add_class(.Call(UFO_C_vectors_rawsxp_bin, path.expand(.check_path(.expect_exactly_one(path))), as.logical(.expect_exactly_one(read_only)), as.integer(.expect_exactly_one(min_load_count))), @@ -112,7 +112,7 @@ ufo_raw_bin <- function(path, read_only = FALSE, min_load_count = 0, add_class = } ufo_matrix_integer_bin <- function(path, rows, cols, read_only = FALSE, min_load_count = 0, add_class = .check_add_class()) { - .add_class(.Call("ufo_matrix_intsxp_bin", + .add_class(.Call(UFO_C_matrix_intsxp_bin, path.expand(.check_path(.expect_exactly_one(path))), as.integer(.expect_exactly_one(rows)), as.integer(.expect_exactly_one(cols)), @@ -122,7 +122,7 @@ ufo_matrix_integer_bin <- function(path, rows, cols, read_only = FALSE, min_load } ufo_matrix_numeric_bin <- function(path, rows, cols, read_only = FALSE, min_load_count = 0, add_class = .check_add_class()) { - .add_class(.Call("ufo_matrix_realsxp_bin", + .add_class(.Call(UFO_C_matrix_realsxp_bin, path.expand(.check_path(.expect_exactly_one(path))), as.integer(.expect_exactly_one(rows)), as.integer(.expect_exactly_one(cols)), @@ -132,7 +132,7 @@ ufo_matrix_numeric_bin <- function(path, rows, cols, read_only = FALSE, min_load } ufo_matrix_complex_bin <- function(path, rows, cols, read_only = FALSE, min_load_count = 0, add_class = .check_add_class()) { - .add_class(.Call("ufo_matrix_cplxsxp_bin", + .add_class(.Call(UFO_C_matrix_cplxsxp_bin, path.expand(.check_path(.expect_exactly_one(path))), as.integer(.expect_exactly_one(rows)), as.integer(.expect_exactly_one(cols)), @@ -142,7 +142,7 @@ ufo_matrix_complex_bin <- function(path, rows, cols, read_only = FALSE, min_load } ufo_matrix_logical_bin <- function(path, rows, cols, read_only = FALSE, min_load_count = 0, add_class = .check_add_class()) { - .add_class(.Call("ufo_matrix_lglsxp_bin", + .add_class(.Call(UFO_C_matrix_lglsxp_bin, path.expand(.check_path(.expect_exactly_one(path))), as.integer(.expect_exactly_one(rows)), as.integer(.expect_exactly_one(cols)), @@ -153,7 +153,7 @@ ufo_matrix_logical_bin <- function(path, rows, cols, read_only = FALSE, min_load } ufo_matrix_raw_bin <- function(path, rows, cols, read_only = FALSE, min_load_count = 0, add_class = .check_add_class()) { - .add_class(.Call("ufo_matrix_rawsxp_bin", + .add_class(.Call(UFO_C_matrix_rawsxp_bin, path.expand(.check_path(.expect_exactly_one(path))), as.integer(.expect_exactly_one(rows)), as.integer(.expect_exactly_one(cols)), @@ -197,7 +197,7 @@ ufo_csv <- function(path, read_only = FALSE, min_load_count = 0, check_names=T, .expect_exactly_one(record_row_offsets_at_interval) .expect_exactly_one(initial_buffer_size) - df <- .Call("ufo_csv", + df <- .Call(UFO_C_csv, path.expand(.check_path(.expect_exactly_one(path))), # SEXP/*STRSXP*/ as.logical(.expect_exactly_one(read_only)), # SEXP/*LGLP*/ as.integer(.expect_exactly_one(min_load_count)), # SEXP/*INTSXP*/ @@ -231,15 +231,14 @@ ufo_vector <- function(mode = "logical", length = 0, populate_with_NAs = FALSE, stop("Vector mode ", mode, " is not supported by UFOs.") } - vector_type = if (mode == "integer") "intsxp" - else if (mode == "double" || mode == "numeric") "realsxp" - else if (mode == "logical") "lglsxp" - else if (mode == "complex") "cplxsxp" - else if (mode == "raw") "rawsxp" - else if (mode == "character" || mode == "string") "strsxp" + constructor <- if (mode == "integer") UFO_C_intsxp_empty + else if (mode == "double" || mode == "numeric") UFO_C_realsxp_empty + else if (mode == "logical") UFO_C_lglsxp_empty + else if (mode == "complex") UFO_C_cplxsxp_empty + else if (mode == "raw") UFO_C_rawsxp_empty + else if (mode == "character" || mode == "string") UFO_C_strsxp_empty else stop("Vector mode ", mode, " is not supported by UFOs.") - constructor <- paste0("ufo_", vector_type, "_empty") .add_class(.Call(constructor, as.numeric(length), as.logical(populate_with_NAs), @@ -248,7 +247,7 @@ ufo_vector <- function(mode = "logical", length = 0, populate_with_NAs = FALSE, } ufo_integer <- function(size, populate_with_NAs = FALSE, min_load_count = 0, add_class = .check_add_class()) { - .add_class(.Call("ufo_intsxp_empty", + .add_class(.Call(UFO_C_intsxp_empty, as.numeric(size), as.logical(populate_with_NAs), as.integer(.expect_exactly_one(min_load_count))), @@ -256,7 +255,7 @@ ufo_integer <- function(size, populate_with_NAs = FALSE, min_load_count = 0, add } ufo_numeric <- function(size, populate_with_NAs = FALSE, min_load_count = 0, add_class = .check_add_class()) { - .add_class(.Call("ufo_realsxp_empty", + .add_class(.Call(UFO_C_realsxp_empty, as.numeric(size), as.logical(populate_with_NAs), as.integer(.expect_exactly_one(min_load_count))), @@ -264,7 +263,7 @@ ufo_numeric <- function(size, populate_with_NAs = FALSE, min_load_count = 0, add } ufo_complex <- function(size, populate_with_NAs = FALSE, min_load_count = 0, add_class = .check_add_class()) { - .add_class(.Call("ufo_cplxsxp_empty", + .add_class(.Call(UFO_C_cplxsxp_empty, as.numeric(size), as.logical(populate_with_NAs), as.integer(.expect_exactly_one(min_load_count))), @@ -272,7 +271,7 @@ ufo_complex <- function(size, populate_with_NAs = FALSE, min_load_count = 0, add } ufo_logical <- function(size, populate_with_NAs = FALSE, min_load_count = 0, add_class = .check_add_class()) { - .add_class(.Call("ufo_lglsxp_empty", + .add_class(.Call(UFO_C_lglsxp_empty, as.numeric(size), as.logical(populate_with_NAs), as.integer(.expect_exactly_one(min_load_count))), @@ -280,14 +279,14 @@ ufo_logical <- function(size, populate_with_NAs = FALSE, min_load_count = 0, add } ufo_raw <- function(size, min_load_count = 0, add_class = .check_add_class()) { - .add_class(.Call("ufo_rawsxp_empty", + .add_class(.Call(UFO_C_rawsxp_empty, as.numeric(size), as.integer(.expect_exactly_one(min_load_count))), "ufo", add_class) } ufo_character <- function(size, populate_with_NAs = FALSE, min_load_count = 0, add_class = .check_add_class()) { - .add_class(.Call("ufo_strsxp_empty", + .add_class(.Call(UFO_C_strsxp_empty, as.numeric(size), as.logical(populate_with_NAs), as.integer(.expect_exactly_one(min_load_count))), @@ -295,5 +294,5 @@ ufo_character <- function(size, populate_with_NAs = FALSE, min_load_count = 0, a } ufo_store_bin <- function(path, vector) { - invisible(.Call("ufo_store_bin", .check_path(.expect_exactly_one(path)), vector)) + invisible(.Call(UFO_C_store_bin, .check_path(.expect_exactly_one(path)), vector)) } diff --git a/ufovectors/src/init.c b/ufovectors/src/init.c index 9fadab5..56c947f 100644 --- a/ufovectors/src/init.c +++ b/ufovectors/src/init.c @@ -11,64 +11,63 @@ // List of functions provided by the package. static const R_CallMethodDef CallEntries[] = { + // Chunking. + {"get_chunk", (DL_FUNC) &ufo_get_chunk, 4}, + //{"calculate_chunk_indices", (DL_FUNC) &ufo_calculate_chunk_indices, 4}, + //{"calculate_chunk_indices", (DL_FUNC) &ufo_calculate_chunk_indices, 4}, + // Constructors for vectors that partially materialize on-demand from // binary files. - {"ufo_vectors_intsxp_bin", (DL_FUNC) &ufo_vectors_intsxp_bin, 3}, - {"ufo_vectors_realsxp_bin", (DL_FUNC) &ufo_vectors_realsxp_bin, 3}, - {"ufo_vectors_cplxsxp_bin", (DL_FUNC) &ufo_vectors_cplxsxp_bin, 3}, - {"ufo_vectors_lglsxp_bin", (DL_FUNC) &ufo_vectors_lglsxp_bin, 3}, - {"ufo_vectors_rawsxp_bin", (DL_FUNC) &ufo_vectors_rawsxp_bin, 3}, + {"vectors_intsxp_bin", (DL_FUNC) &ufo_vectors_intsxp_bin, 3}, + {"vectors_realsxp_bin", (DL_FUNC) &ufo_vectors_realsxp_bin, 3}, + {"vectors_cplxsxp_bin", (DL_FUNC) &ufo_vectors_cplxsxp_bin, 3}, + {"vectors_lglsxp_bin", (DL_FUNC) &ufo_vectors_lglsxp_bin, 3}, + {"vectors_rawsxp_bin", (DL_FUNC) &ufo_vectors_rawsxp_bin, 3}, // Constructors for matrices composed of the above-mentioned vectors. - {"ufo_matrix_intsxp_bin", (DL_FUNC) &ufo_matrix_intsxp_bin, 5}, - {"ufo_matrix_realsxp_bin", (DL_FUNC) &ufo_matrix_realsxp_bin, 5}, - {"ufo_matrix_cplxsxp_bin", (DL_FUNC) &ufo_matrix_cplxsxp_bin, 5}, - {"ufo_matrix_lglsxp_bin", (DL_FUNC) &ufo_matrix_lglsxp_bin, 5}, - {"ufo_matrix_rawsxp_bin", (DL_FUNC) &ufo_matrix_rawsxp_bin, 5}, + {"matrix_intsxp_bin", (DL_FUNC) &ufo_matrix_intsxp_bin, 5}, + {"matrix_realsxp_bin", (DL_FUNC) &ufo_matrix_realsxp_bin, 5}, + {"matrix_cplxsxp_bin", (DL_FUNC) &ufo_matrix_cplxsxp_bin, 5}, + {"matrix_lglsxp_bin", (DL_FUNC) &ufo_matrix_lglsxp_bin, 5}, + {"matrix_rawsxp_bin", (DL_FUNC) &ufo_matrix_rawsxp_bin, 5}, // Constructors for empty vectors. - {"ufo_intsxp_empty", (DL_FUNC) &ufo_intsxp_empty, 3}, - {"ufo_realsxp_empty", (DL_FUNC) &ufo_realsxp_empty, 3}, - {"ufo_cplxsxp_empty", (DL_FUNC) &ufo_cplxsxp_empty, 3}, - {"ufo_lglsxp_empty", (DL_FUNC) &ufo_lglsxp_empty, 3}, - {"ufo_rawsxp_empty", (DL_FUNC) &ufo_rawsxp_empty, 2}, - {"ufo_strsxp_empty", (DL_FUNC) &ufo_strsxp_empty, 3}, - {"ufo_vecsxp_empty", (DL_FUNC) &ufo_vecsxp_empty, 2}, - - {"ufo_intsxp_seq", (DL_FUNC) &ufo_intsxp_seq, 5}, - {"ufo_realsxp_seq", (DL_FUNC) &ufo_realsxp_seq, 5}, + {"intsxp_empty", (DL_FUNC) &ufo_intsxp_empty, 3}, + {"realsxp_empty", (DL_FUNC) &ufo_realsxp_empty, 3}, + {"cplxsxp_empty", (DL_FUNC) &ufo_cplxsxp_empty, 3}, + {"lglsxp_empty", (DL_FUNC) &ufo_lglsxp_empty, 3}, + {"rawsxp_empty", (DL_FUNC) &ufo_rawsxp_empty, 2}, + {"strsxp_empty", (DL_FUNC) &ufo_strsxp_empty, 3}, + {"vecsxp_empty", (DL_FUNC) &ufo_vecsxp_empty, 2}, + + {"intsxp_seq", (DL_FUNC) &ufo_intsxp_seq, 5}, + {"realsxp_seq", (DL_FUNC) &ufo_realsxp_seq, 5}, // CSV support - {"ufo_csv", (DL_FUNC) &ufo_csv, 6}, + {"csv", (DL_FUNC) &ufo_csv, 6}, // Storage. - {"ufo_store_bin", (DL_FUNC) &ufo_store_bin, 2}, + {"store_bin", (DL_FUNC) &ufo_store_bin, 2}, // Turn on debug mode. - {"ufo_vectors_set_debug_mode", (DL_FUNC) &ufo_vectors_set_debug_mode, 1}, + {"vectors_set_debug_mode", (DL_FUNC) &ufo_vectors_set_debug_mode, 1}, // Artihmetic operators result constructors. - {"ufo_fit_result", (DL_FUNC) &ufo_fit_result, 3}, - {"ufo_div_result", (DL_FUNC) &ufo_div_result, 3}, - {"ufo_mod_result", (DL_FUNC) &ufo_mod_result, 3}, - {"ufo_rel_result", (DL_FUNC) &ufo_rel_result, 3}, - {"ufo_log_result", (DL_FUNC) &ufo_log_result, 3}, - {"ufo_neg_result", (DL_FUNC) &ufo_neg_result, 2}, + {"fit_result", (DL_FUNC) &ufo_fit_result, 3}, + {"div_result", (DL_FUNC) &ufo_div_result, 3}, + {"mod_result", (DL_FUNC) &ufo_mod_result, 3}, + {"rel_result", (DL_FUNC) &ufo_rel_result, 3}, + {"log_result", (DL_FUNC) &ufo_log_result, 3}, + {"neg_result", (DL_FUNC) &ufo_neg_result, 2}, // Subsetting operators. - {"ufo_subset", (DL_FUNC) &ufo_subset, 3}, - {"ufo_subset_assign", (DL_FUNC) &ufo_subset_assign, 4}, - - // Chunking. - //{"ufo_calculate_chunk_indices", (DL_FUNC) &ufo_calculate_chunk_indices, 4}, - //{"ufo_calculate_chunk_indices", (DL_FUNC) &ufo_calculate_chunk_indices, 4}, - {"ufo_get_chunk", (DL_FUNC) &ufo_get_chunk, 4}, + {"subset", (DL_FUNC) &ufo_subset, 3}, + {"subset_assign", (DL_FUNC) &ufo_subset_assign, 4}, - {"ufo_subscript", (DL_FUNC) &ufo_subscript, 3}, - {"ufo_subset" , (DL_FUNC) &ufo_subset, 3}, + {"subscript", (DL_FUNC) &ufo_subscript, 3}, // Terminates the function list. Necessary. - {NULL, NULL, 0} + {NULL, NULL, 0} }; // Initializes the package and registers the routines with the Rdynload @@ -76,7 +75,7 @@ static const R_CallMethodDef CallEntries[] = { void attribute_visible R_init_ufovectors(DllInfo *dll) { R_registerRoutines(dll, NULL, CallEntries, NULL, NULL); R_useDynamicSymbols(dll, FALSE); - R_forceSymbols(dll, TRUE); + R_forceSymbols(dll, TRUE); // causes failure to lookup the ufo_get_chunk symbol }