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