Community Company Search Contact

JAssertTest.java from redshed at Krugle

Show JAssertTest.java syntax highlighted

// JAssertTest.java
//   <http://redshed.sf.net/JAssert>
//
// Copyright (c) 2001 Red Shed Software. All rights reserved.
// by Jonathan 'Wolf' Rentzsch (jon at redshed dot net)
// 
// Class to test the JAssert class. Relies on JUnit <http://www.junit.org>.
//
// Mon Dec 24 2001 wolf: Created.

import junit.framework.*;

public class JAssertTest extends TestCase {
	JAssertTestFailureHandler _failureHandler;

	public JAssertTest(String name) { 
        super(name); 
    }
 
    public static void main(String args[]) { 
        junit.textui.TestRunner.run( JAssertTest.class );
        //junit.awtui.TestRunner.run( JAssertTest.class );
        //junit.swingui.TestRunner.run( JAssertTest.class );
    }
	
	protected void setUp() {
		// Put any initialization here.
		_failureHandler = new JAssertTestFailureHandler();
		JAssert.setFailureHandler( _failureHandler );
	}
	
	public void testTrue() {
		JAssert.isTrue( true );
		assertTrue( !_failureHandler.failed() );
		
		JAssert.isTrue( false );
		assertTrue( _failureHandler.failed() );
	}
	
	public void testFalse() {
		JAssert.isFalse( true );
		assertTrue( _failureHandler.failed() );
		
		JAssert.isFalse( false );
		assertTrue( !_failureHandler.failed() );
	}
	
	public void testNull() {
		Object nullObject = null;
		Object object = new Object();
		
		JAssert.isNull( nullObject );
		assertTrue( !_failureHandler.failed() );
		
		JAssert.isNull( object );
		assertTrue( _failureHandler.failed() );
		
		JAssert.notNull( nullObject );
		assertTrue( _failureHandler.failed() );
		
		JAssert.notNull( object );
		assertTrue( !_failureHandler.failed() );
	}
	
	public void testEmpty() {
		String nullString = null;
		String emptyString = "";
		String nonEmptyString = "wolf";
		
		JAssert.isEmpty( nullString );
		assertTrue( !_failureHandler.failed() );
		
		JAssert.isEmpty( emptyString );
		assertTrue( !_failureHandler.failed() );
		
		JAssert.isEmpty( nonEmptyString );
		assertTrue( _failureHandler.failed() );
		
		JAssert.notEmpty( nullString );
		assertTrue( _failureHandler.failed() );
		
		JAssert.notEmpty( emptyString );
		assertTrue( _failureHandler.failed() );
		
		JAssert.notEmpty( nonEmptyString );
		assertTrue( !_failureHandler.failed() );
	}
	
	public void testZeroInt() {
		int	zeroInt = 0;
		int oneInt = 1;
		
		JAssert.isZero( zeroInt );
		assertTrue( !_failureHandler.failed() );
		
		JAssert.isZero( oneInt );
		assertTrue( _failureHandler.failed() );
		
		JAssert.notZero( zeroInt );
		assertTrue( _failureHandler.failed() );
		
		JAssert.notZero( oneInt );
		assertTrue( !_failureHandler.failed() );
	}
	
	public void testZeroLong() {
		long zeroLong = 0L;
		long oneLong = 1L;
		
		JAssert.isZero( zeroLong );
		assertTrue( !_failureHandler.failed() );
		
		JAssert.isZero( oneLong );
		assertTrue( _failureHandler.failed() );
		
		JAssert.notZero( zeroLong );
		assertTrue( _failureHandler.failed() );
		
		JAssert.notZero( oneLong );
		assertTrue( !_failureHandler.failed() );
	}
	
	public void testZeroDouble() {
		double zeroDouble = 0.0;
		double oneDouble = 1.0;
		
		JAssert.isZero( zeroDouble );
		assertTrue( !_failureHandler.failed() );
		
		JAssert.isZero( oneDouble );
		assertTrue( _failureHandler.failed() );
		
		JAssert.notZero( zeroDouble );
		assertTrue( _failureHandler.failed() );
		
		JAssert.notZero( oneDouble );
		assertTrue( !_failureHandler.failed() );
	}
	
