`

JUnit 3 Demo

 
阅读更多

1.Maven Dependency

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>

	<groupId>org.fool.junit</groupId>
	<artifactId>junit3</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<packaging>jar</packaging>

	<name>junit3</name>
	<url>http://maven.apache.org</url>

	<properties>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
	</properties>

	<dependencies>
		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>3.8.2</version>
			<scope>test</scope>
		</dependency>
	</dependencies>
</project>

 

2.Project Directory


 

3.src/main/java

Calculator.java

package org.fool.junit;

public class Calculator
{
	public int add(int a, int b)
	{
		return a + b;
	}

	public int subtract(int a, int b)
	{
		return a - b;
	}

	public int multiply(int a, int b)
	{
		return a * b;
	}

	public int divide(int a, int b) throws Exception
	{
		if (0 == b)
		{
			throw new Exception("除数不能为0");
		}

		return a / b;
	}
}

 

Calculator2.java

package org.fool.junit;

public class Calculator2
{
	@SuppressWarnings("unused")
	private int add(int a, int b)
	{
		return a + b;
	}
}

 

Largest.java

package org.fool.junit;

public class Largest
{
	public int getLargest(int[] array) throws Exception
	{
		if (null == array || 0 == array.length)
		{
			throw new Exception("数组不能为空！");
		}

		int result = array[0];

		for (int i = 0; i < array.length; i++)
		{
			if (result < array[i])
			{
				result = array[i];
			}
		}

		return result;
	}
}

 

DeleteAll.java

package org.fool.junit;

import java.io.File;

public class DeleteAll
{
	public static void deleteAll(File file)
	{
		if (file.isFile() || file.list().length == 0)
		{
			file.delete();
		}
		else
		{
			File[] files = file.listFiles();

			for (File f : files)
			{
				deleteAll(f);

				f.delete();
			}
		}
	}

	public static void main(String[] args)
	{
		deleteAll(new File("c:\\temp1"));
	}
}

 

MyStack.java

package org.fool.junit;

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];
	}

}

 

4.src/test/java

CalculatorTest.java

package org.fool.junit;

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

/**
 * 测试类必须要继承于TestCase父类
 * 
 * 在JUnit3.8中，测试方法需要满足如下原则：
 * 1. public的 
 * 2. void的 
 * 3. 无方法参数 
 * 4. 方法名称必须以test开头
 */
public class CalculatorTest extends TestCase
{
	private Calculator cal;

	public CalculatorTest(String name)
	{
		super(name);
	}

	@Override
	public void setUp() throws Exception
	{
		cal = new Calculator();
	}

	@Override
	public void tearDown() throws Exception
	{
	}

	public void testAdd()
	{
		int result = cal.add(1, 2);
		Assert.assertEquals(3, result);
	}

	public void testSubtract()
	{
		int result = cal.subtract(1, 2);
		Assert.assertEquals(-1, result);
	}

	public void testMultiply()
	{
		int result = cal.multiply(2, 3);
		Assert.assertEquals(6, result);
	}

	public void testDivide()
	{
		int result = 0;

		try
		{
			result = cal.divide(6, 2);
		}
		catch (Exception e)
		{
			e.printStackTrace();

			Assert.fail();
		}

		Assert.assertEquals(3, result);
	}

	public void testDivideByZero()
	{
		Throwable tx = null;

		try
		{
			cal.divide(6, 0);

			Assert.fail("测试失败");
		}
		catch (Exception e)
		{
			tx = e;
		}

		Assert.assertEquals(Exception.class, tx.getClass());
		Assert.assertEquals("除数不能为0", tx.getMessage());
	}

	public static void main(String[] args)
	{
		junit.awtui.TestRunner.run(CalculatorTest.class);
		// junit.textui.TestRunner.run(CalculatorTest.class);
	}
}

 

Calculator2Test.java

package org.fool.junit;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

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

public class Calculator2Test extends TestCase
{
	// 使用反射在测试类中调用目标类的私有方法（推荐）
	public void testAdd()
	{
		try
		{
			Calculator2 cal2 = new Calculator2();

			Class<Calculator2> clazz = Calculator2.class;

			Method method = clazz.getDeclaredMethod("add", new Class[] {
					Integer.TYPE, Integer.TYPE });

			method.setAccessible(true);

			Object result = method.invoke(cal2, new Object[] { 2, 3 });

			Assert.assertEquals(5, result);
		}
		catch (NoSuchMethodException | SecurityException
				| IllegalAccessException | IllegalArgumentException
				| InvocationTargetException e)
		{
			e.printStackTrace();
		}
	}
}

 

LargestTest.java

package org.fool.junit;

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

public class LargestTest extends TestCase
{
	private Largest largest;

	@Override
	public void setUp() throws Exception
	{
		largest = new Largest();
	}

	@Override
	public void tearDown() throws Exception
	{
	}

	public void testGetLargest()
	{
		int[] array = { 1, 9, -10, -20, 23, 34 };

		int result = 0;

		try
		{
			result = largest.getLargest(array);
		}
		catch (Exception e)
		{
			Assert.fail("测试失败");
		}

		Assert.assertEquals(34, result);
	}

	public void testGetLargest2()
	{
		Throwable throwable = null;

		int[] array = {};

		try
		{
			largest.getLargest(array);

			Assert.fail("测试失败");
		}
		catch (Exception e)
		{
			throwable = e;
		}

		Assert.assertNotNull(throwable);

		Assert.assertEquals(Exception.class, throwable.getClass());

		Assert.assertEquals("数组不能为空！", throwable.getMessage());
	}

	public void testGetLargest3()
	{
		Throwable throwable = null;

		int[] array = null;

		try
		{
			largest.getLargest(array);

			Assert.fail();
		}
		catch (Exception e)
		{
			throwable = e;
		}

		Assert.assertNotNull(throwable);

		Assert.assertEquals(Exception.class, throwable.getClass());

		Assert.assertEquals("数组不能为空！", throwable.getMessage());
	}
}

 

DeleteAllTest.java

package org.fool.junit;

import java.io.File;
import java.io.IOException;

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

public class DeleteAllTest extends TestCase
{
	public void testDeleteAll()
	{
		File file = null;

		try
		{
			file = new File("test.txt");
			file.createNewFile();

			DeleteAll.deleteAll(file);
		}
		catch (IOException e)
		{
			Assert.fail();
		}

		boolean isExist = file.exists();

		Assert.assertFalse(isExist);
	}
	
	/**
	 * 构造的是一个目录结构，其结构表示如下
	 * 
	 *      d
	 *     / \
	 *    /   \
	 *   d1   d2
	 *  / \
	 * /   \
	 *s1   s2
	 */
	public void testDeleteAll2()
	{
		File directory = null;
		
		try
		{
			directory = new File("dir");
			directory.mkdir();
			
			File file1 = new File(directory, "file1.txt");
			File file2 = new File(directory, "file2.txt");
			
			file1.createNewFile();
			file2.createNewFile();
			
			File d1 = new File(directory, "d1");
			File d2 = new File(directory, "d2");
			
			d1.mkdir();
			d2.mkdir();
			
			File subFile1 = new File(d1, "subFile1.txt");
			File subFile2 = new File(d2, "subFile2.txt");
			
			subFile1.createNewFile();
			subFile2.createNewFile();
			
			DeleteAll.deleteAll(directory);
		}
		catch (IOException e)
		{
			e.printStackTrace();
		}
		
		Assert.assertNotNull(directory);
		
		String[] names = directory.list();
		
		Assert.assertEquals(0, names.length);
		
		directory.delete();
	}
}

 

MyStackTest.java

package org.fool.junit;

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

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 e)
		{
		}

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

	public void testPush2()
	{
		for (int i = 0; i < 100; i++)
		{
			try
			{
				myStack.push(i + "");
			}
			catch (Exception e)
			{
				Assert.fail();
			}
		}

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

			try
			{
				result = myStack.pop();
			}
			catch (Exception e)
			{
			}
			
			Assert.assertEquals((99 - i) + "", result);
		}
	}

	public void testPush3()
	{
		Throwable 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 e)
		{
			Assert.fail();
		}

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

	public void testPop2()
	{
		Throwable tx = null;

		try
		{
			myStack.pop();

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

		assertData(tx);
	}

	public void testPop3()
	{
		Throwable tx = null;

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

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

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

		assertData(tx);
	}

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

		String result = null;

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

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

	public void testTop2()
	{
		Throwable tx = null;
		try
		{
			myStack.top();

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

		assertData(tx);
	}

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

			myStack.delete(10);
		}
		catch (Exception e)
		{
			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 e)
		{
			tx = e;
		}

		assertData(tx);
	}

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

 

TestAll.java

package org.fool.junit;

import junit.extensions.RepeatedTest;
import junit.framework.Test;
import junit.framework.TestCase;
import junit.framework.TestSuite;

public class TestAll extends TestCase
{
	public static Test suite()
	{
		TestSuite suite = new TestSuite();

		suite.addTestSuite(CalculatorTest.class);
		suite.addTestSuite(Calculator2Test.class);
		suite.addTestSuite(DeleteAllTest.class);
		suite.addTestSuite(LargestTest.class);
		suite.addTestSuite(MyStackTest.class);

		suite.addTest(new RepeatedTest(new CalculatorTest("testSubtract"), 20));

		return suite;
	}
}

 

 

 

 

  • 大小: 13.5 KB
分享到：
| json-lib解析JSON例子
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    android studio junit测试 demo

    在这个“android studio junit测试 demo”中，我们将探讨如何在Android Studio中设置和执行JUnit测试，特别是针对Activity的测试。 首先，理解JUnit测试的基本概念是关键。JUnit是一个基于Java的测试框架，允许...

    junit测试小demo

    在这个名为"junit测试小demo"的压缩包文件中，我们可以预期它包含了一些关于如何使用Junit进行单元测试的示例代码或教程。 首先，让我们来理解一下Junit的基本概念。Junit是一个开源项目，由Eclipse基金会维护，...

    junit-demo.zip

    【Junit-Demo.zip】是一个压缩包，包含了有关测试驱动开发（TDD）的示例代码，特别适合初学者学习和研究。TDD是一种软件开发方法论，它强调在编写实际功能代码之前先编写测试用例。这种方法有助于确保代码的质量，...

    junit实例demo

    在这个“junit实例demo”中，我们将会深入理解JUnit的工作原理及其核心特性。 1. **JUnit简介** JUnit是开源的、基于Java的测试框架，它遵循XUnit测试框架的设计模式。它简化了对Java代码进行单元测试的过程，通过...

    junit测试demo

    在这个“junit测试demo”中，包含了两种类型的测试：纯Java和基于SSH（Spring、Struts和Hibernate）的应用程序的测试。下面将详细介绍这两个方面的内容。 首先，纯Java的JUnit测试主要涉及以下几个知识点： 1. **...

    junit-demo-源码.rar

    《深入解析JUnit测试框架——基于junit-demo-源码》 JUnit是一款广泛应用于Java编程语言中的单元测试框架，它为开发者提供了简洁、高效的测试工具，使得代码的质量得到了显著提升。通过对"junit-demo-源码"的分析，...

    Junit简介和扩展

    2. **继承TestCase类**：`class Junit3Demo extends TestCase { ... }` 3. **命名测试方法**：测试方法必须以`test`开头，例如`public void test1() { ... }` 4. **使用assert方法**：通过`assertTrue`, `...

    json_jackson_junit_demo.zip

    综上所述，`json_jackson_junit_demo.zip`中的代码示例很可能包括了JSON与Bean、List、Map之间的转换，以及使用JUnit进行的转换测试。这是一份非常实用的学习资源，可以帮助开发者更好地理解和应用Jackson库进行JSON...

    android JUnit demo

    "android JUnit demo" 是一个基于Android 2.2（API Level 8）的示例项目，它展示了如何在Android环境中使用JUnit进行应用程序的单元测试。在这个demo中，我们可以看到两个主要的组成部分：`Spinner` 和 `SpinnerTest...

    ExtJS+SSH+Junit的Demo

    "ExtJS+SSH+Junit的Demo" 这个标题指的是一个示例项目，它结合了三个关键技术：ExtJS（一个用于构建Web应用的JavaScript库）、SSH（Struts2、Spring和Hibernate的集成框架）以及Junit（Java单元测试框架）。...

    Spring整合JUnit示例Demo

    在本文中，我们将深入探讨如何将Spring框架与JUnit测试框架整合，以便进行高效且自动化的单元测试。Spring作为Java企业级应用开发的主流框架，提供了丰富的功能，包括依赖注入、AOP（面向切面编程）等，而JUnit则是...

    springboot整合junit测试用例demo

    本示例将详细介绍如何将JUnit集成到Spring Boot项目中，以便编写和执行测试用例。JUnit是一个广泛使用的Java单元测试框架，它简化了测试过程，使得测试更加便捷高效。 首先，我们需要在Spring Boot项目中引入JUnit...

    JUnit3.8.1 以及使用JUnit测试的代码demo

    JUnit是Java编程语言中最常用的单元测试框架之一，它允许开发者编写可重复运行的测试用例，以确保代码的正确性和稳定性。JUnit3.8.1是该框架的一个较早版本，尽管现在已经有更新的版本（如JUnit5），但了解其基本...

    Junit测试demo

    本篇将深入探讨"Junit测试demo"，旨在帮助您理解如何利用JUnit进行有效的单元测试。 一、JUnit简介 JUnit是XUnit家族的一员，由Ernst von Brühl和Kent Beck在2000年创建。它提供了断言机制、测试注解、测试套件和...

    Junit4Demo:Junit4 演示

    junit4 使用总结 @Test @Test(timeout=毫秒)，@Test(expected=异常类) @Ignore @RunWith @BeforeCalss @AfterClass @Before @After 测试套件@RunWith(Suite.class) 参数化设置@RunWith(Parameterized.class)

    JUnit 4 Demo

    JUnit 4 是一个广泛使用的Java编程语言的单元测试框架，由Ernst Leipold、Kent Beck、Krzysztof Ciesielski和Erich Gamma共同开发。它极大地简化了Java应用程序的测试过程，使得开发者能够编写简洁、易于理解和执行...

    junit5-demo：JUnit 5的演示

    JUnit 5的演示 这是一个示例应用程序，演示了JUnit 5的核心功能，尤其是JUnit Jupiter编程模型。 此外，还提供了使用Spring框架中的Spring TestContext框架以及Spring Boot中的测试支持的演示。 使用以下技术。 ...

    Junit

    在“junit3_demo01”和“junit3_demo02”这两个文件中，我们可能会看到JUnit 3版本的示例。JUnit 3的测试类通常继承自TestCase类，测试方法以“test”开头。例如，一个简单的测试可能如下所示： ```java import org...

    JUnit+Ant+Jacoco整合 简单的Demo源码

    本资源是一个关于JUnit、Ant构建工具和Jacoco代码覆盖率工具整合的简单Demo，非常适合初学者了解和实践这三个工具的集成使用。 首先，JUnit是Java开发中的测试框架，它允许开发者编写针对单个方法的测试用例。JUnit...

    Junit 异常测试demo

    result = calculator.divide(12, 3); } catch (Exception e) { e.printStackTrace(); Assert.fail(); } Assert.assertEquals(4, result); } ``` 在这个测试用例中，我们期望`divide()`方法能正常执行并返回4。...

Magicbox
Global site tag (gtag.js) - Google Analytics