tests/testthat/test-expt_dgr-ds.dataFrameSort.R

In datashield/dsBaseClient: DataSHIELD Client Functions

#-------------------------------------------------------------------------------
# Copyright (c) 2019-2022 University of Newcastle upon Tyne. All rights reserved.
#
# This program and the accompanying materials
# are made available under the terms of the GNU Public License v3.0.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.
#-------------------------------------------------------------------------------

#
# Set up
#

context('ds.dataFrameSort::expt_dgr::setup')

source('connection_to_datasets/init_testing_datasets.R')
source('definition_tests/def-ds.dataFrameSort.R')

#
# Tests
#

context("ds.dataFrameSort::expt_dgr::multiple::correct_parameter_class")
test_that('all datasets',
          {  
            connect.all.datasets()
            .test.function.parameters("D","D$LOGICAL",TRUE,"numeric","server.data")
            .test.function.parameters("D","D$LOGICAL",TRUE,"alphabetic","server.data")
            .test.function.parameters("D","D$INTEGER",TRUE,"numeric","server.data")
            .test.function.parameters("D","D$INTEGER",TRUE,"alphabetic","server.data")
            .test.function.parameters("D","D$POSITIVE_INTEGER",FALSE,"alphabetic","server.data")
            .test.function.parameters("D","D$NEGATIVE_INTEGER",TRUE,"numeric","server.data")
            .test.function.parameters("D","D$NUMERIC",TRUE,"numeric","server.data")
            .test.function.parameters("D","D$POSITIVE_NUMERIC",FALSE,"numeric","server.data")
            .test.function.parameters("D","D$NEGATIVE_NUMERIC",TRUE,"alphabetic","server.data")
            .test.function.parameters("D","D$IDENTIFIER",FALSE,"numeric","server.data")
            .test.function.parameters("D","D$CATEGORY",TRUE,"alphabetic","server.data")
            .test.function.parameters("D","D$NUMERIC_ONE_CHANGE",TRUE,"alphabetic","server.data")
            .test.function.parameters("D","D$INTEGER_ONE_CHANGE",TRUE,"numeric","server.data")
          })

context("ds.dataFrameSort::expt_dgr::single::correct_parameter_class")
test_that('dataset 2',
          {  
            connect.dataset.2()
            .test.function.parameters("D","D$LOGICAL",TRUE,"numeric","server.data")
            .test.function.parameters("D","D$LOGICAL",TRUE,"alphabetic","server.data")
            .test.function.parameters("D","D$INTEGER",TRUE,"numeric","server.data")
            .test.function.parameters("D","D$INTEGER",TRUE,"alphabetic","server.data")
            .test.function.parameters("D","D$POSITIVE_INTEGER",FALSE,"alphabetic","server.data")
            .test.function.parameters("D","D$NEGATIVE_INTEGER",TRUE,"numeric","server.data")
            .test.function.parameters("D","D$NUMERIC",TRUE,"numeric","server.data")
            .test.function.parameters("D","D$POSITIVE_NUMERIC",FALSE,"numeric","server.data")
            .test.function.parameters("D","D$NEGATIVE_NUMERIC",TRUE,"alphabetic","server.data")
            .test.function.parameters("D","D$IDENTIFIER",FALSE,"numeric","server.data")
            .test.function.parameters("D","D$CATEGORY",TRUE,"alphabetic","server.data")
            .test.function.parameters("D","D$NUMERIC_ONE_CHANGE",TRUE,"alphabetic","server.data")
            .test.function.parameters("D","D$INTEGER_ONE_CHANGE",TRUE,"numeric","server.data")
          })

context("ds.dataFrameSort::expt_dgr::multiple::incorrect_parameter_class")
test_that('all datasets',
          {  
            connect.all.datasets()
            .test.function.parameters(D,"D$LOGICAL",TRUE,"numeric","server.data")
            .test.function.parameters(2,"D$INTEGER",TRUE,"alphabetic","server.data")
            .test.function.parameters("D","LHD",TRUE,"alphabetic","server.data")
            .test.function.parameters("K","D$NEGATIVE_INTEGER",FALSE,"numeric","server.data")
            #.test.function.parameters("D","D$NUMERIC",10,"numeric","server.data")
            .test.function.parameters("D","D$POSITIVE_NUMERIC","D","numeric","server.data")
            #.test.function.parameters("D","D$NEGATIVE_NUMERIC",TRUE,23,"server.data")
            .test.function.parameters("D","D$IDENTIFIER",TRUE,"CHARACTER","server.data")
            #.test.function.parameters("D","D$CATEGORY",FALSE,"numeric",server.data)
            .test.function.parameters("D","D$NUMERIC_ONE_CHANGE",TRUE,"alphabetic",23)
            .test.function.parameters("dataframe","D$INTEGER_ONE_CHANGE",TRUE,"numeric","server.data")
          })

