    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: 1.17 $ $Date: 2004/10/08 05:08:19 $
    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 }