File AlignCaclManager2Test.java

Branches:

Statements:

159

Methods:

Classes:

LOC:

377

NCLOC:

325

Total complexity:

Complexity density:

0.24

Statements/Method:

5.13

Methods/Class:

15.5

Average method complexity:

1.23

Classes

Class	Line #	Total Statements	Complexity	TOTAL Coverage	Actions
AlignCaclManager2Test	27	142	21	0.00%
AlignCalcWorkerMock	300	17	17	0.00%

Class AlignCaclManager2Test

Class AlignCaclManager2Test	Line # 27	Total Statements 142	Complexity 21	TOTAL Coverage 0.00%
setUpClass() : void setUpClass() : void	3333	2.02	1.01	0.0 0.00%
setUp() : void setUp() : void	4040	4.04	1.01	0.0 0.00%
tearDown() : void tearDown() : void	5050	1.01	1.01	0.0 0.00%
testStartRegisteredWorker() : void testStartRegisteredWorker() : void	5858	6.06	1.01	0.0 0.00%
testIsWorking() : void testIsWorking() : void	6969	9.09	1.01	0.0 0.00%
testIsWorkingWithAnnotation() : void testIsWorkingWithAnnotation() : void	8383	10.010	1.01	0.0 0.00%
testRestartCompletedWorkers() : void testRestartCompletedWorkers() : void	9898	11.011	1.01	0.0 0.00%
testRestartCancelsWorkers() : void testRestartCancelsWorkers() : void	114114	11.011	1.01	0.0 0.00%
testDisableWorker() : void testDisableWorker() : void	132132	6.06	1.01	0.0 0.00%
testRestartDisabledWorker() : void testRestartDisabledWorker() : void	143143	12.012	1.01	0.0 0.00%
testCancelWorker() : void testCancelWorker() : void	162162	6.06	1.01	0.0 0.00%
testStartOneShotWorker() : void testStartOneShotWorker() : void	175175	5.05	1.01	0.0 0.00%
testCancelOneShotWorker() : void testCancelOneShotWorker() : void	185185	6.06	1.01	0.0 0.00%
restartOneShotWorker() : void restartOneShotWorker() : void	196196	7.07	1.01	0.0 0.00%
testGetWorkersOfClass() : void testGetWorkersOfClass() : void	212212	9.09	1.01	0.0 0.00%
testRemoveWorker() : void testRemoveWorker() : void	229229	4.04	1.01	0.0 0.00%
testRemoveWorkersOfClass() : void testRemoveWorkersOfClass() : void	238238	9.09	1.01	0.0 0.00%
testRemoveWorkersForAnnotation() : void testRemoveWorkersForAnnotation() : void	253253	9.09	1.01	0.0 0.00%
testRemoveNonRemovableWorker() : void testRemoveNonRemovableWorker() : void	267267	5.05	1.01	0.0 0.00%
testRemoveNonRemovableWorkersOfClass() : void testRemoveNonRemovableWorkersOfClass() : void	277277	9.09	1.01	0.0 0.00%
newAlignmentAnnotation() : AlignmentAnnotation newAlignmentAnnotation() : AlignmentAnnotation	293293	1.01	1.01	0.0 0.00%

Class AlignCalcWorkerMock

Class AlignCalcWorkerMock	Line # 300	Total Statements 17	Complexity 17	TOTAL Coverage 0.00%
AlignCalcWorkerMock(Future<?>) AlignCalcWorkerMock(Future<?>)	308308	1.01	1.01	0.0 0.00%
getLastResult() : Object getLastResult() : Object	313313	1.01	2.02	0.0 0.00%
getException() : Throwable getException() : Throwable	318318	2.02	2.02	0.0 0.00%
getCallCount() : int getCallCount() : int	324324	1.01	1.01	0.0 0.00%
wasCancelled() : boolean wasCancelled() : boolean	328328	1.01	1.01	0.0 0.00%
involves(AlignmentAnnotation) : boolean involves(AlignmentAnnotation) : boolean	333333	3.03	2.02	0.0 0.00%
updateAnnotation() : void updateAnnotation() : void	342342	0.00	1.01	-1.0 -1.0 -
removeAnnotation() : void removeAnnotation() : void	347347	0.00	1.01	-1.0 -1.0 -
run() : void run() : void	352352	7.07	5.05	0.0 0.00%
isDeletable() : boolean isDeletable() : boolean	372372	1.01	1.01	0.0 0.00%

