SoftwareTest Median Test

1. Sorting语句覆盖测试

1.1 Sorting.java

import java.util.Comparator;
import java.util.Random;

/**
* A class that contains several sorting routines,
* implemented as static methods.
* Arrays are rearranged with smallest item first,
* using compareTo.
* @author Mark Allen Weiss
*/
public final class Sorting
{
/**
* Simple insertion sort.
* @param a an array of Comparable items.
*/
public void insertionSort( int[ ] a )
{
int j;

for( int p = 1; p < a.length; p++ )
{
int tmp = a[ p ];
for( j = p; j > 0 && tmp<a[ j - 1 ]; j-- )
a[ j ] = a[ j - 1 ];
a[ j ] = tmp;
}
}

public  boolean isSorted(int[] a) {
for(int i=0; i<a.length-1; i++) {
if(a[i]>a[i+1]) {
return false;
}
}
return true;
}

public static void quicksort( int[ ] a )
{
quicksort( a, 0, a.length - 1 );
}

private static final int CUTOFF = 10;

public static final void swapReferences( Object [ ] a, int index1, int index2 )
{
Object tmp = a[ index1 ];
a[ index1 ] = a[ index2 ];
a[ index2 ] = tmp;
}
public static final void swap(int[] a,int index1,int index2) {
int tmp = a[ index1 ];
a[ index1 ] = a[ index2 ];
a[ index2 ] = tmp;
}

private static int median3( int[ ] a, int left, int right )
{
int center = ( left + right ) / 2;
if( a[ center ]<a[ left ] )
swap( a, left, center );
if( a[ right ] < a[ left ] )
swap( a, left, right );
if( a[ right ] < a[ center ] )
swap( a, center, right );

// Place pivot at position right - 1
swap( a, center, right - 1 );
return a[ right - 1 ];
}

private static void quicksort( int[ ] a, int left, int right)
{
if( left + CUTOFF <= right )
{
int pivot = median3( a, left, right );

int i = left, j = right - 1;
for( ; ; )
{
while( a[ ++i ] < pivot )  { }
while( a[ --j ] > pivot ) { }
if( i < j )
swap( a, i, j );
else
break;
}

swap( a, i, right - 1 );   // Restore pivot

quicksort( a, left, i - 1 );    // Sort small elements
quicksort( a, i + 1, right );   // Sort large elements
}
else  // Do an insertion sort on the subarray
insertionSort( a, left, right );
}

private static void insertionSort( int[ ] a, int left, int right )
{
for( int p = left + 1; p <= right; p++ )
{
int tmp = a[ p ];
int j;

for( j = p; j > left && tmp < a[ j - 1 ]; j-- )
a[ j ] = a[ j - 1 ];
a[ j ] = tmp;
}
}

private static final int NUM_ITEMS = 1000;
private static int theSeed = 1;

}

1.2 SortingTest.java

import static org.junit.Assert.*;

import org.junit.Test;

public class SortingTest {

private Sorting sorting=new Sorting();
int[] caseA={4,7,4,4,2,0};
int[] caseB={15,16,3,2,10,12,3,6,1,5,1,2};

@Test
public void test() {
//testInsertiongSort
sorting.insertionSort(caseA);
sorting.isSorted(caseA);

// testQuicksort
sorting.quicksort(caseB);

// testSwapReferences
Object[] ob={"123","234","345"};
sorting.swapReferences(ob,0,2);
// testSwap
sorting.swap(caseA,0,2);
sorting.isSorted(caseA);
}

}

2.Triangle分支覆盖测试

2.1 Triangle.java

public class Triangle {
protected long lborderA = 0;

protected long lborderB = 0;

protected long lborderC = 0;

// Constructor
public Triangle(long lborderA, long lborderB, long lborderC) {

this.lborderA = lborderA;

this.lborderB = lborderB;

this.lborderC = lborderC;

}

/**
* check if it is a triangle
*
* @return true for triangle and false not
*/
public boolean isTriangle(Triangle triangle) {
boolean isTriangle = false;

// check boundary
if ((triangle.lborderA > 0 && triangle.lborderA <= Long.MAX_VALUE)
&& (triangle.lborderB > 0 && triangle.lborderB <= Long.MAX_VALUE)
&& (triangle.lborderC > 0 && triangle.lborderC <= Long.MAX_VALUE)) {

// check if subtraction of two border larger than the third
if (diffOfBorders(triangle.lborderA, triangle.lborderB) < triangle.lborderC
&& diffOfBorders(triangle.lborderB, triangle.lborderC) < triangle.lborderA
&& diffOfBorders(triangle.lborderC, triangle.lborderA) < triangle.lborderB) {
isTriangle = true;
}

}
return isTriangle;
}

/**
* Check the type of triangle
*
* Consists of "Illegal", "Regular", "Scalene", "Isosceles"
*/
public String getType(Triangle triangle) {
String strType = "Illegal";

if (isTriangle(triangle)) {
// Is Regular
if (triangle.lborderA == triangle.lborderB
&& triangle.lborderB == triangle.lborderC) {
strType = "Regular";
}
// If scalene
else if ((triangle.lborderA != triangle.lborderB)
&& (triangle.lborderB != triangle.lborderC)
&& (triangle.lborderA != triangle.lborderC)) {
strType = "Scalene";
}
// if isosceles
else {
strType = "Isosceles";
}
}

return strType;
}

/**
* calculate the diff between borders
*
* */
public long diffOfBorders(long a, long b) {
return (a > b) ? (a - b) : (b - a);
}

/**
* get length of borders
*/
public long[] getBorders() {
long[] borders = new long[3];
borders[0] = this.lborderA;
borders[1] = this.lborderB;
borders[2] = this.lborderC;
return borders;
}
}

