Skip to content

Commit adc9847

Browse files
ManengManeng
committed
完成
1 parent 8711906 commit adc9847

File tree

78 files changed

+4106
-154
lines changed

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

78 files changed

+4106
-154
lines changed

‎students/643449856/litejunit/pom.xml

Lines changed: 32 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,32 @@
1+
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
2+
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
3+
<modelVersion>4.0.0</modelVersion>
4+
5+
<groupId>com.coderising</groupId>
6+
<artifactId>ood-assignment</artifactId>
7+
<version>0.0.1-SNAPSHOT</version>
8+
<packaging>jar</packaging>
9+
10+
<name>ood-assignment</name>
11+
<url>http://maven.apache.org</url>
12+
13+
<properties>
14+
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
15+
</properties>
16+
17+
<dependencies>
18+
19+
<dependency>
20+
<groupId>junit</groupId>
21+
<artifactId>junit</artifactId>
22+
<version>4.12</version>
23+
</dependency>
24+
25+
</dependencies>
26+
<repositories>
27+
<repository>
28+
<id>aliyunmaven</id>
29+
<url>http://maven.aliyun.com/nexus/content/groups/public/</url>
30+
</repository>
31+
</repositories>
32+
</project>

‎students/643449856/litejunit/src/main/java/org/litejunit/Assert.java

