1   /*
2    * Copyright 2003-2004 The Apache Software Foundation.
3    * 
4    * Licensed under the Apache License, Version 2.0 (the "License");
5    * you may not use this file except in compliance with the License.
6    * You may obtain a copy of the License at
7    * 
8    *      http://www.apache.org/licenses/LICENSE-2.0
9    * 
10   * Unless required by applicable law or agreed to in writing, software
11   * distributed under the License is distributed on an "AS IS" BASIS,
12   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13   * See the License for the specific language governing permissions and
14   * limitations under the License.
15   */
16  package org.apache.commons.math.random;
17  
18  import junit.framework.Test;
19  import junit.framework.TestSuite;
20  import java.net.URL;
21  
22  import org.apache.commons.math.RetryTestCase;
23  import org.apache.commons.math.stat.descriptive.SummaryStatistics;
24   
25  /**
26   * Test cases for the ValueServer class.
27   *
28   * @version $Revision: 155427 $ $Date: 2005-02-26 06:11:52 -0700 (Sat, 26 Feb 2005) $
29   */
30  
31  public final class ValueServerTest extends RetryTestCase {
32  
33      private ValueServer vs = new ValueServer();
34      
35      public ValueServerTest(String name) {
36          super(name);
37      }
38  
39      public void setUp() {
40          vs.setMode(ValueServer.DIGEST_MODE);
41          try {
42              URL url = getClass().getResource("testData.txt");
43              vs.setValuesFileURL(url); 
44          } catch (Exception ex) {
45              fail("malformed test URL");
46          }
47      }
48  
49      public static Test suite() {
50          TestSuite suite = new TestSuite(ValueServerTest.class);
51          suite.setName("ValueServer Tests");
52          return suite;
53      }
54  
55     
56      /** 
57        * Generate 1000 random values and make sure they look OK.<br>
58        * Note that there is a non-zero (but very small) probability that
59        * these tests will fail even if the code is working as designed.
60        */
61      public void testNextDigest() throws Exception{
62          double next = 0.0;
63          double tolerance = 0.1;
64          vs.computeDistribution();
65          assertTrue("empirical distribution property", 
66              vs.getEmpiricalDistribution() != null);
67          SummaryStatistics stats = SummaryStatistics.newInstance();
68          for (int i = 1; i < 1000; i++) {
69              next = vs.getNext();
70              stats.addValue(next);
71          }    
72          assertEquals("mean", 5.069831575018909, stats.getMean(), tolerance);
73          assertEquals
74           ("std dev", 1.0173699343977738, stats.getStandardDeviation(), 
75              tolerance);
76          
77          vs.computeDistribution(500);
78          stats = SummaryStatistics.newInstance();
79          for (int i = 1; i < 1000; i++) {
80              next = vs.getNext();
81              stats.addValue(next);
82          }    
83          assertEquals("mean", 5.069831575018909, stats.getMean(), tolerance);
84          assertEquals
85           ("std dev", 1.0173699343977738, stats.getStandardDeviation(), 
86              tolerance);
87          
88      }
89      
90      /**
91        * Make sure exception thrown if digest getNext is attempted
92        * before loading empiricalDistribution.
93        */
94      public void testNextDigestFail() throws Exception {
95          try {
96              vs.getNext();
97              fail("Expecting IllegalStateException");
98          } catch (IllegalStateException ex) {;}
99      }
100     
101     /**
102      * Test ValueServer REPLAY_MODE using values in testData file.<br> 
103      * Check that the values 1,2,1001,1002 match data file values 1 and 2.
104      * the sample data file.
105      */
106     public void testReplay() throws Exception {
107         double firstDataValue = 4.038625496201205;
108         double secondDataValue = 3.6485326248346936;
109         double tolerance = 10E-15;
110         double compareValue = 0.0d;
111         vs.setMode(ValueServer.REPLAY_MODE);
112         vs.resetReplayFile();
113         compareValue = vs.getNext();
114         assertEquals(compareValue,firstDataValue,tolerance);
115         compareValue = vs.getNext();
116         assertEquals(compareValue,secondDataValue,tolerance);
117         for (int i = 3; i < 1001; i++) {
118            compareValue = vs.getNext();
119         }
120         compareValue = vs.getNext();
121         assertEquals(compareValue,firstDataValue,tolerance);
122         compareValue = vs.getNext();
123         assertEquals(compareValue,secondDataValue,tolerance);
124         vs.closeReplayFile();
125         // make sure no NPE
126         vs.closeReplayFile();
127     }
128     
129     /** 
130      * Test other ValueServer modes
131      */
132     public void testModes() throws Exception {
133         vs.setMode(ValueServer.CONSTANT_MODE);
134         vs.setMu(0);
135         assertEquals("constant mode test",vs.getMu(),vs.getNext(),Double.MIN_VALUE);
136         vs.setMode(ValueServer.UNIFORM_MODE);
137         vs.setMu(2);
138         double val = vs.getNext();
139         assertTrue(val > 0 && val < 4);
140         vs.setSigma(1);
141         vs.setMode(ValueServer.GAUSSIAN_MODE);
142         val = vs.getNext();
143         assertTrue("gaussian value close enough to mean",
144             val < vs.getMu() + 100*vs.getSigma());
145         vs.setMode(ValueServer.EXPONENTIAL_MODE);
146         val = vs.getNext();
147         assertTrue(val > 0);
148         try {
149             vs.setMode(1000);
150             vs.getNext();
151             fail("bad mode, expecting IllegalStateException");
152         } catch (IllegalStateException ex) {
153             ;
154         }
155     }
156     
157     /**
158      * Test fill
159      */
160     public void testFill() throws Exception {
161         vs.setMode(ValueServer.CONSTANT_MODE);
162         vs.setMu(2);
163         double[] val = new double[5];
164         vs.fill(val);
165         for (int i = 0; i < 5; i++) {
166             assertEquals("fill test in place",2,val[i],Double.MIN_VALUE);
167         }
168         double v2[] = vs.fill(3);
169         for (int i = 0; i < 3; i++) {
170             assertEquals("fill test in place",2,v2[i],Double.MIN_VALUE);
171         }
172     }
173     
174     /**
175      * Test getters to make Clover happy
176      */
177     public void testProperties() throws Exception {
178         vs.setMode(ValueServer.CONSTANT_MODE);
179         assertEquals("mode test",ValueServer.CONSTANT_MODE,vs.getMode());
180         vs.setValuesFileURL("http://www.apache.org");
181         URL url = vs.getValuesFileURL();
182         assertEquals("valuesFileURL test","http://www.apache.org",url.toString());
183     }
184                           
185 }