context("ds.dataFrameSort::expt_dgr::single::incorrect_parameter_class")
test_that('dataset 2',
          {  
            connect.dataset.2()
            .test.function.parameters(D,"D$LOGICAL",TRUE,"numeric","server.data")
            .test.function.parameters(2,"D$INTEGER",TRUE,"alphabetic","server.data")
            .test.function.parameters("D","LHD",TRUE,"alphabetic","server.data")
            .test.function.parameters("K","D$NEGATIVE_INTEGER",FALSE,"numeric","server.data")
            #.test.function.parameters("D","D$NUMERIC",10,"numeric","server.data")
            .test.function.parameters("D","D$POSITIVE_NUMERIC","D","numeric","server.data")
            #.test.function.parameters("D","D$NEGATIVE_NUMERIC",TRUE,23,"server.data")
            .test.function.parameters("D","D$IDENTIFIER",TRUE,"CHARACTER","server.data")
            #.test.function.parameters("D","D$CATEGORY",FALSE,"numeric",server.data)
            .test.function.parameters("D","D$NUMERIC_ONE_CHANGE",TRUE,"alphabetic",23)
            .test.function.parameters("dataframe","D$INTEGER_ONE_CHANGE",TRUE,"numeric","server.data")
          })

context("ds.dataFrameSort::expt_dgr::multiple::df::creation")
test_that('all datasets',
          {  
            connect.all.datasets()
            .test.data.frame.creation("D","LOGICAL",TRUE,"numeric","server.data")
            .test.data.frame.creation("D","INTEGER",TRUE,"numeric","server.data")
            .test.data.frame.creation("D","POSITIVE_INTEGER",TRUE,"numeric","server.data")
            .test.data.frame.creation("D","NEGATIVE_INTEGER",TRUE,"numeric","server.data")
            .test.data.frame.creation("D","NUMERIC",TRUE,"numeric","server.data")
            .test.data.frame.creation("D","POSITIVE_NUMERIC",TRUE,"numeric","server.data")
            .test.data.frame.creation("D","NEGATIVE_NUMERIC",TRUE,"numeric","server.data")
            .test.data.frame.creation("D","IDENTIFIER",TRUE,"numeric","server.data")
            .test.data.frame.creation("D","CATEGORY",TRUE,"numeric","server.data")
            .test.data.frame.creation("D","NUMERIC_ONE_CHANGE",TRUE,"numeric","server.data")
            .test.data.frame.creation("D","INTEGER_ONE_CHANGE",TRUE,"numeric","server.data")
          })

context("ds.dataFrameSort::expt_dgr::single::df::creation")
test_that('dataset 3',
          {  
            connect.dataset.3()
            .test.data.frame.creation("D","LOGICAL",FALSE,"numeric","server.data")
            .test.data.frame.creation("D","INTEGER",TRUE,"alphabetic","server.data")
            .test.data.frame.creation("D","POSITIVE_INTEGER",TRUE,"numeric","server.data")
            .test.data.frame.creation("D","NEGATIVE_INTEGER",TRUE,"alphabetic","server.data")
            .test.data.frame.creation("D","NUMERIC",TRUE,"numeric","server.data")
            .test.data.frame.creation("D","POSITIVE_NUMERIC",TRUE,"numeric","server.data")
            .test.data.frame.creation("D","NEGATIVE_NUMERIC",FALSE,"alphabetic","server.data")
            .test.data.frame.creation("D","IDENTIFIER",TRUE,"alphabetic","server.data")
            .test.data.frame.creation("D","CATEGORY",TRUE,"numeric","server.data")
            .test.data.frame.creation("D","NUMERIC_ONE_CHANGE",TRUE,"numeric","server.data")
            .test.data.frame.creation("D","INTEGER_ONE_CHANGE",FALSE,"alphabetic","server.data")
          })

