vrsn <- "20120811"
Dirname <- "RSeq"
FileName <- "RCTvalidateRSeq"

RCTvalidateOutputDirname <- paste(RCTdirnameV,Dirname,sep="")
if(!file.exists(RCTvalidateOutputDirname))
	dir.create(RCTvalidateOutputDirname)
RCTvalidateOutputDirname <- paste(RCTvalidateOutputDirname,"/",sep="")
cat("#####", FileName, "-", vrsn, "\n")
if (!exists("runRCTvalidateTests")) {
	runRCTvalidateTests <- 1:38
} else {
	cat("   ## Tests ", runRCTvalidateTests, "\n")
}

####################
TestName <- "One Sample Mean   "
####################

rslt <- NULL
testLbls <- NULL

# Tests  1.1-.3
# Test computation of t test estimates, statistic, p value
test <- 1
if (test %in% runRCTvalidateTests) {
	testLbls <- c(testLbls,paste(test,1:3,sep="."))
	dsnName <- "Fixed N"
	J <- 1
	P <- 1
	alpha <- 0.025
	beta <- 0.975
	fn <- paste(RCTvalidateOutputDirname,"test",substring(format(10000+test),2),sep="")
	dsnfn <- paste(fn,"dsn",sep="")
	rfn <- paste(fn,"rSeq",sep="")
	z <- seqDesign (arms=1,sample.size=100,nbr.analyses=J,alpha=alpha,beta=beta,P=P,suppressErrors=T,EPSILON=1e-8)
	zz <- z
	zz$call <- NULL
	if(!file.exists(dsnfn)) {
		dput(zz,file=dsnfn)
	}
	check <- all.equal(z,dget(file=dsnfn))
	############## test rslt 1.1     #################
	rslt <- c(rslt,ifelse1(is.logical(check),check,F))
	set.seed(test)
	zr <- rSeq(100, z, theta=0, sufficient=F, returnData=T)
	tmp <- matrix(0,100,3)
	for (i in 1:100) {
		zt <- t.test(zr$Data[,i],alternative="greater")
		tmp[i,] <- c(zt$estimate,zt$statistic,zt$p.value)
	}
	if(!file.exists(rfn)) {
		dput(zr,file=rfn)
	}
	check <- all.equal(zr,dget(file=rfn))
	############## test rslt 1.2     #################
	rslt <- c(rslt,ifelse1(is.logical(check),check,F))
	############## test rslt 1.3     #################
	rslt <- c(rslt,max(abs(tmp - cbind(zr$thetaHat,zr$Zstat,zr$Pstat))) <= 1e-12)
}

if (any(2:6 %in% runRCTvalidateTests)) {
	test <- 2
	dsnName <- "OBF1s.025.4 N"
	J <- 4
	P <- 1
	alpha <- 0.025
	beta <- 0.975
	fn <- paste(RCTvalidateOutputDirname,"test",substring(format(10000+test),2),sep="")
	dsnfn <- paste(fn,"dsn",sep="")
	rfn <- paste(fn,"rSeq",sep="")
	z <- seqDesign (arms=1,sample.size=100,nbr.analyses=J,alpha=alpha,beta=beta,P=P,suppressErrors=T,EPSILON=1e-8)
}

# Tests  2.1-.3
# Test computation of t test estimates, statistic, p value
test <- 2
if (test %in% runRCTvalidateTests) {
	testLbls <- c(testLbls,paste(test,1:3,sep="."))
	zz <- z
	zz$call <- NULL
	if(!file.exists(dsnfn)) {
		dput(zz,file=dsnfn)
	}
	check <- all.equal(z,dget(file=dsnfn))
	############## test rslt 2.1     #################
	rslt <- c(rslt,ifelse1(is.logical(check),check,F))
	set.seed(test)
	zr <- rSeq(100, z, theta=0, sufficient=F, returnData=T)
	tmp <- matrix(0,100,3)
	for (i in 1:100) {
		zt <- t.test(zr$Data[,i],alternative="greater")
		tmp[i,] <- c(zt$estimate,zt$statistic,zt$p.value)
	}
	if(!file.exists(rfn)) {
		dput(zr,file=rfn)
	}
	check <- all.equal(zr,dget(file=rfn))
	############## test rslt 2.2     #################
	rslt <- c(rslt,ifelse1(is.logical(check),check,F))
	############## test rslt 2.3     #################
	rslt <- c(rslt,max(abs(tmp - cbind(zr$thetaHat,zr$Zstat,zr$Pstat))) <= 1e-12)
}

# Tests  3 - 6
# Test agreement between asymptotic and sufficient statistics
test <- 3
if (test %in% runRCTvalidateTests) {
	testLbls <- c(testLbls,test)
	rslt <- c(rslt,seqCheckOC(z,dsnName,seed=test,standardize=F))
}
test <- 4
if (test %in% runRCTvalidateTests) {
	testLbls <- c(testLbls,test)
	rslt <- c(rslt,seqCheckOC(update(z,variance=1.5),paste(dsnName,"vrnc 1.5"),seed=test,standardize=F)) 
}
test <- 5
if (test %in% runRCTvalidateTests) {
	testLbls <- c(testLbls,test)
	rslt <- c(rslt,seqCheckOC(z,paste(dsnName,"data"),seed=test,standardize=F,sufficient=F))
}
test <- 6
if (test %in% runRCTvalidateTests) {
	testLbls <- c(testLbls,test)
	rslt <- c(rslt,seqCheckOC(update(z,variance=1.5),paste(dsnName,"vrnc 1.5 data"),seed=test,standardize=F,sufficient=F)) 
}

# Tests 7.1 - 7.10
# Test specification of means, sd
test <- 7
if (test %in% runRCTvalidateTests) {
	testLbls <- c(testLbls,paste(test,1:10,sep="."))
	J <- 1
	P <- 1
	alpha <- 0.025
	beta <- 0.975
	z <- seqDesign (arms=1,sample.size=100,nbr.analyses=J,alpha=alpha,beta=beta,P=P,suppressErrors=T,EPSILON=1e-8)
	N <- 100000
	theta <- 0
	vrnc <- 1
	tol <- qnorm(.99) * sqrt(vrnc / (sampleSize(z) * N))
	tol2 <- qnorm(.99) * vrnc * sqrt (2 / (sampleSize(z) * N-1))
	set.seed(test+101)
	zr <- rSeq(N, z, theta=theta, sufficient=F, returnData=T)
	############## test rslt 7.1 - 7.2 #################
	rslt <- c(rslt,abs(mean(zr$Data) - theta) <= tol,abs(var(as.vector(zr$Data))-vrnc) <= tol2)
	theta <- 0.1
	vrnc <- 2
	tol <- qnorm(.99) * sqrt(vrnc / (sampleSize(z) * N))
	tol2 <- qnorm(.99) * vrnc * sqrt (2 / (sampleSize(z) * N-1))
	set.seed(test+102)
	zr <- rSeq(N, z, theta=theta, variance=vrnc, sufficient=F, returnData=T)
	############## test rslt 7.3 - 7.4 #################
	rslt <- c(rslt,abs(mean(zr$Data) - theta) <= tol,abs(var(as.vector(zr$Data))-vrnc) <= tol2)
	theta <- 0.1
	vrnc <- 2
	tol <- qnorm(.99) * sqrt(vrnc / (sampleSize(z) * N))
	tol2 <- qnorm(.99) * vrnc * sqrt (2 / (sampleSize(z) * N-1))
	set.seed(test+103)
	zr <- rSeq(N, z, mean=theta, variance=vrnc, sufficient=F, returnData=T)
	############## test rslt 7.5 - 7.6 #################
	rslt <- c(rslt,abs(mean(zr$Data) - theta) <= tol,abs(var(as.vector(zr$Data))-vrnc) <= tol2)
	theta <- 0.05
	vrnc <- 0.2
	tol <- qnorm(.99) * sqrt(vrnc / (sampleSize(z) * N))
	tol2 <- qnorm(.99) * vrnc * sqrt (2 / (sampleSize(z) * N-1))
	set.seed(test+104)
	zr <- rSeq(N, z, theta=theta, sd=sqrt(vrnc), sufficient=F, returnData=T)
	############## test rslt 7.7 - 7.8 #################
	rslt <- c(rslt,abs(mean(zr$Data) - theta) <= tol,abs(var(as.vector(zr$Data))-vrnc) <= tol2)
	ow <- options()$warn
	options(warn=-1)
	set.seed(test+105)
	zr <- rSeq(N, z, theta=theta, sd=sqrt(vrnc), variance=5*vrnc, sufficient=F, returnData=T)
	############## test rslt 7.9 - 7.10 #################
	rslt <- c(rslt,abs(mean(zr$Data) - theta) <= tol,abs(var(as.vector(zr$Data))-vrnc) <= tol2)
	options(warn=ow)
}

# Tests 8.1 - 8.6
# Test user specified function
test <- 8
if (test %in% runRCTvalidateTests) {
	testLbls <- c(testLbls,paste(test,1:6,sep="."))
	grbg <- function (n, theta, argList) rexp(n, 1 / (theta+1))
	theta <- 0
	vrnc <- (theta + 1)^2
	tol <- qnorm(.99) * sqrt(vrnc / (sampleSize(z) * N))
	tol2 <- qnorm(.99) * vrnc * sqrt (8 / (sampleSize(z) * N-1))
	set.seed(test+101)
	zr <- rSeq(N, z, theta=theta, sd=sqrt(vrnc), distn=grbg, sufficient=F, returnData=T)
	############## test rslt 8.1 - 8.2 #################
	rslt <- c(rslt,abs(mean(zr$Data) - (theta+1)) <= tol,abs(var(as.vector(zr$Data))-vrnc) <= tol2)
	theta <- 0.5
	vrnc <- (theta + 1)^2
	tol <- qnorm(.99) * sqrt(vrnc / (sampleSize(z) * N))
	tol2 <- qnorm(.99) * vrnc * sqrt (8 / (sampleSize(z) * N-1))
	set.seed(test+102)
	zr <- rSeq(N, z, theta=theta, sd=sqrt(vrnc), distn=grbg, sufficient=F, returnData=T)
	############## test rslt 8.3 - 8.4 #################
	rslt <- c(rslt,abs(mean(zr$Data) - (theta+1)) <= tol,abs(var(as.vector(zr$Data))-vrnc) <= tol2)
	theta <- 2
	vrnc <- (theta + 1)^2
	tol <- qnorm(.99) * sqrt(vrnc / (sampleSize(z) * N))
	tol2 <- qnorm(.99) * vrnc * sqrt (8 / (sampleSize(z) * N-1))
	set.seed(test+103)
	zr <- rSeq(N, z, theta=theta, sd=sqrt(vrnc), distn=grbg, sufficient=F, returnData=T)
	############## test rslt 8.5 - 8.6 #################
	rslt <- c(rslt,abs(mean(zr$Data) - (theta+1)) <= tol,abs(var(as.vector(zr$Data))-vrnc) <= tol2)
}