2.2 TriangleTest.java

import org.junit.Test;
import static org.junit.Assert.*;

public class TriangleTest {
//triangle is scalene
private Triangle illegalT,regularT,isoscelesT,tri;
@Test
public void test(){
// initialize of the triangles
illegalT = new Triangle(1, 2, 3);
regularT = new Triangle(2, 2, 2);
isoscelesT = new Triangle(2, 2, 3);
tri = new Triangle(2, 3, 4);

assertEquals(true, tri.isTriangle(tri));
assertEquals(false, tri.isTriangle(illegalT));
Triangle temp = new Triangle(-2, -3, 0);
assertEquals(false, tri.isTriangle(temp));

assertEquals("Scalene", tri.getType(tri));
assertEquals("Regular", tri.getType(regularT));
assertEquals("Isosceles", tri.getType(isoscelesT));
assertEquals("Illegal", tri.getType(illegalT));

long[] borders = tri.getBorders();
long[] expected = {(long)2.0, (long)3.0, (long)4.0};
for(int i = 0; i < 3; i++){
assertEquals(expected[i], borders[i], 0.0);
}

assertEquals(1, tri.diffOfBorders(2, 1), 0.0);
}
}

3.Schedule分支覆盖测试

3.1 Work.java

public class Work {
/** 作业名*/
private String name;
/** 作业到达时间*/
private int arrivalTime;
/** 作业服务时间*/
private int serviceTime;
/** 开始执行时间*/
private int beginTime;
/** 完成时间*/
private int endTime;
/** 作业是否调入系统*/
private boolean in=false;
/**
* 作业已调入
*/
public void setIn(){
this.in=true;
}
/**
* 判断作业是否已调入系统
* @return
*/
public boolean isIn(){
return this.in;
}
/**
* Constructor
* @param name
* @param t1
* @param t2
*/
public Work(String name,int t1,int t2){
this.name=name;
this.arrivalTime=t1;
this.serviceTime=t2;
}
/**
* 设置开始执行时间
* @param t
*/
public void setBeginTime(int t){
this.beginTime=t;
}
/**
* 获取开始时间
* @return
*/
public int getBeginTime(){
return this.beginTime;
}
/**
* 设置完成时间
* @param t
*/
public void setEndTime(int t){
this.endTime=t;
}
/**
* 获取结束时间
* @return
*/
public int getEndTime(){
return this.endTime;
}
/**
* 计算“周转时间”=完成时间-到达时间
* @return int
*/
public int getCircleTime(){
return this.endTime-this.arrivalTime;
}
/**
* 计算“带权周转时间”=周转时间/服务时间
* @return
*/
public double getCircleWPTime(){

return ((double)getCircleTime())/this.serviceTime;
}
/**
* 计算"响应比"=（等待时间+要求服务时间）/要求服务时间=响应时间/要求服务时间
* @return
*/
public int getPriority(){
//TODO

return 0;
}
/**
*获取到达时间
* @return
*/
public int getArrivalTime(){
return this.arrivalTime;
}
/**
* 获取服务时间
* @return
*/
public int getServiceTime(){
return this.serviceTime;
}
}

3.2 Schedule.java

import java.util.ArrayList;
import java.util.List;

