Running 'test_block_write.R' [171s]
  Running 'test_bracket1.R' [168s]
  Running 'test_bracket2.R' [159s]
  Running 'test_extent_index.R' [168s]
  Running 'test_fused_write_object1.R' [0s]
  Comparing 'test_fused_write_object1.Rout' to 'test_fused_write_object1.Rout.save' ... OK
  Running 'test_hash.R' [164s]
  Running 'test_indexed_copy.R' [1s]
  Comparing 'test_indexed_copy.Rout' to 'test_indexed_copy.Rout.save' ... OK
  Running 'test_order1.R' [170s]
Running the tests in 'tests/test_block_write.R' failed.
Complete output:
  > require("RMVL")
  Loading required package: RMVL
  > 
  > mvl_block_write<-function(MVLHANDLE, N, f, name=NULL, block=1000, type=NULL, ...) {
  + 	obj<-NULL
  + 	offset<-NULL
  + 	for(i in seq(1.0, N, by=block)) {
  + 		idx<-i-1+(1:block)
  + 		idx<-idx[idx<=N]
  + 		
  + 		v<-f(idx, ...)
  + 		
  + 		if(is.null(obj)) {
  + 			if(!is.null(type))attr(v, "MVL_TYPE")<-type
  + 			offset<-mvl_start_write_vector(MVLHANDLE, v, expected.length=N, name=name)
  + 			MVLHANDLE<-mvl_remap(MVLHANDLE)
  + 			obj<-MVLHANDLE[offset,ref=TRUE]
  + 			} else {
  + 			mvl_rewrite_vector(obj, i, v)
  + 			}
  + 		}
  + 	return(invisible(offset))
  + 	}
  > 
  > test_write<-function(MVLHANDLE, vec, name, block=1000) {
  + 	f<-function(idx) { return(vec[idx]) }
  + 	
  + 	mvl_block_write(M, length(vec), f, name=name, block=block)
  + 	
  + 	MVLHANDLE<-mvl_remap(MVLHANDLE)
  + 	
  + 	if(any(vec!=mvl2R(MVLHANDLE[name]))) {
  + 		cat("Block write test", name, "failed\n")
  + 		print(all.equal(vec, mvl2R(MVLHANDLE[name])))
  + 		}
  + 	}
  > 	
  > M<-mvl_open("test1.mvl", append=TRUE, create=TRUE)
  > 
  > test_write(M, rnorm(1e6), "double1")
  > test_write(M, as.integer(1:1e6), "int1")
  > test_write(M, as.integer(1:1e6) %% 2==0, "logical1")
  > test_write(M, as.Date("2001-01-01")+as.integer(1:1e6), "date1")
  > 
  > mvl_close(M)
  > unlink("test1.mvl")
  > 
  > 
  > 
  > 
  > proc.time()
     user  system elapsed 
     0.57    0.29    0.85 