if (is.null(rslt)) {cat("     ",TestName,": No tests performed\n")
} else if (all(rslt)) {cat("     ",TestName,": All",length(rslt),"tests  PASS\n")
} else cat("     ",TestName,": failing test numbers ", testLbls[!rslt],"\n")

####################
TestName <- "One Sample GeomMn "
####################

rslt <- NULL
testLbls <- NULL

# Tests  9.1-.3
# Test computation of t test estimates, statistic, p value
test <- 9
if (test %in% runRCTvalidateTests) {
	testLbls <- c(testLbls,paste(test,1:3,sep="."))
	dsnName <- "Fixed L"
	J <- 1
	P <- 1
	alpha <- 0.025
	beta <- 0.975
	fn <- paste(RCTvalidateOutputDirname,"test",substring(format(10000+test-6),2),sep="")
	dsnfn <- paste(fn,"dsn",sep="")
	rfn <- paste(fn,"rSeq",sep="")
	z <- seqDesign ("geom",arms=1,sample.size=100,nbr.analyses=J,alpha=alpha,beta=beta,P=P,suppressErrors=T,EPSILON=1e-8)
	zz <- z
	zz$call <- NULL
	if(!file.exists(dsnfn)) {
		dput(zz,file=dsnfn)
	}
	check <- all.equal(z,dget(file=dsnfn))
	############## test rslt 9.1     #################
	rslt <- c(rslt,ifelse1(is.logical(check),check,F))
	set.seed(test-6)
	zr <- rSeq(100, z, theta=1, sufficient=F, returnData=T)
	tmp <- matrix(0,100,3)
	for (i in 1:100) {
		zt <- t.test(log(zr$Data[,i]),alternative="greater")
		tmp[i,] <- c(exp(zt$estimate),zt$statistic,zt$p.value)
	}
	if(!file.exists(rfn)) {
		dput(zr,file=rfn)
	}
	check <- all.equal(zr,dget(file=rfn))
	############## test rslt 9.2     #################
	rslt <- c(rslt,ifelse1(is.logical(check),check,F))
	############## test rslt 9.3     #################
	rslt <- c(rslt,max(abs(tmp - cbind(zr$thetaHat,zr$Zstat,zr$Pstat))) <= 1e-12)
}

# Tests  10.1-.3
# Test computation of t test estimates, statistic, p value
test <- 10
if (test %in% runRCTvalidateTests) {
	testLbls <- c(testLbls,paste(test,1:3,sep="."))
	dsnName <- "Fixed L log"
	J <- 1
	P <- 1
	alpha <- 0.025
	beta <- 0.975
	fn <- paste(RCTvalidateOutputDirname,"test",substring(format(10000+test-6),2),sep="")
	dsnfn <- paste(fn,"dsn",sep="")
	rfn <- paste(fn,"rSeq",sep="")
	z <- seqDesign ("geom",log.transform=T,arms=1,sample.size=100,nbr.analyses=J,alpha=alpha,beta=beta,P=P,suppressErrors=T,EPSILON=1e-8)
	zz <- z
	zz$call <- NULL
	if(!file.exists(dsnfn)) {
		dput(zz,file=dsnfn)
	}
	check <- all.equal(z,dget(file=dsnfn))
	############## test rslt 10.1     #################
	rslt <- c(rslt,ifelse1(is.logical(check),check,F))
	set.seed(test-6)
	zr <- rSeq(100, z, theta=0, sufficient=F, returnData=T)
	tmp <- matrix(0,100,3)
	for (i in 1:100) {
		zt <- t.test(log(zr$Data[,i]),alternative="greater")
		tmp[i,] <- c(zt$estimate,zt$statistic,zt$p.value)
	}
	if(!file.exists(rfn)) {
		dput(zr,file=rfn)
	}
	check <- all.equal(zr,dget(file=rfn))
	############## test rslt 10.2     #################
	rslt <- c(rslt,ifelse1(is.logical(check),check,F))
	############## test rslt 10.3     #################
	rslt <- c(rslt,max(abs(tmp - cbind(zr$thetaHat,zr$Zstat,zr$Pstat))) <= 1e-12)
}

if (any(11:15 %in% runRCTvalidateTests)) {
	test <- 4
	dsnName <- "OBF1s.025.4 L"
	J <- 4
	P <- 1
	alpha <- 0.025
	beta <- 0.975
	fn <- paste(RCTvalidateOutputDirname,"test",substring(format(10000+test-7),2),sep="")
	dsnfn <- paste(fn,"dsn",sep="")
	rfn <- paste(fn,"rSeq",sep="")
	z <- seqDesign ("geom",arms=1,sample.size=100,nbr.analyses=J,alpha=alpha,beta=beta,P=P,suppressErrors=T,EPSILON=1e-8)
}

# Tests  11.1-.3
# Test computation of t test estimates, statistic, p value
test <- 11
if (test %in% runRCTvalidateTests) {
	testLbls <- c(testLbls,paste(test,1:3,sep="."))
	zz <- z
	zz$call <- NULL
	if(!file.exists(dsnfn)) {
		dput(zz,file=dsnfn)
	}
	check <- all.equal(z,dget(file=dsnfn))
	############## test rslt 11.1     #################
	rslt <- c(rslt,ifelse1(is.logical(check),check,F))
	set.seed(test-7)
	zr <- rSeq(100, z, theta=1, sufficient=F, returnData=T)
	tmp <- matrix(0,100,3)
	for (i in 1:100) {
		zt <- t.test(log(zr$Data[,i]),alternative="greater",na.action=na.omit)
		tmp[i,] <- c(exp(zt$estimate),zt$statistic,zt$p.value)
	}
	if(!file.exists(rfn)) {
		dput(zr,file=rfn)
	}
	check <- all.equal(zr,dget(file=rfn))
	############## test rslt 11.2     #################
	rslt <- c(rslt,ifelse1(is.logical(check),check,F))
	############## test rslt 11.3     #################
	rslt <- c(rslt,max(abs(tmp - cbind(zr$thetaHat,zr$Zstat,zr$Pstat))) <= 1e-12)
}

# Tests 12 - 15
# Test agreement between asymptotic and sufficient statistics
test <- 12
if (test %in% runRCTvalidateTests) {
	testLbls <- c(testLbls,test)
	rslt <- c(rslt,seqCheckOC(z,dsnName,seed=test,standardize=F))
}
test <- 13
if (test %in% runRCTvalidateTests) {
	testLbls <- c(testLbls,test)
	rslt <- c(rslt,seqCheckOC(z,paste(dsnName,"data"),seed=test,standardize=F,sufficient=F))
}
test <- 14
if (test %in% runRCTvalidateTests) {
	testLbls <- c(testLbls,test)
	rslt <- c(rslt,seqCheckOC(update(z,variance=1.5),paste(dsnName,"vrnc 1.5"),seed=test,standardize=F))
}
test <- 15
if (test %in% runRCTvalidateTests) {
	testLbls <- c(testLbls,test)
	rslt <- c(rslt,seqCheckOC(update(z,variance=1.5),paste(dsnName,"vrnc 1.5 data"),seed=test,standardize=F,sufficient=F))
}

# Tests 16.1 - 16.14
# Test specification of means, sd
test <- 16
if (test %in% runRCTvalidateTests) {
	testLbls <- c(testLbls,paste(test,1:14,sep="."))
	J <- 1
	P <- 1
	alpha <- 0.025
	beta <- 0.975
	z <- seqDesign ("geom",arms=1,sample.size=100,nbr.analyses=J,alpha=alpha,beta=beta,P=P,suppressErrors=T,EPSILON=1e-8)
	N <- 100000
	theta <- 1
	vrnc <- 1
	tol <- qnorm(.99) * sqrt(vrnc / (sampleSize(z) * N))
	tol2 <- qnorm(.99) * vrnc * sqrt (2 / (sampleSize(z) * N-1))
	set.seed(test+101)
	zr <- rSeq(N, z, theta=theta, sufficient=F, returnData=T)
	############## test rslt 16.1 - 16.2 #################
	rslt <- c(rslt,abs(mean(log(zr$Data)) - log(theta)) <= tol,abs(var(as.vector(log(zr$Data)))-vrnc) <= tol2)
	theta <- 1.1
	vrnc <- 2
	tol <- qnorm(.99) * sqrt(vrnc / (sampleSize(z) * N))
	tol2 <- qnorm(.99) * vrnc * sqrt (2 / (sampleSize(z) * N-1))
	set.seed(test+102)
	zr <- rSeq(N, z, theta=theta, variance=vrnc, sufficient=F, returnData=T)
	############## test rslt 16.3 - 16.4 #################
	rslt <- c(rslt,abs(mean(log(zr$Data)) - log(theta)) <= tol,abs(var(as.vector(log(zr$Data)))-vrnc) <= tol2)
	theta <- 1.1
	vrnc <- 2
	tol <- qnorm(.99) * sqrt(vrnc / (sampleSize(z) * N))
	tol2 <- qnorm(.99) * vrnc * sqrt (2 / (sampleSize(z) * N-1))
	set.seed(test+103)
	zr <- rSeq(N, z, geomMean=theta, variance=vrnc, sufficient=F, returnData=T)
	############## test rslt 16.5 - 16.6 #################
	rslt <- c(rslt,abs(mean(log(zr$Data)) - log(theta)) <= tol,abs(var(as.vector(log(zr$Data)))-vrnc) <= tol2)
	theta <- 1.1
	vrnc <- 2
	tol <- qnorm(.99) * sqrt(vrnc / (sampleSize(z) * N))
	tol2 <- qnorm(.99) * vrnc * sqrt (2 / (sampleSize(z) * N-1))
	set.seed(test+104)
	zr <- rSeq(N, z, meanlog=log(theta), variance=vrnc, sufficient=F, returnData=T)
	############## test rslt 16.7 - 16.8 #################
	rslt <- c(rslt,abs(mean(log(zr$Data)) - log(theta)) <= tol,abs(var(as.vector(log(zr$Data)))-vrnc) <= tol2)
	theta <- 0.05
	vrnc <- 0.2
	tol <- qnorm(.99) * sqrt(vrnc / (sampleSize(z) * N))
	tol2 <- qnorm(.99) * vrnc * sqrt (2 / (sampleSize(z) * N-1))
	set.seed(test+105)
	zr <- rSeq(N, z, theta=theta, sdlog=sqrt(vrnc), sufficient=F, returnData=T)
	############## test rslt 16.9 - 16.10 #################
	rslt <- c(rslt,abs(mean(log(zr$Data)) - log(theta)) <= tol,abs(var(as.vector(log(zr$Data)))-vrnc) <= tol2)
	ow <- options()$warn
	options(warn=-1)
	set.seed(test+106)
	zr <- rSeq(N, z, theta=theta, sdlog=sqrt(vrnc), variance=5*vrnc, sufficient=F, returnData=T)
	############## test rslt 16.11 - 16.12 #################
	rslt <- c(rslt,abs(mean(log(zr$Data)) - log(theta)) <= tol,abs(var(as.vector(log(zr$Data)))-vrnc) <= tol2)
	set.seed(test+107)
	zr <- rSeq(N, z, theta=theta, sdlog=sqrt(vrnc), variance=5*vrnc, sufficient=F, returnData=T)
	############## test rslt 16.13 - 16.14 #################
	rslt <- c(rslt,abs(mean(log(zr$Data)) - log(theta)) <= tol,abs(var(as.vector(log(zr$Data)))-vrnc) <= tol2)
	options(warn=ow)
}