context("ds.dataFrameSort::expt_dgr::multiple::numeric::ascending")
test_that('all datasets',
          {  
            connect.all.datasets()
            all.local.values <- list(ds.test_env$local.values.1, ds.test_env$local.values.2, ds.test_env$local.values.3)
            .test.data.frame.sorting("D","LOGICAL",FALSE,"numeric","server.data",all.local.values)
            .test.data.frame.sorting("D","INTEGER",FALSE,"numeric","server.data",all.local.values)
            .test.data.frame.sorting("D","POSITIVE_INTEGER",FALSE,"numeric","server.data",all.local.values)
            .test.data.frame.sorting("D","NEGATIVE_INTEGER",FALSE,"numeric","server.data",all.local.values)
            .test.data.frame.sorting("D","NUMERIC",FALSE,"numeric","server.data",all.local.values)
            .test.data.frame.sorting("D","POSITIVE_NUMERIC",FALSE,"numeric","server.data",all.local.values)
            .test.data.frame.sorting("D","NEGATIVE_NUMERIC",FALSE,"numeric","server.data",all.local.values)
            .test.data.frame.sorting("D","IDENTIFIER",FALSE,"numeric","server.data",all.local.values)
            .test.data.frame.sorting("D","CATEGORY",FALSE,"numeric","server.data",all.local.values)
            .test.data.frame.sorting("D","NUMERIC_ONE_CHANGE",FALSE,"numeric","server.data",all.local.values)
            .test.data.frame.sorting("D","INTEGER_ONE_CHANGE",FALSE,"numeric","server.data",all.local.values)
            #.test.data.frame.sorting("D","FACTOR_INTEGER",FALSE,"numeric","server.data",all.local.values)
            #.test.data.frame.sorting("D","FACTOR_CHARACTER",FALSE,"numeric","server.data",all.local.values)
            #.test.data.frame.sorting("D","CHARACTER",FALSE,"numeric","server.data",all.local.values)
          })

context("ds.dataFrameSort::expt_dgr::single::numeric::ascending")
test_that('dataset 1',
          {  
            connect.dataset.1()
            all.local.values <- list(ds.test_env$local.values.1)
            .test.data.frame.sorting("D","LOGICAL",FALSE,"numeric","server.data",all.local.values)
            .test.data.frame.sorting("D","INTEGER",FALSE,"numeric","server.data",all.local.values)
            .test.data.frame.sorting("D","POSITIVE_INTEGER",FALSE,"numeric","server.data",all.local.values)
            .test.data.frame.sorting("D","NEGATIVE_INTEGER",FALSE,"numeric","server.data",all.local.values)
            .test.data.frame.sorting("D","NUMERIC",FALSE,"numeric","server.data",all.local.values)
            .test.data.frame.sorting("D","POSITIVE_NUMERIC",FALSE,"numeric","server.data",all.local.values)
            .test.data.frame.sorting("D","NEGATIVE_NUMERIC",FALSE,"numeric","server.data",all.local.values)
            .test.data.frame.sorting("D","IDENTIFIER",FALSE,"numeric","server.data",all.local.values)
            .test.data.frame.sorting("D","CATEGORY",FALSE,"numeric","server.data",all.local.values)
            .test.data.frame.sorting("D","NUMERIC_ONE_CHANGE",FALSE,"numeric","server.data",all.local.values)
            .test.data.frame.sorting("D","INTEGER_ONE_CHANGE",FALSE,"numeric","server.data",all.local.values)
            #.test.data.frame.sorting("D","FACTOR_INTEGER",FALSE,"numeric","server.data",all.local.values)
            #.test.data.frame.sorting("D","FACTOR_CHARACTER",FALSE,"numeric","server.data",all.local.values)
            #.test.data.frame.sorting("D","CHARACTER",FALSE,"numeric","server.data",all.local.values)
          })