Lines changed: 225 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,225 @@
1+
package org.litejunit;
2+
3+
/**
4+
* A set of assert methods.
5+
*/
6+
7+
public class Assert {
8+
/**
9+
* Protect constructor since it is a static only class
10+
*/
11+
protected Assert() {
12+
}
13+
14+
/**
15+
* Asserts that a condition is true. If it isn't it throws
16+
* an AssertionFailedError with the given message.
17+
*/
18+
static public void assertTrue(String message, boolean condition) {
19+
if (!condition)
20+
fail(message);
21+
}
22+
/**
23+
* Asserts that a condition is true. If it isn't it throws
24+
* an AssertionFailedError.
25+
*/
26+
static public void assertTrue(boolean condition) {
27+
assertTrue(null, condition);
28+
}
29+
/**
30+
* Fails a test with the given message.
31+
*/
32+
static public void fail(String message) {
33+
throw new AssertionFailedError(message);
34+
}
35+
/**
36+
* Fails a test with no message.
37+
*/
38+
static public void fail() {
39+
fail(null);
40+
}
41+
/**
42+
* Asserts that two objects are equal. If they are not
43+
* an AssertionFailedError is thrown.
44+
*/
45+
static public void assertEquals(String message, Object expected, Object actual) {
46+
if (expected == null && actual == null)
47+
return;
48+
if (expected != null && expected.equals(actual))
49+
return;
50+
failNotEquals(message, expected, actual);
51+
}
52+
/**
53+
* Asserts that two objects are equal. If they are not
54+
* an AssertionFailedError is thrown.
55+
*/
56+
static public void assertEquals(Object expected, Object actual) {
57+
assertEquals(null, expected, actual);
58+
}
59+
/**
60+
* Asserts that two doubles are equal concerning a delta. If the expected
61+
* value is infinity then the delta value is ignored.
62+
*/
63+
static public void assertEquals(String message, double expected, double actual, double delta) {
64+
// handle infinity specially since subtracting to infinite values gives NaN and the
65+
// the following test fails
66+
if (Double.isInfinite(expected)) {
67+
if (!(expected == actual))
68+
failNotEquals(message, new Double(expected), new Double(actual));
69+
} else if (!(Math.abs(expected-actual) <= delta)) // Because comparison with NaN always returns false
70+
failNotEquals(message, new Double(expected), new Double(actual));
71+
}
72+
/**
73+
* Asserts that two doubles are equal concerning a delta. If the expected
74+
* value is infinity then the delta value is ignored.
75+
*/
76+
static public void assertEquals(double expected, double actual, double delta) {
77+
assertEquals(null, expected, actual, delta);
78+
}
79+
/**
80+
* Asserts that two floats are equal concerning a delta. If the expected
81+
* value is infinity then the delta value is ignored.
82+
*/
83+
static public void assertEquals(String message, float expected, float actual, float delta) {
84+
// handle infinity specially since subtracting to infinite values gives NaN and the
85+
// the following test fails
86+
if (Float.isInfinite(expected)) {
87+
if (!(expected == actual))
88+
failNotEquals(message, new Float(expected), new Float(actual));
89+
} else if (!(Math.abs(expected-actual) <= delta))
90+
failNotEquals(message, new Float(expected), new Float(actual));
91+
}
92+
/**
93+
* Asserts that two floats are equal concerning a delta. If the expected
94+
* value is infinity then the delta value is ignored.
95+
*/
96+
static public void assertEquals(float expected, float actual, float delta) {
97+
assertEquals(null, expected, actual, delta);
98+
}
99+
/**
100+
* Asserts that two longs are equal.
101+
*/
102+
static public void assertEquals(String message, long expected, long actual) {
103+
assertEquals(message, new Long(expected), new Long(actual));
104+
}
105+
/**
106+
* Asserts that two longs are equal.
107+
*/
108+
static public void assertEquals(long expected, long actual) {
109+
assertEquals(null, expected, actual);
110+
}
111+
/**
112+
* Asserts that two booleans are equal.
113+
*/
114+
static public void assertEquals(String message, boolean expected, boolean actual) {
115+
assertEquals(message, new Boolean(expected), new Boolean(actual));
116+
}
117+
/**
118+
* Asserts that two booleans are equal.
119+
*/
120+
static public void assertEquals(boolean expected, boolean actual) {
121+
assertEquals(null, expected, actual);
122+
}
123+
/**
124+
* Asserts that two bytes are equal.
125+
*/
126+
static public void assertEquals(String message, byte expected, byte actual) {
127+
assertEquals(message, new Byte(expected), new Byte(actual));
128+
}
129+
/**
130+
* Asserts that two bytes are equal.
131+
*/
132+
static public void assertEquals(byte expected, byte actual) {
133+
assertEquals(null, expected, actual);
134+
}
135+
/**
136+
* Asserts that two chars are equal.
137+
*/
138+
static public void assertEquals(String message, char expected, char actual) {
139+
assertEquals(message, new Character(expected), new Character(actual));
140+
}
141+
/**
142+
* Asserts that two chars are equal.
143+
*/
144+
static public void assertEquals(char expected, char actual) {
145+
assertEquals(null, expected, actual);
146+
}
147+
/**
148+
* Asserts that two shorts are equal.
149+
*/
150+
static public void assertEquals(String message, short expected, short actual) {
151+
assertEquals(message, new Short(expected), new Short(actual));
152+
}
153+
/**
154+
* Asserts that two shorts are equal.
155+
*/
156+
static public void assertEquals(short expected, short actual) {
157+
assertEquals(null, expected, actual);
158+
}
159+
/**
160+
* Asserts that two ints are equal.
161+
*/
162+
static public void assertEquals(String message, int expected, int actual) {
163+
assertEquals(message, new Integer(expected), new Integer(actual));
164+
}
165+
/**
166+
* Asserts that two ints are equal.
167+
*/
168+
static public void assertEquals(int expected, int actual) {
169+
assertEquals(null, expected, actual);
170+
}
171+
/**
172+
* Asserts that an object isn't null.
173+
*/
174+
static public void assertNotNull(Object object) {
175+
assertNotNull(null, object);
176+
}
177+
/**
178+
* Asserts that an object isn't null.
179+
*/
180+
static public void assertNotNull(String message, Object object) {
181+
assertTrue(message, object != null);
182+
}
183+
/**
184+
* Asserts that an object is null.
185+
*/
186+
static public void assertNull(Object object) {
187+
assertNull(null, object);
188+
}
189+
/**
190+
* Asserts that an object is null.
191+
*/
192+
static public void assertNull(String message, Object object) {
193+
assertTrue(message, object == null);
194+
}
195+
/**
196+
* Asserts that two objects refer to the same object. If they are not
197+
* an AssertionFailedError is thrown.
198+
*/
199+
static public void assertSame(String message, Object expected, Object actual) {
200+
if (expected == actual)
201+
return;
202+
failNotSame(message, expected, actual);
203+
}
204+
/**
205+
* Asserts that two objects refer to the same object. If they are not
206+
* the same an AssertionFailedError is thrown.
207+
*/
208+
static public void assertSame(Object expected, Object actual) {
209+
assertSame(null, expected, actual);
210+
}
211+
212+
static private void failNotEquals(String message, Object expected, Object actual) {
213+
String formatted= "";
214+
if (message != null)
215+
formatted= message+" ";
216+
fail(formatted+"expected:<"+expected+"> but was:<"+actual+">");
217+
}
218+
219+
static private void failNotSame(String message, Object expected, Object actual) {
220+
String formatted= "";
221+
if (message != null)
222+
formatted= message+" ";
223+
fail(formatted+"expected same");
224+
}
225+
}

