# HG changeset patch
# User japod@localhost
# Date 1223331953 -7200
# Node ID d333e45f6df14493ecefe1a0a304fae936c45e36
# Parent  6102a569c7fa2623cca1e3949a7bd693775140ea
adding solution11 for task 2

diff -r 6102a569c7fa -r d333e45f6df1 task2/solution11/nbproject/build-impl.xml
--- a/task2/solution11/nbproject/build-impl.xml	Tue Oct 07 00:24:22 2008 +0200
+++ b/task2/solution11/nbproject/build-impl.xml	Tue Oct 07 00:25:53 2008 +0200
@@ -218,13 +218,13 @@
             </sequential>
         </macrodef>
     </target>
-    <target depends="-init-debug-args" name="-init-macrodef-nbjpda">
+    <target name="-init-macrodef-nbjpda">
         <macrodef name="nbjpdastart" uri="http://www.netbeans.org/ns/j2se-project/1">
             <attribute default="${main.class}" name="name"/>
             <attribute default="${debug.classpath}" name="classpath"/>
             <attribute default="" name="stopclassname"/>
             <sequential>
-                <nbjpdastart addressproperty="jpda.address" name="@{name}" stopclassname="@{stopclassname}" transport="${debug-transport}">
+                <nbjpdastart addressproperty="jpda.address" name="@{name}" stopclassname="@{stopclassname}" transport="dt_socket">
                     <classpath>
                         <path path="@{classpath}"/>
                     </classpath>
@@ -255,12 +255,6 @@
         <condition else="-Xdebug" property="debug-args-line" value="-Xdebug -Xnoagent -Djava.compiler=none">
             <istrue value="${have-jdk-older-than-1.4}"/>
         </condition>
-        <condition else="dt_socket" property="debug-transport-by-os" value="dt_shmem">
-            <os family="windows"/>
-        </condition>
-        <condition else="${debug-transport-by-os}" property="debug-transport" value="${debug.transport}">
-            <isset property="debug.transport"/>
-        </condition>
     </target>
     <target depends="-init-debug-args" name="-init-macrodef-debug">
         <macrodef name="debug" uri="http://www.netbeans.org/ns/j2se-project/3">
@@ -270,7 +264,7 @@
             <sequential>
                 <java classname="@{classname}" dir="${work.dir}" fork="true">
                     <jvmarg line="${debug-args-line}"/>
-                    <jvmarg value="-Xrunjdwp:transport=${debug-transport},address=${jpda.address}"/>
+                    <jvmarg value="-Xrunjdwp:transport=dt_socket,address=${jpda.address}"/>
                     <jvmarg line="${run.jvmargs}"/>
                     <classpath>
                         <path path="@{classpath}"/>
@@ -317,13 +311,6 @@
                 ===================
             -->
     <target depends="init" name="deps-jar" unless="no.deps"/>
-    <target depends="init,-check-automatic-build,-clean-after-automatic-build" name="-verify-automatic-build"/>
-    <target depends="init" name="-check-automatic-build">
-        <available file="${build.classes.dir}/.netbeans_automatic_build" property="netbeans.automatic.build"/>
-    </target>
-    <target depends="init" if="netbeans.automatic.build" name="-clean-after-automatic-build">
-        <antcall target="clean"/>
-    </target>
     <target depends="init,deps-jar" name="-pre-pre-compile">
         <mkdir dir="${build.classes.dir}"/>
     </target>
@@ -344,7 +331,7 @@
         <!-- Empty placeholder for easier customization. -->
         <!-- You can override this target in the ../build.xml file. -->
     </target>
-    <target depends="init,deps-jar,-verify-automatic-build,-pre-pre-compile,-pre-compile,-do-compile,-post-compile" description="Compile project." name="compile"/>
+    <target depends="init,deps-jar,-pre-pre-compile,-pre-compile,-do-compile,-post-compile" description="Compile project." name="compile"/>
     <target name="-pre-compile-single">
         <!-- Empty placeholder for easier customization. -->
         <!-- You can override this target in the ../build.xml file. -->
@@ -358,7 +345,7 @@
         <!-- Empty placeholder for easier customization. -->
         <!-- You can override this target in the ../build.xml file. -->
     </target>