Contributing tests

No tests hitting this source file were found.

Source view

package jalview.workers;

import static org.testng.Assert.*;

import java.util.ArrayList;

import java.util.concurrent.CancellationException;

import java.util.concurrent.CompletableFuture;

import java.util.concurrent.ExecutionException;

import java.util.concurrent.Future;

import org.testng.annotations.AfterMethod;

import org.testng.annotations.BeforeClass;

import org.testng.annotations.BeforeMethod;

import org.testng.annotations.Test;

import jalview.api.AlignCalcManagerI2;

import jalview.api.AlignCalcWorkerI;

import jalview.datamodel.Alignment;

import jalview.datamodel.AlignmentAnnotation;

import jalview.datamodel.AlignmentI;

import jalview.datamodel.Annotation;

import jalview.datamodel.Sequence;

import jalview.datamodel.SequenceI;

import jalview.gui.AlignFrame;

import jalview.gui.JvOptionPane;

@Test(singleThreaded = true)

public class AlignCaclManager2Test

{

AlignFrame alignFrame;

AlignCalcManagerI2 calcManager;

@BeforeClass(alwaysRun = true)

public void setUpClass()

{

JvOptionPane.setInteractiveMode(false);

JvOptionPane.setMockResponse(JvOptionPane.CANCEL_OPTION);

}

@BeforeMethod(alwaysRun = true)

public void setUp()

{

AlignmentI al = new Alignment(

new SequenceI[] { new Sequence("Seq1", "ABC") });

al.setDataset(null);

alignFrame = new AlignFrame(al, 3, 1);

calcManager = alignFrame.getViewport().getCalcManager();

}

@AfterMethod(alwaysRun = true)

public void tearDown()

{

calcManager.shutdown();

}

// Running workers

@Test(groups = "Functional")

public void testStartRegisteredWorker() throws InterruptedException

{

var sentinel = new Object();

var job = CompletableFuture.completedFuture(sentinel);

var worker = new AlignCalcWorkerMock(job);

calcManager.registerWorker(worker);

Thread.sleep(10);

assertSame(worker.getLastResult(), sentinel);

}

@Test(groups = "Functional")

public void testIsWorking() throws InterruptedException

{

var job = new CompletableFuture<Object>();

var worker = new AlignCalcWorkerMock(job);

calcManager.registerWorker(worker);

assertTrue(calcManager.isWorking(worker));

assertTrue(calcManager.isWorking());

job.complete(null);

Thread.sleep(10);

assertFalse(calcManager.isWorking(worker));

assertFalse(calcManager.isWorking());

}

@Test(groups = "Functional")

public void testIsWorkingWithAnnotation() throws InterruptedException

{

var job = new CompletableFuture<Void>();

var worker1 = new AlignCalcWorkerMock(job);

var annot = worker1.annotation = newAlignmentAnnotation();

var otherAnnot = newAlignmentAnnotation();

calcManager.registerWorker(worker1);

assertTrue(calcManager.isWorkingWithAnnotation(annot));

assertFalse(calcManager.isWorkingWithAnnotation(otherAnnot));

job.complete(null);

Thread.sleep(10);

assertFalse(calcManager.isWorkingWithAnnotation(annot));

}

@Test(groups = "Functional")

public void testRestartCompletedWorkers() throws Throwable

100

{

101

var sentinel1 = new Object();

102

var sentinel2 = new Object();

103

var job = CompletableFuture.completedFuture(sentinel1);

104

var worker = new AlignCalcWorkerMock(job);

105

calcManager.registerWorker(worker);

106

Thread.sleep(10);

107

assertSame(worker.getLastResult(), sentinel1);

108

job.obtrudeValue(sentinel2);

109

calcManager.restartWorkers();

110

Thread.sleep(10);

111

assertSame(worker.getLastResult(), sentinel2);

112

}

113

114

@Test(groups = "Functional")

115

public void testRestartCancelsWorkers() throws Throwable

116

{

117

var job = new CompletableFuture<Object>();

118

var worker = new AlignCalcWorkerMock(job);

119

var sentinel = new Object();

120

calcManager.registerWorker(worker);

121

Thread.sleep(10);

122

calcManager.restartWorkers();

123

Thread.sleep(10);

124

assertTrue(worker.wasCancelled());

125

job.obtrudeValue(sentinel);

126

Thread.sleep(10);

127

assertSame(worker.getLastResult(), sentinel);

}

// Disabling workers

@Test(groups = "Functional")

133

public void testDisableWorker()

134

{

135

var worker = new AlignCalcWorkerMock(null);

136

calcManager.registerWorker(worker);

137

calcManager.disableWorker(worker);

138

assertTrue(calcManager.isDisabled(worker));

139

calcManager.enableWorker(worker);

140

assertFalse(calcManager.isDisabled(worker));

141

}

142

143

@Test(groups = "Functional")

144

public void testRestartDisabledWorker() throws InterruptedException

145

{

146

var worker = new AlignCalcWorkerMock(null);

147

calcManager.registerWorker(worker);

148

Thread.sleep(10);

149

assertEquals(worker.getCallCount(), 1);

150

calcManager.disableWorker(worker);

151

calcManager.restartWorkers();

152

Thread.sleep(10);

153

assertEquals(worker.getCallCount(), 1);

154

calcManager.enableWorker(worker);

155

calcManager.restartWorkers();

156

Thread.sleep(10);

157

assertEquals(worker.getCallCount(), 2);

}

// Canceling workers

@Test(groups = "Functional")

163

public void testCancelWorker() throws InterruptedException

164

{

165

var worker = new AlignCalcWorkerMock(new CompletableFuture<>());

166

calcManager.registerWorker(worker);

167

Thread.sleep(10);

168

calcManager.cancelWorker(worker);

169

Thread.sleep(10);

170

assertTrue(worker.wasCancelled());

}

// One-shot workers

@Test(groups = "Functional")

176

public void testStartOneShotWorker() throws InterruptedException

177

{

178

var job = CompletableFuture.completedFuture("result");

179

var worker = new AlignCalcWorkerMock(job);

180

calcManager.startWorker(worker);

181

Thread.sleep(10);

182

assertEquals(worker.getLastResult(), "result");

183

}

184

185

@Test(groups = "Functional")

186

public void testCancelOneShotWorker() throws InterruptedException

187

{

188

var worker = new AlignCalcWorkerMock(new CompletableFuture<>());

189

calcManager.startWorker(worker);

190

Thread.sleep(10);

191

calcManager.cancelWorker(worker);

192

Thread.sleep(10);

193

assertTrue(worker.wasCancelled());

194

}

195

196

@Test(groups = "Functional")

197

public void restartOneShotWorker() throws InterruptedException

198

{

199

var job = CompletableFuture.completedFuture("result1");

200

var worker = new AlignCalcWorkerMock(job);

201

calcManager.startWorker(worker);

202

Thread.sleep(10);

203

job.obtrudeValue("result2");

204

calcManager.restartWorkers();

Thread.sleep(10);

}

// Retrieving workers

211

212

@Test(groups = "Functional")

213

public void testGetWorkersOfClass() throws InterruptedException

214

{

215

var worker1 = new AlignCalcWorkerMock(null);

216

var worker2 = new AlignCalcWorkerMock(null);

217

var worker3 = new AlignCalcWorkerMock(null) {};

218

calcManager.registerWorker(worker1);

219

calcManager.registerWorker(worker2);

220

calcManager.registerWorker(worker3);

221

final var workers = calcManager

222

.getWorkersOfClass(AlignCalcWorkerMock.class);

223

assertTrue(workers.contains(worker1) && workers.contains(worker2));

224

assertFalse(workers.contains(worker3));

}

// Removing workers

@Test(groups = "Functional")

230

public void testRemoveWorker()

231

{

232

var worker = new AlignCalcWorkerMock(null);

233

calcManager.registerWorker(worker);

234

calcManager.removeWorker(worker);

235

assertFalse(calcManager.getWorkers().contains(worker));

236

}

237

238

@Test(groups = "Functional")

239

public void testRemoveWorkersOfClass()

240

{

241

var worker1 = new AlignCalcWorkerMock(null);

242

var worker2 = new AlignCalcWorkerMock(null);

243

var worker3 = new AlignCalcWorkerMock(null) {};

244

calcManager.registerWorker(worker1);

245

calcManager.registerWorker(worker2);

246

calcManager.registerWorker(worker3);

247

calcManager.removeWorkersOfClass(worker1.getClass());

248

assertFalse(calcManager.getWorkers().contains(worker1)

249

|| calcManager.getWorkers().contains(worker2));

250

assertTrue(calcManager.getWorkers().contains(worker3));

251

}

252

253

@Test(groups = "Functional")

254

public void testRemoveWorkersForAnnotation()

255

{

256

var worker1 = new AlignCalcWorkerMock(null);

257

var worker2 = new AlignCalcWorkerMock(null);

258

var annot = worker1.annotation = newAlignmentAnnotation();

259

calcManager.registerWorker(worker1);

260

calcManager.registerWorker(worker2);

261

calcManager.removeWorkerForAnnotation(annot);

262

var workers = calcManager.getWorkers();

263

assertFalse(workers.contains(worker1));

264

assertTrue(workers.contains(worker2));

265

}

266

267

@Test(groups = "Functional")

268

public void testRemoveNonRemovableWorker()

269

{

270

var worker = new AlignCalcWorkerMock(null);

271

worker.deletable = false;

272

calcManager.registerWorker(worker);

273

calcManager.removeWorker(worker);

274

assertTrue(calcManager.getWorkers().contains(worker));

275

}

276

277

@Test(groups = "Functional")

278

public void testRemoveNonRemovableWorkersOfClass()

279

{

280

var worker1 = new AlignCalcWorkerMock(null);

281

var worker2 = new AlignCalcWorkerMock(null);

282

worker2.deletable = false;

283

calcManager.registerWorker(worker1);

284

calcManager.registerWorker(worker2);

285

calcManager.removeWorkersOfClass(worker1.getClass());

286

var workers = calcManager.getWorkers();

287

assertFalse(workers.contains(worker1));

288

assertTrue(workers.contains(worker2));

289

}

290

291

private int annotationCount = 0;

292

293

private AlignmentAnnotation newAlignmentAnnotation()

294

{

295

return new AlignmentAnnotation("Ann" + annotationCount++, "description",

296

new Annotation[] {});

}

}

