source: MotivateDuringTherapy/src/test/java/tudelft/mentalhealth/motivatepersisting/ProbOfCategoriesPerSituationTest.java

package tudelft.mentalhealth.motivatepersisting;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;

import java.io.IOException;
import java.util.HashMap;
import java.util.Map;

import org.junit.Before;
import org.junit.Test;

import tudelft.utilities.statistic.WeightedSet;

public class ProbOfCategoriesPerSituationTest {
        private ProbOfCategoriesPerSituation probs;
        private int NTESTS = 3000;

        @Before
        public void before() throws IOException {
                probs = ProbOfCategoriesPerSituation.instance();

        }

        @Test
        public void smokeTest() throws IOException {
                System.out.println(probs);
        }

        @Test
        public void testSomeTableEntries() throws IOException {
                assertEquals((Double) 0.77, probs.get(Category.MOTIVATION,
                                Subcategory.ALL, new Situation(PclTrend.DROPPING, Trust.HIGH)));
                assertEquals((Double) 0.01, probs.get(Category.FUTURE, Subcategory.PCL,
                                new Situation(PclTrend.DROPPING, Trust.MEDIUM)));
                assertEquals((Double) 0.61, probs.get(Category.GIVEPERSPECTIVE,
                                Subcategory.ALL, new Situation(PclTrend.RISING, Trust.HIGH)));
        }

        @Test
        public void getRandomSubTest() {
                // EMPATHY has only 1 subcat so this should be trivial
                assertEquals(Subcategory.NEGATIVE,
                                probs.getweightedRandomSubcategory(Category.EMPATHY,
                                                new Situation(PclTrend.DROPPING, Trust.HIGH)));
        }

        @Test
        public void getRandomSubTest2() {
                int compl = 0, goon = 0, its = 0, hold = 0;
                for (int n = 0; n < NTESTS; n++) {
                        Subcategory subcat = probs.getweightedRandomSubcategory(
                                        Category.MOTIVATION,
                                        new Situation(PclTrend.RISING, Trust.MEDIUM));
                        switch (subcat) {
                        case COMPLIMENT:
                                compl++;
                                break;
                        case GOONLIKETHIS:
                                goon++;
                                break;
                        case ITSGOINGWELL:
                                its++;
                                break;
                        case HOLDON:
                                hold++;
                                break;
                        default:
                                throw new IllegalStateException(
                                                "Unexpected subcategory received " + subcat);
                        }

                }
                // check against table: 0.03, 0.01, 0.04, 0.15 (sums to 0.23)
                isExpected(Subcategory.COMPLIMENT.name(), compl, 0.03 / 0.23);
                isExpected(Subcategory.GOONLIKETHIS.name(), goon, 0.01 / 0.23);
                isExpected(Subcategory.ITSGOINGWELL.name(), its, 0.04 / 0.23);
                isExpected(Subcategory.HOLDON.name(), hold, 0.15 / 0.23);

        }

        @Test
        public void testGetRandom2() {

                Map<String, Double> values = new HashMap<>();
                values.put("a", 0.2);
                values.put("b", 0.3);
                values.put("c", 0.5);
                WeightedSet<String> map1 = new WeightedSet<String>(values);

                int as = 0, bs = 0, cs = 0;
                for (int n = 0; n < NTESTS; n++) {
                        switch (map1.getRandom()) {
                        case "a":
                                as++;
                                break;
                        case "b":
                                bs++;
                                break;
                        case "c":
                                cs++;
                                break;
                        }
                }
                isExpected("a", as, 0.2);
                isExpected("b", bs, 0.3);
                isExpected("c", cs, 0.5);
        }

        /**
         * Check that the number of accurences of value is with 99% confidence range
         * 
         * @param value  the value that was tested.
         * @param amount the number of occurences of value
         * @param p      the probability that value occured in [0,1]
         */
        private void isExpected(String value, int amount, double p) {
                // approximate binomial with normal distri.
                // mean = n p (n=#samples, p=probability of drawing X)
                // variance sigma^2 = n p (1-p)
                // 99% of the trials should be within mean - 2sigma, mean+2sigma.
                double mean = NTESTS * p;
                double sigma2 = 2 * Math.sqrt(NTESTS * p * (1 - p));
                assertTrue(
                                "random draws of " + value
                                                + " were out of 99% confidence interval. Expected ["
                                                + (mean - sigma2) + "," + (mean + sigma2)
                                                + "], actual  " + amount,
                                Math.abs(amount - mean) < sigma2);

        }

        @Test
        public void validateTableTest() {
                // all categories that have p>0 for some Situation must have at least
                // one
                // subcategory with p>0
                for (PclTrend pcl : PclTrend.values()) {
                        for (Trust trust : Trust.values()) {
                                Situation situation = new Situation(pcl, trust);
                                for (Category category : Category.values()) {
                                        if (!category.getSubCategories().isEmpty() && probs
                                                        .get(category, Subcategory.ALL, situation) > 0) {
                                                checkHasSelectableSubcategory(category, situation);
                                        }
                                }
                        }
                }

        }

        /**
         * Check at least one of the subcategories of given category has p>0
         * 
         * @param category  the {@link Category} to check
         * @param situation the {@link Situation} to check
         */
        private void checkHasSelectableSubcategory(Category category,
                        Situation situation) {
                for (Subcategory subcat : category.getSubCategories()) {
                        if (probs.get(category, subcat, situation) > 0.)
                                return;
                }
                throw new IllegalStateException(
                                "Category " + category + " in situation " + situation
                                                + " has no selectable subcategories");
        }
}