	public void testNegativeInt() {
		int positiveInt = 1;
		int zeroInt = 0;
		int negativeInt = -1;
		
		JAssert.isNegative( positiveInt );
		assertTrue( _failureHandler.failed() );
		
		JAssert.isNegative( zeroInt );
		assertTrue( _failureHandler.failed() );
		
		JAssert.isNegative( negativeInt );
		assertTrue( !_failureHandler.failed() );
		
		JAssert.notNegative( positiveInt );
		assertTrue( !_failureHandler.failed() );
		
		JAssert.notNegative( zeroInt );
		assertTrue( !_failureHandler.failed() );
		
		JAssert.notNegative( negativeInt );
		assertTrue( _failureHandler.failed() );
	}
	
	public void testNegativeLong() {
		long positiveLong = 1L;
		long zeroLong = 0L;
		long negativeLong = -1L;
		
		JAssert.isNegative( positiveLong );
		assertTrue( _failureHandler.failed() );
		
		JAssert.isNegative( zeroLong );
		assertTrue( _failureHandler.failed() );
		
		JAssert.isNegative( negativeLong );
		assertTrue( !_failureHandler.failed() );
		
		JAssert.notNegative( positiveLong );
		assertTrue( !_failureHandler.failed() );
		
		JAssert.notNegative( zeroLong );
		assertTrue( !_failureHandler.failed() );
		
		JAssert.notNegative( negativeLong );
		assertTrue( _failureHandler.failed() );
	}
	
	public void testNegativeDouble() {
		double positiveDouble = 1.0;
		double zeroDouble = 0.0;
		double negativeDouble = -1.0;
		
		JAssert.isNegative( positiveDouble );
		assertTrue( _failureHandler.failed() );
		
		JAssert.isNegative( zeroDouble );
		assertTrue( _failureHandler.failed() );
		
		JAssert.isNegative( negativeDouble );
		assertTrue( !_failureHandler.failed() );
		
		JAssert.notNegative( positiveDouble );
		assertTrue( !_failureHandler.failed() );
		
		JAssert.notNegative( zeroDouble );
		assertTrue( !_failureHandler.failed() );
		
		JAssert.notNegative( negativeDouble );
		assertTrue( _failureHandler.failed() );
	}
	
	public void testPositiveInt() {
		int positiveInt = 1;
		int zeroInt = 0;
		int negativeInt = -1;
		
		JAssert.isPositive( positiveInt );
		assertTrue( !_failureHandler.failed() );
		
		JAssert.isPositive( zeroInt );
		assertTrue( !_failureHandler.failed() );
		
		JAssert.isPositive( negativeInt );
		assertTrue( _failureHandler.failed() );
		
		JAssert.notPositive( positiveInt );
		assertTrue( _failureHandler.failed() );
		
		JAssert.notPositive( zeroInt );
		assertTrue( _failureHandler.failed() );
		
		JAssert.notPositive( negativeInt );
		assertTrue( !_failureHandler.failed() );
	}
	
	public void testPositiveLong() {
		long positiveLong = 1L;
		long zeroLong = 0L;
		long negativeLong = -1L;
		
		JAssert.isPositive( positiveLong );
		assertTrue( !_failureHandler.failed() );
		
		JAssert.isPositive( zeroLong );
		assertTrue( !_failureHandler.failed() );
		
		JAssert.isPositive( negativeLong );
		assertTrue( _failureHandler.failed() );
		
		JAssert.notPositive( positiveLong );
		assertTrue( _failureHandler.failed() );
		
		JAssert.notPositive( zeroLong );
		assertTrue( _failureHandler.failed() );
		
		JAssert.notPositive( negativeLong );
		assertTrue( !_failureHandler.failed() );
	}
	
	public void testPositiveDouble() {
		double positiveDouble = 1.0;
		double zeroDouble = 0.0;
		double negativeDouble = -1.0;
		
		JAssert.isPositive( positiveDouble );
		assertTrue( !_failureHandler.failed() );
		
		JAssert.isPositive( zeroDouble );
		assertTrue( !_failureHandler.failed() );
		
		JAssert.isPositive( negativeDouble );
		assertTrue( _failureHandler.failed() );
		
		JAssert.notPositive( positiveDouble );
		assertTrue( _failureHandler.failed() );
		
		JAssert.notPositive( zeroDouble );
		assertTrue( _failureHandler.failed() );
		
		JAssert.notPositive( negativeDouble );
		assertTrue( !_failureHandler.failed() );
	}
	
