服务计算概论作业报告.doc

慕测平台测试报告（二）

学 院：
计算机学院
姓 名：
赵红娜
专 业：
软件工程
学 号：
3130608003
班 级：
1301
完毕日期：
-10-22

10月22日
1.题目
针对如下4个项目编写测试用例进行测试。代码如下：
题目1）

// BinaryHeap class
//
// CONSTRUCTION: with optional capacity (that defaults to 100)
//
// ******************PUBLIC OPERATIONS*********************
// void insert( x ) --> Insert x
// int deleteMin( )--> Return and remove smallest item
// int findMin( ) --> Return smallest item
// boolean isEmpty( ) --> Return true if empty; else false
// boolean isFull( ) --> Return true if full; else false
// void makeEmpty( ) --> Remove all items
// ******************ERRORS********************************
// Throws Overflow if capacity exceeded

/**
* Implements a binary heap.
* Note that all "matching" is based on the compareTo method.
* @author Mark Allen Weiss
*/
public class BinaryHeap
{
//@ invariant wellFormed();
/**
* Construct the binary heap.
*/
public BinaryHeap( )
{
this( DEFAULT_CAPACITY );
}

/**
* Construct the binary heap.
* @param capacity the capacity of the binary heap.
*/
//@ requires capacity > 0;
//@ ensures isEmpty();
public BinaryHeap( int capacity )
{
currentSize = 0;
array = new int[ capacity + 1 ];
}

/**
* Insert into the priority queue, maintaining heap order.
* Duplicates are allowed.
* @param x the item to insert.
* @exception Overflow if container is full.
*/
public void insert( int x ) throws Overflow
{
if( isFull( ) )
throw new Overflow( );

// Percolate up
int hole = ++currentSize;
for( ; hole > 1 && x< array[ hole / 2 ]; hole /= 2 )
array[ hole ] = array[ hole / 2 ];
array[ hole ] = x;
}

/**
* Find the smallest item in the priority queue.
* @return the smallest item, or null, if empty.
*/
public int findMin( )
{
if( isEmpty( ) )
return -1;
return array[ 1 ];
}
boolean wellFormed() {
if(array==null) {//array!=null
return false;
}
if(currentSize<0 currentSize>=array.length) {//currentSize>=0; currentSizearray[2*i]) {
return false;
}
if(i*2 + 1<= currentSize && array[i]>array[2*i+1]) {
return false;
}
}
return true;
}
/**
* Remove the smallest item from the priority queue.
* @return the smallest item, or null, if empty.
*/
public int deleteMin( )
{
if( isEmpty( ) )
return -1;

int minItem = findMin( );
array[ 1 ] = array[ currentSize-- ];
percolateDown( 1 );

return minItem;
}

/**
* Establish heap order property from an arbitrary
* arrangement of items. Runs in linear time.
*/
public void buildHeap( )
{
for( int i = currentSize / 2; i > 0; i-- )
percolateDown( i );
}

/**
* Test if the priority queue is logically empty.
* @return true if empty, false otherwise.
*/
public boolean isEmpty( )
{
return currentSize == 0;
}

/**
* Test if the priority queue is logically full.
* @return true if full, false otherwise.
*/
public boolean isFull( )
{
return currentSize == array.length - 1;
}

/**
* Make the priority queue logically empty.
*/
//@ ensures isEmpty();
public void makeEmpty( )
{
currentSize = 0;
}

private static final int DEFAULT_CAPACITY = 100;

private int currentSize; // Number of elements in heap
private int [ ] array; // The heap array

/**
* Internal method to percolate down in the heap.
* @param hole the index at which the percolate begins.
*/
private void percolateDown( int hole )
{
int child;
int tmp = array[ hole ];

for( ; hole * 2 <= currentSize; hole = child )
{
child = hole * 2;

if( child != currentSize &&
array[ child + 1 ]< array[ child ] )
child++;
if( array[ child ]< tmp )
array[ hole ] = array[ child ];
else
break;
}
array[ hole ] = tmp;
}

}

/**
* Exception class for access in full containers
* such as stacks, queues, and priority queues.
* @author Mark Allen Weiss
*/
public class Overflow extends Exception
{
}
题目（2）

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 && tmpp;
}
}

