Source code

001/*
002 * $Id: DistHashTableTest.java 4093 2012-08-12 10:51:06Z kredel $
003 */
004
005package edu.jas.util;
006
007import java.util.Iterator;
008
009import junit.framework.Test;
010import junit.framework.TestCase;
011import junit.framework.TestSuite;
012
013import org.apache.log4j.BasicConfigurator;
014
015
016/**
017 * DistHashTable test with JUnit.
018 * @author Heinz Kredel
019 */
020public class DistHashTableTest extends TestCase {
021
022    /**
023     * main.
024     */
025    public static void main (String[] args) {
026        BasicConfigurator.configure();
027        junit.textui.TestRunner.run( suite() );
028    }
029
030
031    /**
032     * Constructs a <CODE>DistHashTableTest</CODE> object.
033     * @param name String.
034     */
035    public DistHashTableTest(String name) {
036        super(name);
037    }
038
039
040    /**
041     * suite.
042     * @return a test suite.
043     */
044    public static Test suite() {
045        TestSuite suite= new TestSuite(DistHashTableTest.class);
046        return suite;
047    }
048
049    private static final String host = "localhost";
050
051    private DistHashTable<Integer,Integer> l1;
052    private DistHashTable<Integer,Integer> l2;
053    private DistHashTable<Integer,Integer> l3;
054
055    private DistHashTableServer<Integer> dls;
056
057    int rl = 7; 
058    int kl = 10;
059    int ll = 10;
060    int el = 5;
061    float q = 0.5f;
062
063    protected void setUp() {
064        dls = new DistHashTableServer<Integer>();
065        dls.init();
066    }
067
068    protected void tearDown() {
069        dls.terminate();
070        dls = null;
071        if ( l1 != null ) l1.terminate();
072        if ( l2 != null ) l2.terminate();
073        if ( l3 != null ) l3.terminate();
074        l1 = l2 = l3 = null;
075    }
076
077
078    /**
079     * Tests create and terminate DistHashTableServer.
080     */
081    public void testDistHashTable0() {
082    }
083
084
085    /**
086     * Tests create and terminate DistHashTable.
087     */
088    public void testDistHashTable1() {
089        l1 = new DistHashTable<Integer,Integer>(host);
090        l1.init();
091        assertTrue("l1==empty",l1.isEmpty());
092    }
093
094
095    /**
096     * Tests if the created DistHashTable has #n objects as content.
097     */
098    public void testDistHashTable2() {
099        l1 = new DistHashTable<Integer,Integer>(host);
100        l1.init();
101        assertTrue("l1==empty",l1.isEmpty());
102
103        l1.putWait( Integer.valueOf(1), Integer.valueOf(1) );
104        assertFalse("l1!=empty",l1.isEmpty());
105        assertTrue("#l1==1", l1.size() == 1 );
106        l1.putWait( Integer.valueOf(2), Integer.valueOf(2) );
107        assertTrue("#l1==2", l1.size() == 2 );
108        l1.putWait( Integer.valueOf(3), Integer.valueOf(3) );
109        assertTrue("#l1==3", l1.size() == 3 );
110
111        Iterator it = null;
112        it = l1.iterator();
113        int i = 0;
114        while ( it.hasNext() ) {
115            Object k = it.next();
116            Object o = l1.get(k);
117            Integer x = Integer.valueOf( ++i );
118            assertEquals("l1(i)==v(i)", x, o );
119            assertEquals("l1(i)==k(i)", x, k );
120        }
121
122        l1.clear();
123        assertTrue("#l1==0", l1.size() == 0 );
124    }
125
126
127    /**
128     * Tests if the two created DistHashTables have #n objects as content.
129     */
130    public void testDistHashTable3() {
131        l2 = new DistHashTable<Integer,Integer>(host);
132        l2.init();
133        assertTrue("l2==empty",l2.isEmpty());
134        l1 = new DistHashTable<Integer,Integer>(host);
135        l1.init();
136        assertTrue("l1==empty",l1.isEmpty());
137
138        int i = 0, loops = 10;
139        while ( i < loops ) {
140            Integer x = Integer.valueOf( ++i );
141            l1.putWait( x, x );
142            assertTrue("#l1==i", l1.size() == i );
143        }
144        assertTrue("#l1=="+loops, l1.size() == loops );
145
146        while ( l2.size() < loops ) {
147            try {
148                //System.out.print("*2");
149                Thread.sleep(100);
150            } catch (InterruptedException e) {
151            }
152        }
153        assertTrue("#l2=="+loops, l2.size() == loops );
154        Iterator it = null;
155        it = l2.iterator();
156        i = 0;
157        while ( it.hasNext() ) {
158            Object k = it.next();
159            Object o = l2.get(k);
160            Integer x = Integer.valueOf( ++i );
161            //System.out.println("o = " + o + " x = "+ x);
162            assertEquals("l2(i)==k(i)", x, k );
163            assertEquals("l2(i)==v(i)", x, o );
164        }
165    }
166
167
168    /**
169     * Tests if the three created DistHashTables have #n objects as content.
170     */
171    public void testDistHashTable4() {
172        l1 = new DistHashTable<Integer,Integer>(host);
173        l1.init();
174        assertTrue("l1==empty",l1.isEmpty());
175        l2 = new DistHashTable<Integer,Integer>(host);
176        l2.init();
177        assertTrue("l2==empty",l2.isEmpty());
178        l3 = new DistHashTable<Integer,Integer>(host);
179        l3.init();
180        assertTrue("l3==empty",l3.isEmpty());
181
182        int i = 0, loops = 10;
183        while ( i < loops ) {
184            Integer x = Integer.valueOf( ++i );
185            l3.putWait( x, x );
186            assertTrue("#l3==i", l3.size() == i );
187        }
188        assertTrue("#l3=="+loops, l3.size() == loops );
189
190        while ( l2.size() < loops || l1.size() < loops-1 ) {
191            try {
192                //System.out.print("*3");
193                Thread.sleep(100);
194            } catch (InterruptedException e) {
195            }
196        }
197        assertTrue("#l2=="+loops, l2.size() == loops );
198        assertTrue("#l1=="+loops, l1.size() == loops );
199        Iterator it = null;
200        it = l2.iterator();
201        Iterator it3 = null;
202        it3 = l1.iterator();
203        i = 0;
204        while ( it.hasNext() && it3.hasNext() ) {
205            Object k1 = it.next();
206            Object k2 = it3.next();
207            Object v1 = l2.get(k1);
208            Object v2 = l1.get(k2);
209            Integer x = Integer.valueOf( ++i );
210            //System.out.println("o = " + o + " x = "+ x);
211            assertEquals("l2(i)==k(i)", x, k1 );
212            assertEquals("l1(i)==k(i)", x, k2 );
213            assertEquals("l2(i)==v(i)", x, v1 );
214            assertEquals("l1(i)==v(i)", x, v2 );
215        }
216    }
217
218
219    /**
220     * Tests if the two created DistHashTables have #n objects as content 
221     * when one is created later.
222     */
223    public void testDistHashTable5() {
224        l1 = new DistHashTable<Integer,Integer>(host);
225        l1.init();
226        assertTrue("l1==empty",l1.isEmpty());
227
228        int i = 0, loops = 10;
229        while ( i < loops ) {
230            Integer x = Integer.valueOf( ++i );
231            l1.putWait( x, x );
232            assertTrue("#l1==i", l1.size() == i );
233        }
234        assertTrue("#l1=="+loops, l1.size() == loops );
235
236        l2 = new DistHashTable<Integer,Integer>(host);
237        l2.init();
238        // assertTrue("l2==empty",l2.isEmpty());
239        while ( l2.size() < loops ) {
240            try {
241                //System.out.print("*2");
242                Thread.sleep(100);
243            } catch (InterruptedException e) {
244            }
245        }
246        Iterator it = null;
247        it = l2.iterator();
248        i = 0;
249        while ( it.hasNext() ) {
250            Object k = it.next();
251            Object v = l2.get(k);
252            Integer x = Integer.valueOf( ++i );
253            //System.out.println("o = " + o + " x = "+ x);
254            assertEquals("l2(i)==k(i)", x, k );
255            assertEquals("l2(i)==v(i)", x, v );
256        }
257        assertTrue("#l2=="+loops, l2.size() == loops );
258    }
259
260
261    /**
262     * Tests if the two created DistHashTables have #n objects as content 
263     * using getWait() when one is created later.
264     */
265    public void testDistHashTable6() {
266        l1 = new DistHashTable<Integer,Integer>(host);
267        l1.init();
268        assertTrue("l1==empty",l1.isEmpty());
269
270        int i = 0, loops = 10;
271        while ( i < loops ) {
272            Integer x = Integer.valueOf( ++i );
273            l1.putWait( x, x );
274            assertTrue("#l1==i", l1.size() == i );
275        }
276        assertTrue("#l1=="+loops, l1.size() == loops );
277
278        l2 = new DistHashTable<Integer,Integer>(host);
279        l2.init();
280
281        Iterator<Integer> it = null;
282        it = l1.iterator();
283        i = 0;
284        while ( it.hasNext() ) {
285            Integer k = it.next();
286            Integer v = l2.getWait(k);
287            Integer x = Integer.valueOf( ++i );
288            //System.out.println("o = " + o + " x = "+ x);
289            assertEquals("l1(i)==k(i)", x, k );
290            assertEquals("l2(i)==v(i)", x, v );
291        }
292        assertTrue("#l2=="+loops, l2.size() == loops );
293    }
294
295}