001/*
002 * $Id: ExecutableChannelsTest.java 3789 2011-10-01 18:54:43Z kredel $
003 */
004
005package edu.jas.util;
006
007import java.io.FileNotFoundException;
008import java.io.IOException;
009
010import junit.framework.Test;
011import junit.framework.TestCase;
012import junit.framework.TestSuite;
013
014import org.apache.log4j.BasicConfigurator;
015
016//import edu.unima.ky.parallel.ChannelFactory;
017
018
019/**
020 * ExecutableChannels tests with JUnit.
021 * @author Heinz Kredel
022 */
023
024public class ExecutableChannelsTest extends TestCase {
025
026/**
027 * main.
028 */
029   public static void main (String[] args) {
030          BasicConfigurator.configure();
031          junit.textui.TestRunner.run( suite() );
032   }
033
034/**
035 * Constructs a <CODE>ExecutableChannelsTest</CODE> object.
036 * @param name String.
037 */
038   public ExecutableChannelsTest(String name) {
039          super(name);
040   }
041
042/**
043 * suite.
044 */ 
045 public static Test suite() {
046     TestSuite suite= new TestSuite(ExecutableChannelsTest.class);
047     return suite;
048   }
049
050   private static final String host = "localhost";
051   private static final int port = ChannelFactory.DEFAULT_PORT;
052   private static final String mfile = ExecutableChannels.DEFAULT_MFILE;
053
054   private ExecutableChannels ec;
055   private ExecutableServer es;
056
057   protected void setUp() {
058       ec = null;
059       es = new ExecutableServer(port);
060       es.init();
061   }
062
063   protected void tearDown() {
064       es.terminate();
065       es = null;
066       if ( ec != null ) {
067          ec.close();
068          ec = null;
069       }
070   }
071
072
073/**
074 * Tests if the ExecutableChannels could be initialized with null.
075 */
076 public void testExecutableChannels1() {
077     String[] servers = null;
078     ec = new ExecutableChannels(servers);
079     assertEquals("numServers<0", -1, ec.numServers() );
080     assertEquals("numChannels<0", -1, ec.numChannels() );
081     String ts = "" + ec;
082     assertEquals("toString", "ExecutableChannels()", ts );
083   }
084
085
086/**
087 * Tests if the ExecutableChannels could be initialized with small server array.
088 */
089 public void testExecutableChannels2() {
090     int nums = 1;
091     String[] servers = new String[nums];
092     for ( int i = 0; i < nums; i++ ) {
093         servers[i] = host + ":" + port;
094     }
095     ec = new ExecutableChannels(servers);
096     assertEquals("numServers==1", 1, ec.numServers() );
097     assertEquals("numChannels<0", -1, ec.numChannels() );
098     String ts = "" + ec;
099     assertEquals("toString", "ExecutableChannels("+host+":"+port+")", ts );
100   }
101
102
103/**
104 * Tests if the ExecutableChannels could be initialized with big server array.
105 */
106 public void testExecutableChannels3() {
107     int nums = 100;
108     String[] servers = new String[nums];
109     for ( int i = 0; i < nums; i++ ) {
110         servers[i] = host + ":" + port;
111     }
112     ec = new ExecutableChannels(servers);
113     assertEquals("numServers==100", 100, ec.numServers() );
114     assertEquals("numChannels<0", -1, ec.numChannels() );
115     String ts = "" + ec;
116     int l = "ExecutableChannels()".length() + nums * servers[0].length() + nums-1;
117     assertEquals("toString.length()", l, ts.length());
118   }
119
120
121/**
122 * Tests if the ExecutableChannels could be initialized and opened.
123 */
124 public void testExecutableChannels4() {
125     int nums = 2;
126     int numc = nums - 1;
127     String[] servers = new String[nums];
128     for ( int i = 0; i < nums; i++ ) {
129         servers[i] = host + ":" + port;
130     }
131     ec = new ExecutableChannels(servers);
132     assertEquals("numServers==2", nums, ec.numServers() );
133     assertEquals("numChannels<0", -1, ec.numChannels() );
134     String ts = "" + ec;
135     int l = "ExecutableChannels()".length() + nums * servers[0].length() + nums-1;
136     assertEquals("toString.length()", l, ts.length());
137     try {
138         ec.open();
139         assertEquals("numServers==1", nums, ec.numServers() );
140         assertEquals("numServers==numChannels", numc, ec.numChannels() );
141     } catch (IOException e) {
142         fail("open()"+e);
143     }
144     ec.close();
145     assertEquals("numChannels<0", -1, ec.numChannels() );
146   }
147
148
149/**
150 * Tests if 11 ExecutableChannels could be initialized and opened.
151 */
152 public void testExecutableChannels5() {
153     int nums = 11; // max 11 by some limit on number of threads
154     int numc = nums - 1;
155     String[] servers = new String[nums];
156     for ( int i = 0; i < nums; i++ ) {
157         servers[i] = host + ":" + port;
158     }
159     ec = new ExecutableChannels(servers);
160     assertEquals("numServers==1", nums, ec.numServers() );
161     assertEquals("numChannels<0", -1, ec.numChannels() );
162     String ts = "" + ec;
163     int l = "ExecutableChannels()".length() + nums * servers[0].length() + nums-1;
164     assertEquals("toString.length()", l, ts.length());
165     try {
166         ec.open();
167         assertEquals("numServers==1", nums, ec.numServers() );
168         assertEquals("numServers==numChannels", numc, ec.numChannels() );
169     } catch (IOException e) {
170         fail("open()"+e);
171     }
172     ec.close();
173     assertEquals("numChannels<0", -1, ec.numChannels() );
174   }
175
176
177/**
178 * Tests if 10 ExecutableChannels to 1 server could be initialized and opened.
179 */
180 public void testExecutableChannels6() {
181     int nums = 2; // max 11 by some limit on number of threads
182     int numc = 10; // max 11 by some limit on number of threads
183     String[] servers = new String[nums];
184     for ( int i = 0; i < nums; i++ ) {
185         servers[i] = host + ":" + port;
186     }
187     ec = new ExecutableChannels(servers);
188     assertEquals("numServers==1", nums, ec.numServers() );
189     assertEquals("numChannels<0", -1, ec.numChannels() );
190     try {
191         ec.open(numc);
192         assertEquals("numServers==1", nums, ec.numServers() );
193         assertEquals("numServers==numChannels", numc, ec.numChannels() );
194     } catch (IOException e) {
195         fail("open()"+e);
196     }
197     ec.close();
198     assertEquals("numChannels<0", -1, ec.numChannels() );
199   }
200
201
202/**
203 * Tests if 5 ExecutableChannels to 10 servers could be initialized and opened.
204 */
205 public void testExecutableChannels7() {
206     int nums = 10; // max 11 by some limit on number of threads
207     int numc = 5; // max 11 by some limit on number of threads
208     String[] servers = new String[nums];
209     for ( int i = 0; i < nums; i++ ) {
210         servers[i] = host + ":" + port;
211     }
212     ec = new ExecutableChannels(servers);
213     assertEquals("numServers==1", nums, ec.numServers() );
214     assertEquals("numChannels<0", -1, ec.numChannels() );
215     try {
216         ec.open(numc);
217         assertEquals("numServers==1", nums, ec.numServers() );
218         assertEquals("numServers==numChannels", numc, ec.numChannels() );
219     } catch (IOException e) {
220         fail("open()"+e);
221     }
222     ec.close();
223     assertEquals("numChannels<0", -1, ec.numChannels() );
224   }
225
226
227/**
228 * Tests if the ExecutableChannels could be initialized with servers from file.
229 */
230 public void testExecutableChannels8() {
231     try {
232         ec = new ExecutableChannels( mfile );
233     } catch (FileNotFoundException e) {
234         fail("readfile()"+e);
235     }
236     assertEquals("numServers==4", 4, ec.numServers() );
237     assertEquals("numChannels<0", -1, ec.numChannels() );
238     int numc = ec.numServers();
239     try {
240         ec.open(numc);
241         assertEquals("numServers==numChannels", numc, ec.numChannels() );
242     } catch (IOException e) {
243         fail("open()"+e);
244     }
245     ec.close();
246     assertEquals("numChannels<0", -1, ec.numChannels() );
247   }
248
249
250/**
251 * Tests if the ExecutableChannels could be initialized with servers from file.
252 */
253 public void testExecutableChannels9() {
254     try {
255         ec = new ExecutableChannels( mfile );
256     } catch (FileNotFoundException e) {
257         fail("readfile()"+e);
258     }
259     assertEquals("numServers==4", 4, ec.numServers() );
260     assertEquals("numChannels<0", -1, ec.numChannels() );
261     int numc = 10;
262     try {
263         ec.open(numc);
264         assertEquals("numServers==numChannels", numc, ec.numChannels() );
265     } catch (IOException e) {
266         fail("open()"+e);
267     }
268     ec.close();
269     assertEquals("numChannels<0", -1, ec.numChannels() );
270   }
271
272
273}