Running the tests in 'tests/test_bracket1.R' failed.
Complete output:
  > require("RMVL")
  Loading required package: RMVL
  >  
  > M3<-mvl_open("test2.mvl", append=TRUE, create=TRUE)
  > 
  > L<-list()
  > 
  > df<-data.frame(x=1:1e5, y=rnorm(1e5), s=rep(c("a", "b"), 5e4), b=rnorm(1e5)<0.5)
  > L[["x"]]<-mvl_write_object(M3, df)
  > 
  > aa<-array(rnorm(10000), c(10, 50, 20))
  > L[["y"]]<-aa
  > 
  > mm<-matrix(rnorm(10000), 10, 1000)
  > L[["z"]]<-mm
  > 
  > LL2<-as.list(rnorm(10000))
  > names(LL2)<-paste("x", 1:10000, sep="")
  > L[["LL2"]]<-LL2
  > 
  > L[["description"]]<-"Example of large data frame"
  > mvl_write_object(M3, L, "test_object")
  > 
  > LM1<-lm(rnorm(100)~runif(100))
  > mvl_write_serialized_object(M3, LM1, "LM1")
  > 
  > mvl_close(M3)
  > 
  > M3<-mvl_open("test2.mvl")
  > print(names(M3))
  [1] "test_object" "LM1"        
  > L2<-M3["test_object"]
  > 
  > N<-dim(df)[1]
  > 
  > compare_df<-function(x, y) {
  + 	if(length(dim(x))!=length(dim(y)))return(FALSE)
  + 	if(any(dim(x)!=dim(y)))return(FALSE)
  + 	if(any(names(x)!=names(y)))return(FALSE)
  + 	if(dim(x)[2]>0) {
  + 		for(i in 1:(dim(x)[2])) {
  + 			if(any(x[,i]!=y[,i]))return(FALSE)
  + 			}
  + 		}
  + 	return(TRUE)
  + 	}
  > 
  > if(!compare_df(df, L2[["x"]][,])) {
  + 	cat("test1a failed\n")
  + 	print(attributes(df))
  + 	print(attributes(L2[["x"]][,]))
  + 	cat("-----------\n")
  + 	}
  > if(!compare_df(df[1:20,], L2[["x"]][1:20,]))cat("test1b failed\n")
  > 
  > if(!compare_df(df[(1:N) %% 5==0,], L2[["x"]][(1:N) %% 5==0,]))cat("test2 failed\n")
  > 
  > if(!compare_df(df[(1:N) %% 5==0,], L2[["x"]][(1:N)[(1:N) %% 5==0],]))cat("test3 failed\n")
  > 
  > if(!compare_df(df[(1:N) %% 5==0, c("y", "s")], L2[["x"]][(1:N)[(1:N) %% 5==0], c("y", "s")]))cat("test4 failed\n")
  > 
  > if(!identical(df[(1:N) %% 5==0, c("s")], L2[["x"]][(1:N)[(1:N) %% 5==0], c("s")]))cat("test5 failed\n")
  > 
  > if(!compare_df(df[(1:N) %% 5==0, 2:3], L2[["x"]][(1:N)[(1:N) %% 5==0], 2:3]))cat("test6 failed\n")
  > 
  > if(!isTRUE(all.equal(aa, L2[["y"]][])))cat("test7 failed\n")
  > if(!compare_df(mm, L2[["z"]][])) {
  + 	cat("test8 failed\n")
  + 	print(all.equal(mm, L2[["z"]][]))
  + 	print(attributes(mm))
  + 	print(attributes(L2[["z"]][]))
  + 	cat("-----------\n")
  + 	}
  > 
  > if(!isTRUE(all.equal(aa[c(2,3,5),,], L2[["y"]][c(2,3,5),,])))cat("test9 failed\n")
  > if(!isTRUE(all.equal(aa[,c(2,3,5),], L2[["y"]][,c(2,3,5),])))cat("test10 failed\n")
  > if(!isTRUE(all.equal(aa[,,c(2,3,5)], L2[["y"]][,,c(2,3,5)])))cat("test11 failed\n")
  > if(!isTRUE(all.equal(aa[c(2,3,5),c(6,10,20),c(7,3,5)], L2[["y"]][c(2,3,5),c(6,10,20),c(7,3,5)])))cat("test12 failed\n")
  > 
  > if(!isTRUE(all.equal(mm[c(2,3,5),], L2[["z"]][c(2,3,5),])))cat("test13 failed\n")
  > if(!isTRUE(all.equal(mm[,c(2,3,5)], L2[["z"]][,c(2,3,5)])))cat("test14 failed\n")
  > if(!isTRUE(all.equal(mm[c(2,3,5),c(6,10,20)], L2[["z"]][c(2,3,5),c(6,10,20)])))cat("test15 failed\n")
  > 
  > if(!isTRUE(all.equal(LL2, L2[["LL2"]][]))) {
  + 	cat("test16 failed\n")
  + 	print(all.equal(LL2, L2[["LL2"]][]))
  + 	cat("-----------\n")
  + 	}
  > 
  > idx1<-20:2001
  > if(!isTRUE(all.equal(LL2[idx1], L2[["LL2"]][idx1]))) {
  + 	cat("test17 failed\n")
  + 	print(all.equal(LL2[idx1], L2[["LL2"]][idx1]))
  + 	cat("-----------\n")
  + 	}
  > 	
  > if(!isTRUE(all.equal(LL2[5], L2[["LL2"]][5]))) {
  + 	cat("test18 failed\n")
  + 	print(all.equal(LL2[5], L2[["LL2"]][5]))
  + 	print(LL2[5])
  + 	print(L2[["LL2"]][5])
  + 	cat("-----------\n")
  + 	}
  > 
  > if(!identical(LM1, mvl2R(M3["LM1"]))) {
  + 	cat("test19 failed\n")
  + 	print(all.equal(LM1, mvl2R(M3["LM1"])))
  + 	cat("-----------\n")
  + 	}
  > 	
  > # TODO:
  > # Testing of [,raw=TRUE] is complicated because R's as.raw() function is only meant for conversion of characters,
  > # while MVL raw mode only returns raw vectors when there is no equivalent R vector (such as the case of floats and INT64)
  > #
  > # if(!isTRUE(all.equal(as.raw(aa[c(2,3,5),c(6,10,20),c(7,3,5)]), L2[["y"]][c(2,3,5),c(6,10,20),c(7,3,5),raw=TRUE]))){
  > # 	cat("test19 failed\n")
  > # 	print(all.equal(as.raw(aa[c(2,3,5),c(6,10,20),c(7,3,5)]), L2[["y"]][c(2,3,5),c(6,10,20),c(7,3,5),raw=TRUE]))
  > # 	print(as.raw(aa[c(2,3,5),c(6,10,20),c(7,3,5)]))
  > # 	print(L2[["y"]][c(2,3,5),c(6,10,20),c(7,3,5),raw=TRUE])
  > # 	cat("-----------\n")
  > # 	}
  > 	
  > print(mvl_object_stats(L2[["x"]])[c("length", "type")])
  $length
  [1] 4
  
  $type
  [1] 100
  
  > print(mvl_object_stats(L2[["y"]])[c("length", "type")])
  $length
  [1] 10000
  
  $type
  [1] 5
  
  > print(mvl_object_stats(L2[["z"]])[c("length", "type")])
  $length
  [1] 10000
  
  $type
  [1] 5
  
  > print(mvl_object_stats(L2[["LL2"]])[c("length", "type")])
  $length
  [1] 10000
  
  $type
  [1] 100
  
  > 
  > mvl_close(M3)
  > 
  > unlink("test2.mvl")
  > 
  > 
  > proc.time()
     user  system elapsed 
     1.14    0.15    1.28 
