Classes

Class	Line #	Total Statements	Complexity	TOTAL Coverage	Actions
patInt	14	41	30	0.00%	Show methods

Class patInt

Class patInt	Line # 14	Total Statements 41	Complexity 30	TOTAL Coverage 0.00%
patInt()   patInt()	2121	2.02	1.01	0.0 0.00%
patInt(int)   patInt(int)	2828	2.02	1.01	0.0 0.00%
patInt(patInt)   patInt(patInt)	3535	2.02	1.01	0.0 0.00%
setInf(boolean) : void   setInf(boolean) : void	4242	3.03	2.02	0.0 0.00%
inc() : void   inc() : void	5252	2.02	2.02	0.0 0.00%
dec() : void   dec() : void	6161	2.02	2.02	0.0 0.00%
lessEq(patInt) : boolean   lessEq(patInt) : boolean	7070	1.01	1.01	0.0 0.00%
equals(patInt) : boolean   equals(patInt) : boolean	7878	1.01	1.01	0.0 0.00%
toString() : String   toString() : String	8787	3.03	2.02	0.0 0.00%
pluseq(patInt) : patInt   pluseq(patInt) : patInt	102102	4.04	3.03	0.0 0.00%
mul(patInt) : patInt   mul(patInt) : patInt	119119	3.03	3.03	0.0 0.00%
mineq(patInt) : patInt   mineq(patInt) : patInt	132132	8.08	4.04	0.0 0.00%
maxeq(patInt) : patInt   maxeq(patInt) : patInt	153153	6.06	4.04	0.0 0.00%
finite() : boolean   finite() : boolean	168168	1.01	1.01	0.0 0.00%
intValue() : int   intValue() : int	176176	1.01	2.02	0.0 0.00%

 

Contributing tests

Source view

1		//
2		// This software is now distributed according to
3		// the Lesser Gnu Public License. Please see
4		// http://www.gnu.org/copyleft/lesser.txt for
5		// the details.
6		// -- Happy Computing!
7		//
8		package com.stevesoft.pat;
9
10		/**
11		* This is just an integer that can have infinite value. It is used internally
12		* to implement the *, and + parts of regular expressions.
13		*/
		0% Uncovered Elements: 80 (80) Complexity: 30 Complexity Density: 0.73
14		public class patInt
15		{
16		int i;
17
18		boolean inf;
19
20		/** Initialize to zero. */
		0% Uncovered Elements: 2 (2) Complexity: 1 Complexity Density: 0.5
21	0	public patInt()...
22		{
23	0	i = 0;
24	0	inf = false;
25		}
26
27		/** Initialize to the value of init. */
		0% Uncovered Elements: 2 (2) Complexity: 1 Complexity Density: 0.5
28	0	public patInt(int init)...
29		{
30	0	i = init;
31	0	inf = false;
32		}
33
34		/** Initialize to the value of p. */
		0% Uncovered Elements: 2 (2) Complexity: 1 Complexity Density: 0.5
35	0	public patInt(patInt p)...
36		{
37	0	i = p.i;
38	0	inf = p.inf;
39		}
40
41		/** set this int to infinity. */
		0% Uncovered Elements: 5 (5) Complexity: 2 Complexity Density: 0.67
42	0	public void setInf(boolean b)...
43		{
44	0	inf = b;
45	0	if (b)
46		{
47	0	i = Integer.MAX_VALUE;
48		}
49		}
50
51		/** Increment the value of this by 1. */
		0% Uncovered Elements: 4 (4) Complexity: 2 Complexity Density: 1
52	0	public final void inc()...
53		{
54	0	if (!inf)
55		{
56	0	i++;
57		}
58		}
59
60		/** Decrement the value of this by 1. */
		0% Uncovered Elements: 4 (4) Complexity: 2 Complexity Density: 1
61	0	public final void dec()...
62		{
63	0	if (!inf)
64		{
65	0	i--;
66		}
67		}
68
69		/** Test to see if this is less than or equal to j. */
		0% Uncovered Elements: 1 (1) Complexity: 1 Complexity Density: 1
70	0	public final boolean lessEq(patInt j)...
71		{ /*
72		* if(inf) return false; if(j.inf) return true; return i <= j.i;
73		*/
74	0	return !inf && (j.inf || i <= j.i);
75		}
76
77		/** Test to see if two patterns are equal. */
		0% Uncovered Elements: 1 (1) Complexity: 1 Complexity Density: 1
78	0	public final boolean equals(patInt j)...
79		{
80	0	return !j.inf && !inf && i == j.i;
81		}
82
83		/**
84		* Formats the pattern as a String. Contrary to what you might expect,
85		* infinity is formatted as ""
86		*/
		0% Uncovered Elements: 5 (5) Complexity: 2 Complexity Density: 0.67
87	0	final public String toString()...
88		{
89	0	if (inf)
90		{
91	0	return "";
92		}
93		else
94		{
95	0	return "" + i;
96		}
97		}
98
99		/**
100		* This would be operator+=(patInt) if I were programming in C++.
101		*/
		0% Uncovered Elements: 6 (6) Complexity: 3 Complexity Density: 0.75
102	0	public final patInt pluseq(patInt p)...
103		{
104	0	if (inf || p.inf)
105		{
106	0	setInf(true);
107		}
108		else
109		{
110	0	i += p.i;
111		}
112	0	return this;
113		}
114
115		/**
116		* Returns a patInt with value equal to the product of the value of p and
117		* this.
118		*/
		0% Uncovered Elements: 5 (5) Complexity: 3 Complexity Density: 1
119	0	public final patInt mul(patInt p)...
120		{
121	0	if (inf || p.inf)
122		{
123	0	return new patInf();
124		}
125	0	return new patInt(i * p.i);
126		}
127
128		/**
129		* If the argument p has a smaller value than this, then set this Object equal
130		* to p.
131		*/
		0% Uncovered Elements: 14 (14) Complexity: 4 Complexity Density: 0.5
132	0	public final patInt mineq(patInt p)...
133		{
134	0	if (p.inf)
135		{
136	0	return this;
137		}
138	0	if (inf)
139		{
140	0	i = p.i;
141		}
142	0	else if (p.i < i)
143		{
144	0	i = p.i;
145		}
146	0	setInf(false);
147	0	return this;
148		}
149
150		/**
151		* If the argument p has a greater than this, then set this object equal to p.
152		*/
		0% Uncovered Elements: 10 (10) Complexity: 4 Complexity Density: 0.67
153	0	public final patInt maxeq(patInt p)...
154		{
155	0	if (inf || p.inf)
156		{
157	0	setInf(true);
158	0	return this;
159		}
160	0	if (p.i > i)
161		{
162	0	i = p.i;
163		}
164	0	return this;
165		}
166
167		/** Tests to see if this represents an infinite quantity. */
		0% Uncovered Elements: 1 (1) Complexity: 1 Complexity Density: 1
168	0	public boolean finite()...
169		{
170	0	return !inf;
171		}
172
173		/**
174		* Converts to a patInt to an int. Infinity is mapped Integer.MAX_VALUE;
175		*/
		0% Uncovered Elements: 3 (3) Complexity: 2 Complexity Density: 2
176	0	public int intValue()...
177		{
178	0	return inf ? Integer.MAX_VALUE : i;
179		}
180		};