File AAFrequencyTest.java

Branches:

Statements:

192

Methods:

Classes:

LOC:

415

NCLOC:

261

Total complexity:

Complexity density:

0.06

Statements/Method:

19.2

Methods/Class:

Average method complexity:

1.1

Classes

Class	Line #	Total Statements	Complexity	TOTAL Coverage	Actions
AAFrequencyTest	41	192	11	0.926470692.6%

Class AAFrequencyTest

Class AAFrequencyTest	Line # 41	Total Statements 192	Complexity 11	TOTAL Coverage 0.926470692.6%
setUpJvOptionPane() : void setUpJvOptionPane() : void	4444	2.02	1.01	1.0 1.0100%
testCalculate_noProfile() : void testCalculate_noProfile() : void	5151	33.033	1.01	1.0 1.0100%
testCalculate_withProfile() : void testCalculate_withProfile() : void	9999	25.025	1.01	1.0 1.0100%
testCalculate_withProfileTiming() : void testCalculate_withProfileTiming() : void	133133	12.012	2.02	0.0 0.00%
testCompleteConsensus_includeGaps_showLogo() : void testCompleteConsensus_includeGaps_showLogo() : void	161161	24.024	1.01	1.0 1.0100%
testCompleteConsensus_ignoreGaps_noLogo() : void testCompleteConsensus_ignoreGaps_noLogo() : void	202202	24.024	1.01	1.0 1.0100%
testExtractProfile() : void testExtractProfile() : void	241241	16.016	1.01	1.0 1.0100%
testExtractProfile_countGaps() : void testExtractProfile_countGaps() : void	285285	16.016	1.01	1.0 1.0100%
testExtractCdnaProfile() : void testExtractCdnaProfile() : void	326326	20.020	1.01	1.0 1.0100%
testExtractCdnaProfile_countGaps() : void testExtractCdnaProfile_countGaps() : void	371371	20.020	1.01	1.0 1.0100%

Contributing tests

This file is covered by 8 tests. .

Contributing tests

Test contribution	Test	Result
0.16666667	jalview.analysis.AAFrequencyTest.testCalculate_noProfilejalview.analysis.AAFrequencyTest.testCalculate_noProfile	1PASS
0.12745099	jalview.analysis.AAFrequencyTest.testCalculate_withProfilejalview.analysis.AAFrequencyTest.testCalculate_withProfile	1PASS
0.12254902	jalview.analysis.AAFrequencyTest.testCompleteConsensus_includeGaps_showLogojalview.analysis.AAFrequencyTest.testCompleteConsensus_includeGaps_showLogo	1PASS
0.12254902	jalview.analysis.AAFrequencyTest.testCompleteConsensus_ignoreGaps_noLogojalview.analysis.AAFrequencyTest.testCompleteConsensus_ignoreGaps_noLogo	1PASS
0.10294118	jalview.analysis.AAFrequencyTest.testExtractCdnaProfile_countGapsjalview.analysis.AAFrequencyTest.testExtractCdnaProfile_countGaps	1PASS
0.10294118	jalview.analysis.AAFrequencyTest.testExtractCdnaProfilejalview.analysis.AAFrequencyTest.testExtractCdnaProfile	1PASS
0.083333336	jalview.analysis.AAFrequencyTest.testExtractProfile_countGapsjalview.analysis.AAFrequencyTest.testExtractProfile_countGaps	1PASS
0.083333336	jalview.analysis.AAFrequencyTest.testExtractProfilejalview.analysis.AAFrequencyTest.testExtractProfile	1PASS

Source view

* Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)

* Copyright (C) $$Year-Rel$$ The Jalview Authors

* This file is part of Jalview.

* Jalview is free software: you can redistribute it and/or

* modify it under the terms of the GNU General Public License

* as published by the Free Software Foundation, either version 3

* of the License, or (at your option) any later version.

* Jalview is distributed in the hope that it will be useful, but

* WITHOUT ANY WARRANTY; without even the implied warranty

* of MERCHANTABILITY or FITNESS FOR A PARTICULAR

* PURPOSE. See the GNU General Public License for more details.

* You should have received a copy of the GNU General Public License

* along with Jalview. If not, see <http://www.gnu.org/licenses/>.