# Tests 17.1 - 17.6
# Test user specified function
test <- 17
if (test %in% runRCTvalidateTests) {
	testLbls <- c(testLbls,paste(test,1:6,sep="."))
	grbg <- function (n, theta, argList) rlnorm(n, theta, argList)
	theta <- 0
	vrnc <- (theta + 1)^2
	tol <- qnorm(.99) * sqrt(vrnc / (sampleSize(z) * N))
	tol2 <- qnorm(.99) * vrnc * sqrt (2 / (sampleSize(z) * N-1))
	############## test rslt 17.1 - 17.2 #################
	set.seed(test+101)
	zr <- rSeq(N, z, theta=theta, distnArgs=sqrt(vrnc), distn=grbg, sufficient=F, returnData=T)
	rslt <- c(rslt,abs(mean(log(zr$Data)) - theta) <= tol,abs(var(as.vector(log(zr$Data)))-vrnc) <= tol2)
	theta <- 0.5
	vrnc <- (theta + 1)^2
	tol <- qnorm(.99) * sqrt(vrnc / (sampleSize(z) * N))
	tol2 <- qnorm(.99) * vrnc * sqrt (2 / (sampleSize(z) * N-1))
	############## test rslt 17.3 - 17.4 #################
	set.seed(test+102)
	zr <- rSeq(N, z, theta=theta, distnArgs =sqrt(vrnc), distn=grbg, sufficient=F, returnData=T)
	rslt <- c(rslt,abs(mean(log(zr$Data)) - theta) <= tol,abs(var(as.vector(log(zr$Data)))-vrnc) <= tol2)
	theta <- 2
	vrnc <- (theta + 1)^2
	tol <- qnorm(.99) * sqrt(vrnc / (sampleSize(z) * N))
	tol2 <- qnorm(.99) * vrnc * sqrt (2 / (sampleSize(z) * N-1))
	############## test rslt 17.5 - 17.6 #################
	set.seed(test+103)
	zr <- rSeq(N, z, theta=theta, distnArgs =sqrt(vrnc), distn=grbg, sufficient=F, returnData=T)
	rslt <- c(rslt,abs(mean(log(zr$Data)) - theta) <= tol,abs(var(as.vector(log(zr$Data)))-vrnc) <= tol2)
}

if (is.null(rslt)) {cat("     ",TestName,": No tests performed\n")
} else if (all(rslt)) {cat("     ",TestName,": All",length(rslt),"tests  PASS\n")
} else cat("     ",TestName,": failing test numbers ", testLbls[!rslt],"\n")

####################
TestName <- "Two Sample Mean   "
####################

rslt <- NULL
testLbls <- NULL

# Tests  18.1-.4
# Test computation of t test estimates, statistic, p value
test <- 18
if (test %in% runRCTvalidateTests) {
	testLbls <- c(testLbls,paste(test,1:4,sep="."))
	dsnName <- "Fixed N"
	J <- 1
	P <- 1
	alpha <- 0.025
	beta <- 0.975
	fn <- paste(RCTvalidateOutputDirname,"test",substring(format(10000+test-12),2),sep="")
	dsnfn <- paste(fn,"dsn",sep="")
	rfn <- paste(fn,"rSeq",sep="")
	z <- seqDesign (arms=2,sample.size=200,nbr.analyses=J,alpha=alpha,beta=beta,P=P,suppressErrors=T,EPSILON=1e-8)
	zz <- z
	zz$call <- NULL
	if(!file.exists(dsnfn)) {
		dput(zz,file=dsnfn)
	}
	check <- all.equal(z,dget(file=dsnfn))
	############## test rslt 18.1     #################
	rslt <- c(rslt,ifelse1(is.logical(check),check,F))
	set.seed(test-12)
	zr <- rSeq(100, z, theta=0, sufficient=F, returnData=T)
	tmp <- matrix(0,100,3)
	for (i in 1:100) {
		zt <- t.test(zr$Data.Tx[,i],zr$Data.Ctrl[,i],alternative="greater") 
		tmp[i,] <- c(-diff(zt$estimate),zt$statistic,zt$p.value)
	}
	if(!file.exists(rfn)) {
		dput(zr,file=rfn)
	}
	check <- all.equal(zr,dget(file=rfn))
	############## test rslt 18.2     #################
	rslt <- c(rslt,ifelse1(is.logical(check),check,F))
	############## test rslt 18.3     #################
	rslt <- c(rslt,max(abs(tmp - cbind(zr$thetaHat,zr$Zstat,zr$Pstat))) <= 1e-12)
	set.seed(test)
	zr <- rSeq(100, z, theta=0, sufficient=F, returnData=T, var.equal=T)
	tmp <- matrix(0,100,3)
	for (i in 1:100) {
		zt <- t.test(zr$Data.Tx[,i],zr$Data.Ctrl[,i],alternative="greater", var.equal=T) 
		tmp[i,] <- c(-diff(zt$estimate),zt$statistic,zt$p.value)
	}
	############## test rslt 18.4     #################
	rslt <- c(rslt,max(abs(tmp - cbind(zr$thetaHat,zr$Zstat,zr$Pstat))) <= 1e-12)
}

# Tests  19.1-.6
# Test computation of t test estimates, statistic, p value
test <- 19
if (test %in% runRCTvalidateTests) {
	testLbls <- c(testLbls,paste(test,1:6,sep="."))
	dsnName <- "OBF2s.025.4 N"
	J <- 4
	P <- 1
	alpha <- 0.025
	beta <- 0.975
	fn <- paste(RCTvalidateOutputDirname,"test",substring(format(10000+test-12),2),sep="")
	dsnfn <- paste(fn,"dsn",sep="")
	rfn <- paste(fn,"rSeq",sep="")
	z <- seqDesign (arms=2,sample.size=200,nbr.analyses=J,alpha=alpha,beta=beta,P=P,suppressErrors=T,EPSILON=1e-8)
	zz <- z
	zz$call <- NULL
	if(!file.exists(dsnfn)) {
		dput(zz,file=dsnfn)
	}
	check <- all.equal(z,dget(file=dsnfn))
	############## test rslt 19.1     #################
	rslt <- c(rslt,ifelse1(is.logical(check),check,F))
	set.seed(test-12)
	zr <- rSeq(100, z, theta=0, sufficient=F, returnData=T)
	tmp <- matrix(0,100,3)
	for (i in 1:100) {
		zt <- t.test(zr$Data.Tx[,i],zr$Data.Ctrl[,i],alternative="greater",na.action=na.omit) 
		tmp[i,] <- c(-diff(zt$estimate),zt$statistic,zt$p.value)
	}
	if(!file.exists(rfn)) {
		dput(zr,file=rfn)
	}
	check <- all.equal(zr,dget(file=rfn))
	############## test rslt 19.2     #################
	rslt <- c(rslt,ifelse1(is.logical(check),check,F))
	############## test rslt 19.3     #################
	rslt <- c(rslt,max(abs(tmp - cbind(zr$thetaHat,zr$Zstat,zr$Pstat))) <= 1e-12)
	set.seed(test)
	zr <- rSeq(100, z, theta=0, sufficient=F, returnData=T, var.equal=T)
	tmp <- matrix(0,100,3)
	for (i in 1:100) {
		zt <- t.test(zr$Data.Tx[,i],zr$Data.Ctrl[,i],alternative="greater", var.equal=T,na.action=na.omit) 
		tmp[i,] <- c(-diff(zt$estimate),zt$statistic,zt$p.value)
	}
	############## test rslt 19.4     #################
	rslt <- c(rslt,max(abs(tmp - cbind(zr$thetaHat,zr$Zstat,zr$Pstat))) <= 1e-12)
	zr <- rSeq(100, z, theta=0, ratio=4, sufficient=F, returnData=T)
	tmp <- matrix(0,100,3)
	for (i in 1:100) {
		zt <- t.test(zr$Data.Tx[,i],zr$Data.Ctrl[,i],alternative="greater",na.action=na.omit) 
		tmp[i,] <- c(-diff(zt$estimate),zt$statistic,zt$p.value)
	}
	############## test rslt 19.5     #################
	rslt <- c(rslt,max(abs(tmp - cbind(zr$thetaHat,zr$Zstat,zr$Pstat))) <= 1e-12)
	zr <- rSeq(100, z, theta=0, ratio=4, sufficient=F, returnData=T, var.equal=T)
	tmp <- matrix(0,100,3)
	for (i in 1:100) {
		zt <- t.test(zr$Data.Tx[,i],zr$Data.Ctrl[,i],alternative="greater", var.equal=T,na.action=na.omit) 
		tmp[i,] <- c(-diff(zt$estimate),zt$statistic,zt$p.value)
	}
	############## test rslt 19.6     #################
	rslt <- c(rslt,max(abs(tmp - cbind(zr$thetaHat,zr$Zstat,zr$Pstat))) <= 1e-12)
}