Running the tests in 'tests/test_bracket2.R' failed.
Complete output:
  > require("RMVL")
  Loading required package: RMVL
  > 
  > M3<-mvl_open("test_bracket2a.mvl", append=TRUE, create=TRUE)
  > 
  > L<-list()
  > 
  > df<-data.frame(x=1:1e5, y=rnorm(1e5), s=rep(c("a", "b"), 5e4), b=rnorm(1e5)<0.5)
  > L[["x"]]<-mvl_write_object(M3, df)
  > 
  > aa<-array(rnorm(10000), c(10, 50, 20))
  > L[["y"]]<-aa
  > 
  > mm<-matrix(rnorm(10000), 10, 1000)
  > L[["z"]]<-mm
  > 
  > LL2<-as.list(rnorm(10000))
  > names(LL2)<-paste("x", 1:10000, sep="")
  > L[["LL2"]]<-LL2
  > 
  > L[["description"]]<-"Example of large data frame"
  > mvl_write_object(M3, L, "test_object")
  > 
  > LM1<-lm(rnorm(100)~runif(100))
  > mvl_write_serialized_object(M3, LM1, "LM1")
  > 
  > mvl_close(M3)
  > 
  > 
  > M3<-mvl_open("test_bracket2a.mvl")
  > print(names(M3))
  [1] "test_object" "LM1"        
  > 
  > L2<-M3["test_object", ref=TRUE]
  > 
  > N<-dim(df)[1]
  > 
  > compare_df<-function(x, y) {
  + 	if(length(dim(x))!=length(dim(y)))return(FALSE)
  + 	if(any(dim(x)!=dim(y)))return(FALSE)
  + 	if(any(names(x)!=names(y)))return(FALSE)
  + 	if(dim(x)[2]>0) {
  + 		for(i in 1:(dim(x)[2])) {
  + 			if(any(x[,i]!=y[,i]))return(FALSE)
  + 			}
  + 		}
  + 	return(TRUE)
  + 	}
  > 
  > if(!compare_df(df, mvl2R(L2[["x"]]))) {
  + 	cat("test1a failed\n")
  + 	print(attributes(df))
  + 	print(attributes(mvl2R(L2[["x"]])))
  + 	cat("-----------\n")
  + 	}
  > 	
  > if(!isTRUE(all.equal(aa, mvl2R(L2[["y"]])))) {
  + 	cat("test1b failed\n")
  + 	print(all.equal(aa, mvl2R(L2[["y"]])))
  + 	print(attributes(aa))
  + 	print(attributes(mvl2R(L2[["y"]])))
  + 	cat("-----------\n")
  + 	}
  > 	
  > if(!compare_df(mm, mvl2R(L2[["z"]]))) {
  + 	cat("test1c failed\n")
  + 	print(all.equal(mm, mvl2R(L2[["z"]])))
  + 	print(attributes(mm))
  + 	print(attributes(mvl2R(L2[["z"]])))
  + 	cat("-----------\n")
  + 	}
  > 	
  > if(!isTRUE(all.equal(LL2, mvl2R(L2[["LL2"]])))) {
  + 	cat("test1d failed\n")
  + 	print(all.equal(LL2, mvl2R(L2[["LL2"]])))
  + 	print(attributes(LL2))
  + 	print(attributes(mvl2R(L2[["LL2"]])))
  + 	cat("-----------\n")
  + 	}
  > 	
  > if(!isTRUE(all.equal("Example of large data frame", L2[["description"]]))) {
  + 	cat("test1e failed\n")
  + 	print(all.equal("Example of large data frame", L2[["description"]]))
  + 	print(attributes("Example of large data frame"))
  + 	print(attributes(L2[["description"]]))
  + 	cat("-----------\n")
  + 	}
  > 
  > # # R behaviour is mixed in this situation
  > # # For lists R returns empty list, but (1:5)[[NA]] throws an exception
  > # # It would not be unreasonable to think that vec[[NA]] should be NA
  > # # On the other hand, subscripting with NA is inefficient, and throwing an exception
  > # # forces to filter out NAs first
  > # # For now, we throw an exception and bypass the test
  > # if(!isTRUE(all.equal(L[[NA]], mvl2R(L2[[NA]])))) {
  > # 	cat("test1e failed\n")
  > # 	print(all.equal(L[[NA]], mvl2R(L2[[NA]])))
  > # 	print(attributes(L[[NA]]))
  > # 	print(attributes(mvl2R(L2[[NA]])))
  > # 	cat("-----------\n")
  > # 	}
  > 
  > if(!compare_df(df, mvl2R(L2[[1]]))) {
  + 	cat("test1f failed\n")
  + 	print(attributes(df))
  + 	print(attributes(mvl2R(L2[[1]])))
  + 	cat("-----------\n")
  + 	}
  > 	
  > if(!isTRUE(all.equal(aa, mvl2R(L2[[2]])))) {
  + 	cat("test1g failed\n")
  + 	print(all.equal(aa, mvl2R(L2[[2]])))
  + 	print(attributes(aa))
  + 	print(attributes(mvl2R(L2[[2]])))
  + 	cat("-----------\n")
  + 	}
  > 	
  > if(!compare_df(mm, mvl2R(L2[[3]]))) {
  + 	cat("test1h failed\n")
  + 	print(all.equal(mm, mvl2R(L2[[3]])))
  + 	print(attributes(mm))
  + 	print(attributes(mvl2R(L2[[3]])))
  + 	cat("-----------\n")
  + 	}
  > 	
  > if(!isTRUE(all.equal(LL2, mvl2R(L2[[4]])))) {
  + 	cat("test1i failed\n")
  + 	print(all.equal(LL2, mvl2R(L2[[4]])))
  + 	print(attributes(LL2))
  + 	print(attributes(mvl2R(L2[[4]])))
  + 	cat("-----------\n")
  + 	}
  > 	
  > if(!isTRUE(all.equal("Example of large data frame", L2[[5]]))) {
  + 	cat("test1j failed\n")
  + 	print(all.equal("Example of large data frame", L2[[5]]))
  + 	print(attributes("Example of large data frame"))
  + 	print(attributes(L2[[5]]))
  + 	cat("-----------\n")
  + 	}
  > 
  > 
  > if(!isTRUE(all.equal(L[c(2, 3)], L2[c(2,3), recurse=TRUE]))) {
  + 	cat("test2a failed\n")
  + 	print(all.equal(L[c(2, 3)], L2[c(2, 3), recurse=TRUE]))
  + 	print(attributes(L[c(2, 3)]))
  + 	print(attributes(L2[c(2, 3), recurse=TRUE]))
  + 	cat("-----------\n")
  + 	}
  > 
  > # Some of the names are NA and all.equal() does not handle this properly
  > if(!isTRUE(all.equal.list(L[c(2, NA, 3)], L2[c(2, NA, 3), recurse=TRUE], use.names=FALSE))) {
  + 	cat("test2b failed\n")
  + 	print(all.equal.list(L[c(2, NA, 3)], L2[c(2, NA, 3), recurse=TRUE], use.names=FALSE))
  + 	print(attributes(L[c(2, NA, 3)]))
  + 	print(attributes(L2[c(2, NA, 3), recurse=TRUE]))
  + 	cat("-----------\n")
  + 	}
  > 	
  > if(!isTRUE(all.equal(L[c("y", "z")], L2[c("y", "z"), recurse=TRUE]))) {
  + 	cat("test2c failed\n")
  + 	print(all.equal(L[c("y", "z")], L2[c("y", "z"), recurse=TRUE]))
  + 	print(attributes(L[c("y", "z")]))
  + 	print(attributes(L2[c("y", "z"), recurse=TRUE]))
  + 	cat("-----------\n")
  + 	}
  > 
  > if(!isTRUE(all.equal(L[c("W", "y", "z")], L2[c("W", "y", "z"), recurse=TRUE]))) {
  + 	cat("test2d failed\n")
  + 	print(all.equal(L[c("W", "y", "z")], L2[c("W", "y", "z"), recurse=TRUE]))
  + 	print(attributes(L[c("W", "y", "z")]))
  + 	print(attributes(L2[c("W", "y", "z"), recurse=TRUE]))
  + 	cat("-----------\n")
  + 	}
  > 
  > if(!isTRUE(all.equal(L[c("W", "y", NA, "z")], L2[c("W", "y", NA, "z"), recurse=TRUE]))) {
  + 	cat("test2e failed\n")
  + 	print(all.equal(L[c("W", "y", NA, "z")], L2[c("W", "y", NA, "z"), recurse=TRUE]))
  + 	print(attributes(L[c("W", "y", NA, "z")]))
  + 	print(attributes(L2[c("W", "y", NA, "z"), recurse=TRUE]))
  + 	cat("-----------\n")
  + 	}
  > 	
  > 
  > proc.time()
     user  system elapsed 
     1.75    0.17    1.89 