* The Jalview Authors are detailed in the 'AUTHORS' file.

package jalview.analysis;

import static org.testng.AssertJUnit.assertEquals;

import static org.testng.AssertJUnit.assertNull;

import jalview.datamodel.AlignmentAnnotation;

import jalview.datamodel.Annotation;

import jalview.datamodel.Profile;

import jalview.datamodel.ProfileI;

import jalview.datamodel.ProfilesI;

import jalview.datamodel.ResidueCount;

import jalview.datamodel.Sequence;

import jalview.datamodel.SequenceI;

import jalview.gui.JvOptionPane;

import java.util.Hashtable;

import org.testng.annotations.BeforeClass;

import org.testng.annotations.Test;

public class AAFrequencyTest

{

@BeforeClass(alwaysRun = true)

public void setUpJvOptionPane()

{

JvOptionPane.setInteractiveMode(false);

JvOptionPane.setMockResponse(JvOptionPane.CANCEL_OPTION);

}

@Test(groups = { "Functional" })

public void testCalculate_noProfile()

{

SequenceI seq1 = new Sequence("Seq1", "CAG-T");

SequenceI seq2 = new Sequence("Seq2", "CAC-T");

SequenceI seq3 = new Sequence("Seq3", "C---G");

SequenceI seq4 = new Sequence("Seq4", "CA--t");

SequenceI[] seqs = new SequenceI[] { seq1, seq2, seq3, seq4 };

int width = seq1.getLength();

ProfilesI result = AAFrequency.calculate(seqs, width, 0, width, false);

// col 0 is 100% C

ProfileI col = result.get(0);

assertEquals(100f, col.getPercentageIdentity(false));

assertEquals(100f, col.getPercentageIdentity(true));

assertEquals(4, col.getMaxCount());

assertEquals("C", col.getModalResidue());

assertNull(col.getCounts());

// col 1 is 75% A

col = result.get(1);

assertEquals(75f, col.getPercentageIdentity(false));

assertEquals(100f, col.getPercentageIdentity(true));

assertEquals(3, col.getMaxCount());

assertEquals("A", col.getModalResidue());

// col 2 is 50% G 50% C or 25/25 counting gaps

col = result.get(2);

assertEquals(25f, col.getPercentageIdentity(false));

assertEquals(50f, col.getPercentageIdentity(true));

assertEquals(1, col.getMaxCount());

assertEquals("CG", col.getModalResidue());

// col 3 is all gaps

col = result.get(3);

assertEquals(0f, col.getPercentageIdentity(false));

assertEquals(0f, col.getPercentageIdentity(true));

assertEquals(0, col.getMaxCount());

assertEquals("", col.getModalResidue());

// col 4 is 75% T 25% G

col = result.get(4);

assertEquals(75f, col.getPercentageIdentity(false));

assertEquals(75f, col.getPercentageIdentity(true));

assertEquals(3, col.getMaxCount());

assertEquals("T", col.getModalResidue());

}

@Test(groups = { "Functional" })

100

public void testCalculate_withProfile()

101

{

102

SequenceI seq1 = new Sequence("Seq1", "CAGT");

103

SequenceI seq2 = new Sequence("Seq2", "CACT");

104

SequenceI seq3 = new Sequence("Seq3", "C--G");

105

SequenceI seq4 = new Sequence("Seq4", "CA-t");

106

SequenceI[] seqs = new SequenceI[] { seq1, seq2, seq3, seq4 };

107

int width = seq1.getLength();

108

ProfilesI result = AAFrequency.calculate(seqs, width, 0, width, true);

109

110

ProfileI profile = result.get(0);

111

assertEquals(4, profile.getCounts().getCount('C'));

112

assertEquals(4, profile.getHeight());

113

assertEquals(4, profile.getNonGapped());

114

115

profile = result.get(1);

116

assertEquals(3, profile.getCounts().getCount('A'));

117

assertEquals(4, profile.getHeight());

118

assertEquals(3, profile.getNonGapped());

119

120

profile = result.get(2);

121

assertEquals(1, profile.getCounts().getCount('C'));

122

assertEquals(1, profile.getCounts().getCount('G'));

123

assertEquals(4, profile.getHeight());

124

assertEquals(2, profile.getNonGapped());

125

126

profile = result.get(3);

127

assertEquals(3, profile.getCounts().getCount('T'));

128

assertEquals(1, profile.getCounts().getCount('G'));

129

assertEquals(4, profile.getHeight());

130

assertEquals(4, profile.getNonGapped());

131

}

132

133

@Test(groups = { "Functional" }, enabled = false)

134

public void testCalculate_withProfileTiming()

135

{

136

SequenceI seq1 = new Sequence("Seq1", "CAGT");

137

SequenceI seq2 = new Sequence("Seq2", "CACT");

138

SequenceI seq3 = new Sequence("Seq3", "C--G");

139

SequenceI seq4 = new Sequence("Seq4", "CA-t");

140

SequenceI[] seqs = new SequenceI[] { seq1, seq2, seq3, seq4 };

141

142

// ensure class loaded and initialised

143

int width = seq1.getLength();

144

AAFrequency.calculate(seqs, width, 0, width, true);

145

146

int reps = 100000;

147

long start = System.currentTimeMillis();

148

for (int i = 0; i < reps; i++)

149

{

150

AAFrequency.calculate(seqs, width, 0, width, true);

151

}

152

System.out.println(System.currentTimeMillis() - start);

}

/**

* Test generation of consensus annotation with options 'include gaps'

157

* (profile percentages are of all sequences, whether gapped or not), and

158

* 'show logo' (the full profile with all residue percentages is reported in

159

* the description for the tooltip)

160

161

@Test(groups = { "Functional" })

162

public void testCompleteConsensus_includeGaps_showLogo()

163

{

164

165

* first compute the profiles

166

167

SequenceI seq1 = new Sequence("Seq1", "CAG-T");

168

SequenceI seq2 = new Sequence("Seq2", "CAC-T");

169

SequenceI seq3 = new Sequence("Seq3", "C---G");

170

SequenceI seq4 = new Sequence("Seq4", "CA--t");

171

SequenceI[] seqs = new SequenceI[] { seq1, seq2, seq3, seq4 };

172

int width = seq1.getLength();

173

ProfilesI profiles = AAFrequency.calculate(seqs, width, 0, width, true);

174

175

AlignmentAnnotation consensus = new AlignmentAnnotation("Consensus",

176

"PID", new Annotation[width]);

177

AAFrequency.completeConsensus(consensus, profiles, 0, 5, false, true,

178

4);

179

180

Annotation ann = consensus.annotations[0];

181

assertEquals("C 100%", ann.description);

182

assertEquals("C", ann.displayCharacter);

183

ann = consensus.annotations[1];

184

assertEquals("A 75%", ann.description);

185

assertEquals("A", ann.displayCharacter);

186

ann = consensus.annotations[2];

187

assertEquals("C 25%; G 25%", ann.description);

188

assertEquals("+", ann.displayCharacter);

189

ann = consensus.annotations[3];

190

assertEquals("", ann.description);

191

assertEquals("-", ann.displayCharacter);

192

ann = consensus.annotations[4];

193

assertEquals("T 75%; G 25%", ann.description);

194

assertEquals("T", ann.displayCharacter);

}

/**

* Test generation of consensus annotation with options 'ignore gaps' (profile

199

* percentages are of the non-gapped sequences) and 'no logo' (only the modal

200

* residue[s] percentage is reported in the description for the tooltip)

201

202

@Test(groups = { "Functional" })

203

public void testCompleteConsensus_ignoreGaps_noLogo()

204

{

205

206

* first compute the profiles

207

208

SequenceI seq1 = new Sequence("Seq1", "CAG-T");

209

SequenceI seq2 = new Sequence("Seq2", "CAC-T");

210

SequenceI seq3 = new Sequence("Seq3", "C---G");

211

SequenceI seq4 = new Sequence("Seq4", "CA--t");

212

SequenceI[] seqs = new SequenceI[] { seq1, seq2, seq3, seq4 };

213

int width = seq1.getLength();

214

ProfilesI profiles = AAFrequency.calculate(seqs, width, 0, width, true);

215

216

AlignmentAnnotation consensus = new AlignmentAnnotation("Consensus",

217

"PID", new Annotation[width]);

218

AAFrequency.completeConsensus(consensus, profiles, 0, 5, true, false,

219

4);

220

221

Annotation ann = consensus.annotations[0];

222

assertEquals("C 100%", ann.description);

223

assertEquals("C", ann.displayCharacter);

224

ann = consensus.annotations[1];

225

assertEquals("A 100%", ann.description);

226

assertEquals("A", ann.displayCharacter);

227

ann = consensus.annotations[2];

228

assertEquals("[CG] 50%", ann.description);

229

assertEquals("+", ann.displayCharacter);

230

ann = consensus.annotations[3];

231

assertEquals("", ann.description);

232

assertEquals("-", ann.displayCharacter);

233

ann = consensus.annotations[4];

234

assertEquals("T 75%", ann.description);

235

assertEquals("T", ann.displayCharacter);

}

/**

* Test to include rounding down of a non-zero count to 0% (JAL-3202)

240

241

@Test(groups = { "Functional" })

242

public void testExtractProfile()

243

{

244

245

* 200 sequences of which 30 gapped (170 ungapped)

246

* max count 70 for modal residue 'G'

247

248

ProfileI profile = new Profile(200, 30, 70, "G");

249

ResidueCount counts = new ResidueCount();

counts.put('G', 70);

counts.put('R', 60);

counts.put('L', 38);

counts.put('H', 2);

profile.setCounts(counts);

255

256

257

* [0, noOfValues, totalPercent, char1, count1, ...]

258

* G: 70/170 = 41.2 = 41

259

* R: 60/170 = 35.3 = 35

260

* L: 38/170 = 22.3 = 22

261

* H: 2/170 = 1

262

* total (rounded) percentages = 99

263

264

int[] extracted = AAFrequency.extractProfile(profile, true);

265

int[] expected = new int[] { 0, 4, 99, 'G', 41, 'R', 35, 'L', 22, 'H',

266

1 };

267

org.testng.Assert.assertEquals(extracted, expected);

268

269

270

* add some counts of 1; these round down to 0% and should be discarded

271

272

counts.put('G', 68); // 68/170 = 40% exactly (percentages now total 98)

273

counts.put('Q', 1);

274

counts.put('K', 1);

275

extracted = AAFrequency.extractProfile(profile, true);

276

expected = new int[] { 0, 4, 98, 'G', 40, 'R', 35, 'L', 22, 'H', 1 };

277

org.testng.Assert.assertEquals(extracted, expected);

}

/**

* Tests for the profile calculation where gaps are included i.e. the

283

* denominator is the total number of sequences in the column

284

285

@Test(groups = { "Functional" })

286

public void testExtractProfile_countGaps()

287

{

288

289

* 200 sequences of which 30 gapped (170 ungapped)

290

* max count 70 for modal residue 'G'

291

292

ProfileI profile = new Profile(200, 30, 70, "G");

293

ResidueCount counts = new ResidueCount();

counts.put('G', 70);

counts.put('R', 60);

counts.put('L', 38);

counts.put('H', 2);

profile.setCounts(counts);

299

300

301

* [0, noOfValues, totalPercent, char1, count1, ...]

* G: 70/200 = 35%

* R: 60/200 = 30%

* L: 38/200 = 19%

* H: 2/200 = 1%

* total (rounded) percentages = 85

307

308

int[] extracted = AAFrequency.extractProfile(profile, false);

309

int[] expected = new int[] { AlignmentAnnotation.SEQUENCE_PROFILE, 4,

310

85, 'G', 35, 'R', 30, 'L', 19, 'H', 1 };

311

org.testng.Assert.assertEquals(extracted, expected);

312

313

314

* add some counts of 1; these round down to 0% and should be discarded

315

316

counts.put('G', 68); // 68/200 = 34%

317

counts.put('Q', 1);

318

counts.put('K', 1);

319

extracted = AAFrequency.extractProfile(profile, false);

320

expected = new int[] { AlignmentAnnotation.SEQUENCE_PROFILE, 4, 84, 'G',

321

34, 'R', 30, 'L', 19, 'H', 1 };

322

org.testng.Assert.assertEquals(extracted, expected);

}

@Test(groups = { "Functional" })

327

public void testExtractCdnaProfile()

328

{

329

330

* 200 sequences of which 30 gapped (170 ungapped)

331

* max count 70 for modal residue 'G'

332

333

Hashtable profile = new Hashtable();

334

335

336

* cdna profile is {seqCount, ungappedCount, codonCount1, ...codonCount64}

337

* where 1..64 positions correspond to encoded codons

338

* see CodingUtils.encodeCodon()

339

340

int[] codonCounts = new int[66];

341

char[] codon1 = new char[] { 'G', 'C', 'A' };

342

char[] codon2 = new char[] { 'c', 'C', 'A' };

343

char[] codon3 = new char[] { 't', 'g', 'A' };

344

char[] codon4 = new char[] { 'G', 'C', 't' };

345

int encoded1 = CodingUtils.encodeCodon(codon1);

346

int encoded2 = CodingUtils.encodeCodon(codon2);

347

int encoded3 = CodingUtils.encodeCodon(codon3);

348

int encoded4 = CodingUtils.encodeCodon(codon4);

349

codonCounts[2 + encoded1] = 30;

350

codonCounts[2 + encoded2] = 70;

351

codonCounts[2 + encoded3] = 9;

352

codonCounts[2 + encoded4] = 1;

353

codonCounts[0] = 120;

354

codonCounts[1] = 110;

355

profile.put(AAFrequency.PROFILE, codonCounts);

356

357

358

* [0, noOfValues, totalPercent, char1, count1, ...]

359

* codon1: 30/110 = 27.2 = 27%

360

* codon2: 70/110 = 63.6% = 63%

361

* codon3: 9/110 = 8.1% = 8%

362

* codon4: 1/110 = 0.9% = 0% should be discarded

363

* total (rounded) percentages = 98

364

365

int[] extracted = AAFrequency.extractCdnaProfile(profile, true);

366

int[] expected = new int[] { AlignmentAnnotation.CDNA_PROFILE, 3, 98,

367

encoded2, 63, encoded1, 27, encoded3, 8 };

368

org.testng.Assert.assertEquals(extracted, expected);

369

}

370

371

@Test(groups = { "Functional" })

372

public void testExtractCdnaProfile_countGaps()

373

{

374

375

* 200 sequences of which 30 gapped (170 ungapped)

376

* max count 70 for modal residue 'G'

377

378

Hashtable profile = new Hashtable();

379

380

381

* cdna profile is {seqCount, ungappedCount, codonCount1, ...codonCount64}

382

* where 1..64 positions correspond to encoded codons

383

* see CodingUtils.encodeCodon()

384

385

int[] codonCounts = new int[66];

386

char[] codon1 = new char[] { 'G', 'C', 'A' };

387

char[] codon2 = new char[] { 'c', 'C', 'A' };

388

char[] codon3 = new char[] { 't', 'g', 'A' };

389

char[] codon4 = new char[] { 'G', 'C', 't' };

390

int encoded1 = CodingUtils.encodeCodon(codon1);

391

int encoded2 = CodingUtils.encodeCodon(codon2);

392

int encoded3 = CodingUtils.encodeCodon(codon3);

393

int encoded4 = CodingUtils.encodeCodon(codon4);

394

codonCounts[2 + encoded1] = 30;

395

codonCounts[2 + encoded2] = 70;

396

codonCounts[2 + encoded3] = 9;

397

codonCounts[2 + encoded4] = 1;

398

codonCounts[0] = 120;

399

codonCounts[1] = 110;

400

profile.put(AAFrequency.PROFILE, codonCounts);

401

402

403

* [0, noOfValues, totalPercent, char1, count1, ...]

404

* codon1: 30/120 = 25%

405

* codon2: 70/120 = 58.3 = 58%

406

* codon3: 9/120 = 7.5 = 7%

407

* codon4: 1/120 = 0.8 = 0% should be discarded

408

* total (rounded) percentages = 90

409

410

int[] extracted = AAFrequency.extractCdnaProfile(profile, false);

411

int[] expected = new int[] { AlignmentAnnotation.CDNA_PROFILE, 3, 90,

412

encoded2, 58, encoded1, 25, encoded3, 7 };

413

org.testng.Assert.assertEquals(extracted, expected);

414

}

415

}

Coverage Report

File AAFrequencyTest.java

Code metrics

Classes

Class AAFrequencyTest

Contributing tests

Contributing tests

Source view