# Tests 20.1 - 20.22
# Test specification of means, sd
test <- 20
if (test %in% runRCTvalidateTests) {
	testLbls <- c(testLbls,paste(test,1:22,sep="."))
	J <- 1
	P <- 1
	alpha <- 0.025
	beta <- 0.975
	z <- seqDesign (arms=2,sample.size=200,nbr.analyses=J,alpha=alpha,beta=beta,P=P,suppressErrors=T,EPSILON=1e-8)
	N <- 100000
	theta <- 0
	vrnc <- 1
	means <- c(seqExtract(z,"alt.hypothesis"))
	tol <- qnorm(.99) * sqrt(vrnc / (sampleSize(z) / 2 * N))
	tol2 <- qnorm(.99) * vrnc * sqrt (2 / (sampleSize(z) / 2 * N-1))
	set.seed(test+101)
	zr <- rSeq(N, z, theta=theta, sufficient=F, returnData=T)
	############## test rslt 20.1 20.2 #################
	rslt <- c(rslt,abs(mean(zr$Data.Ctrl) - means[2]) <= tol,abs(var(as.vector(zr$Data.Ctrl))-vrnc) <= tol2)
	############## test rslt 20.3 20.4 #################
	rslt <- c(rslt,abs(mean(zr$Data.Tx) - theta - means[2]) <= tol,abs(var(as.vector(zr$Data.Tx))-vrnc) <= tol2)
	theta <- 0.1
	vrnc <- 1
	means <- c(seqExtract(z,"alt.hypothesis"))
	tol <- qnorm(.99) * sqrt(vrnc / (sampleSize(z) / 2 * N))
	tol2 <- qnorm(.99) * vrnc * sqrt (2 / (sampleSize(z) / 2 * N-1))
	set.seed(test+102)
	zr <- rSeq(N, z, theta=theta, sufficient=F, returnData=T)
	############## test rslt 20.5 20.6 #################
	rslt <- c(rslt,abs(mean(zr$Data.Ctrl) - means[2]) <= tol,abs(var(as.vector(zr$Data.Ctrl))-vrnc) <= tol2)
	############## test rslt 20.7 20.8 #################
	rslt <- c(rslt,abs(mean(zr$Data.Tx) - theta - means[2]) <= tol,abs(var(as.vector(zr$Data.Tx))-vrnc) <= tol2)
	vrnc <- c(0.8,1.2)
	means <- c(seqExtract(z,"alt.hypothesis")) + 0.1
	theta <- -diff(means)
	set.seed(test+103)
	zr <- rSeq(N, z, mean=means, variance=vrnc, sufficient=F, returnData=T)
	############## test rslt 20.9 20.10 #################
	tol <- qnorm(.99) * sqrt(vrnc[2] / (sampleSize(z) / 2 * N))
	tol2 <- qnorm(.99) * vrnc[2] * sqrt (2 / (sampleSize(z) / 2 * N-1))
	rslt <- c(rslt,abs(mean(zr$Data.Ctrl) - means[2]) <= tol,abs(var(as.vector(zr$Data.Ctrl))-vrnc[2]) <= tol2)
	############## test rslt 20.11 20.12 #################
	tol <- qnorm(.99) * sqrt(vrnc[1] / (sampleSize(z) / 2 * N))
	tol2 <- qnorm(.99) * vrnc[1] * sqrt (2 / (sampleSize(z) / 2 * N-1))
	rslt <- c(rslt,abs(mean(zr$Data.Tx) - theta - means[2]) <= tol,abs(var(as.vector(zr$Data.Tx))-vrnc[1]) <= tol2)
	theta <- -diff(means)
	vrnc <- c(0.8,1.2)
	means <- c(seqExtract(z,"alt.hypothesis"))
	set.seed(test+104)
	zr <- rSeq(N, z, sd=sqrt(vrnc), sufficient=F, returnData=T)
	############## test rslt 20.13 20.14 #################
	tol <- qnorm(.99) * sqrt(vrnc[2] / (sampleSize(z) / 2 * N))
	tol2 <- qnorm(.99) * vrnc[2] * sqrt (2 / (sampleSize(z) / 2 * N-1))
	rslt <- c(rslt,abs(mean(zr$Data.Ctrl) - means[2]) <= tol,abs(var(as.vector(zr$Data.Ctrl))-vrnc[2]) <= tol2)
	############## test rslt 20.1 20.2 #################
	tol <- qnorm(.99) * sqrt(vrnc[1] / (sampleSize(z) / 2 * N))
	tol2 <- qnorm(.99) * vrnc[1] * sqrt (2 / (sampleSize(z) / 2 * N-1))
	rslt <- c(rslt,abs(mean(zr$Data.Tx) - theta - means[2]) <= tol,abs(var(as.vector(zr$Data.Tx))-vrnc[1]) <= tol2)
	theta <- 0.1
	vrnc <- c(0.8,1.2)
	means <- c(seqExtract(z,"alt.hypothesis"))
	set.seed(test+105)
	zr <- rSeq(N, z, theta=theta, mean=means, sd=sqrt(vrnc), variance=1, sufficient=F, returnData=T)
	############## test rslt 20.15 20.16 #################
	tol <- qnorm(.99) * sqrt(vrnc[2] / (sampleSize(z) / 2 * N))
	tol2 <- qnorm(.99) * vrnc[2] * sqrt (2 / (sampleSize(z) / 2 * N-1))
	rslt <- c(rslt,abs(mean(zr$Data.Ctrl) - means[2]) <= tol,abs(var(as.vector(zr$Data.Ctrl))-vrnc[2]) <= tol2)
	############## test rslt 20.17 20.18 #################
	tol <- qnorm(.99) * sqrt(vrnc[1] / (sampleSize(z) / 2 * N))
	tol2 <- qnorm(.99) * vrnc[1] * sqrt (2 / (sampleSize(z) / 2 * N-1))
	rslt <- c(rslt,abs(mean(zr$Data.Tx) - theta - means[2]) <= tol,abs(var(as.vector(zr$Data.Tx))-vrnc[1]) <= tol2)
	theta <- 0.1
	vrnc <- c(0.8,1.2)
	means <- c(seqExtract(z,"alt.hypothesis"))
	set.seed(test+106)
	zr <- rSeq(N, z, theta=theta, mean=means, sd=sqrt(vrnc), variance=1, ratio=4, sufficient=F, returnData=T)
	############## test rslt 20.19 20.20 #################
	tol <- qnorm(.99) * sqrt(vrnc[2] / (sampleSize(z) / 5 * N))
	tol2 <- qnorm(.99) * vrnc[2] * sqrt (2 / (sampleSize(z) / 5 * N-1))
	rslt <- c(rslt,abs(mean(zr$Data.Ctrl) - means[2]) <= tol,abs(var(as.vector(zr$Data.Ctrl))-vrnc[2]) <= tol2)
	############## test rslt 20.21 20.22 #################
	tol <- qnorm(.99) * sqrt(vrnc[1] / (4*sampleSize(z) / 5 * N))
	tol2 <- qnorm(.99) * vrnc[1] * sqrt (2 / (4*sampleSize(z) / 5 * N-1))
	rslt <- c(rslt,abs(mean(zr$Data.Tx) - theta - means[2]) <= tol,abs(var(as.vector(zr$Data.Tx))-vrnc[1]) <= tol2)
}

# Test agreement between asymptotic and sufficient statistics
if (any(21:24 %in% runRCTvalidateTests)) {
	dsnName <- "OBF2s.025.4 N"
	J <- 4
	P <- 1
	alpha <- 0.025
	beta <- 0.975
	z <- seqDesign (arms=2,sample.size=200,nbr.analyses=J,alpha=alpha,beta=beta,P=P,suppressErrors=T,EPSILON=1e-8)
}
test <- 21
if (test %in% runRCTvalidateTests) {
	testLbls <- c(testLbls,test)
	rslt <- c(rslt,seqCheckOC(z,dsnName,seed=test,standardize=F))
}
test <- 22
if (test %in% runRCTvalidateTests) {
	testLbls <- c(testLbls,test)
	rslt <- c(rslt,seqCheckOC(z,paste(dsnName,"data"),seed=test,standardize=F,sufficient=F))
}
test <- 23
if (test %in% runRCTvalidateTests) {
	testLbls <- c(testLbls,test)
	rslt <- c(rslt,seqCheckOC(update(z,variance=1.5),paste(dsnName,"vrnc 1.5"),seed=test,standardize=F)) 
}
test <- 24
if (test %in% runRCTvalidateTests) {
	testLbls <- c(testLbls,test)
	rslt <- c(rslt,seqCheckOC(update(z,variance=1.5),paste(dsnName,"vrnc 1.5 data"),seed=test,standardize=F,sufficient=F)) 
}