class AlignCalcWorkerMock implements AlignCalcWorkerI

301

{

302

AlignmentAnnotation annotation = null;

303

Future<?> job;

304

ArrayList<Object> values = new ArrayList<>();

305

int callCount = 0;

306

boolean deletable = true;

307

308

AlignCalcWorkerMock(Future<?> job)

{

this.job = job;

}

public Object getLastResult()

314

{

315

return values.isEmpty() ? null : values.get(values.size() - 1);

316

}

317

318

public Throwable getException()

319

{

320

var result = getLastResult();

321

return (result instanceof Throwable) ? (Throwable) result : null;

322

}

323

324

public int getCallCount() {

return callCount;

}

public boolean wasCancelled()

329

{

330

return getException() instanceof InterruptedException;

}

@Override

public boolean involves(AlignmentAnnotation annot)

335

{

336

if (annotation == null)

337

return false;

338

else

339

return annot == annotation;

}

@Override

public void updateAnnotation()

{

}

@Override

public void removeAnnotation()

{

}

@Override

public void run() throws Throwable

{

callCount++;

if (job != null)

{

try

{

values.add(job.get());

361

}

362

catch (InterruptedException e) { values.add(e); }

363

catch (CancellationException e) {

364

values.add(new InterruptedException());

365

} catch (ExecutionException e)

366

{

367

values.add(e.getCause());

}

}

}

@Override

public boolean isDeletable()

{

return deletable;

}

}

Coverage Report

File AlignCaclManager2Test.java

Code metrics

Classes

Class AlignCaclManager2Test

Class AlignCalcWorkerMock

Contributing tests

Source view