Junit3.8 Stack测试

package test;

public class MyStack
{
    private String[] elements;
    
    private int nextIndex;
    
    public MyStack()
    {
        elements = new String[100];
        nextIndex = 0;
    }
    
    public void push(String element) throws Exception
    {
        if(100 == nextIndex)
        {
            throw new Exception("数组越界异常!");
        }
        
        elements[nextIndex++] = element;
    }
    
    public String pop() throws Exception
    {
        if(0 == nextIndex)
        {
            throw new Exception("数组越界异常!");
        }
        
        return elements[--nextIndex];
    }
    
    public void delete(int n) throws Exception
    {
        if(nextIndex - n < 0)
        {
            throw new Exception("数组越界异常!");
        }
        
        nextIndex -= n;
    }
    
    public String top() throws Exception
    {
        if(0 == nextIndex)
        {
            throw new Exception("数组越界异常!");
        }
        
        return elements[nextIndex - 1];
    }
    
}

package junit;

import junit.framework.Assert;
import junit.framework.TestCase;

@SuppressWarnings("deprecation")
public class MyStackTest extends TestCase
{
    private MyStack myStack;

    @Override
    public void setUp() throws Exception
    {
        myStack = new MyStack();
    }
    
    //测试正常情况的一般情况，向栈内放入一个元素，然后取出。
    public void testPush()
    {
        try
        {
            myStack.push("hello world");
        }
        catch (Exception e)
        {
            Assert.fail();
        }

        String result = null;

        try
        {
            result = myStack.pop();
        }
        catch (Exception ex)
        {

        }

        Assert.assertEquals("hello world", result);
    }

    //测试正常情况的临界情况，即放入100个元素栈是否会出错
    public void testPush2()
    {
        for (int i = 0; i < 100; i++)
        {
            try
            {
                myStack.push(i + "");
            }
            catch (Exception ex)
            {
                Assert.fail();
            }
        }

        for (int i = 0; i < 100; i++)
        {
            String result = null;

            try
            {
                result = myStack.pop();
            }
            catch (Exception ex)
            {

            }

            Assert.assertEquals((99 - i) + "", result);
        }
    }
    
    //测试异常情况，101个元素输入
    public void testPush3()
    {
        Exception tx = null;

        try
        {
            for (int i = 0; i <= 100; i++)
            {
                myStack.push(i + "");
            }

            Assert.fail();
        }
        catch (Exception ex)
        {
            tx = ex;
        }

        assertData(tx);
    }

    public void testPop()
    {
        try
        {
            myStack.push("hello world");
        }
        catch (Exception e)
        {

        }

        String result = null;

        try
        {
            result = myStack.pop();
        }
        catch (Exception ex)
        {
            Assert.fail();
        }

        Assert.assertEquals("hello world", result);
    }

    public void testPop2()
    {
        Throwable tx = null;

        try
        {
            myStack.pop();

            Assert.fail();
        }
        catch (Exception ex)
        {
            tx = ex;
        }

        assertData(tx);
    }

    public void testPop3()
    {
        Throwable tx = null;

        try
        {
            myStack.push("hello");
        }
        catch (Exception ex)
        {

        }

        try
        {
            myStack.pop();
            myStack.pop();

            Assert.fail();
        }
        catch (Exception ex)
        {
            tx = ex;
        }

        assertData(tx);
    }

    public void testTop()
    {
        try
        {
            myStack.push("hello");
        }
        catch (Exception ex)
        {

        }

        String result = null;

        try
        {
            result = myStack.top();
        }
        catch (Exception ex)
        {
            Assert.fail();
        }

        Assert.assertEquals("hello", result);
    }

    public void testTop2()
    {
        Throwable tx = null;

        try
        {
            myStack.top();

            Assert.fail();
        }
        catch (Exception ex)
        {
            tx = ex;
        }

        assertData(tx);
    }

    public void testDelete()
    {
        try
        {
            for (int i = 0; i < 10; i++)
            {
                myStack.push(i + "");
            }

            myStack.delete(10);
        }
        catch (Exception ex)
        {
            Assert.fail();
        }
    }

    public void testDelete2()
    {
        Throwable tx = null;

        try
        {
            for (int i = 0; i < 10; i++)
            {
                myStack.push(i + "");
            }

            myStack.delete(11);

            Assert.fail();
        }
        catch (Exception ex)
        {
            tx = ex;
        }

        assertData(tx);
    }

    private void assertData(Throwable tx)
    {
        Assert.assertNotNull(tx);
        Assert.assertEquals(Exception.class, tx.getClass());
        Assert.assertEquals("数组越界异常!", tx.getMessage());
    }

}