# Tests 25.1 - 25.4
# Test user specified function
test <- 25
if (test %in% runRCTvalidateTests) {
	testLbls <- c(testLbls,paste(test,1:4,sep="."))
	grbg <- function (n, theta, argList) {
		if (theta==0) rnorm(n, theta, argList)
		else rexp(n, 1 / (theta+1))
	}
	J <- 1
	P <- 1
	alpha <- 0.025
	beta <- 0.975
	z <- seqDesign (arms=2,sample.size=200,nbr.analyses=J,alpha=alpha,beta=beta,P=P,suppressErrors=T,EPSILON=1e-8)
	means <- c(0.5,0)
	theta <- -diff(means)
	vrnc <- c((theta + 1)^2,1)
	zr <- rSeq(N, z, mean=means, sd=sqrt(vrnc), distnArgs=1, distn=grbg, sufficient=F, returnData=T)
	############## test rslt 25.1 - 25.2 #################
	tol <- qnorm(.99) * sqrt(vrnc[2] / (sampleSize(z) / 2 * N))
	tol2 <- qnorm(.99) * vrnc[2] * sqrt (2 / (sampleSize(z) / 2 * N-1))
	rslt <- c(rslt,abs(mean(zr$Data.Ctrl) - means[2]) <= tol,abs(var(as.vector(zr$Data.Ctrl))-vrnc[2]) <= tol2)
	############## test rslt 25.3 - 25.4 #################
	tol <- qnorm(.99) * sqrt(vrnc[1] / (sampleSize(z) / 2 * N))
	tol2 <- qnorm(.99) * vrnc[1] * sqrt (8 / (sampleSize(z) / 2 * N-1))
	rslt <- c(rslt,abs(mean(zr$Data.Tx) - (theta+1) - means[2]) <= tol,abs(var(as.vector(zr$Data.Tx))-vrnc[1]) <= tol2)
}

if (is.null(rslt)) {cat("     ",TestName,": No tests performed\n")
} else if (all(rslt)) {cat("     ",TestName,": All",length(rslt),"tests  PASS\n")
} else cat("     ",TestName,": failing test numbers ", testLbls[!rslt],"\n")

####################
TestName <- "Two Sample GeomMn "
####################

rslt <- NULL
testLbls <- NULL

# Tests  26.1-.4
# Test computation of t test estimates, statistic, p value
test <- 26
if (test %in% runRCTvalidateTests) {
	testLbls <- c(testLbls,paste(test,1:4,sep="."))
	dsnName <- "Fixed L"
	J <- 1
	P <- 1
	alpha <- 0.025
	beta <- 0.975
	fn <- paste(RCTvalidateOutputDirname,"test",substring(format(10000+test-18),2),sep="")
	dsnfn <- paste(fn,"dsn",sep="")
	rfn <- paste(fn,"rSeq",sep="")
	z <- seqDesign ("geom", arms=2,sample.size=200,nbr.analyses=J,alpha=alpha,beta=beta,P=P,suppressErrors=T,EPSILON=1e-8)
	zz <- z
	zz$call <- NULL
	if(!file.exists(dsnfn)) {
		dput(zz,file=dsnfn)
	}
	check <- all.equal(z,dget(file=dsnfn))
	############## test rslt 26.1     #################
	rslt <- c(rslt,ifelse1(is.logical(check),check,F))
	set.seed(test-18)
	zr <- rSeq(100, z, theta=1, sufficient=F, returnData=T)
	tmp <- matrix(0,100,3)
	for (i in 1:100) {
		zt <- t.test(log(zr$Data.Tx[,i]),log(zr$Data.Ctrl[,i]),alternative="greater") 
		tmp[i,] <- c(exp(-diff(zt$estimate)),zt$statistic,zt$p.value)
	}
	if(!file.exists(rfn)) {
		dput(zr,file=rfn)
	}
	check <- all.equal(zr,dget(file=rfn))
	############## test rslt 26.2     #################
	rslt <- c(rslt,ifelse1(is.logical(check),check,F))
	############## test rslt 26.3     #################
	rslt <- c(rslt,max(abs(tmp - cbind(zr$thetaHat,zr$Zstat,zr$Pstat))) <= 1e-12)
	set.seed(test)
	zr <- rSeq(100, z, theta=1, sufficient=F, returnData=T, var.equal=T)
	tmp <- matrix(0,100,3)
	for (i in 1:100) {
		zt <- t.test(log(zr$Data.Tx[,i]),log(zr$Data.Ctrl[,i]),alternative="greater", var.equal=T) 
		tmp[i,] <- c(exp(-diff(zt$estimate)),zt$statistic,zt$p.value)
	}
	############## test rslt 26.4     #################
	rslt <- c(rslt,max(abs(tmp - cbind(zr$thetaHat,zr$Zstat,zr$Pstat))) <= 1e-12)
}

# Tests  27.1-.4
# Test computation of t test estimates, statistic, p value
test <- 27
if (test %in% runRCTvalidateTests) {
	testLbls <- c(testLbls,paste(test,1:4,sep="."))
	dsnName <- "Fixed L"
	J <- 1
	P <- 1
	alpha <- 0.025
	beta <- 0.975
	fn <- paste(RCTvalidateOutputDirname,"test",substring(format(10000+test-18),2),sep="")
	dsnfn <- paste(fn,"dsn",sep="")
	rfn <- paste(fn,"rSeq",sep="")
	z <- seqDesign ("geom", log.transform=T,arms=2,sample.size=200,nbr.analyses=J,alpha=alpha,beta=beta,P=P,suppressErrors=T,EPSILON=1e-8)
	zz <- z
	zz$call <- NULL
	if(!file.exists(dsnfn)) {
		dput(zz,file=dsnfn)
	}
	check <- all.equal(z,dget(file=dsnfn))
	############## test rslt 27.1     #################
	rslt <- c(rslt,ifelse1(is.logical(check),check,F))
	set.seed(test-18)
	zr <- rSeq(100, z, theta=0, sufficient=F, returnData=T)
	tmp <- matrix(0,100,3)
	for (i in 1:100) {
		zt <- t.test(log(zr$Data.Tx[,i]),log(zr$Data.Ctrl[,i]),alternative="greater") 
		tmp[i,] <- c(-diff(zt$estimate),zt$statistic,zt$p.value)
	}
	if(!file.exists(rfn)) {
		dput(zr,file=rfn)
	}
	check <- all.equal(zr,dget(file=rfn))
	############## test rslt 27.2     #################
	rslt <- c(rslt,ifelse1(is.logical(check),check,F))
	############## test rslt 27.3     #################
	rslt <- c(rslt,max(abs(tmp - cbind(zr$thetaHat,zr$Zstat,zr$Pstat))) <= 1e-12)
	set.seed(test)
	zr <- rSeq(100, z, theta=1, sufficient=F, returnData=T, var.equal=T)
	tmp <- matrix(0,100,3)
	for (i in 1:100) {
		zt <- t.test(log(zr$Data.Tx[,i]),log(zr$Data.Ctrl[,i]),alternative="greater", var.equal=T) 
		tmp[i,] <- c(-diff(zt$estimate),zt$statistic,zt$p.value)
	}
	############## test rslt 27.4     #################
	rslt <- c(rslt,max(abs(tmp - cbind(zr$thetaHat,zr$Zstat,zr$Pstat))) <= 1e-12)
}

# Tests  28.1-.6
# Test computation of t test estimates, statistic, p value
test <- 28
if (test %in% runRCTvalidateTests) {
	testLbls <- c(testLbls,paste(test,1:6,sep="."))
	dsnName <- "OBF2s.025.4 L"
	J <- 4
	P <- 1
	alpha <- 0.025
	beta <- 0.975
	fn <- paste(RCTvalidateOutputDirname,"test",substring(format(10000+test-18),2),sep="")
	dsnfn <- paste(fn,"dsn",sep="")
	rfn <- paste(fn,"rSeq",sep="")
	z <- seqDesign ("geom",arms=2,sample.size=200,nbr.analyses=J,alpha=alpha,beta=beta,P=P,suppressErrors=T,EPSILON=1e-8)
	zz <- z
	zz$call <- NULL
	if(!file.exists(dsnfn)) {
		dput(zz,file=dsnfn)
	}
	check <- all.equal(z,dget(file=dsnfn))
	############## test rslt 28.1     #################
	rslt <- c(rslt,ifelse1(is.logical(check),check,F))
	set.seed(test-18)
	zr <- rSeq(100, z, theta=1, sufficient=F, returnData=T)
	tmp <- matrix(0,100,3)
	for (i in 1:100) {
		zt <- t.test(log(zr$Data.Tx[,i]),log(zr$Data.Ctrl[,i]),alternative="greater",na.action=na.omit) 
		tmp[i,] <- c(exp(-diff(zt$estimate)),zt$statistic,zt$p.value)
	}
	if(!file.exists(rfn)) {
		dput(zr,file=rfn)
	}
	check <- all.equal(zr,dget(file=rfn))
	############## test rslt 28.2    #################
	rslt <- c(rslt,ifelse1(is.logical(check),check,F))
	############## test rslt 28.3    #################
	rslt <- c(rslt,max(abs(tmp - cbind(zr$thetaHat,zr$Zstat,zr$Pstat))) <= 1e-12)
	set.seed(test-18)
	zr <- rSeq(100, z, theta=1, sufficient=F, returnData=T, var.equal=T)
	tmp <- matrix(0,100,3)
	for (i in 1:100) {
		zt <- t.test(log(zr$Data.Tx[,i]),log(zr$Data.Ctrl[,i]),alternative="greater", var.equal=T,na.action=na.omit) 
		tmp[i,] <- c(exp(-diff(zt$estimate)),zt$statistic,zt$p.value)
	}
	############## test rslt 28.4     #################
	rslt <- c(rslt,max(abs(tmp - cbind(zr$thetaHat,zr$Zstat,zr$Pstat))) <= 1e-12)
	zr <- rSeq(100, z, theta=1, ratio=4, sufficient=F, returnData=T)
	tmp <- matrix(0,100,3)
	for (i in 1:100) {
		zt <- t.test(log(zr$Data.Tx[,i]),log(zr$Data.Ctrl[,i]),alternative="greater",na.action=na.omit) 
		tmp[i,] <- c(exp(-diff(zt$estimate)),zt$statistic,zt$p.value)
	}
	############## test rslt 28.5     #################
	rslt <- c(rslt,max(abs(tmp - cbind(zr$thetaHat,zr$Zstat,zr$Pstat))) <= 1e-12)
	zr <- rSeq(100, z, theta=1, ratio=4, sufficient=F, returnData=T, var.equal=T)
	tmp <- matrix(0,100,3)
	for (i in 1:100) {
		zt <- t.test(log(zr$Data.Tx[,i]),log(zr$Data.Ctrl[,i]),alternative="greater", var.equal=T,na.action=na.omit) 
		tmp[i,] <- c(exp(-diff(zt$estimate)),zt$statistic,zt$p.value)
	}
	############## test rslt 28.6     #################
	rslt <- c(rslt,max(abs(tmp - cbind(zr$thetaHat,zr$Zstat,zr$Pstat))) <= 1e-12)
}

