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