Simplify test suites.

6 files changed, 137 insertions, 129 deletions

diff --git a/src/cz/crcs/ectester/reader/test/CardCompositeCurvesSuite.java b/src/cz/crcs/ectester/reader/test/CardCompositeCurvesSuite.java
index 2c2ba26..a53806c 100644
--- a/src/cz/crcs/ectester/reader/test/CardCompositeCurvesSuite.java
+++ b/src/cz/crcs/ectester/reader/test/CardCompositeCurvesSuite.java
@@ -2,13 +2,13 @@ package cz.crcs.ectester.reader.test;
 
 import cz.crcs.ectester.applet.ECTesterApplet;
 import cz.crcs.ectester.applet.EC_Consts;
-import cz.crcs.ectester.common.test.BaseRunnable;
+import cz.crcs.ectester.common.ec.EC_Curve;
+import cz.crcs.ectester.common.ec.EC_Key;
+import cz.crcs.ectester.common.output.TestWriter;
 import cz.crcs.ectester.data.EC_Store;
 import cz.crcs.ectester.reader.CardMngr;
 import cz.crcs.ectester.reader.ECTesterReader;
 import cz.crcs.ectester.reader.command.Command;
-import cz.crcs.ectester.common.ec.EC_Curve;
-import cz.crcs.ectester.common.ec.EC_Key;
 import javacard.security.KeyPair;
 
 import java.util.Map;
