source: bidspace/src/test/java/geniusweb/bidspace/BidsWithUtilityTest.java@ 52

package geniusweb.bidspace;

import static org.junit.Assert.assertTrue;

import java.io.IOException;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.math.RoundingMode;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.Arrays;
import java.util.Collection;
import java.util.Random;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.junit.runners.Parameterized.Parameters;

import com.fasterxml.jackson.databind.ObjectMapper;

import geniusweb.issuevalue.Bid;
import geniusweb.profile.Profile;
import geniusweb.profile.utilityspace.LinearAdditiveUtilitySpace;
import tudelft.utilities.immutablelist.ImmutableList;

@RunWith(Parameterized.class)
public class BidsWithUtilityTest {
        private final static ObjectMapper jackson = new ObjectMapper();
        private final Interval utilityGoal = new Interval(new BigDecimal("0.50"),
                        new BigDecimal("0.51"));
        private LinearAdditiveUtilitySpace profile;
        private long expectedSize;
        private int accuracy = 5;
        private final static Runtime r = Runtime.getRuntime();

        @Parameters
        public static Collection<Object[]> data() {
                return Arrays.asList(new Object[][] {
                                { "src/test/resources/jobs/jobs1.json", 11 },
                                { "src/test/resources/7issues/7issues1.json", 260000 },
                                { "src/test/resources/9issues/9issues1.json", 25000000 } });
        }

        public BidsWithUtilityTest(String filename, long expectedsize)
                        throws IOException {
                String file = new String(Files.readAllBytes(Paths.get(filename)));
                profile = (LinearAdditiveUtilitySpace) jackson.readValue(file,
                                Profile.class);
                this.expectedSize = expectedsize;
        }

        /**
         * Test if the values are within acceptable range from the goal.
         */
        @Test
        public void test() {
                ImmutableList<Bid> list = new BidsWithUtility(profile, accuracy)
                                .getBids(utilityGoal);
                Random rand = new Random();
                // check not all but only 10000 random bids as list may be way too large
                // to test them all. Testing 1 billion bids may take 15 minutes or so on
                // quad core i7 @2.4GHz.....
                // also notice that we may be checking only part of the list if
                // the size of the list would become bigger than maxint.
                for (int n = 0; n < 10000; n++) {
                        Bid bid = list.get(rand.nextInt(list.size().intValue()));
                        assertTrue(utilityGoal.contains(profile.getUtility(bid)
                                        .setScale(accuracy - 1, RoundingMode.HALF_UP)));
                }
                assertTrue(
                                list.size().compareTo(BigInteger.valueOf(expectedSize)) >= 0);

        }

        @Test
        public void testMaxUtil() {
                BidsWithUtility bidswithutil = new BidsWithUtility(profile);
                // notice, this is the *rounded* max util
                BigDecimal maxutil = bidswithutil.getRange().getMax();
                Interval goal = new Interval(
                                maxutil.subtract(new BigDecimal("0.00001")), maxutil);

                ImmutableList<Bid> bidsnearmax = bidswithutil.getBids(goal);
                assertTrue(bidsnearmax.size() != BigInteger.ZERO);

                BigDecimal foundmax = BigDecimal.ZERO;
                for (Bid bid : bidsnearmax) {
                        BigDecimal util = profile.getUtility(bid);
                        if (util.compareTo(foundmax) > 0) {
                                foundmax = util;
                        }
                }
                // found maximum may be slightly lower or higher because we rounded
                // all weighted utilities.
                assertTrue(Math
                                .abs(foundmax.doubleValue() - maxutil.doubleValue()) < 0.0001);
        }

        @Test
        public void benchmark() {
                System.out.println("\nBenchmarking " + profile.getName());
                BigInteger domainsize = new AllBidsList(profile.getDomain()).size();

                long presize = usedMemory();
                long start = System.currentTimeMillis();
                BidsWithUtility body = new BidsWithUtility(profile, accuracy);
                ImmutableList<Bid> list = body.getBids(utilityGoal);
                long end = System.currentTimeMillis();
                long postsize = usedMemory();
                System.out.println("run time: " + (end - start) / 1000. + "s");
                System.out.println("Total size of complete domain:" + domainsize);
                System.out.println("size of selection: " + list.size());
                System.out.println("Memory use of selection(MB):"
                                + (double) (postsize - presize) / (1024 * 1024));
        }

        /**
         * see https://www.geeksforgeeks.org/java-lang-runtime-class-in-java/
         * 
         * @return currently used memory after doing GC.
         * 
         */
        public static long usedMemory() {
                for (int n = 0; n < 4; n++)
                        gc1(); // repeat as gct seems getting more agressive then
                return used();
        }

        /**
         * 
         * @return used heap mem. Does NOT GC. Uses {@link Runtime#totalMemory()}
         *         and {@link Runtime#freeMemory()} to avoid problems when JVM gets
         *         more system memory which can happen at any time.
         */
        private static long used() {
                return r.totalMemory() - r.freeMemory();
        }

        /**
         * repeat garbage collection till heap memory gets stable
         */
        private static void gc1() {
                long usedMem1 = used(), usedMem2 = Long.MAX_VALUE;
                for (int i = 0; (usedMem1 < usedMem2) && (i < 500); ++i) {
                        r.runFinalization();
                        r.gc();
                        Thread.currentThread().yield();

                        usedMem2 = usedMem1;
                        usedMem1 = used();
                }
        }
}