-    <target depends="init,deps-jar,-verify-automatic-build,-pre-pre-compile,-pre-compile-single,-do-compile-single,-post-compile-single" name="compile-single"/>
+    <target depends="init,deps-jar,-pre-pre-compile,-pre-compile-single,-do-compile-single,-post-compile-single" name="compile-single"/>
     <!--
                 ====================
                 JAR BUILDING SECTION
diff -r 6102a569c7fa -r d333e45f6df1 task2/solution11/nbproject/genfiles.properties
--- a/task2/solution11/nbproject/genfiles.properties	Tue Oct 07 00:24:22 2008 +0200
+++ b/task2/solution11/nbproject/genfiles.properties	Tue Oct 07 00:25:53 2008 +0200
@@ -4,5 +4,5 @@
 # This file is used by a NetBeans-based IDE to track changes in generated files such as build-impl.xml.
 # Do not edit this file. You may delete it but then the IDE will never regenerate such files for you.
 nbproject/build-impl.xml.data.CRC32=0e1e702f
-nbproject/build-impl.xml.script.CRC32=6cbb076a
-nbproject/build-impl.xml.stylesheet.CRC32=e55b27f5
+nbproject/build-impl.xml.script.CRC32=c899f2cf
+nbproject/build-impl.xml.stylesheet.CRC32=487672f9
diff -r 6102a569c7fa -r d333e45f6df1 task2/solution11/src/org/apidesign/apifest08/currency/Convertor.java
--- a/task2/solution11/src/org/apidesign/apifest08/currency/Convertor.java	Tue Oct 07 00:24:22 2008 +0200
+++ b/task2/solution11/src/org/apidesign/apifest08/currency/Convertor.java	Tue Oct 07 00:25:53 2008 +0200
@@ -1,5 +1,10 @@
 package org.apidesign.apifest08.currency;
 
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
 import org.apidesign.apifest08.currency.Computer.ComputerRequest;
 import org.apidesign.apifest08.currency.Computer.ComputerResponse;
 
@@ -10,31 +15,50 @@
  * with amount stored in integer or double, that are identified
  * with string value. Exchange rates are immutable.
  * 
