001/*
002 * $Id: DistHashTableTest.java 4601 2013-08-25 11:37:13Z 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        l1.clear();
167        assertTrue("l1==empty",l1.isEmpty());
168        while ( l2.size() > 0 ) {
169            try {
170                //System.out.print("*5");
171                Thread.sleep(100);
172            } catch (InterruptedException e) {
173            }
174        }
175        assertTrue("l2==empty",l2.isEmpty());
176    }
177
178
179    /**
180     * Tests if the three created DistHashTables have #n objects as content.
181     */
182    public void testDistHashTable4() {
183        l1 = new DistHashTable<Integer,Integer>(host);
184        l1.init();
185        assertTrue("l1==empty",l1.isEmpty());
186        l2 = new DistHashTable<Integer,Integer>(host);
187        l2.init();
188        assertTrue("l2==empty",l2.isEmpty());
189        l3 = new DistHashTable<Integer,Integer>(host);
190        l3.init();
191        assertTrue("l3==empty",l3.isEmpty());
192
193        int i = 0, loops = 10;
194        while ( i < loops ) {
195            Integer x = Integer.valueOf( ++i );
196            l3.putWait( x, x );
197            assertTrue("#l3==i", l3.size() == i );
198        }
199        assertTrue("#l3=="+loops, l3.size() == loops );
200
201        while ( l2.size() < loops || l1.size() < loops-1 ) {
202            try {
203                //System.out.print("*3");
204                Thread.sleep(100);
205            } catch (InterruptedException e) {
206            }
207        }
208        assertTrue("#l2=="+loops, l2.size() == loops );
209        assertTrue("#l1=="+loops, l1.size() == loops );
210        Iterator it = null;
211        it = l2.iterator();
212        Iterator it3 = null;
213        it3 = l1.iterator();
214        i = 0;
215        while ( it.hasNext() && it3.hasNext() ) {
216            Object k1 = it.next();
217            Object k2 = it3.next();
218            Object v1 = l2.get(k1);
219            Object v2 = l1.get(k2);
220            Integer x = Integer.valueOf( ++i );
221            //System.out.println("o = " + o + " x = "+ x);
222            assertEquals("l2(i)==k(i)", x, k1 );
223            assertEquals("l1(i)==k(i)", x, k2 );
224            assertEquals("l2(i)==v(i)", x, v1 );
225            assertEquals("l1(i)==v(i)", x, v2 );
226        }
227        
228        l1.clear();
229        assertTrue("l1==empty",l1.isEmpty());
230        while ( l2.size() > 0 || l3.size() > 0 ) {
231            try {
232                //System.out.print("*4");
233                Thread.sleep(100);
234            } catch (InterruptedException e) {
235            }
236        }
237        assertTrue("l2==empty",l2.isEmpty());
238        assertTrue("l3==empty",l3.isEmpty());
239    }
240
241
242    /**
243     * Tests if the two created DistHashTables have #n objects as content 
244     * when one is created later.
245     */
246    public void testDistHashTable5() {
247        l1 = new DistHashTable<Integer,Integer>(host);
248        l1.init();
249        assertTrue("l1==empty",l1.isEmpty());
250
251        int i = 0, loops = 10;
252        while ( i < loops ) {
253            Integer x = Integer.valueOf( ++i );
254            l1.putWait( x, x );
255            assertTrue("#l1==i", l1.size() == i );
256        }
257        assertTrue("#l1=="+loops, l1.size() == loops );
258
259        l2 = new DistHashTable<Integer,Integer>(host);
260        l2.init();
261        // assertTrue("l2==empty",l2.isEmpty());
262        while ( l2.size() < loops ) {
263            try {
264                //System.out.print("*2");
265                Thread.sleep(100);
266            } catch (InterruptedException e) {
267            }
268        }
269        Iterator it = null;
270        it = l2.iterator();
271        i = 0;
272        while ( it.hasNext() ) {
273            Object k = it.next();
274            Object v = l2.get(k);
275            Integer x = Integer.valueOf( ++i );
276            //System.out.println("o = " + o + " x = "+ x);
277            assertEquals("l2(i)==k(i)", x, k );
278            assertEquals("l2(i)==v(i)", x, v );
279        }
280        assertTrue("#l2=="+loops, l2.size() == loops );
281    }
282
283
284    /**
285     * Tests if the two created DistHashTables have #n objects as content 
286     * using getWait() when one is created later.
287     */
288    public void testDistHashTable6() {
289        l1 = new DistHashTable<Integer,Integer>(host);
290        l1.init();
291        assertTrue("l1==empty",l1.isEmpty());
292
293        int i = 0, loops = 10;
294        while ( i < loops ) {
295            Integer x = Integer.valueOf( ++i );
296            l1.putWait( x, x );
297            assertTrue("#l1==i", l1.size() == i );
298        }
299        assertTrue("#l1=="+loops, l1.size() == loops );
300
301        l2 = new DistHashTable<Integer,Integer>(host);
302        l2.init();
303
304        Iterator<Integer> it = null;
305        it = l1.iterator();
306        i = 0;
307        while ( it.hasNext() ) {
308            Integer k = it.next();
309            Integer v = l2.getWait(k);
310            Integer x = Integer.valueOf( ++i );
311            //System.out.println("o = " + o + " x = "+ x);
312            assertEquals("l1(i)==k(i)", x, k );
313            assertEquals("l2(i)==v(i)", x, v );
314        }
315        assertTrue("#l2=="+loops, l2.size() == loops );
316    }
317
318}