‎students/643449856/litejunit/src/main/java/org/litejunit/AssertionFailedError.java

Lines changed: 11 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,11 @@
1+
package org.litejunit;
2+
3+
public class AssertionFailedError extends Error {
4+
public AssertionFailedError(){
5+
6+
}
7+
8+
public AssertionFailedError(String message) {
9+
super(message);
10+
}
11+
}

‎students/643449856/litejunit/src/main/java/org/litejunit/Test.java

Lines changed: 7 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,7 @@
1+
package org.litejunit;
2+
3+
public interface Test {
4+
public void run(TestResult testResult);
5+
6+
public Integer getCaseCount();
7+
}

‎students/643449856/litejunit/src/main/java/org/litejunit/TestCase.java

Lines changed: 69 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,69 @@
1+
package org.litejunit;
2+
3+
import java.lang.reflect.InvocationTargetException;
4+
import java.lang.reflect.Method;
5+
import java.lang.reflect.Modifier;
6+
7+
public abstract class TestCase extends Assert implements Test {
8+
private String name;
9+
10+
public TestCase(String name) {
11+
this.name = name;
12+
}
13+
14+
@Override
15+
public void run(TestResult testResult) {
16+
testResult.run(this);
17+
}
18+
19+
public void doRun(TestResult testResult) throws Throwable {
20+
setUp();
21+
try {
22+
runTest();
23+
24+
} finally {
25+
tearDown();
26+
}
27+
}
28+
29+
protected void setUp() {
30+
31+
}
32+
33+
protected void runTest() throws Throwable {
34+
Class<?> clazz = this.getClass();
35+
Method method=null;
36+
try {
37+
method = clazz.getDeclaredMethod(name);
38+
39+
} catch (NoSuchMethodException | SecurityException e1) {
40+
// e1.printStackTrace();
41+
}
42+
43+
if(!Modifier.isPublic(method.getModifiers())){
44+
fail("method "+name+" is not a public menthod!");
45+
}
46+
47+
try {
48+
method.invoke(this);
49+
} catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
50+
// e.printStackTrace();
51+
52+
Throwable ta = e.getCause();
53+
throw ta;
54+
// }
55+
56+
}
57+
58+
}
59+
60+
protected void tearDown() {
61+
62+
}
63+
64+
@Override
65+
public Integer getCaseCount() {
66+
return 1;
67+
}
68+
69+
}

‎students/643449856/litejunit/src/main/java/org/litejunit/TestFailure.java

Lines changed: 20 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,20 @@
1+
package org.litejunit;
2+
3+
public class TestFailure {
4+
5+
private Test test;
6+
private Throwable throwable;
7+
8+
public TestFailure(Test test, Throwable throwable) {
9+
this.test = test;
10+
this.throwable = throwable;
11+
}
12+
13+
public Test getTestCase() {
14+
return this.test;
15+
}
16+
17+
public Throwable getThrowable() {
18+
return this.throwable;
19+
}
20+
}

0 commit comments

Comments
 (0)