File ComparisonTest.java

Branches:

Statements:

123

Methods:

Classes:

LOC:

311

NCLOC:

216

Total complexity:

Complexity density:

0.09

Statements/Method:

11.18

Methods/Class:

Average method complexity:

Classes

Class	Line #	Total Statements	Complexity	TOTAL Coverage	Actions
ComparisonTest	36	123	11	1.0100%

Class ComparisonTest

Class ComparisonTest	Line # 36	Total Statements 123	Complexity 11	TOTAL Coverage 1.0100%
setUpJvOptionPane() : void setUpJvOptionPane() : void	3939	2.02	1.01	1.0 1.0100%
loadProperties() : void loadProperties() : void	4646	1.01	1.01	1.0 1.0100%
testIsGap() : void testIsGap() : void	5252	7.07	1.01	1.0 1.0100%
testIsNucleotide_sequences() : void testIsNucleotide_sequences() : void	6868	34.034	1.01	1.0 1.0100%
testPID_includingGaps() : void testPID_includingGaps() : void	149149	11.011	1.01	1.0 1.0100%
testIsNucleotide() : void testIsNucleotide() : void	178178	12.012	1.01	1.0 1.0100%
testIsNucleotideAmbiguity() : void testIsNucleotideAmbiguity() : void	195195	14.014	1.01	1.0 1.0100%
testPID_ungappedOnly() : void testPID_ungappedOnly() : void	217217	5.05	1.01	1.0 1.0100%
testIsNucleotideSequence() : void testIsNucleotideSequence() : void	244244	21.021	1.01	1.0 1.0100%
testIsSameResidue() : void testIsSameResidue() : void	281281	6.06	1.01	1.0 1.0100%
testNucleotideProportion() : void testNucleotideProportion() : void	293293	10.010	1.01	1.0 1.0100%

Contributing tests

This file is covered by 9 tests. .

Contributing tests

Test contribution	Test	Result
0.26119402	jalview.util.ComparisonTest.testIsNucleotide_sequencesjalview.util.ComparisonTest.testIsNucleotide_sequences	1PASS
0.1641791	jalview.util.ComparisonTest.testIsNucleotideSequencejalview.util.ComparisonTest.testIsNucleotideSequence	1PASS
0.1119403	jalview.util.ComparisonTest.testIsNucleotideAmbiguityjalview.util.ComparisonTest.testIsNucleotideAmbiguity	1PASS
0.09701493	jalview.util.ComparisonTest.testIsNucleotidejalview.util.ComparisonTest.testIsNucleotide	1PASS
0.08955224	jalview.util.ComparisonTest.testPID_includingGapsjalview.util.ComparisonTest.testPID_includingGaps	1PASS
0.08208955	jalview.util.ComparisonTest.testNucleotideProportionjalview.util.ComparisonTest.testNucleotideProportion	1PASS
0.05970149	jalview.util.ComparisonTest.testIsGapjalview.util.ComparisonTest.testIsGap	1PASS
0.052238807	jalview.util.ComparisonTest.testIsSameResiduejalview.util.ComparisonTest.testIsSameResidue	1PASS
0.04477612	jalview.util.ComparisonTest.testPID_ungappedOnlyjalview.util.ComparisonTest.testPID_ungappedOnly	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.util;

import static org.testng.AssertJUnit.assertEquals;

import static org.testng.AssertJUnit.assertFalse;

import static org.testng.AssertJUnit.assertTrue;

import org.testng.annotations.BeforeClass;

import org.testng.annotations.BeforeMethod;

import org.testng.annotations.Test;

import jalview.bin.Cache;

import jalview.datamodel.Sequence;

import jalview.datamodel.SequenceI;

import jalview.gui.JvOptionPane;

public class ComparisonTest