context("ds.dataFrameSort::expt_dgr::multiple::numeric::descending")
test_that('all datasets',
          {  
            connect.all.datasets()
            all.local.values <- list(ds.test_env$local.values.1, ds.test_env$local.values.2, ds.test_env$local.values.3)
            .test.data.frame.sorting("D","LOGICAL",TRUE,"numeric","server.data",all.local.values)
            .test.data.frame.sorting("D","INTEGER",TRUE,"numeric","server.data",all.local.values)
            .test.data.frame.sorting("D","POSITIVE_INTEGER",TRUE,"numeric","server.data",all.local.values)
            .test.data.frame.sorting("D","NEGATIVE_INTEGER",TRUE,"numeric","server.data",all.local.values)
            .test.data.frame.sorting("D","NUMERIC",TRUE,"numeric","server.data",all.local.values)
            .test.data.frame.sorting("D","POSITIVE_NUMERIC",TRUE,"numeric","server.data",all.local.values)
            .test.data.frame.sorting("D","NEGATIVE_NUMERIC",TRUE,"numeric","server.data",all.local.values)
            .test.data.frame.sorting("D","IDENTIFIER",TRUE,"numeric","server.data",all.local.values)
            .test.data.frame.sorting("D","CATEGORY",TRUE,"numeric","server.data",all.local.values)
            .test.data.frame.sorting("D","NUMERIC_ONE_CHANGE",TRUE,"numeric","server.data",all.local.values)
            .test.data.frame.sorting("D","INTEGER_ONE_CHANGE",TRUE,"numeric","server.data",all.local.values)
            #.test.data.frame.sorting("D","FACTOR_INTEGER",TRUE,"numeric","server.data",all.local.values)
            #.test.data.frame.sorting("D","FACTOR_CHARACTER",TRUE,"numeric","server.data",all.local.values)
            #.test.data.frame.sorting("D","CHARACTER",TRUE,"numeric","server.data",all.local.values)
            
            
          })

context("ds.dataFrameSort::expt_dgr::single::numeric::descending")
test_that('dataset 1',
          {  
            connect.dataset.1()
            all.local.values <- list(ds.test_env$local.values.1)
            .test.data.frame.sorting("D","LOGICAL",TRUE,"numeric","server.data",all.local.values)
            .test.data.frame.sorting("D","INTEGER",TRUE,"numeric","server.data",all.local.values)
            .test.data.frame.sorting("D","POSITIVE_INTEGER",TRUE,"numeric","server.data",all.local.values)
            .test.data.frame.sorting("D","NEGATIVE_INTEGER",TRUE,"numeric","server.data",all.local.values)
            .test.data.frame.sorting("D","NUMERIC",TRUE,"numeric","server.data",all.local.values)
            .test.data.frame.sorting("D","POSITIVE_NUMERIC",TRUE,"numeric","server.data",all.local.values)
            #.test.data.frame.sorting("D","NEGATIVE_NUMERIC",TRUE,"numeric","server.data",all.local.values)
            .test.data.frame.sorting("D","IDENTIFIER",TRUE,"numeric","server.data",all.local.values)
            .test.data.frame.sorting("D","CATEGORY",TRUE,"numeric","server.data",all.local.values)
            .test.data.frame.sorting("D","NUMERIC_ONE_CHANGE",TRUE,"numeric","server.data",all.local.values)
            .test.data.frame.sorting("D","INTEGER_ONE_CHANGE",TRUE,"numeric","server.data",all.local.values)
            #.test.data.frame.sorting("D","FACTOR_INTEGER",TRUE,"numeric","server.data",all.local.values)
            #.test.data.frame.sorting("D","FACTOR_CHARACTER",TRUE,"numeric","server.data",all.local.values)
            #.test.data.frame.sorting("D","CHARACTER",TRUE,"numeric","server.data",all.local.values)
          })


context("ds.dataFrameSort::expt_dgr::multiple::alphabetic::ascending")
test_that('all datasets',
          {  
            #connect.all.datasets()
            #local.df.list<-list(ds.test_env$local.values.1[,-1],ds.test_env$local.values.2[,-1],ds.test_env$local.values.3[,-1])
            #server.FC_levels<-ds.levels("D$FACTOR_CHARACTER")
            #for(i in 1:length(local.df.list)){
            #  local.df.list[[i]][,"CHARACTER"]<-as.character(local.df.list[[i]][,"CHARACTER"])
            #  local.df.list[[i]][,"FACTOR_INTEGER"]<-as.factor(local.df.list[[i]][,"FACTOR_INTEGER"])
            #  levels(local.df.list[[i]][,"FACTOR_CHARACTER"])<-server.FC_levels[[i]]
            #  colnames(local.df.list[[i]])<-ds.colnames("D",datasources = ds.test_env$connections[i][[1]])
            #}
            #.test.data.frame.sorting("D","LOGICAL",FALSE,"alphabetic","server.data",all.local.values)
            #.test.data.frame.sorting("D","INTEGER",FALSE,"alphabetic","server.data",all.local.values)
            #.test.data.frame.sorting("D","POSITIVE_INTEGER",FALSE,"alphabetic","server.data",all.local.values)
            #.test.data.frame.sorting("D","NEGATIVE_INTEGER",FALSE,"alphabetic","server.data",all.local.values)
            #.test.data.frame.sorting("D","NUMERIC",FALSE,"alphabetic","server.data",all.local.values)
            #.test.data.frame.sorting("D","POSITIVE_NUMERIC",FALSE,"alphabetic","server.data",all.local.values)
            #.test.data.frame.sorting("D","NEGATIVE_NUMERIC",FALSE,"alphabetic","server.data",all.local.values)
            #.test.data.frame.sorting("D","IDENTIFIER",FALSE,"alphabetic","server.data",all.local.values)
            #.test.data.frame.sorting("D","CATEGORY",FALSE,"alphabetic","server.data",all.local.values)
            #.test.data.frame.sorting("D","NUMERIC_ONE_CHANGE",FALSE,"alphabetic","server.data",all.local.values)
            #.test.data.frame.sorting("D","INTEGER_ONE_CHANGE",FALSE,"alphabetic","server.data",all.local.values)
            #.test.data.frame.sorting("D","FACTOR_INTEGER",FALSE,"alphabetic","server.data",all.local.values)
            #.test.data.frame.sorting("D","FACTOR_CHARACTER",FALSE,"alphabetic","server.data",all.local.values) 
            #.test.data.frame.sorting("D","CHARACTER",FALSE,"alphabetic","server.data",all.local.values)
          })