Running the tests in 'tests/test_extent_index.R' failed.
Complete output:
  > require("RMVL")
  Loading required package: RMVL
  >  
  > M3<-mvl_open("test2.mvl", append=TRUE, create=TRUE)
  > L<-list()
  > df<-data.frame(x=(1:1e5) %% 11, y=round(cos(1:1e5)*1000), s=rep(c("a", "b"), 5e4))
  > mvl_write_object(M3, df, "test_object")
  > 
  > M3<-mvl_remap(M3)
  > 
  > mvl_write_extent_index(M3, list(M3$test_object[,"x", ref=TRUE]), "test_object_extent_index_x")
  > mvl_write_extent_index(M3, list(M3$test_object[,"s", ref=TRUE]), "test_object_extent_index_s")
  > 
  > mvl_close(M3)
  > 
  > M3<-mvl_open("test2.mvl")
  > L2<-M3["test_object", ref=TRUE]
  > 
  > N<-dim(df)[1]
  > 
  > idx0<-50:100
  > 
  > S1<-sum(df[df[,"x"] %in% idx0, "y"])
  > S2<-sum(unlist(mvl_extent_index_lapply(M3["test_object_extent_index_x", ref=TRUE], list(as.integer(idx0)), function(i, idx) {
  + 	return(sum(M3$test_object[idx, "y"]))
  + 	})))
  > if(abs(S1-S2)>1e-5)cat("test1 failed: S1=", S1, "S2=", S2, "\n")
  > 
  > S2<-sum(unlist(mvl_extent_index_lapply(M3["test_object_extent_index_x", ref=TRUE], list(as.numeric(idx0)), function(i, idx) {
  + 	return(sum(M3$test_object[idx, "y"]))
  + 	})))
  > if(abs(S1-S2)>1e-5)cat("test2 failed: S1=", S1, "S2=", S2, "\n")
  > 
  > S1<-sum(df[df[,"s"]=="a", "y"])
  > S2<-sum(unlist(mvl_extent_index_lapply(M3["test_object_extent_index_s", ref=TRUE], list("a"), function(i, idx) {
  + 	return(sum(M3$test_object[idx, "y"]))
  + 	})))
  > if(abs(S1-S2)>1e-5)cat("test2 failed: S1=", S1, "S2=", S2, "\n")
  > 
  > mvl_close(M3)
  > 
  > unlink("test2.mvl")
  > 
  > 
  > proc.time()
     user  system elapsed 
     0.21    0.07    0.28 