{

@BeforeClass(alwaysRun = true)

public void setUpJvOptionPane()

{

JvOptionPane.setInteractiveMode(false);

JvOptionPane.setMockResponse(JvOptionPane.CANCEL_OPTION);

}

@BeforeMethod(alwaysRun = true)

public void loadProperties()

{

Cache.loadProperties("test/jalview/util/comparisonTestProps.jvprops");

}

@Test(groups = { "Functional" })

public void testIsGap()

{

assertTrue(Comparison.isGap('-'));

assertTrue(Comparison.isGap('.'));

assertTrue(Comparison.isGap(' '));

assertFalse(Comparison.isGap('X'));

assertFalse(Comparison.isGap('x'));

assertFalse(Comparison.isGap('*'));

assertFalse(Comparison.isGap('G'));

}

/**

* Test for isNucleotide is that sequences in a dataset are more than 85%

* AGCTU. Test is not case-sensitive and ignores gaps.

@Test(groups = { "Functional" })

public void testIsNucleotide_sequences()

{

SequenceI seq = new Sequence("eightypercent+fivepercent", "agctuagcPV");

assertFalse(Comparison.isNucleotide(new SequenceI[] { seq }));

assertFalse(

Comparison.isNucleotide(new SequenceI[][]

{ new SequenceI[] { seq } }));

seq = new Sequence("eightyfivepercent+tenpercent",

"agctuagcgVagctuagcuVE");

assertFalse(Comparison.isNucleotide(new SequenceI[] { seq }));

seq = new Sequence(">nineyfivepercent+0percent",

"aagctuagcgEagctuagcua");

assertFalse(Comparison.isNucleotide(new SequenceI[] { seq }));

seq = new Sequence("nineyfivepercent+0percent", "agctuagcgEagctuagcua");

assertFalse(Comparison.isNucleotide(new SequenceI[] { seq }));

seq = new Sequence("nineyfivepercent+fivepercent",

"agctuagcgWagctuagcua");

assertTrue(Comparison.isNucleotide(new SequenceI[] { seq }));

seq = new Sequence("nineyfivepercent+tenpercent",

"agctuagcgEWWctuagcua");

assertFalse(Comparison.isNucleotide(new SequenceI[] { seq }));

seq = new Sequence("eightyfivepercent+fifteenpercent",

"agctuagcgWWWctuagcua");

assertFalse(Comparison.isNucleotide(new SequenceI[] { seq }));

100

seq = new Sequence("eightyfivepercentgapped",

101

"--agc--tuA--GCPV-a---gct-uA-GC---UV");

102

assertFalse(Comparison.isNucleotide(new SequenceI[] { seq }));

103

104

seq = new Sequence("ninetyfivepercentgapped",

105

"ag--ct-u-a---gc---g----aag--c---tuagcuV");

106

assertTrue(Comparison.isNucleotide(new SequenceI[] { seq }));

107

108

seq = new Sequence("allgap", "---------");

109

assertFalse(Comparison.isNucleotide(new SequenceI[] { seq }));

110

111

seq = new Sequence("DNA", "ACTugGCCAG");

112

SequenceI seq2 = new Sequence("Protein", "FLIMVSPTYW");

113

114

* 90% DNA but one protein sequence - expect false

115

116

assertFalse(

117

Comparison.isNucleotide(new SequenceI[]

118

{ seq, seq, seq, seq, seq, seq, seq, seq, seq, seq2 }));

119

assertFalse(

120

Comparison.isNucleotide(new SequenceI[][]

121

{ new SequenceI[] { seq }, new SequenceI[] { seq, seq, seq },

122

new SequenceI[]

123

{ seq, seq, seq, seq, seq, seq2 } }));

124

125

* 80% DNA but one protein sequence - Expect false

126

127

assertFalse(

128

Comparison.isNucleotide(new SequenceI[]

129

{ seq, seq, seq, seq, seq, seq, seq, seq, seq2, seq2 }));

130

assertFalse(

131

Comparison.isNucleotide(new SequenceI[][]

132

{ new SequenceI[] { seq }, new SequenceI[] { seq, seq, seq },

133

new SequenceI[]

134

{ seq, seq, seq, seq, seq2, seq2, null } }));

135

136

String seqString = "aaatatatatgEcctgagtcgt";

137

seq = new Sequence("ShortProteinThatLooksLikeDNA", seqString);

138

assertFalse(Comparison.isNucleotide(new SequenceI[] { seq }));

139

seq = new Sequence("LongProteinThatLooksLikeDNA", seqString.repeat(10));

140

assertTrue(Comparison.isNucleotide(new SequenceI[] { seq }));

141

142

assertFalse(Comparison.isNucleotide((SequenceI[]) null));

143

assertFalse(Comparison.isNucleotide((SequenceI[][]) null));

}

/**

* Test the percentage identity calculation for two sequences

148

149

@Test(groups = { "Functional" })

150

public void testPID_includingGaps()

151

{

152

String seq1 = "ABCDEFG"; // extra length here is ignored

153

String seq2 = "abcdef";

154

assertEquals("identical", 100f, Comparison.PID(seq1, seq2), 0.001f);

155

156

// comparison range defaults to length of first sequence

157

seq2 = "abcdefghijklmnopqrstuvwxyz";

158

assertEquals("identical", 100f, Comparison.PID(seq1, seq2), 0.001f);

159

160

// 5 identical, 2 gap-gap, 2 gap-residue, 1 mismatch

161

seq1 = "a--b-cdefh";

162

seq2 = "a---bcdefg";

163

int length = seq1.length();

164

165

// match gap-residue, match gap-gap: 9/10 identical

166

// TODO should gap-gap be included in a PID score? JAL-791

167

assertEquals(90f, Comparison.PID(seq1, seq2, 0, length, true, false),

168

0.001f);

169

// overloaded version of the method signature above:

170

assertEquals(90f, Comparison.PID(seq1, seq2), 0.001f);

171

172

// don't match gap-residue, match gap-gap: 7/10 identical

173

// TODO should gap-gap be included in a PID score?

174

assertEquals(70f, Comparison.PID(seq1, seq2, 0, length, false, false),

0.001f);

}

@Test(groups = { "Functional" })

179

public void testIsNucleotide()

180

{

181

assertTrue(Comparison.isNucleotide('a'));

182

assertTrue(Comparison.isNucleotide('A'));

183

assertTrue(Comparison.isNucleotide('c'));

184

assertTrue(Comparison.isNucleotide('C'));

185

assertTrue(Comparison.isNucleotide('g'));

186

assertTrue(Comparison.isNucleotide('G'));

187

assertTrue(Comparison.isNucleotide('t'));

188

assertTrue(Comparison.isNucleotide('T'));

189

assertTrue(Comparison.isNucleotide('u'));

190

assertTrue(Comparison.isNucleotide('U'));

191

assertFalse(Comparison.isNucleotide('-'));

192

assertFalse(Comparison.isNucleotide('P'));

193

}

194

195

@Test(groups = { "Functional" })

196

public void testIsNucleotideAmbiguity()

197

{

198

assertTrue(Comparison.isNucleotide('b', true));

199

assertTrue(Comparison.isNucleotide('B', true));

200

assertTrue(Comparison.isNucleotide('d', true));

201

assertTrue(Comparison.isNucleotide('V', true));

202

assertTrue(Comparison.isNucleotide('M', true));

203

assertTrue(Comparison.isNucleotide('s', true));

204

assertTrue(Comparison.isNucleotide('W', true));

205

assertTrue(Comparison.isNucleotide('x', true));

206

assertTrue(Comparison.isNucleotide('Y', true));

207

assertTrue(Comparison.isNucleotide('r', true));

208

assertTrue(Comparison.isNucleotide('i', true));

209

assertFalse(Comparison.isNucleotide('-', true));

210

assertFalse(Comparison.isNucleotide('n', true));

211

assertFalse(Comparison.isNucleotide('P', true));

}

/**

* Test the percentage identity calculation for two sequences

216

217

@Test(groups = { "Functional" })

218

public void testPID_ungappedOnly()

219

{

220

// 5 identical, 2 gap-gap, 2 gap-residue, 1 mismatch

221

// the extra length of seq1 is ignored

222

String seq1 = "a--b-cdefhr";

223

String seq2 = "a---bcdefg";

224

int length = seq1.length();

225

226

227

* As currently coded, 'ungappedOnly' ignores gap-residue but counts

228

* gap-gap. Is this a bug - should gap-gap also be ignored, giving a PID of

229

* 5/6?

230

231

* Note also there is no variant of the calculation that penalises

232

* gap-residue i.e. counts it as a mismatch. This would give a score of 5/8

233

* (if we ignore gap-gap) or 5/10 (if we count gap-gap as a match).

234

235

// match gap-residue, match gap-gap: 7/8 identical

236

assertEquals(87.5f, Comparison.PID(seq1, seq2, 0, length, true, true),

237

0.001f);

238

239

// don't match gap-residue with 'ungapped only' - same as above

240

assertEquals(87.5f, Comparison.PID(seq1, seq2, 0, length, false, true),

0.001f);

}

@Test(groups = { "Functional" })

245

public void testIsNucleotideSequence()

246

{

247

assertFalse(Comparison.isNucleotideSequence(null, true));

248

assertTrue(Comparison.isNucleotideSequence("", true));

249

assertTrue(Comparison.isNucleotideSequence("aAgGcCtTuU", true));

250

assertTrue(Comparison.isNucleotideSequence("aAgGcCtTuU", false));

251

assertFalse(Comparison.isNucleotideSequence("xAgGcCtTuU", false));

252

assertFalse(Comparison.isNucleotideSequence("aAgGcCtTuUx", false));

253

assertTrue(Comparison.isNucleotideSequence("a A-g.GcCtTuU", true));

254

assertFalse(Comparison.isNucleotideSequence("a A-g.GcCtTuU", false));

255

assertFalse(Comparison.isNucleotideSequence("gatactawgataca", false));

256

// including nucleotide ambiguity

257

assertTrue(

258

Comparison.isNucleotideSequence("gatacaWgataca", true, true));

259

assertFalse(

260

Comparison.isNucleotideSequence("gatacaEgataca", true, true));

261

262

// not quite all nucleotides and ambiguity codes

263

Sequence seq = new Sequence("Ambiguity DNA codes", "gatacagatacabve");

264

assertFalse(Comparison.isNucleotide(seq));

265

// all nucleotide and nucleotide ambiguity codes

266

seq = new Sequence("Ambiguity DNA codes", "gatacagatacabvt");

267

assertFalse(Comparison.isNucleotide(seq));

268

seq = new Sequence("Ambiguity DNA codes", "agatacabb");

269

assertFalse(Comparison.isNucleotide(seq));

270

// 55% nucleotide with only Xs or Ns

271

assertTrue(Comparison

272

.isNucleotide(new Sequence("dnaWithXs", "gatacaXXXX")));

273

assertTrue(Comparison

274

.isNucleotide(new Sequence("dnaWithXs", "gatacaNNNN")));

275

assertFalse(Comparison

276

.isNucleotide(new Sequence("dnaWithXs", "gatacXXXXX")));

277

assertFalse(Comparison

278

.isNucleotide(new Sequence("dnaWithXs", "gatacNNNNN")));

279

}

280

281

@Test(groups = { "Functional" })

282

public void testIsSameResidue()

283

{

284

assertTrue(Comparison.isSameResidue('a', 'a', false));

285

assertTrue(Comparison.isSameResidue('a', 'a', true));

286

assertTrue(Comparison.isSameResidue('A', 'a', false));

287

assertTrue(Comparison.isSameResidue('a', 'A', false));

288

289

assertFalse(Comparison.isSameResidue('a', 'A', true));

290

assertFalse(Comparison.isSameResidue('A', 'a', true));

291

}

292

293

@Test(groups = { "Functional" })

294

public void testNucleotideProportion()

295

{

296

assertFalse(Comparison.myShortSequenceNucleotideProportionCount(2, 3));

297

assertTrue(Comparison.myShortSequenceNucleotideProportionCount(3, 3));

298

assertFalse(Comparison.myShortSequenceNucleotideProportionCount(2, 4));

299

assertTrue(Comparison.myShortSequenceNucleotideProportionCount(3, 4));

300

assertFalse(

301

Comparison.myShortSequenceNucleotideProportionCount(17, 20));

302

assertTrue(Comparison.myShortSequenceNucleotideProportionCount(18, 20));

303

assertFalse(

304

Comparison.myShortSequenceNucleotideProportionCount(38, 50));

305

assertTrue(Comparison.myShortSequenceNucleotideProportionCount(39, 50));

306

assertFalse(

307

Comparison.myShortSequenceNucleotideProportionCount(54, 100));

308

assertTrue(

309

Comparison.myShortSequenceNucleotideProportionCount(55, 100));

310

}

311

}

Coverage Report

File ComparisonTest.java

Code metrics

Classes

Class ComparisonTest

Contributing tests

Contributing tests

Source view