public class Schedule {

public List<Double> FCFS(List<Work> works) {
double avgCircleTime = 0;
double avgCircleTimeWP = 0;
List<Double> lst = new ArrayList<Double>();
for (int i = 0; i < works.size(); i++) {
// works.get(i).getArrivalTime();
// works.get(i).getServiceTime();
if (i != 0) {
works.get(i).setBeginTime(works.get(i - 1).getEndTime());
} else {
works.get(i).setBeginTime(works.get(i).getArrivalTime());
}
works.get(i)
.setEndTime(
works.get(i).getBeginTime()
+ works.get(i).getServiceTime());
avgCircleTime += works.get(i).getCircleTime();
avgCircleTimeWP += works.get(i).getCircleWPTime();
}
avgCircleTime /= works.size();
avgCircleTimeWP /= works.size();
lst.add(avgCircleTime);
lst.add(avgCircleTimeWP);
return lst;
}

/**
* 改后的短作业优先调度算法
*
* @param works
* @return
*/
public List<Double> SJF(List<Work> works) {
List<Double> lst = new ArrayList<Double>();
double avgCircleTime = 0;
double avgCircleTimeWP = 0;
List<Work> ins = new ArrayList<Work>();
int i = 0;
int counter = 0; // 已完成作业的计数器
// 判断是否已经把所有的作业都处理完毕
while (counter < works.size()) {
// 找到所有未执行，且到达时间小于i的作业
for (int j = 0; j < works.size(); j++) {
if (works.get(j).isIn())
continue;
if (works.get(j).getArrivalTime() <= i) {
ins.add(works.get(j));
}
}
if (ins.isEmpty()) {
i++;
} else {
ins = sortByServiceTime(ins);
// 将当前已到达的作业中，服务时间最短的作业加入到CPU执行
Work now = ins.get(0);
now.setBeginTime(i);
now.setEndTime(now.getBeginTime() + now.getServiceTime());
now.setIn(); // 标记作业已调度
counter++;
i = now.getEndTime(); // 更新当前时间
ins.clear(); // 清空临时数组ins
}

}
for (int m = 0; m < works.size(); m++) {
avgCircleTime += works.get(m).getCircleTime();
avgCircleTimeWP += works.get(m).getCircleWPTime();
}
avgCircleTime = avgCircleTime / works.size();
avgCircleTimeWP = avgCircleTimeWP / works.size();
lst.add(avgCircleTime);
lst.add(avgCircleTimeWP);
return lst;
}

/**
* 对加入到系统中的作业依据服务时间多少进行排序<BR>
* 然后直接返回
*
* @param ins
* @return ins
*/
public static List<Work> sortByServiceTime(List<Work> ins) {
for (int i = 0; i < ins.size(); i++) {
for (int j = i + 1; j < ins.size(); j++) {
Work aw = ins.get(i);
int a = aw.getServiceTime();
Work bw = ins.get(j);
int b = bw.getServiceTime();
if (a > b) {
ins.remove(j);
ins.add(i, bw);
}
}
}
return ins;
}
}

3.3 ScheduleTest.java

import org.junit.*;
import static org.junit.Assert.*;

import java.util.ArrayList;
import java.util.List;

public class ScheduleTest {
@Test
public void testFCFS(){
Schedule schedule = new Schedule();
List<Work> works = new ArrayList<Work>();
for(int i = 0; i < 10; i++){
works.add(new Work("Work" + i, i, i + 1));
}
List<Double> lst = schedule.FCFS(works);
assertEquals(lst.get(0), 17.5, 0.0);
assertEquals(lst.get(1), 2.542896825396825, 0.0);

List<Work> emptyWorks = new ArrayList<Work>();
emptyWorks.add(new Work("", 1, 10));
List<Double> lst2 = schedule.FCFS(emptyWorks);
assertEquals(lst2.get(0), Float.NaN, 0.0);
assertEquals(lst2.get(1), Float.NaN, 0.0);
}

@Test
public void testSJF(){
Schedule schedule = new Schedule();
List<Work> works = new ArrayList<Work>();
for(int i = 0; i < 10; i++){
works.add(new Work("Work" + i, i, 11 - i));
}
List<Double> lst = schedule.SJF(works);
assertEquals(lst.get(0), 27.5, 0.0);
assertEquals(lst.get(1), 3.957103174603174, 0.0);

List<Work> emptyWorks = new ArrayList<Work>();
emptyWorks.add(new Work("", 1, 10));
List<Double> lst2 = schedule.SJF(emptyWorks);
assertEquals(lst2.get(0), Float.NaN, 0.0);
assertEquals(lst2.get(1), Float.NaN, 0.0);
}

@Test
public void testsortByServiceTime(){
Schedule schedule = new Schedule();
List<Work> works = new ArrayList<Work>();
for(int i = 0; i < 10; i++){
works.add(new Work("Work" + i, i, 11 - i));
}
List<Work> sortedWorks = schedule.sortByServiceTime(works);
for(int i = 0; i < works.size(); i++){
assertEquals(new Work("Work" + (9 - i), 9 - i, i + 1), sortedWorks.get(i));
}
}
}