Classes

Class	Line #	Total Statements	Complexity	Uncovered Elements	TOTAL Coverage	Actions
DnaUtils	28	33	12	2	0.9696%	Show methods

Class DnaUtils

Class DnaUtils	Line # 28	Total Statements 33	Complexity 12	Uncovered Elements 2	TOTAL Coverage 0.9696%
parseLocation(String) : List<int[]>   parseLocation(String) : List<int[]>	4747	14.014	8.08	2.02	0.9166667 0.916666791.7%
parseComplement(String) : List<int[]>   parseComplement(String) : List<int[]>	9898	10.010	2.02	0.00	1.0 1.0100%
parseJoin(String) : List<int[]>   parseJoin(String) : List<int[]>	131131	9.09	2.02	0.00	1.0 1.0100%

 

Contributing tests

Contributing tests

Select all

	Test contribution	Test	Result	Actions
	0.96	jalview.util.DnaUtilsTest.testParseLocationjalview.util.DnaUtilsTest.testParseLocation	1PASS
	0.8	jalview.datamodel.xdb.embl.EmblEntryTest.testParseCodingFeaturejalview.datamodel.xdb.embl.EmblEntryTest.testParseCodingFeature	1PASS
	0.8	jalview.datamodel.xdb.embl.EmblEntryTest.testGetCdsRangesjalview.datamodel.xdb.embl.EmblEntryTest.testGetCdsRanges	1PASS

 

Source view

1		/*
2		* Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
3		* Copyright (C) $$Year-Rel$$ The Jalview Authors
4		*
5		* This file is part of Jalview.
6		*
7		* Jalview is free software: you can redistribute it and/or
8		* modify it under the terms of the GNU General Public License
9		* as published by the Free Software Foundation, either version 3
10		* of the License, or (at your option) any later version.
11		*
12		* Jalview is distributed in the hope that it will be useful, but
13		* WITHOUT ANY WARRANTY; without even the implied warranty
14		* of MERCHANTABILITY or FITNESS FOR A PARTICULAR
15		* PURPOSE. See the GNU General Public License for more details.
16		*
17		* You should have received a copy of the GNU General Public License
18		* along with Jalview. If not, see <http://www.gnu.org/licenses/>.
19		* The Jalview Authors are detailed in the 'AUTHORS' file.
20		*/
21		package jalview.util;
22
23		import java.text.ParseException;
24		import java.util.ArrayList;
25		import java.util.Collections;
26		import java.util.List;
27
		96% Uncovered Elements: 2 (50) Complexity: 12 Complexity Density: 0.36
28		public class DnaUtils
29		{
30
31		/**
32		* Parses an ENA/GenBank format location specifier and returns a list of
33		* [start, end] ranges. Throws an exception if not able to parse.
34		* <p>
35		* Currently we do not parse "order()" specifiers, or indeterminate ranges of
36		* the format "&lt;start..end" or "start..&gt;end" or "start.end" or
37		* "start^end"
38		*
39		* @param location
40		* @return
41		* @throws ParseException
42		* if unable to parse the location (the exception message is the
43		* location specifier being parsed); we use ParseException in
44		* preference to the unchecked IllegalArgumentException
45		* @see http://www.insdc.org/files/feature_table.html#3.4
46		*/
		91.7% Uncovered Elements: 2 (24) Complexity: 8 Complexity Density: 0.57
47	52	public static List<int[]> parseLocation(String location)...
48		throws ParseException
49		{
50	51	if (location.startsWith("join("))
51		{
52	11	return parseJoin(location);
53		}
54	40	else if (location.startsWith("complement("))
55		{
56	11	return parseComplement(location);
57		}
58	29	if (location.startsWith("order("))
59		{
60	1	throw new ParseException(location, 0);
61		}
62
63		/*
64		* try to parse m..n (or simply m)
65		*/
66	28	String[] range = location.split("\\.\\.");
67	28	if (range.length == 1 || range.length == 2)
68		{
69	28	try
70		{
71	28	int start = Integer.valueOf(range[0]);
72	23	int end = range.length == 1 ? start : Integer.valueOf(range[1]);
73	22	return Collections.singletonList(new int[] { start, end });
74		} catch (NumberFormatException e)
75		{
76		/*
77		* could be a location like <1..888 or 1..>888
78		*/
79	6	throw new ParseException(location, 0);
80		}
81		}
82		else
83		{
84		/*
85		* could be a location like 102.110 or 123^124
86		*/
87	0	throw new ParseException(location, 0);
88		}
89		}
90
91		/**
92		* Parses a complement(locationSpec) into a list of start-end ranges
93		*
94		* @param location
95		* @return
96		* @throws ParseException
97		*/
		100% Uncovered Elements: 0 (12) Complexity: 2 Complexity Density: 0.2
98	11	static List<int[]> parseComplement(String location) throws ParseException...
99		{
100		/*
101		* take what is inside complement()
102		*/
103	11	if (!location.endsWith(")"))
104		{
105	3	throw new ParseException(location, 0);
106		}
107	8	String toComplement = location.substring("complement(".length(),
108		location.length() - 1);
109	8	List<int[]> ranges = parseLocation(toComplement);
110
111		/*
112		* reverse the order and direction of ranges
113		*/
114	8	Collections.reverse(ranges);
115	8	for (int[] range : ranges)
116		{
117	9	int temp = range[0];
118	9	range[0] = range[1];
119	9	range[1] = temp;
120		}
121	8	return ranges;
122		}
123
124		/**
125		* Parses a join(loc1,loc2,...,locn) into a list of start-end ranges
126		*
127		* @param location
128		* @return
129		* @throws ParseException
130		*/
		100% Uncovered Elements: 0 (11) Complexity: 2 Complexity Density: 0.22
131	11	static List<int[]> parseJoin(String location) throws ParseException...
132		{
133	11	List<int[]> ranges = new ArrayList<int[]>();
134
135		/*
136		* take what is inside join()
137		*/
138	11	if (!location.endsWith(")"))
139		{
140	3	throw new ParseException(location, 0);
141		}
142	8	String joinedLocs = location.substring("join(".length(),
143		location.length() - 1);
144	8	String[] locations = joinedLocs.split(",");
145	8	for (String loc : locations)
146		{
147	19	List<int[]> range = parseLocation(loc);
148	17	ranges.addAll(range);
149		}
150	6	return ranges;
151		}
152
153		}