LimitedRoundRobinTest.java

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

package org.ow2.choreos.selector;

import static org.junit.Assert.assertEquals;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

import org.junit.Before;
import org.junit.Test;
import org.ow2.choreos.selectors.LimitedRoundRobinSelector;
import org.ow2.choreos.selectors.NotSelectedException;
import org.ow2.choreos.selectors.Selector;
import org.ow2.choreos.utils.Concurrency;

public class LimitedRoundRobinTest {

    private StringRetriever retriever;

    @Before
    public void setup() {

        this.retriever = new StringRetriever();
        this.retriever.addObject("0");
        this.retriever.addObject("1");
        this.retriever.addObject("2");
    }

    @Test
    public void shouldCreateSomeObjectsAndAfterRoundRobin() throws NotSelectedException {

        final int LIMIT = 3;
        StringFactory fac = new StringFactory();
        Selector<String, String> selector = new LimitedRoundRobinSelector<String, String>(LIMIT, retriever, fac);
        String requirements = "requirements";
        int quantity = 1;

        final String[] expectedSequence = new String[] { "0", "1", "2", "0", "1", "2", "0" };

        for (int i = 0; i < expectedSequence.length; i++) {
            String obj = selector.select(requirements, quantity).get(0);
            assertEquals(expectedSequence[i], obj);
        }
    }

    @Test
    public void shouldCreateSomeObjectsAndAfterRoundRobinWithQuantityEquals2() throws NotSelectedException {

        final int LIMIT = 3;
        StringFactory fac = new StringFactory();
        Selector<String, String> selector = new LimitedRoundRobinSelector<String, String>(LIMIT, retriever, fac);
        String requirements = "requirements";
        int quantity = 2;

        final String[][] expectedSequence = new String[][] { new String[] { "0", "1" }, new String[] { "2", "0" } };

        for (int i = 0; i < expectedSequence.length; i++) {

            List<String> selected = selector.select(requirements, quantity);
            String obj0 = selected.get(0);
            String obj1 = selected.get(1);
            assertEquals(expectedSequence[i][0], obj0);
            assertEquals(expectedSequence[i][1], obj1);
        }
    }

    @Test
    public void shouldCreateSomeObjectsAndAfterRoundRobinConcurrently() throws NotSelectedException,
            InterruptedException, ExecutionException {

        final int LIMIT = 3;
        StringFactory fac = new StringFactory();
        Selector<String, String> limtiedRRSelector = new LimitedRoundRobinSelector<String, String>(LIMIT, retriever,
                fac);
        int quantity = 1;

        final int N = 6;
        ExecutorService executor = Executors.newFixedThreadPool(N);
        List<CallableSelector> selectors = new ArrayList<CallableSelector>();
        List<Future<String>> futures = new ArrayList<Future<String>>();
        for (int i = 0; i < N; i++) {
            CallableSelector selector = new CallableSelector(limtiedRRSelector, quantity);
            selectors.add(selector);
            Future<String> f = executor.submit(selector);
            futures.add(f);
        }

        Concurrency.waitExecutor(executor, 1, "pam!");

        int count = 0, count0 = 0, count1 = 0, count2 = 0;
        for (Future<String> f : futures) {
            String object = f.get();
            count++;
            if (object.equals("0"))
                count0++;
            if (object.equals("1"))
                count1++;
            if (object.equals("2"))
                count2++;
        }

        assertEquals(6, count);
        assertEquals(2, count0);
        assertEquals(2, count1);
        assertEquals(2, count2);
    }

    private class CallableSelector implements Callable<String> {

        Selector<String, String> selector;
        int quantity;

        CallableSelector(Selector<String, String> selector, int quantity) {
            this.selector = selector;
            this.quantity = quantity;
        }

        @Override
        public String call() throws Exception {
            List<String> nodes = selector.select("requirements", quantity);
            return nodes.get(0);
        }
    }
}