/*
 *  Licensed to the Apache Software Foundation (ASF) under one or more
 *  contributor license agreements.  See the NOTICE file distributed with
 *  this work for additional information regarding copyright ownership.
 *  The ASF licenses this file to You under the Apache License, Version 2.0
 *  (the "License"); you may not use this file except in compliance with
 *  the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */

package tests.api.java.util;

import dalvik.annotation.TestTargetNew;
import dalvik.annotation.TestTargets;
import dalvik.annotation.TestLevel;
import dalvik.annotation.TestTargetClass; 

import java.util.Random;

@TestTargetClass(Random.class) 
public class RandomTest extends junit.framework.TestCase {

    Random r;

    /**
     * @tests java.util.Random#Random()
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "Random",
        args = {}
    )
    public void test_Constructor() {
        // Test for method java.util.Random()
        assertTrue("Used to test", true);
    }

    /**
     * @tests java.util.Random#Random(long)
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "Random",
        args = {long.class}
    )
    public void test_ConstructorJ() {
        Random r = new Random(8409238L);
        Random r2 = new Random(8409238L);
        for (int i = 0; i < 100; i++)
            assertTrue("Values from randoms with same seed don't match", r
                    .nextInt() == r2.nextInt());
    }

    /**
     * @tests java.util.Random#nextBoolean()
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "nextBoolean",
        args = {}
    )
    public void test_nextBoolean() {
        // Test for method boolean java.util.Random.nextBoolean()
        boolean falseAppeared = false, trueAppeared = false;
        for (int counter = 0; counter < 100; counter++)
            if (r.nextBoolean())
                trueAppeared = true;
            else
                falseAppeared = true;
        assertTrue("Calling nextBoolean() 100 times resulted in all trues",
                falseAppeared);
        assertTrue("Calling nextBoolean() 100 times resulted in all falses",
                trueAppeared);
    }

    /**
     * @tests java.util.Random#nextBytes(byte[])
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "nextBytes",
        args = {byte[].class}
    )
    public void test_nextBytes$B() {
        // Test for method void java.util.Random.nextBytes(byte [])
        boolean someDifferent = false;
        byte[] randomBytes = new byte[100];
        r.nextBytes(randomBytes);
        byte firstByte = randomBytes[0];
        for (int counter = 1; counter < randomBytes.length; counter++)
            if (randomBytes[counter] != firstByte)
                someDifferent = true;
        assertTrue(
                "nextBytes() returned an array of length 100 of the same byte",
                someDifferent);
    }

    /**
     * @tests java.util.Random#nextDouble()
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "nextDouble",
        args = {}
    )
    public void test_nextDouble() {
        // Test for method double java.util.Random.nextDouble()
        double lastNum = r.nextDouble();
        double nextNum;
        boolean someDifferent = false;
        boolean inRange = true;
        for (int counter = 0; counter < 100; counter++) {
            nextNum = r.nextDouble();
            if (nextNum != lastNum)
                someDifferent = true;
            if (!(0 <= nextNum && nextNum < 1.0))
                inRange = false;
            lastNum = nextNum;
        }
        assertTrue("Calling nextDouble 100 times resulted in same number",
                someDifferent);
        assertTrue(
                "Calling nextDouble resulted in a number out of range [0,1)",
                inRange);
    }

    /**
     * @tests java.util.Random#nextFloat()
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "nextFloat",
        args = {}
    )
    public void test_nextFloat() {
        // Test for method float java.util.Random.nextFloat()
        float lastNum = r.nextFloat();
        float nextNum;
        boolean someDifferent = false;
        boolean inRange = true;
        for (int counter = 0; counter < 100; counter++) {
            nextNum = r.nextFloat();
            if (nextNum != lastNum)
                someDifferent = true;
            if (!(0 <= nextNum && nextNum < 1.0))
                inRange = false;
            lastNum = nextNum;
        }
        assertTrue("Calling nextFloat 100 times resulted in same number",
                someDifferent);
        assertTrue("Calling nextFloat resulted in a number out of range [0,1)",
                inRange);
    }

    /**
     * @tests java.util.Random#nextGaussian()
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "nextGaussian",
        args = {}
    )
    public void test_nextGaussian() {
        // Test for method double java.util.Random.nextGaussian()
        double lastNum = r.nextGaussian();
        double nextNum;
        boolean someDifferent = false;
        boolean someInsideStd = false;
        for (int counter = 0; counter < 100; counter++) {
            nextNum = r.nextGaussian();
            if (nextNum != lastNum)
                someDifferent = true;
            if (-1.0 <= nextNum && nextNum <= 1.0)
                someInsideStd = true;
            lastNum = nextNum;
        }
        assertTrue("Calling nextGaussian 100 times resulted in same number",
                someDifferent);
        assertTrue(
                "Calling nextGaussian 100 times resulted in no number within 1 std. deviation of mean",
                someInsideStd);
    }

    /**
     * @tests java.util.Random#nextInt()
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "nextInt",
        args = {}
    )
    public void test_nextInt() {
        // Test for method int java.util.Random.nextInt()
        int lastNum = r.nextInt();
        int nextNum;
        boolean someDifferent = false;
        for (int counter = 0; counter < 100; counter++) {
            nextNum = r.nextInt();
            if (nextNum != lastNum)
                someDifferent = true;
            lastNum = nextNum;
        }
        assertTrue("Calling nextInt 100 times resulted in same number",
                someDifferent);
    }

    /**
     * @tests java.util.Random#nextInt(int)
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "nextInt",
        args = {int.class}
    )
    public void test_nextIntI() {
        // Test for method int java.util.Random.nextInt(int)
        final int range = 10;
        int lastNum = r.nextInt(range);
        int nextNum;
        boolean someDifferent = false;
        boolean inRange = true;
        for (int counter = 0; counter < 100; counter++) {
            nextNum = r.nextInt(range);
            if (nextNum != lastNum)
                someDifferent = true;
            if (!(0 <= nextNum && nextNum < range))
                inRange = false;
            lastNum = nextNum;
        }
        assertTrue("Calling nextInt (range) 100 times resulted in same number",
                someDifferent);
        assertTrue(
                "Calling nextInt (range) resulted in a number outside of [0, range)",
                inRange);

    }

    /**
     * @tests java.util.Random#nextLong()
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "nextLong",
        args = {}
    )
    public void test_nextLong() {
        // Test for method long java.util.Random.nextLong()
        long lastNum = r.nextLong();
        long nextNum;
        boolean someDifferent = false;
        for (int counter = 0; counter < 100; counter++) {
            nextNum = r.nextLong();
            if (nextNum != lastNum)
                someDifferent = true;
            lastNum = nextNum;
        }
        assertTrue("Calling nextLong 100 times resulted in same number",
                someDifferent);
    }

    /**
     * @tests java.util.Random#setSeed(long)
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "setSeed",
        args = {long.class}
    )
    public void test_setSeedJ() {
        // Test for method void java.util.Random.setSeed(long)
        long[] randomArray = new long[100];
        boolean someDifferent = false;
        final long firstSeed = 1000;
        long aLong, anotherLong, yetAnotherLong;
        Random aRandom = new Random();
        Random anotherRandom = new Random();
        Random yetAnotherRandom = new Random();
        aRandom.setSeed(firstSeed);
        anotherRandom.setSeed(firstSeed);
        for (int counter = 0; counter < randomArray.length; counter++) {
            aLong = aRandom.nextLong();
            anotherLong = anotherRandom.nextLong();
            assertTrue(
                    "Two randoms with same seeds gave differing nextLong values",
                    aLong == anotherLong);
            yetAnotherLong = yetAnotherRandom.nextLong();
            randomArray[counter] = aLong;
            if (aLong != yetAnotherLong)
                someDifferent = true;
        }
        assertTrue(
                "Two randoms with the different seeds gave the same chain of values",
                someDifferent);
        aRandom.setSeed(firstSeed);
        for (int counter = 0; counter < randomArray.length; counter++)
            assertTrue(
                    "Reseting a random to its old seed did not result in the same chain of values as it gave before",
                    aRandom.nextLong() == randomArray[counter]);
    }
    
    class Mock_Random extends Random {
        boolean nextCalled = false;
        
        public boolean getFlag () {
            boolean retVal = nextCalled;
            nextCalled = false;
            return retVal;
        }
        
        @Override
        protected int next(int bits) {
            nextCalled = true;
            return super.next(bits);
        }
    }
    
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "next",
        args = {int.class}
    )
    public void test_next() {
        Mock_Random mr = new Mock_Random();
        assertFalse(mr.getFlag());
        mr.nextBoolean();
        assertTrue(mr.getFlag());
        mr.nextBytes(new byte[10]);
        assertTrue(mr.getFlag());
        mr.nextDouble();
        assertTrue(mr.getFlag());
        mr.nextFloat();
        assertTrue(mr.getFlag());
        mr.nextGaussian();
        assertTrue(mr.getFlag());
        mr.nextInt();
        assertTrue(mr.getFlag());
        mr.nextInt(10);
        assertTrue(mr.getFlag());
        mr.nextLong();
        assertTrue(mr.getFlag());
    }

    /**
     * Sets up the fixture, for example, open a network connection. This method
     * is called before a test is executed.
     */
    protected void setUp() {
        r = new Random();
    }

    /**
     * Tears down the fixture, for example, close a network connection. This
     * method is called after a test is executed.
     */
    protected void tearDown() {
    }
}