	public void testEqualInt() {
		int originalInt = 1;
		int equalInt = 1;
		int unequalInt = 2;
		
		JAssert.isEqual( originalInt, equalInt );
		assertTrue( !_failureHandler.failed() );
		
		JAssert.isEqual( originalInt, unequalInt );
		assertTrue( _failureHandler.failed() );
		
		JAssert.notEqual( originalInt, equalInt );
		assertTrue( _failureHandler.failed() );
		
		JAssert.notEqual( originalInt, unequalInt );
		assertTrue( !_failureHandler.failed() );
	}
	
	public void testEqualLong() {
		long originalLong = 1;
		long equalLong = 1;
		long unequalLong = 2;
		
		JAssert.isEqual( originalLong, equalLong );
		assertTrue( !_failureHandler.failed() );
		
		JAssert.isEqual( originalLong, unequalLong );
		assertTrue( _failureHandler.failed() );
		
		JAssert.notEqual( originalLong, equalLong );
		assertTrue( _failureHandler.failed() );
		
		JAssert.notEqual( originalLong, unequalLong );
		assertTrue( !_failureHandler.failed() );
	}
	
	public void testEqualDouble() {
		double originalDouble = 1.0;
		double equalDouble = 1.0;
		double unequalDouble = 2.0;
		
		JAssert.isEqual( originalDouble, equalDouble );
		assertTrue( !_failureHandler.failed() );
		
		JAssert.isEqual( originalDouble, unequalDouble );
		assertTrue( _failureHandler.failed() );
		
		JAssert.notEqual( originalDouble, equalDouble );
		assertTrue( _failureHandler.failed() );
		
		JAssert.notEqual( originalDouble, unequalDouble );
		assertTrue( !_failureHandler.failed() );
	}
	
	public void testEqualObject() {
		Integer originalObject = new Integer( 1 );
		Integer equalObject = new Integer( 1 );
		Integer unequalObject = new Integer( 2 );
		Thread anotherUnequalObject = new Thread();
		
		JAssert.isEqual( originalObject, equalObject );
		assertTrue( !_failureHandler.failed() );
		
		JAssert.isEqual( originalObject, unequalObject );
		assertTrue( _failureHandler.failed() );
		
		JAssert.isEqual( originalObject, anotherUnequalObject );
		assertTrue( _failureHandler.failed() );
		
		JAssert.notEqual( originalObject, equalObject );
		assertTrue( _failureHandler.failed() );
		
		JAssert.notEqual( originalObject, unequalObject );
		assertTrue( !_failureHandler.failed() );
		
		JAssert.notEqual( originalObject, anotherUnequalObject );
		assertTrue( !_failureHandler.failed() );
	}
	
	public void testLessThanInt() {
		int zeroInt = 0;
		int oneInt = 1;
		
		JAssert.lessThan( zeroInt, oneInt );
		assertTrue( !_failureHandler.failed() );
		
		JAssert.lessThan( oneInt, zeroInt );
		assertTrue( _failureHandler.failed() );
		
		JAssert.lessThanOrEqual( zeroInt, oneInt );
		assertTrue( !_failureHandler.failed() );
		
		JAssert.lessThanOrEqual( zeroInt, zeroInt );
		assertTrue( !_failureHandler.failed() );
		
		JAssert.lessThanOrEqual( oneInt, zeroInt );
		assertTrue( _failureHandler.failed() );
		
		JAssert.lessThanOrEqual( oneInt, oneInt );
		assertTrue( !_failureHandler.failed() );
	}
	
	public void testLessThanLong() {
		long zeroLong = 0;
		long oneLong = 1;
		
		JAssert.lessThan( zeroLong, oneLong );
		assertTrue( !_failureHandler.failed() );
		
		JAssert.lessThan( oneLong, zeroLong );
		assertTrue( _failureHandler.failed() );
		
		JAssert.lessThanOrEqual( zeroLong, oneLong );
		assertTrue( !_failureHandler.failed() );
		
		JAssert.lessThanOrEqual( zeroLong, zeroLong );
		assertTrue( !_failureHandler.failed() );
		
		JAssert.lessThanOrEqual( oneLong, zeroLong );
		assertTrue( _failureHandler.failed() );
		
		JAssert.lessThanOrEqual( oneLong, oneLong );
		assertTrue( !_failureHandler.failed() );
	}
	