# Tests 29.1 - 29.28
# Test specification of geometric means, sdlog
test <- 29
if (test %in% runRCTvalidateTests) {
	testLbls <- c(testLbls,paste(test,1:28,sep="."))
	J <- 1
	P <- 1
	alpha <- 0.025
	beta <- 0.975
	z <- seqDesign ("geom",arms=2,sample.size=200,nbr.analyses=J,alpha=alpha,beta=beta,P=P,suppressErrors=T,EPSILON=1e-8)
	N <- 100000
	theta <- 1
	vrnc <- 1
	means <- c(seqExtract(z,"alt.hypothesis"))
	tol <- qnorm(.99) * sqrt(vrnc / (sampleSize(z) / 2 * N))
	tol2 <- qnorm(.99) * vrnc * sqrt (2 / (sampleSize(z) / 2 * N-1))
	set.seed(test+101)
	zr <- rSeq(N, z, theta=theta, sufficient=F, returnData=T)
	############## test rslt 29.1 - 29.2 #################
	rslt <- c(rslt,abs(mean(log(zr$Data.Ctrl)) - log(means[2])) <= tol,abs(var(as.vector(log(zr$Data.Ctrl)))-vrnc) <= tol2)
	############## test rslt 29.3 - 29.4 #################
	rslt <- c(rslt,abs(mean(log(zr$Data.Tx)) - log(theta) - log(means[2])) <= tol,abs(var(as.vector(log(zr$Data.Tx)))-vrnc) <= tol2)
	theta <- 1.1
	vrnc <- 1
	means <- c(seqExtract(z,"alt.hypothesis"))
	tol <- qnorm(.99) * sqrt(vrnc / (sampleSize(z) / 2 * N))
	tol2 <- qnorm(.99) * vrnc * sqrt (2 / (sampleSize(z) / 2 * N-1))
	set.seed(test+102)
	zr <- rSeq(N, z, theta=theta, sufficient=F, returnData=T)
	############## test rslt 29.5 - 29.6 #################
	rslt <- c(rslt,abs(mean(log(zr$Data.Ctrl)) - log(means[2])) <= tol,abs(var(as.vector(log(zr$Data.Ctrl)))-vrnc) <= tol2)
	############## test rslt 29.7 - 29.8 #################
	rslt <- c(rslt,abs(mean(log(zr$Data.Tx)) - log(theta) - log(means[2])) <= tol,abs(var(as.vector(log(zr$Data.Tx)))-vrnc) <= tol2)
	vrnc <- c(0.8,1.2)
	means <- c(seqExtract(z,"alt.hypothesis")) + 0.1
	theta <- means[1]/means[2]
	set.seed(test+103)
	zr <- rSeq(N, z, geomMean=means, variance=vrnc, sufficient=F, returnData=T)
	############## test rslt 29.9 - 29.10 #################
	tol <- qnorm(.99) * sqrt(vrnc[2] / (sampleSize(z) / 2 * N))
	tol2 <- qnorm(.99) * vrnc[2] * sqrt (2 / (sampleSize(z) / 2 * N-1))
	rslt <- c(rslt,abs(mean(log(zr$Data.Ctrl)) - log(means[2])) <= tol,abs(var(as.vector(log(zr$Data.Ctrl)))-vrnc[2]) <= tol2)
	############## test rslt 29.11 - 29.12 #################
	tol <- qnorm(.99) * sqrt(vrnc[1] / (sampleSize(z) / 2 * N))
	tol2 <- qnorm(.99) * vrnc[1] * sqrt (2 / (sampleSize(z) / 2 * N-1))
	rslt <- c(rslt,abs(mean(log(zr$Data.Tx)) - log(theta) - log(means[2])) <= tol,abs(var(as.vector(log(zr$Data.Tx)))-vrnc[1]) <= tol2)
	vrnc <- c(0.8,1.2)
	means <- c(seqExtract(z,"alt.hypothesis"))
	theta <- means[1]/means[2]
	set.seed(test+104)
	zr <- rSeq(N, z, sdlog=sqrt(vrnc), sufficient=F, returnData=T)
	############## test rslt 29.13 - 29.14 #################
	tol <- qnorm(.99) * sqrt(vrnc[2] / (sampleSize(z) / 2 * N))
	tol2 <- qnorm(.99) * vrnc[2] * sqrt (2 / (sampleSize(z) / 2 * N-1))
	rslt <- c(rslt,abs(mean(log(zr$Data.Ctrl)) - log(means[2])) <= tol,abs(var(as.vector(log(zr$Data.Ctrl)))-vrnc[2]) <= tol2)
	############## test rslt 29.15 - 29.16 #################
	tol <- qnorm(.99) * sqrt(vrnc[1] / (sampleSize(z) / 2 * N))
	tol2 <- qnorm(.99) * vrnc[1] * sqrt (2 / (sampleSize(z) / 2 * N-1))
	rslt <- c(rslt,abs(mean(log(zr$Data.Tx)) - log(theta) - log(means[2])) <= tol,abs(var(as.vector(log(zr$Data.Tx)))-vrnc[1]) <= tol2)
	theta <- 1.1
	vrnc <- c(0.8,1.2)
	means <- c(seqExtract(z,"alt.hypothesis"))
	set.seed(test+105)
	zr <- rSeq(N, z, theta=theta, geomMean=means, sdlog=sqrt(vrnc), variance=1, sufficient=F, returnData=T)
	############## test rslt 29.17 - 29.18 #################
	tol <- qnorm(.99) * sqrt(vrnc[2] / (sampleSize(z) / 2 * N))
	tol2 <- qnorm(.99) * vrnc[2] * sqrt (2 / (sampleSize(z) / 2 * N-1))
	rslt <- c(rslt,abs(mean(log(zr$Data.Ctrl)) - log(means[2])) <= tol,abs(var(as.vector(log(zr$Data.Ctrl)))-vrnc[2]) <= tol2)
	############## test rslt 29.19 - 29.20 #################
	tol <- qnorm(.99) * sqrt(vrnc[1] / (sampleSize(z) / 2 * N))
	tol2 <- qnorm(.99) * vrnc[1] * sqrt (2 / (sampleSize(z) / 2 * N-1))
	rslt <- c(rslt,abs(mean(log(zr$Data.Tx)) - log(theta) - log(means[2])) <= tol,abs(var(as.vector(log(zr$Data.Tx)))-vrnc[1]) <= tol2)
	set.seed(test+106)
	zr <- rSeq(N, z, theta=theta, meanlog=log(means), sdlog=sqrt(vrnc), variance=1, sufficient=F, returnData=T)
	############## test rslt 29.21 - 29.22 #################
	tol <- qnorm(.99) * sqrt(vrnc[2] / (sampleSize(z) / 2 * N))
	tol2 <- qnorm(.99) * vrnc[2] * sqrt (2 / (sampleSize(z) / 2 * N-1))
	rslt <- c(rslt,abs(mean(log(zr$Data.Ctrl)) - log(means[2])) <= tol,abs(var(as.vector(log(zr$Data.Ctrl)))-vrnc[2]) <= tol2)
	############## test rslt 29.23 - 29.24 #################
	tol <- qnorm(.99) * sqrt(vrnc[1] / (sampleSize(z) / 2 * N))
	tol2 <- qnorm(.99) * vrnc[1] * sqrt (2 / (sampleSize(z) / 2 * N-1))
	rslt <- c(rslt,abs(mean(log(zr$Data.Tx)) - log(theta) - log(means[2])) <= tol,abs(var(as.vector(log(zr$Data.Tx)))-vrnc[1]) <= tol2)
	theta <- 1.1
	vrnc <- c(0.8,1.2)
	means <- c(seqExtract(z,"alt.hypothesis"))
	set.seed(test+107)
	zr <- rSeq(N, z, theta=theta, geomMean=means, sdlog=sqrt(vrnc), variance=1, ratio=4, sufficient=F, returnData=T)
	############## test rslt 29.25 - 29.26 #################
	tol <- qnorm(.99) * sqrt(vrnc[2] / (sampleSize(z) / 5 * N))
	tol2 <- qnorm(.99) * vrnc[2] * sqrt (2 / (sampleSize(z) / 5 * N-1))
	rslt <- c(rslt,abs(mean(log(zr$Data.Ctrl)) - log(means[2])) <= tol,abs(var(as.vector(log(zr$Data.Ctrl)))-vrnc[2]) <= tol2)
	############## test rslt 29.27 - 29.28 #################
	tol <- qnorm(.99) * sqrt(vrnc[1] / (sampleSize(z) / 2 * N))
	tol2 <- qnorm(.99) * vrnc[1] * sqrt (2 / (sampleSize(z) / 2 * N-1))
	rslt <- c(rslt,abs(mean(log(zr$Data.Tx)) - log(theta) - log(means[2])) <= tol,abs(var(as.vector(log(zr$Data.Tx)))-vrnc[1]) <= tol2)
}

# Test agreement between asymptotic and sufficient statistics
if (any(30:33 %in% runRCTvalidateTests)) {
	dsnName <- "OBF2s.025.4 L"
	J <- 4
	P <- 1
	alpha <- 0.025
	beta <- 0.975
	z <- seqDesign ("geom",arms=2,sample.size=200,nbr.analyses=J,alpha=alpha,beta=beta,P=P,suppressErrors=T,EPSILON=1e-8)
}
test <- 30
if (test %in% runRCTvalidateTests) {
	testLbls <- c(testLbls,test)
	rslt <- c(rslt,seqCheckOC(z,dsnName,seed=test,standardize=F))
}
test <- 31
if (test %in% runRCTvalidateTests) {
	testLbls <- c(testLbls,test)
	rslt <- c(rslt,seqCheckOC(z,paste(dsnName,"data"),seed=test,standardize=F,sufficient=F))
}
test <- 32
if (test %in% runRCTvalidateTests) {
	testLbls <- c(testLbls,test)
	rslt <- c(rslt,seqCheckOC(update(z,variance=1.5),paste(dsnName,"vrnc 1.5"),seed=test,standardize=F)) 
}
test <- 33
if (test %in% runRCTvalidateTests) {
	testLbls <- c(testLbls,test)
	rslt <- c(rslt,seqCheckOC(update(z,variance=1.5),paste(dsnName,"vrnc 1.5 data"),seed=test,standardize=F,sufficient=F)) 
}