+ * In Task2's version provides support for multiple exchange rates
+ * between different currencies & merging exchange rates from
+ * existing convertors into new convertor's instance.
+ * No time for javadoc these features, sorry.
+ * 
  * @author ked
  */
 public final class Convertor<AmountType, IdentifierType> {
 
     Computer<AmountType> computer;
-    CurrencyValue<AmountType, IdentifierType> firstCurrencyExchangeRate;
-    CurrencyValue<AmountType, IdentifierType> secondCurrencyExchangeRate;
+    List<ExchangeRateValue<AmountType, IdentifierType>> exchangeRates = new ArrayList<ExchangeRateValue<AmountType, IdentifierType>>();
 
     Convertor(
             Computer<AmountType> computer,
-            CurrencyValue<AmountType, IdentifierType> firstCurrencyExchangeRate,
-            CurrencyValue<AmountType, IdentifierType> secondCurrencyExchangeRate) {
-        if (firstCurrencyExchangeRate.getIdentifier() == null ||
-            secondCurrencyExchangeRate.getIdentifier() == null ||
-            firstCurrencyExchangeRate.getIdentifier().equals(secondCurrencyExchangeRate.getIdentifier())) {
-                throw new IllegalArgumentException("Inappropriate exchange rates' identifiers!");
+            Collection<ExchangeRateValue<AmountType, IdentifierType>> exchangeRates) {
+        this.computer = computer;
+
+        for (ExchangeRateValue<AmountType, IdentifierType> exchangeRate : exchangeRates) {
+            if (findExchangeRate(
+                    this.exchangeRates,
+                    exchangeRate.getCurrencyA().getIdentifier(),
+                    exchangeRate.getCurrencyB().getIdentifier()) != null) {
+                throw new IllegalArgumentException("Duplicate exchange rate!");
+            }
+            this.exchangeRates.add(exchangeRate);
         }
-        this.computer = computer;
-        this.firstCurrencyExchangeRate = firstCurrencyExchangeRate;
-        this.secondCurrencyExchangeRate = secondCurrencyExchangeRate;
+    }
+
+    private ExchangeRateValue<AmountType, IdentifierType> findExchangeRate(
+            Collection<ExchangeRateValue<AmountType, IdentifierType>> exchangeRates,
+            IdentifierType currencyA,
+            IdentifierType currencyB) {
+        for (ExchangeRateValue<AmountType, IdentifierType> exchangeRate : exchangeRates) {
+            if ((exchangeRate.getCurrencyA().getIdentifier().equals(currencyA) && exchangeRate.getCurrencyB().getIdentifier().equals(currencyB)) ||
+                    (exchangeRate.getCurrencyA().getIdentifier().equals(currencyB) && exchangeRate.getCurrencyB().getIdentifier().equals(currencyA))) {
+                return exchangeRate;
+            }
+        }
+        return null;
     }
 
     /**
      * Convert an amount of the one currency to an amount of the another one currency
-     * with respect to previously specified exchange rate.
+     * with respect to previously specified exchange rates.
      * 
      * @param targetCurrency an identifier of the requested currency
      * @param currencyValue an amount of the another one currency
@@ -43,52 +67,117 @@
     public CurrencyValue<AmountType, IdentifierType> convert(
             IdentifierType targetCurrency,
             CurrencyValue<AmountType, IdentifierType> currencyValue) {
-        if (firstCurrencyExchangeRate.getIdentifier().equals(targetCurrency) &&
-            secondCurrencyExchangeRate.getIdentifier().equals(currencyValue.getIdentifier())) {
-            ComputerRequest<AmountType> computerRequest = new ComputerRequest<AmountType>();
-            computerRequest.setInput(currencyValue.getAmount());
-            computerRequest.setInputCurrencyRatio(secondCurrencyExchangeRate.getAmount());
-            computerRequest.setOutputCurrencyRatio(firstCurrencyExchangeRate.getAmount());
-            ComputerResponse<AmountType> computerResponse = computer.compute(computerRequest);
-
-            return CurrencyValue.getCurrencyValue(
-                    computerResponse.getResult(),
-                    firstCurrencyExchangeRate.getIdentifier());
-        } else if (secondCurrencyExchangeRate.getIdentifier().equals(targetCurrency) &&
-                   firstCurrencyExchangeRate.getIdentifier().equals(currencyValue.getIdentifier())) {
-            ComputerRequest<AmountType> computerRequest = new ComputerRequest<AmountType>();
-            computerRequest.setInput(currencyValue.getAmount());
-            computerRequest.setInputCurrencyRatio(firstCurrencyExchangeRate.getAmount());
-            computerRequest.setOutputCurrencyRatio(secondCurrencyExchangeRate.getAmount());
-            ComputerResponse<AmountType> computerResponse = computer.compute(computerRequest);
-
-            return CurrencyValue.getCurrencyValue(
-                    computerResponse.getResult(),
-                    secondCurrencyExchangeRate.getIdentifier());
-        } else {
+        ExchangeRateValue<AmountType, IdentifierType> exchangeRate =
+                findExchangeRate(exchangeRates, currencyValue.getIdentifier(), targetCurrency);
+        if (exchangeRate == null) {
             throw new IllegalArgumentException("Inappropriate currencies to convert!");
         }
+
+        ComputerRequest<AmountType> computerRequest = new ComputerRequest<AmountType>();
+        computerRequest.setInput(currencyValue.getAmount());
+
+        IdentifierType targetCurrencyRef; // just for backward compatibility :-(
+        if (exchangeRate.getCurrencyA().getIdentifier().equals(targetCurrency)) {
+            computerRequest.setInputCurrencyRatio(exchangeRate.getCurrencyB().getAmount());
+            computerRequest.setOutputCurrencyRatio(exchangeRate.getCurrencyA().getAmount());
+            targetCurrencyRef = exchangeRate.getCurrencyA().getIdentifier();
+        } else {
+            computerRequest.setInputCurrencyRatio(exchangeRate.getCurrencyA().getAmount());
+            computerRequest.setOutputCurrencyRatio(exchangeRate.getCurrencyB().getAmount());
+            targetCurrencyRef = exchangeRate.getCurrencyB().getIdentifier();
+        }
+
+        ComputerResponse<AmountType> computerResponse = computer.compute(computerRequest);
+        return CurrencyValue.getCurrencyValue(
+                computerResponse.getResult(),
+                targetCurrencyRef);
+    }
+
+    // ---
+    // MERGING
+    // ---
+    static <AmountType, IdentifierType> Convertor<AmountType, IdentifierType> mergeConvertors(
+            Computer<AmountType> computer,
+            Collection<Convertor<AmountType, IdentifierType>> convertors) {
+        Set<ExchangeRateValue<AmountType, IdentifierType>> exchangeRatesSet = new HashSet<ExchangeRateValue<AmountType, IdentifierType>>();
+        for (Convertor<AmountType, IdentifierType> convertor : convertors) {
+            exchangeRatesSet.addAll(convertor.exchangeRates);
+        }
+        return getConvertor(computer, exchangeRatesSet);
+    }
+
+    static <AmountType, IdentifierType> Convertor<AmountType, IdentifierType> mergeConvertors(
+            Computer<AmountType> computer,
+            Convertor<AmountType, IdentifierType> convertorA,
+            Convertor<AmountType, IdentifierType> convertorB) {
+        Collection<Convertor<AmountType, IdentifierType>> convertors =
+                new ArrayList<Convertor<AmountType, IdentifierType>>();
+        convertors.add(convertorA);
+        convertors.add(convertorB);
+        return mergeConvertors(computer, convertors);
+    }
+
+    public static Convertor<Double, String> mergeConvertorsDoubleString(
+            Collection<Convertor<Double, String>> convertors) {
+        return mergeConvertors(DoubleComputer, convertors);
+    }
+
+    public static Convertor<Double, String> mergeConvertorsDoubleString(
+            Convertor<Double, String> convertorA,
+            Convertor<Double, String> convertorB) {
+        return mergeConvertors(DoubleComputer, convertorA, convertorB);
+    }
+
+    public static Convertor<Integer, String> mergeConvertorsIntegerString(
+            Collection<Convertor<Integer, String>> convertors) {
+        return mergeConvertors(IntegerComputer, convertors);
+    }
+
+    public static Convertor<Integer, String> mergeConvertorsIntegerString(
+            Convertor<Integer, String> convertorA,
+            Convertor<Integer, String> convertorB) {
+        return mergeConvertors(IntegerComputer, convertorA, convertorB);
+    }
+
+    // ---
+    // CREATION
+    // ---
+    static <AmountType, IdentifierType> Convertor<AmountType, IdentifierType> getConvertor(
+            Computer<AmountType> computer, Collection<ExchangeRateValue<AmountType, IdentifierType>> exchangeRates) {
+        return new Convertor<AmountType, IdentifierType>(computer, exchangeRates);
     }
 
     static <AmountType, IdentifierType> Convertor<AmountType, IdentifierType> getConvertor(
-            Computer<AmountType> computer,
-            CurrencyValue<AmountType, IdentifierType> firstCurrencyExchangeRate,
-            CurrencyValue<AmountType, IdentifierType> secondCurrencyExchangeRate) {
-        return new Convertor<AmountType, IdentifierType>(
-                computer,
-                firstCurrencyExchangeRate,
-                secondCurrencyExchangeRate);
+            Computer<AmountType> computer, ExchangeRateValue<AmountType, IdentifierType> exchangeRate) {
+        Collection<ExchangeRateValue<AmountType, IdentifierType>> exchangeRates =
+                new ArrayList<ExchangeRateValue<AmountType, IdentifierType>>();
+        exchangeRates.add(exchangeRate);
+        return getConvertor(computer, exchangeRates);
     }
     
-    static final Computer<Double> DoubleComputer = new Computer<Double>() {
+    public static Convertor<Double, String> getConvertorDoubleString(
+            Collection<ExchangeRateValue<Double, String>> exchangeRates) {
+        return getConvertor(DoubleComputer, exchangeRates);
+    }
 
-        public ComputerResponse<Double> compute(ComputerRequest<Double> request) {
-            ComputerResponse<Double> response = new ComputerResponse<Double>();
-            response.setResult(request.getInput() * request.getOutputCurrencyRatio() / request.getInputCurrencyRatio());
-            return response;
-        }
-    };
+    public static Convertor<Double, String> getConvertorDoubleString(
+            ExchangeRateValue<Double, String> exchangeRate) {
+        return getConvertor(DoubleComputer, exchangeRate);
+    }
 
+    public static Convertor<Integer, String> getConvertorIntegerString(
+            Collection<ExchangeRateValue<Integer, String>> exchangeRates) {
+        return getConvertor(IntegerComputer, exchangeRates);
+    }
+
+    public static Convertor<Integer, String> getConvertorIntegerString(
+            ExchangeRateValue<Integer, String> exchangeRate) {
+        return getConvertor(IntegerComputer, exchangeRate);
+    }
+
+    // ---
+    // BACKWARD COMPATIBILITY - CREATION
+    // ---
     /**
      * Creates convertor for Double|String values with specified exchange rate
      * between two currencies.
@@ -97,21 +186,11 @@
      * @param secondCurrencyExchangeRate second currency
      * @return convertor
      */
-
     public static Convertor<Double, String> getConvertorDoubleString(
             CurrencyValue<Double, String> firstCurrencyExchangeRate,
             CurrencyValue<Double, String> secondCurrencyExchangeRate) {
-        return getConvertor(DoubleComputer, firstCurrencyExchangeRate, secondCurrencyExchangeRate);
+        return getConvertorDoubleString(ExchangeRateValue.getExchangeRate(firstCurrencyExchangeRate, secondCurrencyExchangeRate));
     }
-    
-    static final Computer<Integer> IntegerComputer = new Computer<Integer>() {
-
-        public ComputerResponse<Integer> compute(ComputerRequest<Integer> request) {
-            ComputerResponse<Integer> response = new ComputerResponse<Integer>();
-            response.setResult(request.getInput() * request.getOutputCurrencyRatio() / request.getInputCurrencyRatio());
-            return response;
-        }
-    };
 
     /**
      * Creates convertor for Integer|String values with specified exchange rate
@@ -124,6 +203,26 @@
     public static Convertor<Integer, String> getConvertorIntegerString(
             CurrencyValue<Integer, String> firstCurrencyExchangeRate,
             CurrencyValue<Integer, String> secondCurrencyExchangeRate) {
-        return getConvertor(IntegerComputer, firstCurrencyExchangeRate, secondCurrencyExchangeRate);
+        return getConvertorIntegerString(ExchangeRateValue.getExchangeRate(firstCurrencyExchangeRate, secondCurrencyExchangeRate));
     }
+    
+    // ---
+    // COMPUTERS
+    // ---
+    static final Computer<Double> DoubleComputer = new Computer<Double>() {
+
+        public ComputerResponse<Double> compute(ComputerRequest<Double> request) {
+            ComputerResponse<Double> response = new ComputerResponse<Double>();
+            response.setResult(request.getInput() * request.getOutputCurrencyRatio() / request.getInputCurrencyRatio());
+            return response;
+        }
+    };
+    static final Computer<Integer> IntegerComputer = new Computer<Integer>() {
+
+        public ComputerResponse<Integer> compute(ComputerRequest<Integer> request) {
+            ComputerResponse<Integer> response = new ComputerResponse<Integer>();
+            response.setResult(request.getInput() * request.getOutputCurrencyRatio() / request.getInputCurrencyRatio());
+            return response;
+        }
+    };
 }
diff -r 6102a569c7fa -r d333e45f6df1 task2/solution11/src/org/apidesign/apifest08/currency/ExchangeRateValue.java
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/task2/solution11/src/org/apidesign/apifest08/currency/ExchangeRateValue.java	Tue Oct 07 00:25:53 2008 +0200
@@ -0,0 +1,78 @@
+package org.apidesign.apifest08.currency;
+
+import java.io.Serializable;
+
+/**
+ * Value class, holding an exchange rate between two currencies.
+ * Designed to be an immutable.
+ * 
+ * @author ked
+ */
+public final class ExchangeRateValue<AmountType, IdentifierType> implements Serializable {
+
+    private final CurrencyValue<AmountType, IdentifierType> currencyA;
+    private final CurrencyValue<AmountType, IdentifierType> currencyB;
+
+    private ExchangeRateValue(
+            CurrencyValue<AmountType, IdentifierType> currencyA,
+            CurrencyValue<AmountType, IdentifierType> currencyB) {
+        if (currencyA.getIdentifier() == null ||
+            currencyB.getIdentifier() == null ||
+            currencyA.getIdentifier().equals(currencyB)) {
+                throw new IllegalArgumentException("Inappropriate exchange rates' identifiers!");
+        }
+
+        this.currencyA = currencyA;
+        this.currencyB = currencyB;
+    }
+
+    public CurrencyValue<AmountType, IdentifierType> getCurrencyA() {
+        return currencyA;
+    }
+
+    public CurrencyValue<AmountType, IdentifierType> getCurrencyB() {
+        return currencyB;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (obj == null) {
+            return false;
+        }
+        if (getClass() != obj.getClass()) {
+            return false;
+        }
+        final ExchangeRateValue other = (ExchangeRateValue) obj;
+        if (this.currencyA != other.currencyA && (this.currencyA == null || !this.currencyA.equals(other.currencyA))) {
+            return false;
+        }
+        if (this.currencyB != other.currencyB && (this.currencyB == null || !this.currencyB.equals(other.currencyB))) {
+            return false;
+        }
+        return true;
+    }
+
+    @Override
+    public int hashCode() {
+        int hash = 3;
+        hash = 71 * hash + (this.currencyA != null ? this.currencyA.hashCode() : 0);
+        hash = 71 * hash + (this.currencyB != null ? this.currencyB.hashCode() : 0);
+        return hash;
+    }
+
+    /**
+     * Creates new instance.
+     * Generic types of the new instance are derived from types of the parameters.
+     * 
+     * @param <AmountType> type of the currency amount
+     * @param <IdentifierType> type of the currency identifier
+     * @param currencyA one currency of the exchange rate
+     * @param currencyB another currency of the exchange rate
+     * @return new instance
+     */
+    public static <AmountType, IdentifierType> ExchangeRateValue<AmountType, IdentifierType> getExchangeRate(
+            CurrencyValue<AmountType, IdentifierType> currencyA,
+            CurrencyValue<AmountType, IdentifierType> currencyB) {
+        return new ExchangeRateValue<AmountType, IdentifierType>(currencyA, currencyB);
+    }
+}
diff -r 6102a569c7fa -r d333e45f6df1 task2/solution11/test/org/apidesign/apifest08/test/Task2Test.java
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/task2/solution11/test/org/apidesign/apifest08/test/Task2Test.java	Tue Oct 07 00:25:53 2008 +0200
@@ -0,0 +1,140 @@
+package org.apidesign.apifest08.test;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import junit.framework.TestCase;
+import org.apidesign.apifest08.currency.Convertor;
+import org.apidesign.apifest08.currency.CurrencyValue;
+import org.apidesign.apifest08.currency.ExchangeRateValue;
+
+/** There are many currencies around the world and many banks manipulate
+ * with more than one or two at the same time. As banks are usually the
+ * best paying clients, which is true even in case of your Convertor API,
+ * it is reasonable to listen to their requests.
+ * <p>
+ * The quest for today is to enhance your existing convertor API to hold
+ * information about many currencies and allow conversions between any of them.
+ * Also, as conversion rates for diferent currencies usually arise from various
+ * bank departments, there is another important need. There is a need to
+ * compose two convertors into one by merging all the information about
+ * currencies they know about.
+ */
+public class Task2Test extends TestCase {
+
+    public Task2Test(String testName) {
+        super(testName);
+    }
+
+    @Override
+    protected void setUp() throws Exception {
+    }
+
+    @Override
+    protected void tearDown() throws Exception {
+    }
+
+    // As in Task1Test, keep in mind, that there are three parts
+    // of the whole system:
+    // 1. there is someone who knows the current exchange rate
+    // 2. there is someone who wants to do the conversion
+    // 3. there is the API between 1. and 2. which allows them to communicate
+    // 
+    // Please backward compatibly enhance your existing API to support following
+    // usecases:
+    //
+    /** Create convertor that understands two currencies, CZK and
+     *  SKK. Make 100 SKK == 75 CZK. This is method for the group of users that
+     *  knows the exchange rate, and needs to use the API to create objects
+     *  with the exchange rate. Anyone shall be ready to call this method without
+     *  any other method being called previously. The API itself shall know
+     *  nothing about any rates, before this method is called.
+     */
+    public static Convertor<Integer, String> createTripleConvertor() {
+        // Rates: 1USD = 15CZK
+        // Rates: 1USD = 20SKK
+        // Rates: 75CZK = 100SKK
+        Collection<ExchangeRateValue<Integer, String>> exchangeRates =
+                new ArrayList<ExchangeRateValue<Integer, String>>();
+        exchangeRates.add(ExchangeRateValue.getExchangeRate(
+                CurrencyValue.getCurrencyValue(1, "USD"),
+                CurrencyValue.getCurrencyValue(15, "CZK")));
+        exchangeRates.add(ExchangeRateValue.getExchangeRate(
+                CurrencyValue.getCurrencyValue(1, "USD"),
+                CurrencyValue.getCurrencyValue(20, "SKK")));
+        exchangeRates.add(ExchangeRateValue.getExchangeRate(
+                CurrencyValue.getCurrencyValue(75, "CZK"),
+                CurrencyValue.getCurrencyValue(100, "SKK")));
+        return Convertor.getConvertorIntegerString(exchangeRates);
+    }
+
+    /** Define convertor that understands three currencies. Use it.
+     */
+    public void testConvertorForUSDandCZKandSKK() throws Exception {
+        Convertor<Integer, String> c = createTripleConvertor();
+
+        CurrencyValue<Integer, String> result;
+        // convert $5 to CZK using c:
+        // assertEquals("Result is 75 CZK");
+        result = c.convert("CZK", CurrencyValue.getCurrencyValue(5, "USD"));
+        assertEquals(CurrencyValue.getCurrencyValue(75, "CZK"), result);
+
+        // convert $5 to SKK using c:
+        // assertEquals("Result is 100 SKK");
+        result = c.convert("SKK", CurrencyValue.getCurrencyValue(5, "USD"));
+        assertEquals(CurrencyValue.getCurrencyValue(100, "SKK"), result);
+
+        // convert 200SKK to CZK using c:
+        // assertEquals("Result is 150 CZK");
+        result = c.convert("CZK", CurrencyValue.getCurrencyValue(200, "SKK"));
+        assertEquals(CurrencyValue.getCurrencyValue(150, "CZK"), result);
+
+        // convert 200SKK to USK using c:
+        // assertEquals("Result is 10 USD");
+        result = c.convert("USD", CurrencyValue.getCurrencyValue(200, "SKK"));
+        assertEquals(CurrencyValue.getCurrencyValue(10, "USD"), result);
+    }
+
+    /** Merge all currency rates of convertor 1 with convertor 2.
+     * Implement this using your API, preferably this method just delegates
+     * into some API method which does the actual work, without requiring
+     * API clients to code anything complex.
+     */
+    public static Convertor<Integer, String> merge(Convertor<Integer, String> one, Convertor<Integer, String> two) {
+        return Convertor.mergeConvertorsIntegerString(one, two);
+    }
+
+    /** Join the convertors from previous task, Task1Test and show that it
+     * can be used to do reasonable conversions.
+     */
+    public void testConvertorComposition() throws Exception {
+        Convertor<Integer, String> c = merge(
+                Task1Test.createCZKtoUSD(),
+                Task1Test.createSKKtoCZK());
+
+        CurrencyValue<Integer, String> result;
+        // convert $5 to CZK using c:
+        // assertEquals("Result is 85 CZK");
+        result = c.convert("CZK", CurrencyValue.getCurrencyValue(5, "USD"));
+        assertEquals(CurrencyValue.getCurrencyValue(85, "CZK"), result);
+
+        // convert $8 to CZK using c:
+        // assertEquals("Result is 136 CZK");
+        result = c.convert("CZK", CurrencyValue.getCurrencyValue(8, "USD"));
+        assertEquals(CurrencyValue.getCurrencyValue(136, "CZK"), result);
+
+        // convert 1003CZK to USD using c:
+        // assertEquals("Result is 59 USD");
+        result = c.convert("USD", CurrencyValue.getCurrencyValue(1003, "CZK"));
+        assertEquals(CurrencyValue.getCurrencyValue(59, "USD"), result);
+
+        // convert 16CZK using c:
+        // assertEquals("Result is 20 SKK");
+        result = c.convert("SKK", CurrencyValue.getCurrencyValue(16, "CZK"));
+        assertEquals(CurrencyValue.getCurrencyValue(20, "SKK"), result);
+
+        // convert 500SKK to CZK using c:
+        // assertEquals("Result is 400 CZK");
+        result = c.convert("CZK", CurrencyValue.getCurrencyValue(500, "SKK"));
+        assertEquals(CurrencyValue.getCurrencyValue(400, "CZK"), result);
+    }
+}