Running the tests in 'tests/test_hash.R' failed.
Complete output:
  > require("RMVL")
  Loading required package: RMVL
  > 
  > N<-10000
  > 
  > df<-data.frame(x=(1:N) %% 5, y=((1:N) %% 6)+0.5, ab=paste("ab", ((1:N) %% 10)))
  > 
  > Mtmp<-mvl_open("tmp.mvl", append=TRUE, create=TRUE)
  > mvl_write_object(Mtmp, df, "df")
  > mvl_close(Mtmp)
  > 
  > Mtmp<-mvl_open("tmp.mvl")
  > 
  > h<-mvl_hash_vectors(list(Mtmp$df[,"x",ref=TRUE]))
  > LL<-split(h, Mtmp$df[,"x"][])
  > LL0<-unlist(lapply(LL, function(x){if(length(x)<1)return(x);return(max(abs(diff(x))))}))
  > if(any(LL0!=0))cat("test1 failed\n")
  > 
  > h<-mvl_hash_vectors(list(Mtmp$df[,"y",ref=TRUE]))
  > LL<-split(h, Mtmp$df[,"y"][])
  > LL0<-unlist(lapply(LL, function(x){if(length(x)<1)return(x);return(max(abs(diff(x))))}))
  > if(any(LL0!=0))cat("test2 failed\n")
  > 
  > h<-mvl_hash_vectors(list(Mtmp$df[,"ab",ref=TRUE]))
  > LL<-split(h, Mtmp$df[,"ab"][])
  > LL0<-unlist(lapply(LL, function(x){if(length(x)<1)return(x);return(max(abs(diff(x))))}))
  > if(any(LL0!=0))cat("test3 failed\n")
  > 
  > h<-mvl_hash_vectors(list(Mtmp$df[,"x",ref=TRUE], Mtmp$df[,"y",ref=TRUE], Mtmp$df[,"ab",ref=TRUE]))
  > LL<-split(h, Mtmp$df[,])
  > LL0<-unlist(lapply(LL, function(x){if(length(x)<1)return(x);return(max(abs(diff(x))))}))
  > if(any(LL0!=0))cat("test4 failed\n")
  > 
  > mvl_close(Mtmp)
  > unlink("tmp.mvl")
  > 
  > proc.time()
     user  system elapsed 
     0.31    0.04    0.34 