# Tests 34.1 - 34.4
# Test user specified function
test <- 34
if (test %in% runRCTvalidateTests) {
	testLbls <- c(testLbls,paste(test,1:4,sep="."))
	grbg <- function (n, theta, argList) {
		if (theta==0) rlnorm(n, theta, argList)
		else runif(n)
	}
	J <- 1
	P <- 1
	alpha <- 0.025
	beta <- 0.975
	z <- seqDesign ("geom",log.transform=T,arms=2,sample.size=200,nbr.analyses=J,alpha=alpha,beta=beta,P=P,suppressErrors=T,EPSILON=1e-8)
	means <- c(-1,0)
	theta <- -diff(means)
	vrnc <- c(1,2)
	zr <- rSeq(N, z, meanlog=means, sd=sqrt(vrnc), distnArgs=sqrt(2), distn=grbg, sufficient=F, returnData=T)
	############## test rslt 34.1 - 34.2 #################
	tol <- qnorm(.99) * sqrt(vrnc[2] / (sampleSize(z)/2 * N))
	tol2 <- qnorm(.99) * vrnc[2] * sqrt (2 / (sampleSize(z) * N-1))
	rslt <- c(rslt,abs(mean(log(zr$Data.Ctrl)) - means[2]) <= tol,abs(var(as.vector(log(zr$Data.Ctrl)))-vrnc[2]) <= tol2)
	############## test rslt 34.3 - 34.4 #################
	tol <- qnorm(.99) * sqrt(vrnc[1] / (sampleSize(z)/2 * N))
	tol2 <- qnorm(.99) * vrnc[1] * sqrt (8 / (sampleSize(z) * N-1))
	rslt <- c(rslt,abs(mean(log(zr$Data.Tx)) - theta - means[2]) <= tol,abs(var(as.vector(log(zr$Data.Tx)))-vrnc[1]) <= tol2)
}

if (is.null(rslt)) {cat("     ",TestName,": No tests performed\n")
} else if (all(rslt)) {cat("     ",TestName,": All",length(rslt),"tests  PASS\n")
} else cat("     ",TestName,": failing test numbers ", testLbls[!rslt],"\n")

####################
TestName <- "One Sample Binom  "
####################

rslt <- NULL
testLbls <- NULL

# Tests  35.1-.3
# Test computation of t test estimates, statistic, p value
test <- 35
if (test %in% runRCTvalidateTests) {
	testLbls <- c(testLbls,paste(test,1:3,sep="."))
	dsnName <- "Fixed B"
	J <- 1
	P <- 1
	alpha <- 0.025
	beta <- 0.975
	theta0 <- 0.3
	fn <- paste(RCTvalidateOutputDirname,"test",substring(format(10000+test-24),2),sep="")
	dsnfn <- paste(fn,"dsn",sep="")
	rfn <- paste(fn,"rSeq",sep="")
	z <- seqDesign ("prop", arms=1, sample.size=100, null.hypothesis=theta0, nbr.analyses=J,alpha=alpha,beta=beta,P=P,suppressErrors=T,EPSILON=1e-8)
	zz <- z
	zz$call <- NULL
	if(!file.exists(dsnfn)) {
		dput(zz,file=dsnfn)
	}
	check <- all.equal(z,dget(file=dsnfn))
	############## test rslt 1     #################
	rslt <- c(rslt,ifelse1(is.logical(check),check,F))
	set.seed(test-24)
	zr <- rSeq(100, z, theta=0.3, sufficient=F, returnData=T)
	tmp <- matrix(0,100,4)
	for (i in 1:100) {
		zeh <- binom.test(x=sum(zr$Data[,i],na.rm=T),n=sum(!is.na(zr$Data[,i])),p=theta0,alternative="greater") 
		zel <- binom.test(x=sum(zr$Data[,i],na.rm=T),n=sum(!is.na(zr$Data[,i])),p=theta0,alternative="less") 
		zt <- prop.test(x=sum(zr$Data[,i],na.rm=T),n=sum(!is.na(zr$Data[,i])),p=theta0,alternative="greater") 
		tmp[i,] <- c(zeh$estimate,ifelse(zeh$estimate > theta0,zeh$p.value,ifelse(zeh$estimate < theta0, 1 - zel$p.value,
			0.5)),zt$estimate,zt$p.value)
	}
	if(!file.exists(rfn)) {
		dput(zr,file=rfn)
	}
	check <- all.equal(zr,dget(file=rfn))
	############## test rslt 2     #################
	rslt <- c(rslt,ifelse1(is.logical(check),check,F))
	############## test rslt 3     #################
	rslt <- c(rslt,max(abs(tmp - cbind(zr$thetaHat,zr$Pstat.ex,zr$thetaHat,zr$Pstat))) <= 1e-12)
}

# Tests  36.1-.3
# Test computation of t test estimates, statistic, p value
test <- 36
if (test %in% runRCTvalidateTests) {
	testLbls <- c(testLbls,paste(test,1:3,sep="."))
	dsnName <- "OBFSymm4 B"
	J <- 4
	P <- 1
	alpha <- 0.025
	beta <- 0.975
	theta0 <- 0.3
	fn <- paste(RCTvalidateOutputDirname,"test",substring(format(10000+test-24),2),sep="")
	dsnfn <- paste(fn,"dsn",sep="")
	rfn <- paste(fn,"rSeq",sep="")
	z <- seqDesign ("prop", arms=1, sample.size=100, null.hypothesis=theta0, nbr.analyses=J,alpha=alpha,beta=beta,P=P,suppressErrors=T,EPSILON=1e-8)
	zz <- z
	zz$call <- NULL
	if(!file.exists(dsnfn)) {
		dput(zz,file=dsnfn)
	}
	check <- all.equal(z,dget(file=dsnfn))
	############## test rslt 36.1     #################
	rslt <- c(rslt,ifelse1(is.logical(check),check,F))
	set.seed(test-24)
	zr <- rSeq(100, z, theta=0.3, sufficient=F, returnData=T)
	tmp <- matrix(0,100,4)
	for (i in 1:100) {
		zeh <- binom.test(x=sum(zr$Data[,i],na.rm=T),n=sum(!is.na(zr$Data[,i])),p=theta0,alternative="greater") 
		zel <- binom.test(x=sum(zr$Data[,i],na.rm=T),n=sum(!is.na(zr$Data[,i])),p=theta0,alternative="less") 
		zt <- prop.test(x=sum(zr$Data[,i],na.rm=T),n=sum(!is.na(zr$Data[,i])),p=theta0,alternative="greater") 
		tmp[i,] <- c(zeh$estimate,ifelse(zeh$estimate > theta0,zeh$p.value,ifelse(zeh$estimate < theta0, 1 - zel$p.value,
			0.5)),zt$estimate,zt$p.value)
	}
	if(!file.exists(rfn)) {
		dput(zr,file=rfn)
	}
	check <- all.equal(zr,dget(file=rfn))
	############## test rslt 36.2     #################
	rslt <- c(rslt,ifelse1(is.logical(check),check,F))
	############## test rslt 36.3     #################
	rslt <- c(rslt,max(abs(tmp - cbind(zr$thetaHat,zr$Pstat.ex,zr$thetaHat,zr$Pstat))) <= 1e-12)
}

# Tests  37.1-.3
# Test computation of t test estimates, statistic, p value
test <- 37
if (test %in% runRCTvalidateTests) {
	testLbls <- c(testLbls,paste(test,1:3,sep="."))
	dsnName <- "PocSymm4 B"
	J <- 4
	P <- 0.5
	alpha <- 0.025
	beta <- 0.975
	theta0 <- 0.3
	fn <- paste(RCTvalidateOutputDirname,"test",substring(format(10000+test-24),2),sep="")
	dsnfn <- paste(fn,"dsn",sep="")
	rfn <- paste(fn,"rSeq",sep="")
	z <- seqDesign ("prop", arms=1, sample.size=100, null.hypothesis=theta0, nbr.analyses=J,alpha=alpha,beta=beta,P=P,suppressErrors=T,EPSILON=1e-8)
	zz <- z
	zz$call <- NULL
	if(!file.exists(dsnfn)) {
		dput(zz,file=dsnfn)
	}
	check <- all.equal(z,dget(file=dsnfn))
	############## test rslt 37.1     #################
	rslt <- c(rslt,ifelse1(is.logical(check),check,F))
	set.seed(test-24)
	zr <- rSeq(100, z, theta=0.3, sufficient=F, returnData=T)
	tmp <- matrix(0,100,4)
	for (i in 1:100) {
		zeh <- binom.test(x=sum(zr$Data[,i],na.rm=T),n=sum(!is.na(zr$Data[,i])),p=theta0,alternative="greater") 
		zel <- binom.test(x=sum(zr$Data[,i],na.rm=T),n=sum(!is.na(zr$Data[,i])),p=theta0,alternative="less") 
		zt <- prop.test(x=sum(zr$Data[,i],na.rm=T),n=sum(!is.na(zr$Data[,i])),p=theta0,alternative="greater") 
		tmp[i,] <- c(zeh$estimate,ifelse(zeh$estimate > theta0,zeh$p.value,ifelse(zeh$estimate < theta0, 1 - zel$p.value,
			0.5)),zt$estimate,zt$p.value)
	}
	if(!file.exists(rfn)) {
		dput(zr,file=rfn)
	}
	check <- all.equal(zr,dget(file=rfn))
	############## test rslt 37.2     #################
	rslt <- c(rslt,ifelse1(is.logical(check),check,F))
	############## test rslt 37.3     #################
	rslt <- c(rslt,max(abs(tmp - cbind(zr$thetaHat,zr$Pstat.ex,zr$thetaHat,zr$Pstat))) <= 1e-12)
}

