AbstractRClientTest (baseCode 1.1.18 Test API)

java.lang.Object
- ubic.basecode.util.r.AbstractRClientTest

Direct Known Subclasses:

JRIClientTest, RServeClientTest
```
public abstract class AbstractRClientTest
extends Object
```
Author:

Paul

Field Summary

Fields
Modifier and Type Field and Description

protected static org.slf4j.Logger log

Fields
Modifier and Type	Field and Description
`protected static org.slf4j.Logger`	`log`

Constructor Summary

Constructors
Constructor and Description

AbstractRClientTest()

Constructors
Constructor and Description
`AbstractRClientTest()`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`testAnovaA()`
`void`	`testAnovaB()`
`void`	`testAnovaC()`
`void`	`testAnovaD()`
`void`	`testAnovaE()`
`void`	`testAnovaF()` One way @
`void`	`testAssignAndRetrieveMatrix()`
`void`	`testAssignAndRetrieveMatrixB()`
`void`	`testAssignAndRetrieveMatrixC()`
`void`	`testAssignAndRetrieveMatrixD()`
`void`	`testAssignStringList()`
`void`	`testDataFrameA()`
`void`	`testDoubleArrayTwoDoubleArrayEval()`
`void`	`testDoubleTwoDoubleArrayEval()`
`void`	`testExec()`
`void`	`testExecDoubleArray()`
`void`	`testExecError()`
`void`	`testFactorAssign()`
`void`	`testFindExecutable()`
`void`	`testLimmaA()` Also exercises dataFrameEval
`void`	`testLinearModelA()` Like a two-sample t-test where the intercept is also of interest.
`void`	`testLinearModelB()` With a continuous covariate as well a categorical one.
`void`	`testLinearModelC()`
`void`	`testLinearModelD()` Basically a one-way anova with 4 levels in the factor.
`void`	`testListEvalA()`
`void`	`testListEvalB()`
`void`	`testLoadLibrary()`
`void`	`testLoadScript()`
`void`	`testStringListEval()`
`void`	`testStringListEvalB()`
`void`	`testTTest()`
`void`	`testTTestFail()`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail
- log
```
protected static org.slf4j.Logger log
```

Constructor Detail
- AbstractRClientTest
```
public AbstractRClientTest()
```

Method Detail

testAnovaA
```
public void testAnovaA()
```

testAnovaB
```
public void testAnovaB()
```

testAnovaC
```
public void testAnovaC()
```

testAnovaD
```
public void testAnovaD()
```

testAnovaE
```
public void testAnovaE()
```

testAnovaF
```
public void testAnovaF()
```
One way @

testAssignAndRetrieveMatrix

public void testAssignAndRetrieveMatrix()

testAssignAndRetrieveMatrixB

public void testAssignAndRetrieveMatrixB()

testAssignAndRetrieveMatrixC

public void testAssignAndRetrieveMatrixC()

testAssignAndRetrieveMatrixD

public void testAssignAndRetrieveMatrixD()

testAssignStringList
```
public void testAssignStringList()
```

testDataFrameA
```
public void testDataFrameA()
```

testDoubleArrayTwoDoubleArrayEval

public void testDoubleArrayTwoDoubleArrayEval()

testDoubleTwoDoubleArrayEval

public void testDoubleTwoDoubleArrayEval()

testExec
```
public void testExec()
```

testExecDoubleArray
```
public void testExecDoubleArray()
```

testExecError
```
public void testExecError()
```

testFactorAssign
```
public void testFactorAssign()
```

testFindExecutable

public void testFindExecutable()
                        throws Exception

Throws:: Exception

testLimmaA

public void testLimmaA()
                throws Exception

Also exercises dataFrameEval

 library(limma)
 
 dat<-read.table("data/testdata.txt", header=T, row.names=1)
 
 f1<-factor(c("A", "A", "A", "A", "A", "A", "B", "B", "B", "B", "B", "B"));
 
 f2<-factor(c("X", "X", "Y", "Y", "Z", "Z", "X", "X", "Y", "Y", "Z", "Z"));
 
 cov1<-c( -0.230 , 1.400, -0.210, 0.570, -0.064, 0.980 ,-0.082, -0.094, 0.630, -2.000, 0.640, -0.870);
 
 mo<-model.matrix(˜ f1 + f2 + cov1 - 1);
 
 contr<-makeContrasts(A-B, levels=mo);
 
 fit<-lmFit(dat, mo);
 
 fit<-contrasts.fit(fit, contr);
 
 fit<-eBayes(fit)
 
 res<-topTable(fit)

Throws:: Exception

testLinearModelA
```
public void testLinearModelA()
```
Like a two-sample t-test where the intercept is also of interest. @

testLinearModelB
```
public void testLinearModelB()
```
With a continuous covariate as well a categorical one. @

testLinearModelC
```
public void testLinearModelC()
```

testLinearModelD
```
public void testLinearModelD()
```
Basically a one-way anova with 4 levels in the factor. @

testListEvalA

public void testListEvalA()
                   throws Exception

Throws:: Exception

testListEvalB

public void testListEvalB()
                   throws Exception

Throws:: Exception

testLoadLibrary
```
public void testLoadLibrary()
```

testLoadScript

public void testLoadScript()
                    throws Exception

Throws:: Exception

testStringListEval
```
public void testStringListEval()
```

testStringListEvalB
```
public void testStringListEvalB()
```

testTTest
```
public void testTTest()
```

testTTestFail
```
public void testTTestFail()
```

Class AbstractRClientTest

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

log

Constructor Detail

AbstractRClientTest

Method Detail

testAnovaA

testAnovaB

testAnovaC

testAnovaD

testAnovaE

testAnovaF

testAssignAndRetrieveMatrix

testAssignAndRetrieveMatrixB

testAssignAndRetrieveMatrixC

testAssignAndRetrieveMatrixD

testAssignStringList

testDataFrameA

testDoubleArrayTwoDoubleArrayEval

testDoubleTwoDoubleArrayEval

testExec

testExecDoubleArray

testExecError

testFactorAssign

testFindExecutable

testLimmaA

testLinearModelA

testLinearModelB

testLinearModelC

testLinearModelD

testListEvalA

testListEvalB

testLoadLibrary

testLoadScript

testStringListEval

testStringListEvalB

testTTest

testTTestFail