@@ -20,34 +20,31 @@ import static cz.crcs.ectester.common.test.Result.ExpectedValue;
  */
 public class CardCompositeCurvesSuite extends CardTestSuite {
 
-    public CardCompositeCurvesSuite(EC_Store dataStore, ECTesterReader.Config cfg) {
-        super(dataStore, cfg, "composite", "The composite suite run ECDH over curves with composite order. This should generally fail, as using such a curve is unsafe.");
+    public CardCompositeCurvesSuite(TestWriter writer, ECTesterReader.Config cfg, CardMngr cardManager) {
+        super(writer, cfg, cardManager, "composite", "The composite suite run ECDH over curves with composite order. This should generally fail, as using such a curve is unsafe.");
     }
 
     @Override
-    public void setup(CardMngr cardManager) {
+    protected void runTests() throws Exception {
         /* Do the default run with the public keys set to provided smallorder keys
          * over composite order curves. Essentially small subgroup attacks.
          * These should fail, the curves aren't safe so that if the computation with
          * a small order public key succeeds the private key modulo the public key order
          * is revealed.
          */
-        Map<String, EC_Key> keys = dataStore.getObjects(EC_Key.class, "composite");
+        Map<String, EC_Key> keys = EC_Store.getInstance().getObjects(EC_Key.class, "composite");
         for (EC_Key key : keys.values()) {
-            EC_Curve curve = dataStore.getObject(EC_Curve.class, key.getCurve());
-            if (cfg.namedCurve != null && !(key.getCurve().startsWith(cfg.namedCurve) || key.getCurve().equals(cfg.namedCurve))) {
-                continue;
-            }
+            EC_Curve curve = EC_Store.getInstance().getObject(EC_Curve.class, key.getCurve());
             if (curve.getField() == KeyPair.ALG_EC_FP && !cfg.primeField || curve.getField() == KeyPair.ALG_EC_F2M && !cfg.binaryField) {
                 continue;
             }
             if ((curve.getBits() == cfg.bits || cfg.all)) {
-                run.add(CommandTest.expect(new Command.Allocate(cardManager, ECTesterApplet.KEYPAIR_BOTH, curve.getBits(), curve.getField()), ExpectedValue.SUCCESS));
-                run.add(CommandTest.expect(new Command.Set(cardManager, ECTesterApplet.KEYPAIR_BOTH, EC_Consts.CURVE_external, curve.getParams(), curve.flatten()), ExpectedValue.ANY));
-                run.add(CommandTest.expect(new Command.Generate(cardManager, ECTesterApplet.KEYPAIR_LOCAL), ExpectedValue.ANY));
-                Command ecdhCommand = new Command.ECDH_direct(cardManager, ECTesterApplet.KEYPAIR_LOCAL, ECTesterApplet.EXPORT_FALSE, EC_Consts.CORRUPTION_NONE, ECTesterApplet.KeyAgreement_ALG_EC_SVDP_DH, key.flatten());
-                run.add(CommandTest.expect(ecdhCommand, ExpectedValue.FAILURE, "Card correctly rejected to do ECDH over a composite order curve.", "Card incorrectly does ECDH over a composite order curve, leaks bits of private key."));
-                run.add(new BaseRunnable(() -> new Command.Cleanup(cardManager)));
+                doTest(CommandTest.expect(new Command.Allocate(this.card, ECTesterApplet.KEYPAIR_BOTH, curve.getBits(), curve.getField()), ExpectedValue.SUCCESS));
+                doTest(CommandTest.expect(new Command.Set(this.card, ECTesterApplet.KEYPAIR_BOTH, EC_Consts.CURVE_external, curve.getParams(), curve.flatten()), ExpectedValue.ANY));
+                doTest(CommandTest.expect(new Command.Generate(this.card, ECTesterApplet.KEYPAIR_LOCAL), ExpectedValue.ANY));
+                Command ecdhCommand = new Command.ECDH_direct(this.card, ECTesterApplet.KEYPAIR_LOCAL, ECTesterApplet.EXPORT_FALSE, EC_Consts.CORRUPTION_NONE, ECTesterApplet.KeyAgreement_ALG_EC_SVDP_DH, key.flatten());
+                doTest(CommandTest.expect(ecdhCommand, ExpectedValue.FAILURE, "Card correctly rejected to do ECDH over a composite order curve.", "Card incorrectly does ECDH over a composite order curve, leaks bits of private key."));
+                new Command.Cleanup(this.card).send();
             }
         }
     }
diff --git a/src/cz/crcs/ectester/reader/test/CardDefaultSuite.java b/src/cz/crcs/ectester/reader/test/CardDefaultSuite.java
index 7e7adbb..9de741c 100644
--- a/src/cz/crcs/ectester/reader/test/CardDefaultSuite.java
+++ b/src/cz/crcs/ectester/reader/test/CardDefaultSuite.java
@@ -2,15 +2,15 @@ package cz.crcs.ectester.reader.test;
 
 import cz.crcs.ectester.applet.ECTesterApplet;
 import cz.crcs.ectester.applet.EC_Consts;
-import cz.crcs.ectester.common.test.BaseRunnable;
-import cz.crcs.ectester.data.EC_Store;
+import cz.crcs.ectester.common.output.TestWriter;
+import cz.crcs.ectester.common.test.CompoundTest;
+import cz.crcs.ectester.common.test.Test;
+import cz.crcs.ectester.common.util.CardUtil;
 import cz.crcs.ectester.reader.CardMngr;
 import cz.crcs.ectester.reader.ECTesterReader;
 import cz.crcs.ectester.reader.command.Command;
 import javacard.security.KeyPair;
 
-import java.io.IOException;
-
 import static cz.crcs.ectester.common.test.Result.ExpectedValue;
 
 /**
@@ -18,53 +18,46 @@ import static cz.crcs.ectester.common.test.Result.ExpectedValue;
  */
 public class CardDefaultSuite extends CardTestSuite {
 
-    public CardDefaultSuite(EC_Store dataStore, ECTesterReader.Config cfg) {
-        super(dataStore, cfg, "default", "The default test suite run basic support of ECDH and ECDSA.");
+    public CardDefaultSuite(TestWriter writer, ECTesterReader.Config cfg, CardMngr cardManager) {
+        super(writer, cfg, cardManager, "default", "The default test suite run basic support of ECDH and ECDSA.");
     }
 
     @Override
-    public void setup(CardMngr cardManager) throws IOException {
-        //run.add(CommandTest.expect(new Command.Support(cardManager), ExpectedValue.ANY));
-        if (cfg.namedCurve != null) {
-            String desc = "Default run over the " + cfg.namedCurve + " curve category.";
-            if (cfg.primeField) {
-                run.addAll(defaultCategoryTests(cardManager, cfg.namedCurve, KeyPair.ALG_EC_FP, ExpectedValue.SUCCESS, ExpectedValue.SUCCESS, ExpectedValue.SUCCESS, ExpectedValue.ANY, ExpectedValue.SUCCESS, desc));
-            }
-            if (cfg.binaryField) {
-                run.addAll(defaultCategoryTests(cardManager, cfg.namedCurve, KeyPair.ALG_EC_F2M, ExpectedValue.SUCCESS, ExpectedValue.SUCCESS, ExpectedValue.SUCCESS, ExpectedValue.ANY, ExpectedValue.SUCCESS, desc));
+    protected void runTests() throws Exception {
+        if (cfg.primeField) {
+            runDefault(KeyPair.ALG_EC_FP);
+        }
+        if (cfg.binaryField) {
+            runDefault(KeyPair.ALG_EC_F2M);
+        }
+    }
+
+    private void runDefault(byte field) throws Exception {
+        for (short keyLength : EC_Consts.FP_SIZES) {
+            Test key = doTest(CommandTest.expect(new Command.Allocate(this.card, ECTesterApplet.KEYPAIR_BOTH, keyLength, field), ExpectedValue.SUCCESS));
+            if (!key.ok()) {
+                continue;
             }
-        } else {
-            if (cfg.all) {
-                if (cfg.primeField) {
-                    //iterate over prime curve sizes used: EC_Consts.FP_SIZES
-                    for (short keyLength : EC_Consts.FP_SIZES) {
-                        defaultTests(cardManager, keyLength, KeyPair.ALG_EC_FP);
-                    }
+            doTest(CommandTest.expect(new Command.Generate(this.card, ECTesterApplet.KEYPAIR_BOTH), ExpectedValue.SUCCESS));
+            doTest(CommandTest.expect(new Command.Set(this.card, ECTesterApplet.KEYPAIR_BOTH, EC_Consts.getCurve(keyLength, field), EC_Consts.PARAMETERS_DOMAIN_FP, null), ExpectedValue.SUCCESS));
+            doTest(CommandTest.expect(new Command.Generate(this.card, ECTesterApplet.KEYPAIR_BOTH), ExpectedValue.SUCCESS));
+            for (byte kaType : EC_Consts.KA_TYPES) {
+                Test allocate = CommandTest.expect(new Command.AllocateKeyAgreement(this.card, kaType), ExpectedValue.SUCCESS);
+                allocate.run();
+                if (allocate.ok()) {
+                    Test ka = CommandTest.expect(new Command.ECDH(this.card, ECTesterApplet.KEYPAIR_LOCAL, ECTesterApplet.KEYPAIR_REMOTE, ECTesterApplet.EXPORT_FALSE, EC_Consts.CORRUPTION_NONE, kaType), ExpectedValue.SUCCESS);
+                    ka.run();
+                    Test kaCompressed = CommandTest.expect(new Command.ECDH(this.card, ECTesterApplet.KEYPAIR_LOCAL, ECTesterApplet.KEYPAIR_REMOTE, ECTesterApplet.EXPORT_FALSE, EC_Consts.CORRUPTION_COMPRESS, kaType), ExpectedValue.SUCCESS);
+                    kaCompressed.run();
+                    doTest(CompoundTest.all(ExpectedValue.SUCCESS, "Test of the " + CardUtil.getKATypeString(kaType) + " KeyAgreement.", allocate, ka, kaCompressed));
                 }
-                if (cfg.binaryField) {
-                    //iterate over binary curve sizes used: EC_Consts.F2M_SIZES
-                    for (short keyLength : EC_Consts.F2M_SIZES) {
-                        defaultTests(cardManager, keyLength, KeyPair.ALG_EC_F2M);
-                    }
-                }
-            } else {
-                if (cfg.primeField) {
-                    defaultTests(cardManager, (short) cfg.bits, KeyPair.ALG_EC_FP);
-                }
-
-                if (cfg.binaryField) {
-                    defaultTests(cardManager, (short) cfg.bits, KeyPair.ALG_EC_F2M);
+            }
+            for (byte sigType : EC_Consts.SIG_TYPES) {
+                Test allocate = doTest(CommandTest.expect(new Command.AllocateSignature(this.card, sigType), ExpectedValue.SUCCESS));
+                if (allocate.ok()) {
+                    doTest(CommandTest.expect(new Command.ECDSA(this.card, ECTesterApplet.KEYPAIR_LOCAL, sigType, ECTesterApplet.EXPORT_FALSE, null), ExpectedValue.SUCCESS));
                 }
             }
         }
     }
-
-    private void defaultTests(CardMngr cardManager, short keyLength, byte keyType) throws IOException {
-        run.add(CommandTest.expect(new Command.Allocate(cardManager, ECTesterApplet.KEYPAIR_BOTH, keyLength, keyType), ExpectedValue.SUCCESS));
-        Command curve = Command.prepareCurve(cardManager, dataStore, cfg, ECTesterApplet.KEYPAIR_BOTH, keyLength, keyType);
-        if (curve != null)
-            run.add(CommandTest.expect(curve, ExpectedValue.SUCCESS));
-        run.add(defaultCurveTests(cardManager, ExpectedValue.SUCCESS, ExpectedValue.SUCCESS, ExpectedValue.ANY, ExpectedValue.SUCCESS, "Default run."));
-        run.add(new BaseRunnable(() -> new Command.Cleanup(cardManager)));
-    }
 }
diff --git a/src/cz/crcs/ectester/reader/test/CardInvalidCurvesSuite.java b/src/cz/crcs/ectester/reader/test/CardInvalidCurvesSuite.java
index 3c0795b..0572a66 100644
--- a/src/cz/crcs/ectester/reader/test/CardInvalidCurvesSuite.java
+++ b/src/cz/crcs/ectester/reader/test/CardInvalidCurvesSuite.java
@@ -2,18 +2,17 @@ package cz.crcs.ectester.reader.test;
 
 import cz.crcs.ectester.applet.ECTesterApplet;
 import cz.crcs.ectester.applet.EC_Consts;
-import cz.crcs.ectester.common.test.BaseRunnable;
+import cz.crcs.ectester.common.ec.EC_Curve;
+import cz.crcs.ectester.common.ec.EC_Key;
+import cz.crcs.ectester.common.output.TestWriter;
 import cz.crcs.ectester.common.test.CompoundTest;
 import cz.crcs.ectester.common.test.Test;
 import cz.crcs.ectester.data.EC_Store;
 import cz.crcs.ectester.reader.CardMngr;
 import cz.crcs.ectester.reader.ECTesterReader;
 import cz.crcs.ectester.reader.command.Command;
-import cz.crcs.ectester.common.ec.EC_Curve;
-import cz.crcs.ectester.common.ec.EC_Key;
 import javacard.security.KeyPair;
 
-import java.io.IOException;
 import java.util.HashMap;
 import java.util.LinkedList;
 import java.util.List;
@@ -26,22 +25,19 @@ import static cz.crcs.ectester.common.test.Result.ExpectedValue;
  */
 public class CardInvalidCurvesSuite extends CardTestSuite {
 
-    public CardInvalidCurvesSuite(EC_Store dataStore, ECTesterReader.Config cfg) {
-        super(dataStore, cfg, "invalid", "The invalid curve suite run whether the card rejects points outside of the curve during ECDH.");
+    public CardInvalidCurvesSuite(TestWriter writer, ECTesterReader.Config cfg, CardMngr cardManager) {
+        super(writer, cfg, cardManager, "invalid", "The invalid curve suite run whether the card rejects points outside of the curve during ECDH.");
     }
 
     @Override
-    public void setup(CardMngr cardManager) throws IOException {
+    protected void runTests() throws Exception {
         /* Set original curves (secg/nist/brainpool). Generate local.
          * Try ECDH with invalid public keys of increasing (or decreasing) order.
          */
-        Map<String, EC_Key.Public> pubkeys = dataStore.getObjects(EC_Key.Public.class, "invalid");
+        Map<String, EC_Key.Public> pubkeys = EC_Store.getInstance().getObjects(EC_Key.Public.class, "invalid");
         Map<EC_Curve, List<EC_Key.Public>> curves = new HashMap<>();
         for (EC_Key.Public key : pubkeys.values()) {
-            EC_Curve curve = dataStore.getObject(EC_Curve.class, key.getCurve());
-            if (cfg.namedCurve != null && !(key.getCurve().startsWith(cfg.namedCurve) || key.getCurve().equals(cfg.namedCurve))) {
-                continue;
-            }
+            EC_Curve curve = EC_Store.getInstance().getObject(EC_Curve.class, key.getCurve());
             if (curve.getBits() != cfg.bits && !cfg.all) {
                 continue;
             }
@@ -56,16 +52,16 @@ public class CardInvalidCurvesSuite extends CardTestSuite {
             EC_Curve curve = e.getKey();
             List<EC_Key.Public> keys = e.getValue();
 
-            run.add(CommandTest.expect(new Command.Allocate(cardManager, ECTesterApplet.KEYPAIR_BOTH, curve.getBits(), curve.getField()), ExpectedValue.SUCCESS));
-            run.add(CommandTest.expect(new Command.Set(cardManager, ECTesterApplet.KEYPAIR_BOTH, EC_Consts.CURVE_external, curve.getParams(), curve.flatten()), ExpectedValue.SUCCESS));
-            run.add(CommandTest.expect(new Command.Generate(cardManager, ECTesterApplet.KEYPAIR_LOCAL), ExpectedValue.SUCCESS));
+            doTest(CommandTest.expect(new Command.Allocate(this.card, ECTesterApplet.KEYPAIR_BOTH, curve.getBits(), curve.getField()), ExpectedValue.SUCCESS));
+            doTest(CommandTest.expect(new Command.Set(this.card, ECTesterApplet.KEYPAIR_BOTH, EC_Consts.CURVE_external, curve.getParams(), curve.flatten()), ExpectedValue.SUCCESS));
+            doTest(CommandTest.expect(new Command.Generate(this.card, ECTesterApplet.KEYPAIR_LOCAL), ExpectedValue.SUCCESS));
             List<Test> ecdhTests = new LinkedList<>();
             for (EC_Key.Public pub : keys) {
-                Command ecdhCommand = new Command.ECDH_direct(cardManager, ECTesterApplet.KEYPAIR_LOCAL, ECTesterApplet.EXPORT_FALSE, EC_Consts.CORRUPTION_NONE, ECTesterApplet.KeyAgreement_ALG_EC_SVDP_DH, pub.flatten());
-                ecdhTests.add(CommandTest.expect(ecdhCommand, ExpectedValue.FAILURE, "Card correctly rejected point on invalid curve." , "Card incorrectly accepted point on invalid curve."));
+                Command ecdhCommand = new Command.ECDH_direct(this.card, ECTesterApplet.KEYPAIR_LOCAL, ECTesterApplet.EXPORT_FALSE, EC_Consts.CORRUPTION_NONE, ECTesterApplet.KeyAgreement_ALG_EC_SVDP_DH, pub.flatten());
+                ecdhTests.add(CommandTest.expect(ecdhCommand, ExpectedValue.FAILURE, "Card correctly rejected point on invalid curve.", "Card incorrectly accepted point on invalid curve."));
             }
-            run.add(CompoundTest.all(ExpectedValue.SUCCESS, "Invalid curve test of " + curve.getId(), ecdhTests.toArray(new Test[0])));
-            run.add(new BaseRunnable(() -> new Command.Cleanup(cardManager)));
+            doTest(CompoundTest.all(ExpectedValue.SUCCESS, "Invalid curve test of " + curve.getId(), ecdhTests.toArray(new Test[0])));
+            new Command.Cleanup(this.card).send();
         }
     }
 }
diff --git a/src/cz/crcs/ectester/reader/test/CardTestSuite.java b/src/cz/crcs/ectester/reader/test/CardTestSuite.java
index 7035ca2..e12a588 100644
--- a/src/cz/crcs/ectester/reader/test/CardTestSuite.java
+++ b/src/cz/crcs/ectester/reader/test/CardTestSuite.java
@@ -3,14 +3,16 @@ package cz.crcs.ectester.reader.test;
 import cz.crcs.ectester.applet.ECTesterApplet;
 import cz.crcs.ectester.applet.EC_Consts;
 import cz.crcs.ectester.common.ec.EC_Curve;
-import cz.crcs.ectester.common.test.*;
-import cz.crcs.ectester.common.test.Runnable;
+import cz.crcs.ectester.common.output.TestWriter;
+import cz.crcs.ectester.common.test.CompoundTest;
+import cz.crcs.ectester.common.test.Result;
+import cz.crcs.ectester.common.test.Test;
+import cz.crcs.ectester.common.test.TestSuite;
 import cz.crcs.ectester.data.EC_Store;
 import cz.crcs.ectester.reader.CardMngr;
 import cz.crcs.ectester.reader.ECTesterReader;
 import cz.crcs.ectester.reader.command.Command;
 
-import java.io.IOException;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;
@@ -24,14 +26,14 @@ import static cz.crcs.ectester.common.test.Result.Value;
  */
 public abstract class CardTestSuite extends TestSuite {
     ECTesterReader.Config cfg;
+    CardMngr card;
 
-    CardTestSuite(EC_Store dataStore, ECTesterReader.Config cfg, String name, String description) {
-        super(dataStore, name, description);
+    CardTestSuite(TestWriter writer, ECTesterReader.Config cfg, CardMngr cardManager, String name, String description) {
+        super(writer, name, description);
+        this.card = cardManager;
         this.cfg = cfg;
     }
 
-    public abstract void setup(CardMngr cardManager) throws IOException;
-
     /**
      * @param cardManager          cardManager to send APDU through
      * @param generateExpected     expected result of the Generate command
@@ -98,21 +100,20 @@ public abstract class CardTestSuite extends TestSuite {
      * @param description            compound test description
      * @return run to run
      */
-    List<Runnable> defaultCategoryTests(CardMngr cardManager, String category, byte field, ExpectedValue setExpected, ExpectedValue generateExpected, ExpectedValue ecdhExpected, ExpectedValue ecdhCompressedExpected, ExpectedValue ecdsaExpected, String description) {
-        List<Runnable> tests = new LinkedList<>();
-        Map<String, EC_Curve> curves = dataStore.getObjects(EC_Curve.class, category);
+    List<Test> defaultCategoryTests(CardMngr cardManager, String category, byte field, ExpectedValue setExpected, ExpectedValue generateExpected, ExpectedValue ecdhExpected, ExpectedValue ecdhCompressedExpected, ExpectedValue ecdsaExpected, String description) {
+        Map<String, EC_Curve> curves = EC_Store.getInstance().getObjects(EC_Curve.class, category);
         if (curves == null)
-            return tests;
+            return null;
         for (Map.Entry<String, EC_Curve> entry : curves.entrySet()) {
             EC_Curve curve = entry.getValue();
             if (curve.getField() == field && (curve.getBits() == cfg.bits || cfg.all)) {
-                tests.add(CommandTest.expect(new Command.Allocate(cardManager, ECTesterApplet.KEYPAIR_BOTH, curve.getBits(), field), ExpectedValue.SUCCESS));
-                tests.add(CommandTest.expect(new Command.Set(cardManager, ECTesterApplet.KEYPAIR_BOTH, EC_Consts.CURVE_external, curve.getParams(), curve.flatten()), setExpected));
-                tests.add(defaultCurveTests(cardManager, generateExpected, ecdhExpected, ecdhCompressedExpected, ecdsaExpected, description));
-                run.add(new BaseRunnable(() -> new Command.Cleanup(cardManager)));
+                //tests.add(CommandTest.expect(new Command.Allocate(cardManager, ECTesterApplet.KEYPAIR_BOTH, curve.getBits(), field), ExpectedValue.SUCCESS));
+                //tests.add(CommandTest.expect(new Command.Set(cardManager, ECTesterApplet.KEYPAIR_BOTH, EC_Consts.CURVE_external, curve.getParams(), curve.flatten()), setExpected));
+                //tests.add(defaultCurveTests(cardManager, generateExpected, ecdhExpected, ecdhCompressedExpected, ecdsaExpected, description));
+                //run.add(new BaseRunnable(() -> new Command.Cleanup(cardManager)));
             }
         }
 
-        return tests;
+        return null;
     }
 }
diff --git a/src/cz/crcs/ectester/reader/test/CardTestVectorSuite.java b/src/cz/crcs/ectester/reader/test/CardTestVectorSuite.java
index 025cbe0..73c6621 100644
--- a/src/cz/crcs/ectester/reader/test/CardTestVectorSuite.java
+++ b/src/cz/crcs/ectester/reader/test/CardTestVectorSuite.java
@@ -3,6 +3,7 @@ package cz.crcs.ectester.reader.test;
 import cz.crcs.ectester.applet.ECTesterApplet;
 import cz.crcs.ectester.applet.EC_Consts;
 import cz.crcs.ectester.common.ec.*;
+import cz.crcs.ectester.common.output.TestWriter;
 import cz.crcs.ectester.common.test.*;
 import cz.crcs.ectester.common.util.ByteUtil;
 import cz.crcs.ectester.data.EC_Store;
@@ -25,46 +26,42 @@ import static cz.crcs.ectester.common.test.Result.Value;
  */
 public class CardTestVectorSuite extends CardTestSuite {
 
-    public CardTestVectorSuite(EC_Store dataStore, ECTesterReader.Config cfg) {
-        super(dataStore, cfg, "test", "The test-vectors suite contains a collection of test vectors which test basic ECDH correctness.");
+    public CardTestVectorSuite(TestWriter writer, ECTesterReader.Config cfg, CardMngr cardManager) {
+        super(writer, cfg, cardManager, "test", "The test-vectors suite contains a collection of test vectors which test basic ECDH correctness.");
     }
 
     @Override
-    public void setup(CardMngr cardManager) throws IOException {
+    protected void runTests() throws Exception {
         /* Set original curves (secg/nist/brainpool). Set keypairs from test vectors.
          * Do ECDH both ways, export and verify that the result is correct.
          */
-        Map<String, EC_KAResult> results = dataStore.getObjects(EC_KAResult.class, "test");
+        Map<String, EC_KAResult> results = EC_Store.getInstance().getObjects(EC_KAResult.class, "test");
         for (EC_KAResult result : results.values()) {
-            EC_Curve curve = dataStore.getObject(EC_Curve.class, result.getCurve());
-            if (cfg.namedCurve != null && !(result.getCurve().startsWith(cfg.namedCurve) || result.getCurve().equals(cfg.namedCurve))) {
-                continue;
-            }
+            EC_Curve curve = EC_Store.getInstance().getObject(EC_Curve.class, result.getCurve());
             if (curve.getBits() != cfg.bits && !cfg.all) {
                 continue;
             }
             if (curve.getField() == KeyPair.ALG_EC_FP && !cfg.primeField || curve.getField() == KeyPair.ALG_EC_F2M && !cfg.binaryField) {
                 continue;
             }
-            EC_Params onekey = dataStore.getObject(EC_Keypair.class, result.getOneKey());
+            EC_Params onekey = EC_Store.getInstance().getObject(EC_Keypair.class, result.getOneKey());
             if (onekey == null) {
-                onekey = dataStore.getObject(EC_Key.Private.class, result.getOneKey());
+                onekey = EC_Store.getInstance().getObject(EC_Key.Private.class, result.getOneKey());
             }
-            EC_Params otherkey = dataStore.getObject(EC_Keypair.class, result.getOtherKey());
+            EC_Params otherkey = EC_Store.getInstance().getObject(EC_Keypair.class, result.getOtherKey());
             if (otherkey == null) {
-                otherkey = dataStore.getObject(EC_Key.Public.class, result.getOtherKey());
+                otherkey = EC_Store.getInstance().getObject(EC_Key.Public.class, result.getOtherKey());
             }
             if (onekey == null || otherkey == null) {
                 throw new IOException("Test vector keys couldn't be located.");
             }
             List<Test> testVector = new LinkedList<>();
 
-            testVector.add(CommandTest.expect(new Command.Allocate(cardManager, ECTesterApplet.KEYPAIR_BOTH, curve.getBits(), curve.getField()), ExpectedValue.SUCCESS));
-            testVector.add(CommandTest.expect(new Command.Set(cardManager, ECTesterApplet.KEYPAIR_BOTH, EC_Consts.CURVE_external, curve.getParams(), curve.flatten()), ExpectedValue.SUCCESS));
-            //run.add(new Test.Simple(new Command.Generate(cardManager, ECTesterApplet.KEYPAIR_BOTH), ExpectedValue.SUCCESS));
-            testVector.add(CommandTest.expect(new Command.Set(cardManager, ECTesterApplet.KEYPAIR_LOCAL, EC_Consts.CURVE_external, EC_Consts.PARAMETER_S, onekey.flatten(EC_Consts.PARAMETER_S)), ExpectedValue.SUCCESS));
-            testVector.add(CommandTest.expect(new Command.Set(cardManager, ECTesterApplet.KEYPAIR_REMOTE, EC_Consts.CURVE_external, EC_Consts.PARAMETER_W, otherkey.flatten(EC_Consts.PARAMETER_W)), ExpectedValue.SUCCESS));
-            testVector.add(CommandTest.function(new Command.ECDH(cardManager, ECTesterApplet.KEYPAIR_REMOTE, ECTesterApplet.KEYPAIR_LOCAL, ECTesterApplet.EXPORT_TRUE, EC_Consts.CORRUPTION_NONE, result.getJavaCardKA()), new TestCallback<CommandTestable>() {
+            testVector.add(CommandTest.expect(new Command.Allocate(this.card, ECTesterApplet.KEYPAIR_BOTH, curve.getBits(), curve.getField()), ExpectedValue.SUCCESS));
+            testVector.add(CommandTest.expect(new Command.Set(this.card, ECTesterApplet.KEYPAIR_BOTH, EC_Consts.CURVE_external, curve.getParams(), curve.flatten()), ExpectedValue.SUCCESS));
+            testVector.add(CommandTest.expect(new Command.Set(this.card, ECTesterApplet.KEYPAIR_LOCAL, EC_Consts.CURVE_external, EC_Consts.PARAMETER_S, onekey.flatten(EC_Consts.PARAMETER_S)), ExpectedValue.SUCCESS));
+            testVector.add(CommandTest.expect(new Command.Set(this.card, ECTesterApplet.KEYPAIR_REMOTE, EC_Consts.CURVE_external, EC_Consts.PARAMETER_W, otherkey.flatten(EC_Consts.PARAMETER_W)), ExpectedValue.SUCCESS));
+            testVector.add(CommandTest.function(new Command.ECDH(this.card, ECTesterApplet.KEYPAIR_REMOTE, ECTesterApplet.KEYPAIR_LOCAL, ECTesterApplet.EXPORT_TRUE, EC_Consts.CORRUPTION_NONE, result.getJavaCardKA()), new TestCallback<CommandTestable>() {
                 @Override
                 public Result apply(CommandTestable testable) {
                     Response.ECDH dh = (Response.ECDH) testable.getResponse();
@@ -74,13 +71,13 @@ public class CardTestVectorSuite extends CardTestSuite {
                         return new Result(Value.FAILURE, "ECDH response did not contain the derived secret.");
                     if (!ByteUtil.compareBytes(dh.getSecret(), 0, result.getData(0), 0, dh.secretLength())) {
                         int firstDiff = ByteUtil.diffBytes(dh.getSecret(), 0, result.getData(0), 0, dh.secretLength());
-                        return new Result(Value.FAILURE, "ECDH derived secret does not match the test, first difference was at byte " + String.valueOf(firstDiff) + ".");
+                        return new Result(Value.FAILURE, "ECDH derived secret does not match the test-vector, first difference was at byte " + String.valueOf(firstDiff) + ".");
                     }
                     return new Result(Value.SUCCESS);
                 }
             }));
-            run.add(CompoundTest.all(ExpectedValue.SUCCESS, "Test vector " + result.getId(), testVector.toArray(new Test[0])));
-            run.add(new BaseRunnable(() -> new Command.Cleanup(cardManager)));
+            doTest(CompoundTest.all(ExpectedValue.SUCCESS, "Test vector " + result.getId(), testVector.toArray(new Test[0])));
+            new Command.Cleanup(this.card).send();
         }
     }
 }
diff --git a/src/cz/crcs/ectester/reader/test/CardWrongCurvesSuite.java b/src/cz/crcs/ectester/reader/test/CardWrongCurvesSuite.java
index 8c21aef..3a350c2 100644
--- a/src/cz/crcs/ectester/reader/test/CardWrongCurvesSuite.java
+++ b/src/cz/crcs/ectester/reader/test/CardWrongCurvesSuite.java
@@ -1,34 +1,58 @@
 package cz.crcs.ectester.reader.test;
 
+import cz.crcs.ectester.applet.ECTesterApplet;
+import cz.crcs.ectester.applet.EC_Consts;
+import cz.crcs.ectester.common.ec.EC_Curve;
+import cz.crcs.ectester.common.output.TestWriter;
+import cz.crcs.ectester.common.test.CompoundTest;
+import cz.crcs.ectester.common.test.Result;
+import cz.crcs.ectester.common.test.Test;
 import cz.crcs.ectester.data.EC_Store;
 import cz.crcs.ectester.reader.CardMngr;
 import cz.crcs.ectester.reader.ECTesterReader;
+import cz.crcs.ectester.reader.command.Command;
 import javacard.security.KeyPair;
 
-import java.io.IOException;
-
-import static cz.crcs.ectester.common.test.Result.ExpectedValue;
+import java.util.Map;
 
 /**
  * @author Jan Jancar johny@neuromancer.sk
  */
 public class CardWrongCurvesSuite extends CardTestSuite {
 
-    public CardWrongCurvesSuite(EC_Store dataStore, ECTesterReader.Config cfg) {
-        super(dataStore, cfg, "wrong", "The wrong curve suite run whether the card rejects domain parameters which are not curves.");
+    public CardWrongCurvesSuite(TestWriter writer, ECTesterReader.Config cfg, CardMngr cardManager) {
+        super(writer, cfg, cardManager, "wrong", "The wrong curve suite run whether the card rejects domain parameters which are not curves.");
     }
 
     @Override
-    public void setup(CardMngr cardManager) throws IOException {
+    protected void runTests() throws Exception {
         /* Just do the default run on the wrong curves.
          * These should generally fail, the curves aren't curves.
          */
-        String desc = "Default run over wrong curve params.";
-        if (cfg.primeField) {
-            run.addAll(defaultCategoryTests(cardManager, cfg.testSuite, KeyPair.ALG_EC_FP, ExpectedValue.FAILURE, ExpectedValue.FAILURE, ExpectedValue.FAILURE, ExpectedValue.FAILURE, ExpectedValue.FAILURE, desc));
-        }
-        if (cfg.binaryField) {
-            run.addAll(defaultCategoryTests(cardManager, cfg.testSuite, KeyPair.ALG_EC_F2M, ExpectedValue.FAILURE, ExpectedValue.FAILURE, ExpectedValue.FAILURE, ExpectedValue.FAILURE, ExpectedValue.FAILURE, desc));
+        Map<String, EC_Curve> curves = EC_Store.getInstance().getObjects(EC_Curve.class, "wrong");
+        for (Map.Entry<String, EC_Curve> e : curves.entrySet()) {
+            EC_Curve curve = e.getValue();
+            if (curve.getBits() != cfg.bits && !cfg.all) {
+                continue;
+            }
+            if (curve.getField() == KeyPair.ALG_EC_FP && !cfg.primeField || curve.getField() == KeyPair.ALG_EC_F2M && !cfg.binaryField) {
+                continue;
+            }
+            Test key = doTest(CommandTest.expect(new Command.Allocate(this.card, ECTesterApplet.KEYPAIR_BOTH, curve.getBits(), curve.getField()), Result.ExpectedValue.SUCCESS));
+            if (!key.ok()) {
+                continue;
+            }
+            Test set = runTest(CommandTest.expect(new Command.Set(this.card, ECTesterApplet.KEYPAIR_BOTH, EC_Consts.CURVE_external, curve.getParams(), curve.flatten()), Result.ExpectedValue.SUCCESS));
+            Test generate = runTest(CommandTest.expect(new Command.Generate(this.card, ECTesterApplet.KEYPAIR_BOTH), Result.ExpectedValue.SUCCESS));
+            doTest(CompoundTest.any(Result.ExpectedValue.FAILURE, "Set wrong curve and generate keypairs, should fail." ,set, generate));
+
+            for (byte kaType : EC_Consts.KA_TYPES) {
+                Test allocate = runTest(CommandTest.expect(new Command.AllocateKeyAgreement(this.card, kaType), Result.ExpectedValue.SUCCESS));
+                if (allocate.ok()) {
+                    Test ka = runTest(CommandTest.expect(new Command.ECDH(this.card, ECTesterApplet.KEYPAIR_LOCAL, ECTesterApplet.KEYPAIR_REMOTE, ECTesterApplet.EXPORT_FALSE, EC_Consts.CORRUPTION_NONE, kaType), Result.ExpectedValue.FAILURE));
+                    doTest(CompoundTest.all(Result.ExpectedValue.SUCCESS, "Allocate and perform KA, should fail.", allocate, ka));
+                }
+            }
         }
     }
 }