# Tests 38.1 - 38.8
# Test specification of theta, p, mean
test <- 38
if (test %in% runRCTvalidateTests) {
	testLbls <- c(testLbls,paste(test,1:8,sep="."))
	J <- 1
	P <- 1
	alpha <- 0.025
	beta <- 0.975
	z <- seqDesign ("prop",arms=1,sample.size=200,nbr.analyses=J,alpha=alpha,beta=beta,P=P,suppressErrors=T,EPSILON=1e-8)
	N <- 100000
	theta <- 0.4
	vrnc <- theta * (1 - theta)
	tol <- qnorm(.99) * sqrt(vrnc / (sampleSize(z) * N))
	set.seed(test+101)
	zr <- rSeq(N, z, theta=theta, sufficient=F, returnData=T)
	############## test rslt 38.1     #################
	rslt <- c(rslt,abs(mean(zr$Data) - theta) <= tol)
	set.seed(test+102)
	zr <- rSeq(N, z, p=theta, sufficient=F, returnData=T)
	############## test rslt 38.2     #################
	rslt <- c(rslt,abs(mean(zr$Data) - theta) <= tol)
	set.seed(test+103)
	zr <- rSeq(N, z, mean=theta, sufficient=F, returnData=T)
	############## test rslt 38.3     #################
	rslt <- c(rslt,abs(mean(zr$Data) - theta) <= tol)
	set.seed(test+104)
	zr <- rSeq(N, z, p=theta, mean=theta/2, sufficient=F, returnData=T)
	############## test rslt 38.4     #################
	rslt <- c(rslt,abs(mean(zr$Data) - theta) <= tol)
	set.seed(test+105)
	zr <- rSeq(N, z, theta=theta, p=theta/2, mean=theta/2, sufficient=F, returnData=T)
	############## test rslt 38.5     #################
	rslt <- c(rslt,abs(mean(zr$Data) - theta) <= tol)
	set.seed(test+106)
	zr <- rSeq(N, z, rSeqArgs=list(mean=theta), sufficient=F, returnData=T)
	############## test rslt 38.6     #################
	rslt <- c(rslt,abs(mean(zr$Data,na.rm=T) - theta) <= tol)
	set.seed(test+107)
	zr <- rSeq(N, z, rSeqArgs=list(p=theta), sufficient=F, returnData=T)
	############## test rslt 38.7     #################
	rslt <- c(rslt,abs(mean(zr$Data,na.rm=T) - theta) <= tol)
	set.seed(test+108)
	zr <- rSeq(N, z, p=theta/2,rSeqArgs=list(p=theta), sufficient=F, returnData=T)
	############## test rslt 38.8     #################
	rslt <- c(rslt,abs(mean(zr$Data,na.rm=T) - theta) <= tol)
}

if (is.null(rslt)) {cat("     ",TestName,": No tests performed\n")
} else if (all(rslt)) {cat("     ",TestName,": All",length(rslt),"tests  PASS\n")
} else cat("     ",TestName,": failing test numbers ", testLbls[!rslt],"\n")

####################
TestName <- "Two Sample Binom  "
####################

rslt <- NULL
testLbls <- NULL

# Tests  39.1-.3
# Test computation of test estimates, statistic, p value
test <- 39
if (test %in% runRCTvalidateTests) {
	testLbls <- c(testLbls,paste(test,1:3,sep="."))
	dsnName <- "Fixed B"
	J <- 1
	P <- 1
	alpha <- 0.025
	beta <- 0.975
	p0 <- 0.3
	fn <- paste(RCTvalidateOutputDirname,"test",substring(format(10000+test-25),2),sep="")
	dsnfn <- paste(fn,"dsn",sep="")
	rfn <- paste(fn,"rSeq",sep="")
	z <- seqDesign ("prop", arms=2, sample.size=100, null.hypothesis=p0, nbr.analyses=J,alpha=alpha,beta=beta,P=P,suppressErrors=T,EPSILON=1e-8)
	zz <- z
	zz$call <- NULL
	if(!file.exists(dsnfn)) {
		dput(zz,file=dsnfn)
	}
	check <- all.equal(z,dget(file=dsnfn))
	############## test rslt 39.1     #################
	rslt <- c(rslt,ifelse1(is.logical(check),check,F))
	set.seed(test-25)
	zr <- rSeq(100, z, theta=0.3, sufficient=F, returnData=T)
	tmp <- matrix(0,100,3)
	for (i in 1:100) {
		m <- cbind(c(sum(zr$Data.Tx[,i]==1,na.rm=T),sum(zr$Data.Ctrl[,i]==1,na.rm=T)),
			c(sum(zr$Data.Tx[,i]==0,na.rm=T),sum(zr$Data.Ctrl[,i]==0,na.rm=T)))
		zx <- chisq.test(m,correct=F)
		zt <- prop.test(m,correct=F,alternative="greater") 
		tmp[i,] <- c(-diff(zt$estimate),zt$p.value,zx$p.value/2)
	}
	if(!file.exists(rfn)) {
		dput(zr,file=rfn)
	}
	check <- all.equal(zr,dget(file=rfn))
	############## test rslt 39.2     #################
	rslt <- c(rslt,ifelse1(is.logical(check),check,F))
	############## test rslt 39.3     #################
	rslt <- c(rslt,max(abs(tmp - cbind(zr$thetaHat,zr$Pstat,ifelse(zr$thetaHat<0,1-zr$Pstat,zr$Pstat)))) <= 1e-12)
}

# Tests  40.1-.3
# Test computation of test estimates, statistic, p value
test <- 40
if (test %in% runRCTvalidateTests) {
	testLbls <- c(testLbls,paste(test,1:3,sep="."))
	dsnName <- "OBFSymm4 B"
	J <- 4
	P <- 1
	alpha <- 0.025
	beta <- 0.975
	p0 <- 0.3
	fn <- paste(RCTvalidateOutputDirname,"test",substring(format(10000+test-25),2),sep="")
	dsnfn <- paste(fn,"dsn",sep="")
	rfn <- paste(fn,"rSeq",sep="")
	z <- seqDesign ("prop", arms=2, sample.size=200, null.hypothesis=p0, nbr.analyses=J,alpha=alpha,beta=beta,P=P,suppressErrors=T,EPSILON=1e-8)
	zz <- z
	zz$call <- NULL
	if(!file.exists(dsnfn)) {
		dput(zz,file=dsnfn)
	}
	check <- all.equal(z,dget(file=dsnfn))
		############## test rslt 40.1     #################
	rslt <- c(rslt,ifelse1(is.logical(check),check,F))
	set.seed(test-25)
	zr <- rSeq(100, z, theta=0.3, sufficient=F, returnData=T)
	tmp <- matrix(0,100,3)
	for (i in 1:100) {
		m <- cbind(c(sum(zr$Data.Tx[,i]==1,na.rm=T),sum(zr$Data.Ctrl[,i]==1,na.rm=T)),
			c(sum(zr$Data.Tx[,i]==0,na.rm=T),sum(zr$Data.Ctrl[,i]==0,na.rm=T)))
		zx <- chisq.test(m,correct=F)
		zt <- prop.test(m,correct=F,alternative="greater") 
		tmp[i,] <- c(-diff(zt$estimate),zt$p.value,zx$p.value/2)
	}
	if(!file.exists(rfn)) {
		dput(zr,file=rfn)
	}
	check <- all.equal(zr,dget(file=rfn))
	############## test rslt 40.2     #################
	rslt <- c(rslt,ifelse1(is.logical(check),check,F))
	############## test rslt 40.3     #################
	rslt <- c(rslt,max(abs(tmp - cbind(zr$thetaHat,zr$Pstat,ifelse(zr$thetaHat<0,1-zr$Pstat,zr$Pstat)))) <= 1e-12)
}

# Tests  41.1-.3
# Test computation of test estimates, statistic, p value
test <- 41
if (test %in% runRCTvalidateTests) {
	testLbls <- c(testLbls,paste(test,1:3,sep="."))
	dsnName <- "PocSymm4 B"
	J <- 4
	P <- 0.5
	alpha <- 0.025
	beta <- 0.975
	p0 <- 0.3
	fn <- paste(RCTvalidateOutputDirname,"test",substring(format(10000+test-25),2),sep="")
	dsnfn <- paste(fn,"dsn",sep="")
	rfn <- paste(fn,"rSeq",sep="")
	z <- seqDesign ("prop", arms=2, sample.size=200, null.hypothesis=p0, nbr.analyses=J,alpha=alpha,beta=beta,P=P,suppressErrors=T,EPSILON=1e-8)
	zz <- z
	zz$call <- NULL
	if(!file.exists(dsnfn)) {
		dput(zz,file=dsnfn)
	}
	check <- all.equal(z,dget(file=dsnfn))
	############## test rslt 41.1     #################
	rslt <- c(rslt,ifelse1(is.logical(check),check,F))
	set.seed(test-25)
	zr <- rSeq(100, z, theta=-0.2, sufficient=F, returnData=T)
	tmp <- matrix(0,100,3)
	for (i in 1:100) {
		m <- cbind(c(sum(zr$Data.Tx[,i]==1,na.rm=T),sum(zr$Data.Ctrl[,i]==1,na.rm=T)),
			c(sum(zr$Data.Tx[,i]==0,na.rm=T),sum(zr$Data.Ctrl[,i]==0,na.rm=T)))
		zx <- chisq.test(m,correct=F)
		zt <- prop.test(m,correct=F,alternative="greater") 
		tmp[i,] <- c(-diff(zt$estimate),zt$p.value,zx$p.value/2)
	}
	if(!file.exists(rfn)) {
		dput(zr,file=rfn)
	}
	check <- all.equal(zr,dget(file=rfn))
	############## test rslt 41.2     #################
	rslt <- c(rslt,ifelse1(is.logical(check),check,F))
	############## test rslt 41.3     #################
	rslt <- c(rslt,max(abs(tmp - cbind(zr$thetaHat,zr$Pstat,ifelse(zr$thetaHat<0,1-zr$Pstat,zr$Pstat)))) <= 1e-12)
}

if (is.null(rslt)) {cat("     ",TestName,": No tests performed\n")
} else if (all(rslt)) {cat("     ",TestName,": All",length(rslt),"tests  PASS\n")
} else cat("     ",TestName,": failing test numbers ", testLbls[!rslt],"\n")

rm(FileName,TestName,Dirname, RCTvalidateOutputDirname,runRCTvalidateTests,rslt,check,z,zz,zr,dsnName,J,P,alpha,beta,test,fn,dsnfn,rfn,vrsn,tmp)