context("ds.dataFrameSort::expt_dgr::single::alphabetic::ascending")
test_that('dataset 2',
          {  
            #connect.dataset.2()
            #local.df.list<-list(ds.test_env$local.values.2[,-1])
            #server.FC_levels<-ds.levels("D$FACTOR_CHARACTER")
            #for(i in 1:length(local.df.list)){
            #  local.df.list[[i]][,"CHARACTER"]<-as.character(local.df.list[[i]][,"CHARACTER"])
            #  local.df.list[[i]][,"FACTOR_INTEGER"]<-as.factor(local.df.list[[i]][,"FACTOR_INTEGER"])
            #  levels(local.df.list[[i]][,"FACTOR_CHARACTER"])<-server.FC_levels[[i]]
            #  colnames(local.df.list[[i]])<-ds.colnames("D",datasources = ds.test_env$connections[i][[1]])
            #}
            #.test.data.frame.sorting("D","LOGICAL",FALSE,"alphabetic","server.data",all.local.values)
            #.test.data.frame.sorting("D","INTEGER",FALSE,"alphabetic","server.data",all.local.values)
            #.test.data.frame.sorting("D","POSITIVE_INTEGER",FALSE,"alphabetic","server.data",all.local.values)
            #.test.data.frame.sorting("D","NEGATIVE_INTEGER",FALSE,"alphabetic","server.data",all.local.values)
            #.test.data.frame.sorting("D","NUMERIC",FALSE,"alphabetic","server.data",all.local.values)
            #.test.data.frame.sorting("D","POSITIVE_NUMERIC",FALSE,"alphabetic","server.data",all.local.values)
            #.test.data.frame.sorting("D","NEGATIVE_NUMERIC",FALSE,"alphabetic","server.data",all.local.values)
            #.test.data.frame.sorting("D","IDENTIFIER",FALSE,"alphabetic","server.data",all.local.values)
            #.test.data.frame.sorting("D","CATEGORY",FALSE,"alphabetic","server.data",all.local.values)
            #.test.data.frame.sorting("D","NUMERIC_ONE_CHANGE",FALSE,"alphabetic","server.data",all.local.values)
            #.test.data.frame.sorting("D","INTEGER_ONE_CHANGE",FALSE,"alphabetic","server.data",all.local.values)
            #.test.data.frame.sorting("D","FACTOR_INTEGER",FALSE,"alphabetic","server.data",all.local.values)
            #.test.data.frame.sorting("D","FACTOR_CHARACTER",FALSE,"alphabetic","server.data",all.local.values) 
            #.test.data.frame.sorting("D","CHARACTER",FALSE,"alphabetic","server.data",all.local.values)
          })

