halfdan/eva2
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Started to add unit tests.

Browse Source 
Refactored IntegerArrayList, which is now not needed anymore (who implemented this in the first place?)
Auto-Formatted DPointSetMultiIcon -> it was just so badly formatted I had to do auto formatting to make it readable.

Added test for eva2.tools.StringTools (partly at least)
This commit is contained in:
Fabian Becker 2012-04-20 09:13:21 +00:00
parent dcbb488bb9
commit af82e0e5a2
4 changed files with 386 additions and 475 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
src/eva2/gui/DPointSetMultiIcon.java
View File

@ -8,7 +8,6 @@ import java.awt.Point;
import java.awt.Stroke; import java.awt.Stroke;
import java.util.ArrayList; import java.util.ArrayList;
import eva2.tools.IntegerArrayList;
import eva2.tools.chart2d.DArray; import eva2.tools.chart2d.DArray;
import eva2.tools.chart2d.DBorder; import eva2.tools.chart2d.DBorder;
import eva2.tools.chart2d.DComponent; import eva2.tools.chart2d.DComponent;
@ -37,7 +36,7 @@ public class DPointSetMultiIcon extends DComponent
class JumpManager class JumpManager
{ {
protected int index = -1; protected int index = -1;
protected IntegerArrayList jumps = new IntegerArrayList(); protected ArrayList<Integer> jumps = new ArrayList<Integer>();
public void addJump() public void addJump()
{ {

161
src/eva2/tools/IntegerArrayList.java
View File

@ -1,161 +0,0 @@
/**
* Filename: $RCSfile: IntegerArrayList.java,v $
* Purpose: This class is similar to 'java.util.ArrayList', except that it can
* only hold and manage integer values.
* Language: Java
* Compiler: JDK 1.2
* Authors: Fred Rapp
* Version: $Revision: 1.1.1.1 $
* $Date: 2003/07/03 14:59:40 $
* $Author: ulmerh $
* Copyright (c) Dept. Computer Architecture, University of Tuebingen, Germany
*/
package eva2.tools;
/*==========================================================================*
* CLASS DECLARATION
*==========================================================================*/
/**
* This class is similar to 'java.util.ArrayList', except that it can
* only hold and manage integer values.
*/
public class IntegerArrayList
{
/*-------------------------------------------------------------------------*
* private member variables
*-------------------------------------------------------------------------*/
private int[] integerArray = null;
private int integerCount = 0;
private int initialSize;
private int incrementFactor;
/*------------------------------------------------------------------------*
* constructor
*------------------------------------------------------------------------*/
public IntegerArrayList()
{
// call other constructor with default values
this(100, 3);
}
public IntegerArrayList(int initialSize, int incrementFactor)
{
this.initialSize = initialSize;
this.incrementFactor = incrementFactor;
// create new integer array of initial size
integerArray = new int[initialSize];
}
public void destroy() { integerArray = null; integerCount = 0; }
/*-------------------------------------------------------------------------*
* public methods
*-------------------------------------------------------------------------*/
/**
* Clears the contents of this integer list and sets it back to it's initial state.
*/
public void clear() { integerArray = new int[initialSize]; integerCount = 0; }
/**
* Returns the number of components in this list.
*/
public int size() { return integerCount; }
/**
* Parses given string to integer and adds it to the integer list.
* @return true if parsing was successful, false if an error occured.
*/
public boolean add(String stringValue)
{
boolean success = false;
try {
int value = Integer.parseInt(stringValue);
add(value);
success = true;
}
catch (Exception e) {}
return success;
}
/**
* Adds a new integer value to the integer list.
*/
public void add(int value)
{
// check integer array size
if (integerCount == integerArray.length)
{
// increase size of int array
int old_length = integerArray.length;
int new_length = incrementFactor * old_length;
int[] new_array = new int[new_length];
for (int i=0; i<old_length; i++) {
new_array[i] = integerArray[i];
}
integerArray = new_array;
}
// add given value to array
integerArray[integerCount++] = value;
}
/**
* Returns the integer value at the given position or 'min-value' if out of array bounds.
*/
public int get(int index)
{
if ((index < 0) || (index >= integerCount)) { return Integer.MIN_VALUE; }
return integerArray[index];
}
/**
* Returns the contents of this list as an array of integer values.
* @param exactLength determines if the returned array should have the exactly right length, or if longer arrays are allowed
*/
public int[] getIntegerArray(boolean exactLength)
{
// check if we can simply return our internal integer array
if (!exactLength || (integerArray.length == integerCount)) { return integerArray; }
// make a copy of the array with the exactly right length
int size = integerCount;
int[] new_array = new int[ size];
for (int i=0; i< size; i++) { new_array[i] = integerArray[i]; }
return new_array;
}
/**
* Returns the contents of this list as an array of double values.
*/
public double[] getDoubleArray()
{
// make a copy of the array
int size = integerCount;
double[] new_array = new double[ size];
for (int i=0; i< size; i++) { new_array[i] = integerArray[i]; }
return new_array;
}
/**
* Returns the contents of this list as an array of strings.
*/
public String[] getStringArray()
{
// make a copy of the array
int size = integerCount;
String[] new_array = new String[ size];
for (int i=0; i<size; i++) { new_array[i] = "" + integerArray[i]; }
return new_array;
}
}
/****************************************************************************
* END OF FILE
****************************************************************************/

296
src/eva2/tools/chart2d/DPointSet.java
View File

@ -1,144 +1,133 @@
/** /**
* Filename: $RCSfile: DPointSet.java,v $ * Filename: $RCSfile: DPointSet.java,v $ Purpose: Language: Java Compiler: JDK 1.3 Authors: Fabian
* Purpose: * Hennecke Version: $Revision: 1.1.1.1 $ $Date: 2003/07/03 14:59:42 $ $Author: ulmerh $ Copyright
* Language: Java * (c) Dept. Computer Architecture, University of Tuebingen, Germany
* Compiler: JDK 1.3
* Authors: Fabian Hennecke
* Version: $Revision: 1.1.1.1 $
* $Date: 2003/07/03 14:59:42 $
* $Author: ulmerh $
* Copyright (c) Dept. Computer Architecture, University of Tuebingen, Germany
*/ */
package eva2.tools.chart2d; package eva2.tools.chart2d;
/*==========================================================================* /*
* IMPORTS * ==========================================================================* IMPORTS
*==========================================================================*/ *==========================================================================
*/
import java.awt.*;
import java.awt.* ;
import eva2.tools.IntegerArrayList;
import eva2.tools.math.Mathematics; import eva2.tools.math.Mathematics;
import java.util.ArrayList;
/*==========================================================================* public class DPointSet extends DComponent {
* CLASS DECLARATION
*==========================================================================*/
public class DPointSet extends DComponent
{
protected DPointIcon icon = null; protected DPointIcon icon = null;
/*-------------------------------------------------------------------------* /*
* private member variables * -------------------------------------------------------------------------* private member
*-------------------------------------------------------------------------*/ * variables
*-------------------------------------------------------------------------
*/
protected DIntDoubleMap x, y; protected DIntDoubleMap x, y;
protected boolean connected; protected boolean connected;
protected Stroke stroke = new BasicStroke(); protected Stroke stroke = new BasicStroke();
protected JumpManager jumper = new JumpManager(); protected JumpManager jumper = new JumpManager();
/*-------------------------------------------------------------------------* /*
* constructor * -------------------------------------------------------------------------* constructor
*-------------------------------------------------------------------------*/ *-------------------------------------------------------------------------
public DPointSet(){ */
public DPointSet() {
this(10, 2); this(10, 2);
} }
public DPointSet(int initial_capacity) {
public DPointSet( int initial_capacity ){
this(initial_capacity, 2); this(initial_capacity, 2);
} }
public DPointSet( int initial_capacity, int length_multiplier ){ public DPointSet(int initial_capacity, int length_multiplier) {
this( new DArray(initial_capacity, length_multiplier), this(new DArray(initial_capacity, length_multiplier),
new DArray(initial_capacity, length_multiplier) ); new DArray(initial_capacity, length_multiplier));
} }
public DPointSet(DIntDoubleMap x_values, DIntDoubleMap y_values){ public DPointSet(DIntDoubleMap x_values, DIntDoubleMap y_values) {
if( x_values.getSize() != y_values.getSize() ) throw if (x_values.getSize() != y_values.getSize()) {
new IllegalArgumentException( throw new IllegalArgumentException(
"The number of x-values has to be the same than the number of y-values" "The number of x-values has to be the same than the number of y-values");
); }
x = x_values; x = x_values;
y = y_values; y = y_values;
restore(); restore();
setDBorder(new DBorder(1,1,1,1)); setDBorder(new DBorder(1, 1, 1, 1));
} }
/*-------------------------------------------------------------------------* /*
* public methods * -------------------------------------------------------------------------* public methods
*-------------------------------------------------------------------------*/ *-------------------------------------------------------------------------
*/
public void paint( DMeasures m ){ public void paint(DMeasures m) {
Graphics2D g = (Graphics2D)m.getGraphics(); Graphics2D g = (Graphics2D) m.getGraphics();
g.setStroke(stroke); g.setStroke(stroke);
if( color != null ) g.setColor( color ); if (color != null) {
g.setColor(color);
}
int size = getSize(); int size = getSize();
if( connected && size > 1 ){ if (connected && size > 1) {
jumper.restore(); jumper.restore();
while( jumper.hasMoreIntervals() ){ while (jumper.hasMoreIntervals()) {
int[] interval = jumper.nextInterval(); int[] interval = jumper.nextInterval();
Point p1 = null, p2; Point p1 = null, p2;
for( int i=interval[0]; i<interval[1]; i++ ){ for (int i = interval[0]; i < interval[1]; i++) {
p2 = m.getPoint( x.getImage(i), y.getImage(i) ); p2 = m.getPoint(x.getImage(i), y.getImage(i));
if( p1 != null) if (p1 != null) {
g.drawLine( p1.x, p1.y, p2.x, p2.y ); g.drawLine(p1.x, p1.y, p2.x, p2.y);
if( icon != null ){ }
g.setStroke( new BasicStroke() ); if (icon != null) {
g.setStroke(new BasicStroke());
g.translate(p2.x, p2.y); g.translate(p2.x, p2.y);
icon.paint(g); icon.paint(g);
g.translate(-p2.x, -p2.y); g.translate(-p2.x, -p2.y);
g.setStroke( stroke ); g.setStroke(stroke);
} }
p1 = p2; p1 = p2;
} }
} }
} } else {
else{
Point p; Point p;
for( int i=0; i<size; i++ ){ for (int i = 0; i < size; i++) {
p = m.getPoint( x.getImage(i), y.getImage(i) ); p = m.getPoint(x.getImage(i), y.getImage(i));
if( icon == null ){ if (icon == null) {
g.drawLine(p.x - 1, p.y - 1, p.x + 1, p.y + 1); g.drawLine(p.x - 1, p.y - 1, p.x + 1, p.y + 1);
g.drawLine(p.x + 1, p.y - 1, p.x - 1, p.y + 1); g.drawLine(p.x + 1, p.y - 1, p.x - 1, p.y + 1);
} } else {
else{ g.setStroke(new BasicStroke());
g.setStroke( new BasicStroke() );
g.translate(p.x, p.y); g.translate(p.x, p.y);
icon.paint(g); icon.paint(g);
g.translate(-p.x, -p.y); g.translate(-p.x, -p.y);
} }
} }
} }
g.setStroke( new BasicStroke() ); g.setStroke(new BasicStroke());
} }
public void addDPoint( DPoint p ){ public void addDPoint(DPoint p) {
x.addImage(p.x); x.addImage(p.x);
y.addImage(p.y); y.addImage(p.y);
rectangle.insert(p); rectangle.insert(p);
repaint(); repaint();
} }
public void addDPoint( double x, double y ){ public void addDPoint(double x, double y) {
addDPoint(new DPoint(x, y)); addDPoint(new DPoint(x, y));
} }
/** /**
* method causes the DPointSet to interupt the connected painting at the * method causes the DPointSet to interupt the connected painting at the current position
* current position
*/ */
public void jump(){ public void jump() {
jumper.addJump(); jumper.addJump();
} }
/** /**
* method removes all jump positions * method removes all jump positions if the DPointSet is connected, all points will be painted
* if the DPointSet is connected, all points will be painted connected to * connected to their following point
* their following point
*/ */
public void removeJumps(){ public void removeJumps() {
jumper.reset(); jumper.reset();
} }
@ -148,15 +137,15 @@ public class DPointSet extends DComponent
* @param index the index of the DPoint * @param index the index of the DPoint
* @return the DPoint at the given index * @return the DPoint at the given index
*/ */
public DPoint getDPoint( int index ){ public DPoint getDPoint(int index) {
if( index >= x.getSize() ) { if (index >= x.getSize()) {
System.out.println("getDPoint() index"+index); System.out.println("getDPoint() index" + index);
System.out.println("x.getSize() "+x.getSize()); System.out.println("x.getSize() " + x.getSize());
throw new ArrayIndexOutOfBoundsException(index); throw new ArrayIndexOutOfBoundsException(index);
} }
DPoint p = new DPoint( x.getImage( index ), y.getImage( index ) ); DPoint p = new DPoint(x.getImage(index), y.getImage(index));
p.setIcon( icon ); p.setIcon(icon);
p.setColor( color ); p.setColor(color);
return p; return p;
} }
@ -166,11 +155,13 @@ public class DPointSet extends DComponent
* @param index the index of the point * @param index the index of the point
* @param p the point to insert * @param p the point to insert
*/ */
public void setDPoint( int index, DPoint p ){ public void setDPoint(int index, DPoint p) {
if( index >= x.getSize() ) throw new ArrayIndexOutOfBoundsException(index); if (index >= x.getSize()) {
throw new ArrayIndexOutOfBoundsException(index);
}
rectangle.insert(p); rectangle.insert(p);
x.setImage(index,p.x); x.setImage(index, p.x);
y.setImage(index,p.y); y.setImage(index, p.y);
restore(); restore();
repaint(); repaint();
} }
@ -180,10 +171,13 @@ public class DPointSet extends DComponent
* *
* @param icon the DPointIcon * @param icon the DPointIcon
*/ */
public void setIcon( DPointIcon icon ){ public void setIcon(DPointIcon icon) {
this.icon = icon; this.icon = icon;
if( icon == null ) setDBorder(new DBorder(1,1,1,1)); if (icon == null) {
else setDBorder( icon.getDBorder() ); setDBorder(new DBorder(1, 1, 1, 1));
} else {
setDBorder(icon.getDBorder());
}
} }
/** /**
@ -191,18 +185,20 @@ public class DPointSet extends DComponent
* *
* @return the DPointIcon * @return the DPointIcon
*/ */
public DPointIcon getIcon(){ public DPointIcon getIcon() {
return icon; return icon;
} }
/** /**
* method sets the stroke of the line * method sets the stroke of the line if the points were not connected, they now will be
* if the points were not connected, they now will be connected * connected
* *
* @param s the new stroke * @param s the new stroke
*/ */
public void setStroke( Stroke s ){ public void setStroke(Stroke s) {
if( s == null ) s = new BasicStroke(); if (s == null) {
s = new BasicStroke();
}
stroke = s; stroke = s;
repaint(); repaint();
} }
@ -212,7 +208,7 @@ public class DPointSet extends DComponent
* *
* @return the stroke * @return the stroke
*/ */
public Stroke getStroke(){ public Stroke getStroke() {
return stroke; return stroke;
} }
@ -229,14 +225,18 @@ public class DPointSet extends DComponent
return y.getMinPositiveImageValue(); return y.getMinPositiveImageValue();
} }
public void setConnected( boolean aFlag ){ public void setConnected(boolean aFlag) {
boolean changed = !( aFlag == connected ); boolean changed = !(aFlag == connected);
connected = aFlag; connected = aFlag;
if( changed ) repaint(); if (changed) {
repaint();
}
} }
public void removeAllPoints(){ public void removeAllPoints() {
if( x.getSize() == 0 ) return; if (x.getSize() == 0) {
return;
}
x.reset(); x.reset();
y.reset(); y.reset();
jumper.reset(); jumper.reset();
@ -244,27 +244,32 @@ public class DPointSet extends DComponent
rectangle = DRectangle.getEmpty(); rectangle = DRectangle.getEmpty();
} }
public String toString(){ public String toString() {
String text = "eva2.tools.chart2d.DPointSet[size:"+getSize(); String text = "eva2.tools.chart2d.DPointSet[size:" + getSize();
for( int i=0; i<x.getSize(); i++ ) for (int i = 0; i < x.getSize(); i++) {
text += ",("+x.getImage(i)+","+y.getImage(i)+")"; text += ",(" + x.getImage(i) + "," + y.getImage(i) + ")";
}
text += "]"; text += "]";
return text; return text;
} }
/** /**
* method returns the index to the nearest <code>DPoint</code> in this <code>DPointSet</code>. * method returns the index to the nearest
* <code>DPoint</code> in this
* <code>DPointSet</code>.
* *
* @return the index to the nearest <code>DPoint</code>. -1 if no nearest <code>DPoint</code> was found. * @return the index to the nearest
* <code>DPoint</code>. -1 if no nearest
* <code>DPoint</code> was found.
*/ */
public int getNearestDPointIndex(DPoint point){ public int getNearestDPointIndex(DPoint point) {
double minValue = Double.MAX_VALUE; double minValue = Double.MAX_VALUE;
int minIndex = -1; int minIndex = -1;
for( int i=0; i<x.getSize(); i++ ){ for (int i = 0; i < x.getSize(); i++) {
double dx = point.x - x.getImage(i); double dx = point.x - x.getImage(i);
double dy = point.y - y.getImage(i); double dy = point.y - y.getImage(i);
double dummy = dx*dx + dy*dy; double dummy = dx * dx + dy * dy;
if (dummy < minValue){ if (dummy < minValue) {
minValue = dummy; minValue = dummy;
minIndex = i; minIndex = i;
} }
@ -273,15 +278,21 @@ public class DPointSet extends DComponent
} }
/** /**
* method returns the nearest <code>DPoint</code> in this <code>DPointSet</code>. * method returns the nearest
* <code>DPoint</code> in this
* <code>DPointSet</code>.
* *
* @return the nearest <code>DPoint</code> * @return the nearest
* <code>DPoint</code>
*/ */
public DPoint getNearestDPoint(DPoint point){ public DPoint getNearestDPoint(DPoint point) {
int minIndex = getNearestDPointIndex(point); int minIndex = getNearestDPointIndex(point);
if(minIndex == -1) return null; if (minIndex == -1) {
else return new DPoint(x.getImage(minIndex), y.getImage(minIndex)); return null;
} else {
return new DPoint(x.getImage(minIndex), y.getImage(minIndex));
}
} }
// public int getSize(){ // public int getSize(){
@ -296,16 +307,16 @@ public class DPointSet extends DComponent
/** /**
* *
*/ */
public int getSize(){ // testhu public int getSize() { // testhu
int size = x.getSize(); int size = x.getSize();
if( size <= y.getSize() ) if (size <= y.getSize()) {
return size; return size;
}
return x.getSize(); return x.getSize();
} }
protected void restore() {
protected void restore(){ if (getSize() == 0) {
if( getSize() == 0){
rectangle = DRectangle.getEmpty(); rectangle = DRectangle.getEmpty();
return; return;
} }
@ -313,56 +324,59 @@ public class DPointSet extends DComponent
max_x = x.getMaxImageValue(), max_x = x.getMaxImageValue(),
min_y = y.getMinImageValue(), min_y = y.getMinImageValue(),
max_y = y.getMaxImageValue(); max_y = y.getMaxImageValue();
if (Mathematics.areFinite(min_x, max_x, min_y, max_y) == -1) if (Mathematics.areFinite(min_x, max_x, min_y, max_y) == -1) {
rectangle = new DRectangle(min_x, min_y, max_x - min_x, max_y - min_y ); rectangle = new DRectangle(min_x, min_y, max_x - min_x, max_y - min_y);
// else }
// System.err.println("Warning, rectangle not restored due to invalid (infinite/NaN) values.");
} }
/** /**
* this class stores the jump positions (see this.jump) * this class stores the jump positions (see this.jump)
*/ */
class JumpManager{ class JumpManager {
protected IntegerArrayList jumps = new IntegerArrayList();
protected ArrayList<Integer> jumps = new ArrayList<Integer>();
protected int index = -1; protected int index = -1;
public void addJump(){ public void addJump() {
jumps.add(getSize()); jumps.add(getSize());
} }
public int[] nextInterval(){ public int[] nextInterval() {
int no_jumps = jumps.size(); int noJumps = jumps.size();
if( index >= no_jumps ) throw if (index >= noJumps) {
new ArrayIndexOutOfBoundsException("No more intervals in JumpManager"); throw new ArrayIndexOutOfBoundsException("No more intervals in JumpManager");
}
int[] inter = new int[2]; int[] inter = new int[2];
if( index == -1 ) inter[0] = 0; if (index == -1) {
else inter[0] = jumps.get(index); inter[0] = 0;
} else {
inter[0] = jumps.get(index);
}
index++; index++;
if( index < no_jumps ) inter[1] = jumps.get(index); if (index < noJumps) {
else inter[1] = getSize(); inter[1] = jumps.get(index);
} else {
inter[1] = getSize();
}
return inter; return inter;
} }
public boolean hasMoreIntervals(){ public boolean hasMoreIntervals() {
return index < jumps.size(); return index < jumps.size();
} }
public void restore(){ public void restore() {
index = -1; index = -1;
} }
public void reset(){ public void reset() {
index = -1; index = -1;
jumps.clear(); jumps.clear();
} }
} }
} }
/****************************************************************************
* END OF FILE
****************************************************************************/

59
test/eva2/tools/StringToolsTest.java Normal file
View File

@ -0,0 +1,59 @@
package eva2.tools;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import org.junit.After;
import static org.junit.Assert.assertEquals;
import org.junit.Before;
import org.junit.Test;
/**
*
* @author becker
*/
public class StringToolsTest {
public StringToolsTest() {
}
@Before
public void setUp() {
}
@After
public void tearDown() {
}
/**
* Test of humaniseCamelCase method, of class StringTools.
*/
@Test
public void testHumaniseCamelCase() {
HashMap<String, String> map = new HashMap<String, String>();
map.put("camelCase", "Camel Case");
map.put("Camel Case", "Camel Case");
map.put("thisIsAwesome", "This Is Awesome");
map.put("THQIsNice", "THQ Is Nice");
map.put("iLikeABC", "I Like ABC");
String key, value;
Iterator iter = map.entrySet().iterator();
while (iter.hasNext()) {
Map.Entry pairs = (Map.Entry) iter.next();
key = (String) pairs.getKey();
value = (String) pairs.getValue();
String result = StringTools.humaniseCamelCase(key);
assertEquals(value, result);
}
}
/**
* Test of upcaseFirst method, of class StringTools.
*/
@Test
public void testUpcaseFirst() {
assertEquals("Camel", StringTools.upcaseFirst("camel"));
assertEquals("UpWeGo", StringTools.upcaseFirst("upWeGo"));
}
}