	public void testLessThanDouble() {
		double zeroDouble = 0.0;
		double oneDouble = 1.0;
		
		JAssert.lessThan( zeroDouble, oneDouble );
		assertTrue( !_failureHandler.failed() );
		
		JAssert.lessThan( oneDouble, zeroDouble );
		assertTrue( _failureHandler.failed() );
		
		JAssert.lessThanOrEqual( zeroDouble, oneDouble );
		assertTrue( !_failureHandler.failed() );
		
		JAssert.lessThanOrEqual( zeroDouble, zeroDouble );
		assertTrue( !_failureHandler.failed() );
		
		JAssert.lessThanOrEqual( oneDouble, zeroDouble );
		assertTrue( _failureHandler.failed() );
		
		JAssert.lessThanOrEqual( oneDouble, oneDouble );
		assertTrue( !_failureHandler.failed() );
	}
	
	public void testGreaterThanInt() {
		int oneInt = 1;
		int zeroInt = 0;
		
		JAssert.greaterThan( oneInt, zeroInt );
		assertTrue( !_failureHandler.failed() );
		
		JAssert.greaterThan( zeroInt, oneInt );
		assertTrue( _failureHandler.failed() );
		
		JAssert.greaterThanOrEqual( oneInt, zeroInt );
		assertTrue( !_failureHandler.failed() );
		
		JAssert.greaterThanOrEqual( zeroInt, zeroInt );
		assertTrue( !_failureHandler.failed() );
		
		JAssert.greaterThanOrEqual( zeroInt, oneInt );
		assertTrue( _failureHandler.failed() );
		
		JAssert.greaterThanOrEqual( oneInt, oneInt );
		assertTrue( !_failureHandler.failed() );
	}
	
	public void testGreaterThanLong() {
		long oneLong = 1;
		long zeroLong = 0;
		
		JAssert.greaterThan( oneLong, zeroLong );
		assertTrue( !_failureHandler.failed() );
		
		JAssert.greaterThan( zeroLong, oneLong );
		assertTrue( _failureHandler.failed() );
		
		JAssert.greaterThanOrEqual( oneLong, zeroLong );
		assertTrue( !_failureHandler.failed() );
		
		JAssert.greaterThanOrEqual( zeroLong, zeroLong );
		assertTrue( !_failureHandler.failed() );
		
		JAssert.greaterThanOrEqual( zeroLong, oneLong );
		assertTrue( _failureHandler.failed() );
		
		JAssert.greaterThanOrEqual( oneLong, oneLong );
		assertTrue( !_failureHandler.failed() );
	}
	
	public void testGreaterThanDouble() {
		double oneDouble = 1.0;
		double zeroDouble = 0.0;
		
		JAssert.greaterThan( oneDouble, zeroDouble );
		assertTrue( !_failureHandler.failed() );
		
		JAssert.greaterThan( zeroDouble, oneDouble );
		assertTrue( _failureHandler.failed() );
		
		JAssert.greaterThanOrEqual( oneDouble, zeroDouble );
		assertTrue( !_failureHandler.failed() );
		
		JAssert.greaterThanOrEqual( zeroDouble, zeroDouble );
		assertTrue( !_failureHandler.failed() );
		
		JAssert.greaterThanOrEqual( zeroDouble, oneDouble );
		assertTrue( _failureHandler.failed() );
		
		JAssert.greaterThanOrEqual( oneDouble, oneDouble );
		assertTrue( !_failureHandler.failed() );
	}
	
	public void testSwitchCase() {
		int[] numbers = { 1, 2, 3, 4 };
		
		for( int i = 0; i < numbers.length; i++ ) {
			int value = numbers[ i ];
			
			// Only handle odd numbers.
			switch( value ) {
				case 1:
					break;
				case 3:
					break;
				default:
					JAssert.unknownSwitchCase( value );
			}
			
			if( ( value % 2 ) == 0 )
				//	value is even.
				assertTrue( _failureHandler.failed() );
			else
				//	value is odd.
				assertTrue( !_failureHandler.failed() );
		}
	}
	
	protected void tearDown() {
		//	Put any explicit resource releasing here.
		JAssert.setFailureHandler( null );
	}
}

See more files for this project here

redshed

Code for Mac+WebObjects.

Project homepage: http://sourceforge.net/projects/redshed
Programming language(s): C,Java,Objective C
License: other

  WebObjects/
    JAssertFramework/
      JAssertFramework.pbproj/
        project.pbxproj
  JAssert.java
  JAssertTest.java
  JAssertTestFailureHandler.java
  junit.jar
  worksheet.sh