Running the tests in 'tests/test_order1.R' failed.
Complete output:
  > require("RMVL")
  Loading required package: RMVL
  >  
  > M3<-mvl_open("test2.mvl", append=TRUE, create=TRUE)
  > L<-list()
  > df<-data.frame(x=1:1e5, y=rnorm(1e5), s=rep(c("a", "b"), 5e4))
  > L[["x"]]<-mvl_write_object(M3, df)
  > L[["description"]]<-"Example of large data frame"
  > mvl_write_object(M3, L, "test_object")
  > mvl_close(M3)
  > 
  > M3<-mvl_open("test2.mvl")
  > L2<-M3["test_object"]
  > 
  > N<-dim(df)[1]
  > 
  > idx0<-50:100
  > 
  > idx1a<-idx0[order(df[idx0, "x"])]
  > idx1b<-mvl_order_vectors(list(M3$test_object$x[,"x"]), idx0)
  > if(!isTRUE(all.equal(idx1a, idx1b)))cat("test1 failed\n")
  > 
  > idx1a<-idx0[order(df[idx0, "y"])]
  > idx1b<-mvl_order_vectors(list(M3$test_object$x[,"y"]), idx0)
  > if(!isTRUE(all.equal(idx1a, idx1b)))cat("test2 failed\n")
  > 
  > idx1a<-idx0[order(df[idx0, "s"])]
  > idx1b<-mvl_order_vectors(list(M3$test_object$x[,"s"]), idx0)
  > if(!isTRUE(all.equal(idx1a, idx1b)))cat("test3 failed\n")
  > 
  > idx1a<-idx0[order(df[idx0, "s"], df[idx0, "y"])]
  > idx1b<-mvl_order_vectors(list(M3$test_object$x[,"s"], M3$test_object$x[,"y"]), idx0)
  > if(!isTRUE(all.equal(idx1a, idx1b)))cat("test4 failed\n")
  > 
  > idx1a<-order(df[, "y"])
  > idx1b<-mvl_order_vectors(list(M3$test_object$x[,"y"]))
  > if(!isTRUE(all.equal(idx1a, idx1b)))cat("test5 failed\n")
  > 
  > idx1a<-order(df[, "s"], df[, "y"])
  > idx1b<-mvl_order_vectors(list(M3$test_object$x[,"s"], M3$test_object$x[,"y"]))
  > if(!isTRUE(all.equal(idx1a, idx1b)))cat("test6 failed\n")
  > 
  > idx1a<-order(df[, "s"], df[, "y"], decreasing=TRUE)
  > idx1b<-mvl_order_vectors(list(M3$test_object$x[,"s"], M3$test_object$x[,"y"]), decreasing=TRUE)
  > if(!isTRUE(all.equal(idx1a, idx1b)))cat("test7 failed\n")
  > 
  > idx1a<-idx0[order(df[idx0, "s"], df[idx0, "y"], decreasing=TRUE)]
  > idx1b<-mvl_order_vectors(list(M3$test_object$x[,"s"], M3$test_object$x[,"y"]), idx0, decreasing=TRUE)
  > if(!isTRUE(all.equal(idx1a, idx1b)))cat("test8 failed\n")
  > 
  > 
  > mvl_close(M3)
  > 
  > unlink("test2.mvl")
  > 
  > 
  > proc.time()
     user  system elapsed 
     0.37    0.09    0.46