001 /*
002 * $Id: DistHashTableTest.java 2799 2009-08-31 21:43:36Z kredel $
003 */
004
005 package edu.jas.util;
006
007 import java.util.Iterator;
008
009 import junit.framework.Test;
010 import junit.framework.TestCase;
011 import junit.framework.TestSuite;
012
013 import org.apache.log4j.BasicConfigurator;
014
015
016 /**
017 * DistHashTable test with JUnit.
018 * @author Heinz Kredel
019 */
020 public 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 assertTrue("l1==empty",l1.isEmpty());
091 }
092
093
094 /**
095 * Tests if the created DistHashTable has #n objects as content.
096 */
097 public void testDistHashTable2() {
098 l1 = new DistHashTable<Integer,Integer>(host);
099 assertTrue("l1==empty",l1.isEmpty());
100
101 l1.putWait( new Integer(1), new Integer(1) );
102 assertFalse("l1!=empty",l1.isEmpty());
103 assertTrue("#l1==1", l1.size() == 1 );
104 l1.putWait( new Integer(2), new Integer(2) );
105 assertTrue("#l1==2", l1.size() == 2 );
106 l1.putWait( new Integer(3), new Integer(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 = new Integer( ++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 assertTrue("l2==empty",l2.isEmpty());
131 l1 = new DistHashTable<Integer,Integer>(host);
132 assertTrue("l1==empty",l1.isEmpty());
133
134 int i = 0, loops = 10;
135 while ( i < loops ) {
136 Integer x = new Integer( ++i );
137 l1.putWait( x, x );
138 assertTrue("#l1==i", l1.size() == i );
139 }
140 assertTrue("#l1=="+loops, l1.size() == loops );
141
142 while ( l2.size() < loops ) {
143 try {
144 //System.out.print("*2");
145 Thread.sleep(100);
146 } catch (InterruptedException e) {
147 }
148 }
149 assertTrue("#l2=="+loops, l2.size() == loops );
150 Iterator it = null;
151 it = l2.iterator();
152 i = 0;
153 while ( it.hasNext() ) {
154 Object k = it.next();
155 Object o = l2.get(k);
156 Integer x = new Integer( ++i );
157 //System.out.println("o = " + o + " x = "+ x);
158 assertEquals("l2(i)==k(i)", x, k );
159 assertEquals("l2(i)==v(i)", x, o );
160 }
161 }
162
163
164 /**
165 * Tests if the three created DistHashTables have #n objects as content.
166 */
167 public void testDistHashTable4() {
168 l1 = new DistHashTable<Integer,Integer>(host);
169 assertTrue("l1==empty",l1.isEmpty());
170 l2 = new DistHashTable<Integer,Integer>(host);
171 assertTrue("l2==empty",l2.isEmpty());
172 l3 = new DistHashTable<Integer,Integer>(host);
173 assertTrue("l3==empty",l3.isEmpty());
174
175 int i = 0, loops = 10;
176 while ( i < loops ) {
177 Integer x = new Integer( ++i );
178 l3.putWait( x, x );
179 assertTrue("#l3==i", l3.size() == i );
180 }
181 assertTrue("#l3=="+loops, l3.size() == loops );
182
183 while ( l2.size() < loops || l1.size() < loops-1 ) {
184 try {
185 //System.out.print("*3");
186 Thread.sleep(100);
187 } catch (InterruptedException e) {
188 }
189 }
190 assertTrue("#l2=="+loops, l2.size() == loops );
191 assertTrue("#l1=="+loops, l1.size() == loops );
192 Iterator it = null;
193 it = l2.iterator();
194 Iterator it3 = null;
195 it3 = l1.iterator();
196 i = 0;
197 while ( it.hasNext() && it3.hasNext() ) {
198 Object k1 = it.next();
199 Object k2 = it3.next();
200 Object v1 = l2.get(k1);
201 Object v2 = l1.get(k2);
202 Integer x = new Integer( ++i );
203 //System.out.println("o = " + o + " x = "+ x);
204 assertEquals("l2(i)==k(i)", x, k1 );
205 assertEquals("l1(i)==k(i)", x, k2 );
206 assertEquals("l2(i)==v(i)", x, v1 );
207 assertEquals("l1(i)==v(i)", x, v2 );
208 }
209 }
210
211
212 /**
213 * Tests if the two created DistHashTables have #n objects as content
214 * when one is created later.
215 */
216 public void testDistHashTable5() {
217 l1 = new DistHashTable<Integer,Integer>(host);
218 assertTrue("l1==empty",l1.isEmpty());
219
220 int i = 0, loops = 10;
221 while ( i < loops ) {
222 Integer x = new Integer( ++i );
223 l1.putWait( x, x );
224 assertTrue("#l1==i", l1.size() == i );
225 }
226 assertTrue("#l1=="+loops, l1.size() == loops );
227
228 l2 = new DistHashTable<Integer,Integer>(host);
229 // assertTrue("l2==empty",l2.isEmpty());
230 while ( l2.size() < loops ) {
231 try {
232 //System.out.print("*2");
233 Thread.sleep(100);
234 } catch (InterruptedException e) {
235 }
236 }
237 Iterator it = null;
238 it = l2.iterator();
239 i = 0;
240 while ( it.hasNext() ) {
241 Object k = it.next();
242 Object v = l2.get(k);
243 Integer x = new Integer( ++i );
244 //System.out.println("o = " + o + " x = "+ x);
245 assertEquals("l2(i)==k(i)", x, k );
246 assertEquals("l2(i)==v(i)", x, v );
247 }
248 assertTrue("#l2=="+loops, l2.size() == loops );
249 }
250
251
252 /**
253 * Tests if the two created DistHashTables have #n objects as content
254 * using getWait() when one is created later.
255 */
256 public void testDistHashTable6() {
257 l1 = new DistHashTable<Integer,Integer>(host);
258 assertTrue("l1==empty",l1.isEmpty());
259
260 int i = 0, loops = 10;
261 while ( i < loops ) {
262 Integer x = new Integer( ++i );
263 l1.putWait( x, x );
264 assertTrue("#l1==i", l1.size() == i );
265 }
266 assertTrue("#l1=="+loops, l1.size() == loops );
267
268 l2 = new DistHashTable<Integer,Integer>(host);
269
270 Iterator<Integer> it = null;
271 it = l1.iterator();
272 i = 0;
273 while ( it.hasNext() ) {
274 Integer k = it.next();
275 Integer v = l2.getWait(k);
276 Integer x = new Integer( ++i );
277 //System.out.println("o = " + o + " x = "+ x);
278 assertEquals("l1(i)==k(i)", x, k );
279 assertEquals("l2(i)==v(i)", x, v );
280 }
281 assertTrue("#l2=="+loops, l2.size() == loops );
282 }
283
284 }