KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > jgrapht > graph > SimpleDirectedGraphTest


1 /* ==========================================
2  * JGraphT : a free Java graph-theory library
3  * ==========================================
4  *
5  * Project Info: http://jgrapht.sourceforge.net/
6  * Project Creator: Barak Naveh (http://sourceforge.net/users/barak_naveh)
7  *
8  * (C) Copyright 2003-2006, by Barak Naveh and Contributors.
9  *
10  * This library is free software; you can redistribute it and/or modify it
11  * under the terms of the GNU Lesser General Public License as published by
12  * the Free Software Foundation; either version 2.1 of the License, or
13  * (at your option) any later version.
14  *
15  * This library is distributed in the hope that it will be useful, but
16  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
17  * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
18  * License for more details.
19  *
20  * You should have received a copy of the GNU Lesser General Public License
21  * along with this library; if not, write to the Free Software Foundation,
22  * Inc.,
23  * 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
24  */
25 /* ----------------------------
26  * SimpleDirectedGraphTest.java
27  * ----------------------------
28  * (C) Copyright 2003-2006, by Barak Naveh and Contributors.
29  *
30  * Original Author: Barak Naveh
31  * Contributor(s): -
32  *
33  * $Id: SimpleDirectedGraphTest.java 504 2006-07-03 02:37:26Z perfecthash $
34  *
35  * Changes
36  * -------
37  * 25-Jul-2003 : Initial revision (BN);
38  *
39  */
40 package org.jgrapht.graph;
41
42 import java.util.*;
43
44 import org.jgrapht.*;
45
46
47 /**
48  * A unit test for simple directed graph.
49  *
50  * @author Barak Naveh
51  * @since Jul 25, 2003
52  */
53 public class SimpleDirectedGraphTest
54     extends EnhancedTestCase
55 {
56
57     //~ Instance fields -------------------------------------------------------
58
59     DirectedGraph<String JavaDoc, DefaultEdge> gEmpty;
60     private DirectedGraph<String JavaDoc, DefaultEdge> g1;
61     private DirectedGraph<String JavaDoc, DefaultEdge> g2;
62     private DirectedGraph<String JavaDoc, DefaultEdge> g3;
63     private DirectedGraph<String JavaDoc, DefaultEdge> g4;
64     private DefaultEdge eLoop;
65     private EdgeFactory<String JavaDoc, DefaultEdge> eFactory;
66     private String JavaDoc v1 = "v1";
67     private String JavaDoc v2 = "v2";
68     private String JavaDoc v3 = "v3";
69     private String JavaDoc v4 = "v4";
70
71     //~ Constructors ----------------------------------------------------------
72
73     /**
74      * @see junit.framework.TestCase#TestCase(java.lang.String)
75      */
76     public SimpleDirectedGraphTest(String JavaDoc name)
77     {
78         super(name);
79     }
80
81     //~ Methods ---------------------------------------------------------------
82
83     /**
84      * Class to test for boolean addEdge(V, V, E)
85      */
86     public void testAddEdgeEdge()
87     {
88         init();
89
90         try {
91             g1.addEdge(v1, v1, eLoop); // loops not allowed
92 assertFalse();
93         } catch (IllegalArgumentException JavaDoc e) {
94             assertTrue();
95         }
96
97         try {
98             g3.addEdge(v1, v1, null);
99             assertFalse(); // NPE
100 } catch (NullPointerException JavaDoc e) {
101             assertTrue();
102         }
103
104         DefaultEdge e = eFactory.createEdge(v2, v1);
105
106         try {
107             g1.addEdge("ya", "ya", e); // no such vertex in graph
108 assertFalse();
109         } catch (IllegalArgumentException JavaDoc ile) {
110             assertTrue();
111         }
112
113         assertEquals(false, g2.addEdge(v2, v1, e));
114         assertEquals(false, g3.addEdge(v2, v1, e));
115         assertEquals(true, g4.addEdge(v2, v1, e));
116     }
117
118     /**
119      * Class to test for Edge addEdge(Object, Object)
120      */
121     public void testAddEdgeObjectObject()
122     {
123         init();
124
125         try {
126             g1.addEdge(v1, v1); // loops not allowed
127 assertFalse();
128         } catch (IllegalArgumentException JavaDoc e) {
129             assertTrue();
130         }
131
132         try {
133             g3.addEdge(null, null);
134             assertFalse(); // NPE
135 } catch (NullPointerException JavaDoc e) {
136             assertTrue();
137         }
138
139         try {
140             g1.addEdge(v2, v1); // no such vertex in graph
141 assertFalse();
142         } catch (IllegalArgumentException JavaDoc ile) {
143             assertTrue();
144         }
145
146         assertNull(g2.addEdge(v2, v1));
147         assertNull(g3.addEdge(v2, v1));
148         assertNotNull(g4.addEdge(v2, v1));
149     }
150
151     /**
152      * .
153      */
154     public void testAddVertex()
155     {
156         init();
157
158         assertEquals(1, g1.vertexSet().size());
159         assertEquals(2, g2.vertexSet().size());
160         assertEquals(3, g3.vertexSet().size());
161         assertEquals(4, g4.vertexSet().size());
162
163         assertFalse(g1.addVertex(v1));
164         assertTrue(g1.addVertex(v2));
165         assertEquals(2, g1.vertexSet().size());
166     }
167
168     /**
169      * Class to test for boolean containsEdge(Edge)
170      */
171     public void testContainsEdgeEdge()
172     {
173         init();
174
175         // TODO Implement containsEdge().
176 }
177
178     /**
179      * Class to test for boolean containsEdge(Object, Object)
180      */
181     public void testContainsEdgeObjectObject()
182     {
183         init();
184
185         assertFalse(g1.containsEdge(v1, v2));
186         assertFalse(g1.containsEdge(v1, v1));
187
188         assertTrue(g2.containsEdge(v1, v2));
189         assertTrue(g2.containsEdge(v2, v1));
190
191         assertTrue(g3.containsEdge(v1, v2));
192         assertTrue(g3.containsEdge(v2, v1));
193         assertTrue(g3.containsEdge(v3, v2));
194         assertTrue(g3.containsEdge(v2, v3));
195         assertTrue(g3.containsEdge(v1, v3));
196         assertTrue(g3.containsEdge(v3, v1));
197
198         assertFalse(g4.containsEdge(v1, v4));
199         g4.addEdge(v1, v4);
200         assertTrue(g4.containsEdge(v1, v4));
201
202         assertFalse(g3.containsEdge(v4, v2));
203         assertFalse(g3.containsEdge(null, null));
204     }
205
206     /**
207      * .
208      */
209     public void testContainsVertex()
210     {
211         init();
212
213         // TODO Implement containsVertex().
214 }
215
216     /**
217      * .
218      */
219     public void testEdgeSet()
220     {
221         init();
222
223         // TODO Implement edgeSet().
224 }
225
226     /**
227      * .
228      */
229     public void testEdgesOf()
230     {
231         init();
232
233         assertEquals(g4.edgesOf(v1).size(), 2);
234         assertEquals(g3.edgesOf(v1).size(), 4);
235
236         Iterator<DefaultEdge> iter = g3.edgesOf(v1).iterator();
237         int count = 0;
238
239         while (iter.hasNext()) {
240             iter.next();
241             count++;
242         }
243
244         assertEquals(count, 4);
245     }
246
247     /**
248      * .
249      */
250     public void testGetAllEdges()
251     {
252         init(); // TODO Implement getAllEdges().
253 }
254
255     /**
256      * .
257      */
258     public void testGetEdge()
259     {
260         init(); // TODO Implement getEdge().
261 }
262
263     /**
264      * .
265      */
266     public void testGetEdgeFactory()
267     {
268         init(); // TODO Implement getEdgeFactory().
269 }
270
271     /**
272      * .
273      */
274     public void testInDegreeOf()
275     {
276         init();
277
278         assertEquals(0, g1.inDegreeOf(v1));
279
280         assertEquals(1, g2.inDegreeOf(v1));
281         assertEquals(1, g2.inDegreeOf(v2));
282
283         assertEquals(2, g3.inDegreeOf(v1));
284         assertEquals(2, g3.inDegreeOf(v2));
285         assertEquals(2, g3.inDegreeOf(v3));
286
287         assertEquals(1, g4.inDegreeOf(v1));
288         assertEquals(1, g4.inDegreeOf(v2));
289         assertEquals(1, g4.inDegreeOf(v3));
290         assertEquals(1, g4.inDegreeOf(v4));
291
292         try {
293             g3.inDegreeOf(new String JavaDoc());
294             assertFalse();
295         } catch (IllegalArgumentException JavaDoc e) {
296             assertTrue();
297         }
298
299         try {
300             g3.inDegreeOf(null);
301             assertFalse();
302         } catch (NullPointerException JavaDoc e) {
303             assertTrue();
304         }
305     }
306
307     /**
308      * .
309      */
310     public void testIncomingOutgoingEdgesOf()
311     {
312         init();
313
314         Set<DefaultEdge> e1to2 = g2.outgoingEdgesOf(v1);
315         Set<DefaultEdge> e2from1 = g2.incomingEdgesOf(v2);
316         assertEquals(e1to2, e2from1);
317     }
318
319     /**
320      * .
321      */
322     public void testOutDegreeOf()
323     {
324         init(); // TODO Implement outDegreeOf().
325 }
326
327     /**
328      * .
329      */
330     public void testOutgoingEdgesOf()
331     {
332         init(); // TODO Implement outgoingEdgesOf().
333 }
334
335     /**
336      * Class to test for boolean removeEdge(Edge)
337      */
338     public void testRemoveEdgeEdge()
339     {
340         init();
341
342         assertEquals(g4.edgeSet().size(), 4);
343         g4.removeEdge(v1, v2);
344         assertEquals(g4.edgeSet().size(), 3);
345         assertFalse(g4.removeEdge(eLoop));
346         assertTrue(g4.removeEdge(g4.getEdge(v2, v3)));
347         assertEquals(g4.edgeSet().size(), 2);
348     }
349
350     /**
351      * Class to test for Edge removeEdge(Object, Object)
352      */
353     public void testRemoveEdgeObjectObject()
354     {
355         init(); // TODO Implement removeEdge().
356 }
357
358     /**
359      * .
360      */
361     public void testRemoveVertex()
362     {
363         init();
364         assertEquals(4, g4.vertexSet().size());
365         assertTrue(g4.removeVertex(v1));
366         assertEquals(3, g4.vertexSet().size());
367
368         assertEquals(2, g4.edgeSet().size());
369         assertFalse(g4.removeVertex(v1));
370         assertTrue(g4.removeVertex(v2));
371         assertEquals(1, g4.edgeSet().size());
372         assertTrue(g4.removeVertex(v3));
373         assertEquals(0, g4.edgeSet().size());
374         assertEquals(1, g4.vertexSet().size());
375         assertTrue(g4.removeVertex(v4));
376         assertEquals(0, g4.vertexSet().size());
377     }
378
379     /**
380      * .
381      */
382     public void testVertexSet()
383     {
384         init(); // TODO Implement vertexSet().
385 }
386
387     private void init()
388     {
389         gEmpty =
390             new SimpleDirectedGraph<String JavaDoc, DefaultEdge>(
391                 DefaultEdge.class);
392         g1 = new SimpleDirectedGraph<String JavaDoc, DefaultEdge>(
393                 DefaultEdge.class);
394         g2 = new SimpleDirectedGraph<String JavaDoc, DefaultEdge>(
395                 DefaultEdge.class);
396         g3 = new SimpleDirectedGraph<String JavaDoc, DefaultEdge>(
397                 DefaultEdge.class);
398         g4 = new SimpleDirectedGraph<String JavaDoc, DefaultEdge>(
399                 DefaultEdge.class);
400
401         eFactory = g1.getEdgeFactory();
402         eLoop = eFactory.createEdge(v1, v1);
403
404         g1.addVertex(v1);
405
406         g2.addVertex(v1);
407         g2.addVertex(v2);
408         g2.addEdge(v1, v2);
409         g2.addEdge(v2, v1);
410
411         g3.addVertex(v1);
412         g3.addVertex(v2);
413         g3.addVertex(v3);
414         g3.addEdge(v1, v2);
415         g3.addEdge(v2, v1);
416         g3.addEdge(v2, v3);
417         g3.addEdge(v3, v2);
418         g3.addEdge(v3, v1);
419         g3.addEdge(v1, v3);
420
421         g4.addVertex(v1);
422         g4.addVertex(v2);
423         g4.addVertex(v3);
424         g4.addVertex(v4);
425         g4.addEdge(v1, v2);
426         g4.addEdge(v2, v3);
427         g4.addEdge(v3, v4);
428         g4.addEdge(v4, v1);
429     }
430 }
431
Popular Tags