public boolean isSorted(int[] a) {
for(int i=0; ia[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 ] 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;

}

题目（3）

public class Statistics {

/**
*
* @param numbers
* @return the length of the array
*/
public int calLength(int[] numbers) {
int length = numbers.length;

return length;
}

/**
*
* @param numbers

* @return the mean value of the array
*/

public double calMean(int[] numbers) {
int length = calLength(numbers);

double sum;
sum = 0.0;
for (int i = 0; i < length; i++) {
sum += numbers[i];
}
double mean = sum / (double) length;

return mean;
}

/**
*
* @param numbers
* @return the var value of the array
*/
public double calVar(int[] numbers) {
int length = calLength(numbers);
double mean = calMean(numbers);

double varsum = 0.0;
for (int i = 0; i < length; i++) {
varsum = varsum + ((numbers[i] - mean) * (numbers[i] - mean));
}
double var = varsum / (length - 1.0);

return var;
}

}

题目（4）

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.软件工具
Eclipse

3. 测试代码
题目（1）

import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import org.junit.Assert;

public class BinaryHeapTest {

@Before
public void setUp() throws Exception {
}

@After
public void tearDown() throws Exception {
}

@Test
public void test() {
BinaryHeap heap1 = new BinaryHeap(1024);
for (int i = 1024; i > 0; i--) {
try {
heap1.insert(i);
} catch (Overflow e) {
Assert.fail(e.getMessage());
}
}

if (heap1.wellFormed()) {
heap1.buildHeap();
}
heap1.deleteMin();

heap1.makeEmpty();

heap1.findMin();
heap1.deleteMin();

}

}
题目（2）

import org.junit.Before;
import org.junit.After;
import org.junit.Test;

public class SortingTest {
private int num;
private int[] num1 = new int[50];
private int[] num2 = new int[50];
private Object[] ref = new Object[] { 3, 4, 5, 6, 9 };
private Sorting sorting;

@Before
public void setUp() throws Exception {
sorting = new Sorting()
for (int i = 0; i < 50; i++) {
num = (int) (Math.random() * 50);
num1[i] = num;
}
for (int i = 0; i < 50; i++) {
num = (int) (Math.random() * 50);
num2[i] = num;
}
}

@After
public void tearDown() throws Exception {
}

@Test
public void test() {

sorting.quicksort(num1);
sorting.isSorted(num1);
sorting.insertionSort(num2);
sorting.isSorted(num2);
sorting.swapReferences(ref, 1, 5);
}

}

题目（3）

import org.junit.After;
import org.junit.Before;
import org.junit.Test;
public class StatisticsTest {
private Statistics st
@Before
public void setUp() throws Exception {
st=new Statistics();
}
@After
public void tearDown() throws Exception {
}

@Test
public void testCalVar() {
int []nums=new int[]{200,300,400,500,600};
st.calVar(nums);
}

}

题目（4）

import org.junit.After;
import org.junit.Before;
import org.junit.Test;

public class TriangleTest {
private Triangle triangle1,triangle2,triangle3,triangle4;
@Before
public void setUp() throws Exception {
triangle1 = new Triangle(4, 4, 4);
triangle2 = new Triangle(2,2,3);
triangle3 = new Triangle(4,5,6);
triangle4 = new Triangle(2,5,9);
}

@After
public void tearDown() throws Exception {
}

@Test
public void test() {
triangle1.getBorders();
if(triangle1.isTriangle(triangle1)){
triangle1.getType(triangle1);}
triangle2.getBorders();
if(triangle2.isTriangletriangle2)){
triangle2.getType(triangle2);}
triangle3.getBorders();
if(triangle3.isTriangle(triangle3)){
triangle3.getType(triangle3);}
triangle4.getBorders();
if(triangle4.isTriangle(triangle4)){
triangle4.getType(triangle4);}
}

}

4. 运营成果

5. 分数
95.555
6. 收获和体会
通过这次实验，让我对软件测试旳基本概念，工具，措施均有了清晰旳结识，掌握了基本旳软件测试流程，提高了代码旳编写能力，开扩了眼界，为后来旳学习和工作打下了坚实旳基础。