context("ds.dataFrameSort::expt_dgr::multiple::alphabetic::descending")
test_that('all datasets',
          {  
            #connect.all.datasets()
            #local.df.list<-list(ds.test_env$local.values.1[,-1],ds.test_env$local.values.2[,-1],ds.test_env$local.values.3[,-1])
            #for(i in 1:length(local.df.list)){
            #  local.df.list[[i]][,"CHARACTER"]<-as.character(local.df.list[[i]][,"CHARACTER"])
            #  local.df.list[[i]][,"FACTOR_INTEGER"]<-as.factor(local.df.list[[i]][,"FACTOR_INTEGER"])
            #  colnames(local.df.list[[i]])<-ds.colnames("D",datasources = ds.test_env$connections[i][[1]])
            #}
            #.test.data.frame.sorting("D","LOGICAL",TRUE,"alphabetic","server.data",all.local.values)
            #.test.data.frame.sorting("D","INTEGER",TRUE,"alphabetic","server.data",all.local.values)
            #.test.data.frame.sorting("D","POSITIVE_INTEGER",TRUE,"alphabetic","server.data",all.local.values)
            #.test.data.frame.sorting("D","NEGATIVE_INTEGER",TRUE,"alphabetic","server.data",all.local.values)
            #.test.data.frame.sorting("D","NUMERIC",TRUE,"alphabetic","server.data",all.local.values)
            #.test.data.frame.sorting("D","POSITIVE_NUMERIC",TRUE,"alphabetic","server.data",all.local.values)
            #.test.data.frame.sorting("D","NEGATIVE_NUMERIC",TRUE,"alphabetic","server.data",all.local.values)
            #.test.data.frame.sorting("D","IDENTIFIER",TRUE,"alphabetic","server.data",all.local.values)
            #.test.data.frame.sorting("D","CATEGORY",TRUE,"alphabetic","server.data",all.local.values)
            #.test.data.frame.sorting("D","NUMERIC_ONE_CHANGE",TRUE,"alphabetic","server.data",all.local.values)
            #.test.data.frame.sorting("D","INTEGER_ONE_CHANGE",TRUE,"alphabetic","server.data",all.local.values)
            #.test.data.frame.sorting("D","FACTOR_INTEGER",TRUE,"alphabetic","server.data",all.local.values)
            #.test.data.frame.sorting("D","FACTOR_CHARACTER",TRUE,"alphabetic","server.data",all.local.values)
            #.test.data.frame.sorting("D","CHARACTER",TRUE,"alphabetic","server.data",all.local.values)
          })

context("ds.dataFrameSort::expt_dgr::single::alphabetic::descending")
test_that('dataset 3',
          {  
            #connect.dataset.3()
            #local.df.list<-list(ds.test_env$local.values.3[,-1])
            #for(i in 1:length(local.df.list)){
            #  local.df.list[[i]][,"CHARACTER"]<-as.character(local.df.list[[i]][,"CHARACTER"])
            #  local.df.list[[i]][,"FACTOR_INTEGER"]<-as.factor(local.df.list[[i]][,"FACTOR_INTEGER"])
            #  colnames(local.df.list[[i]])<-ds.colnames("D",datasources = ds.test_env$connections[i][[1]])
            #}
            #.test.data.frame.sorting("D","LOGICAL",TRUE,"alphabetic","server.data",all.local.values)
            #.test.data.frame.sorting("D","INTEGER",TRUE,"alphabetic","server.data",all.local.values)
            #.test.data.frame.sorting("D","POSITIVE_INTEGER",TRUE,"alphabetic","server.data",all.local.values)
            #.test.data.frame.sorting("D","NEGATIVE_INTEGER",TRUE,"alphabetic","server.data",all.local.values)
            #.test.data.frame.sorting("D","NUMERIC",TRUE,"alphabetic","server.data",all.local.values)
            #.test.data.frame.sorting("D","POSITIVE_NUMERIC",TRUE,"alphabetic","server.data",all.local.values)
            #.test.data.frame.sorting("D","NEGATIVE_NUMERIC",TRUE,"alphabetic","server.data",all.local.values)
            #.test.data.frame.sorting("D","IDENTIFIER",TRUE,"alphabetic","server.data",all.local.values)
            #.test.data.frame.sorting("D","CATEGORY",TRUE,"alphabetic","server.data",all.local.values)
            #.test.data.frame.sorting("D","NUMERIC_ONE_CHANGE",TRUE,"alphabetic","server.data",all.local.values)
            #.test.data.frame.sorting("D","INTEGER_ONE_CHANGE",TRUE,"alphabetic","server.data",all.local.values)
            #.test.data.frame.sorting("D","FACTOR_INTEGER",TRUE,"alphabetic","server.data",all.local.values)
            #.test.data.frame.sorting("D","FACTOR_CHARACTER",TRUE,"alphabetic","server.data",all.local.values)
            #.test.data.frame.sorting("D","CHARACTER",TRUE,"alphabetic","server.data",all.local.values)
          })

#
# Shutdown
#

context('ds.dataFrameSort::expt_dgr::shutdown')

#
# Done
#

context('ds.dataFrameSort::expt_dgr::done')