No more runTest in reader.

11 files changed, 159 insertions, 181 deletions

diff --git a/reader/src/main/java/cz/crcs/ectester/reader/test/CardCompressionSuite.java b/reader/src/main/java/cz/crcs/ectester/reader/test/CardCompressionSuite.java
index ee27673..418ed2f 100644
--- a/reader/src/main/java/cz/crcs/ectester/reader/test/CardCompressionSuite.java
+++ b/reader/src/main/java/cz/crcs/ectester/reader/test/CardCompressionSuite.java
@@ -70,56 +70,40 @@ public class CardCompressionSuite extends CardTestSuite {
             String spec = keyLength + "b " + CardUtil.getKeyTypeString(field);
             byte curveId = EC_Consts.getCurve(keyLength, field);
 
-            Test allocateFirst = runTest(CommandTest.expect(new Command.Allocate(this.card, CardConsts.KEYPAIR_BOTH, keyLength, field), Result.ExpectedValue.SUCCESS));
-            if (!allocateFirst.ok()) {
-                doTest(CompoundTest.all(Result.ExpectedValue.SUCCESS, "No support for compression test on " + spec + ".", allocateFirst));
-                continue;
-            }
-
             List<Test> compressionTests = new LinkedList<>();
+            Test allocateFirst = CommandTest.expect(new Command.Allocate(this.card, CardConsts.KEYPAIR_BOTH, keyLength, field), Result.ExpectedValue.SUCCESS);
+            Test setCustom = CommandTest.expect(new Command.Set(this.card, CardConsts.KEYPAIR_BOTH, curveId, domain, null), Result.ExpectedValue.SUCCESS);
+            Test genCustom = CommandTest.expect(new Command.Generate(this.card, CardConsts.KEYPAIR_BOTH), Result.ExpectedValue.SUCCESS);
             compressionTests.add(allocateFirst);
-            Test setCustom = runTest(CommandTest.expect(new Command.Set(this.card, CardConsts.KEYPAIR_BOTH, curveId, domain, null), Result.ExpectedValue.SUCCESS));
-            Test genCustom = runTest(CommandTest.expect(new Command.Generate(this.card, CardConsts.KEYPAIR_BOTH), Result.ExpectedValue.SUCCESS));
             compressionTests.add(setCustom);
             compressionTests.add(genCustom);
 
-            Response.Export key = new Command.Export(this.card, CardConsts.KEYPAIR_REMOTE, EC_Consts.KEY_PUBLIC, EC_Consts.PARAMETER_W).send();
-            byte[] pubkey = key.getParameter(CardConsts.KEYPAIR_REMOTE, EC_Consts.KEY_PUBLIC);
             EC_Curve secgCurve = EC_Store.getInstance().getObject(EC_Curve.class, "secg", CardUtil.getCurveName(curveId));
-            ECPoint pub;
-            try {
-                pub = ECUtil.fromX962(pubkey, secgCurve.toCurve());
-            } catch (IllegalArgumentException iae) {
-                doTest(CompoundTest.all(Result.ExpectedValue.SUCCESS, "", compressionTests.toArray(new Test[0])));
-                continue;
-            }
+            ECPoint pub = ECUtil.toPoint(ECUtil.fixedRandomPoint(secgCurve));
 
             List<Test> kaTests = new LinkedList<>();
             for (byte kaType : EC_Consts.KA_TYPES) {
                 List<Test> thisTests = new LinkedList<>();
-                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, CardConsts.KEYPAIR_LOCAL, CardConsts.KEYPAIR_REMOTE, CardConsts.EXPORT_FALSE, EC_Consts.TRANSFORMATION_NONE, kaType), Result.ExpectedValue.SUCCESS));
+                Test allocate = CommandTest.expect(new Command.AllocateKeyAgreement(this.card, kaType), Result.ExpectedValue.SUCCESS);
+                Test ka = CommandTest.expect(new Command.ECDH(this.card, CardConsts.KEYPAIR_LOCAL, CardConsts.KEYPAIR_REMOTE, CardConsts.EXPORT_FALSE, EC_Consts.TRANSFORMATION_NONE, kaType), Result.ExpectedValue.SUCCESS);
 
-                    thisTests.add(CompoundTest.all(Result.ExpectedValue.SUCCESS, "KeyAgreement setup and basic test.", allocate, ka));
-                    if (ka.ok()) {
-                        // tests of the good stuff
-                        Test kaCompressed = CommandTest.expect(new Command.ECDH(this.card, CardConsts.KEYPAIR_LOCAL, CardConsts.KEYPAIR_REMOTE, CardConsts.EXPORT_FALSE, EC_Consts.TRANSFORMATION_COMPRESS, kaType), Result.ExpectedValue.SUCCESS);
-                        Test kaHybrid = CommandTest.expect(new Command.ECDH(this.card, CardConsts.KEYPAIR_LOCAL, CardConsts.KEYPAIR_REMOTE, CardConsts.EXPORT_FALSE, EC_Consts.TRANSFORMATION_COMPRESS_HYBRID, kaType), Result.ExpectedValue.SUCCESS);
-                        thisTests.add(CompoundTest.any(Result.ExpectedValue.SUCCESS, "Tests of compressed and hybrid form.", kaCompressed, kaHybrid));
+                thisTests.add(CompoundTest.all(Result.ExpectedValue.SUCCESS, "KeyAgreement setup and basic test.", allocate, ka));
+                // tests of the good stuff
+                Test kaCompressed = CommandTest.expect(new Command.ECDH(this.card, CardConsts.KEYPAIR_LOCAL, CardConsts.KEYPAIR_REMOTE, CardConsts.EXPORT_FALSE, EC_Consts.TRANSFORMATION_COMPRESS, kaType), Result.ExpectedValue.SUCCESS);
+                Test kaHybrid = CommandTest.expect(new Command.ECDH(this.card, CardConsts.KEYPAIR_LOCAL, CardConsts.KEYPAIR_REMOTE, CardConsts.EXPORT_FALSE, EC_Consts.TRANSFORMATION_COMPRESS_HYBRID, kaType), Result.ExpectedValue.SUCCESS);
+                thisTests.add(CompoundTest.any(Result.ExpectedValue.SUCCESS, "Tests of compressed and hybrid form.", kaCompressed, kaHybrid));
 
-                        // tests the bad stuff here
-                        byte[] pubHybrid = ECUtil.toX962Hybrid(pub, keyLength);
-                        pubHybrid[pubHybrid.length - 1] ^= 1;
-                        byte[] pubHybridEncoded = ByteUtil.prependLength(pubHybrid);
-                        Test kaBadHybrid = CommandTest.expect(new Command.ECDH_direct(this.card, CardConsts.KEYPAIR_LOCAL, CardConsts.EXPORT_FALSE, EC_Consts.TRANSFORMATION_NONE, kaType, pubHybridEncoded), Result.ExpectedValue.FAILURE);
+                // tests the bad stuff here
+                byte[] pubHybrid = ECUtil.toX962Hybrid(pub, keyLength);
+                pubHybrid[pubHybrid.length - 1] ^= 1;
+                byte[] pubHybridEncoded = ByteUtil.prependLength(pubHybrid);
+                Test kaBadHybrid = CommandTest.expect(new Command.ECDH_direct(this.card, CardConsts.KEYPAIR_LOCAL, CardConsts.EXPORT_FALSE, EC_Consts.TRANSFORMATION_NONE, kaType, pubHybridEncoded), Result.ExpectedValue.FAILURE);
 
-                        byte[] pubInfinityEncoded = {0x00};
-                        Test kaBadInfinity = CommandTest.expect(new Command.ECDH_direct(this.card, CardConsts.KEYPAIR_LOCAL, CardConsts.EXPORT_FALSE, EC_Consts.TRANSFORMATION_INFINITY, kaType, pubInfinityEncoded), Result.ExpectedValue.FAILURE);
-                        thisTests.add(CompoundTest.all(Result.ExpectedValue.SUCCESS, "Tests of corrupted hybrid form and infinity.", kaBadHybrid, kaBadInfinity));
-                    }
-                    kaTests.add(CompoundTest.all(Result.ExpectedValue.SUCCESS, "KeyAgreement tests of " + CardUtil.getKATypeString(kaType) + ".", thisTests.toArray(new Test[0])));
-                }
+                byte[] pubInfinityEncoded = {0x00};
+                Test kaBadInfinity = CommandTest.expect(new Command.ECDH_direct(this.card, CardConsts.KEYPAIR_LOCAL, CardConsts.EXPORT_FALSE, EC_Consts.TRANSFORMATION_INFINITY, kaType, pubInfinityEncoded), Result.ExpectedValue.FAILURE);
+                thisTests.add(CompoundTest.all(Result.ExpectedValue.SUCCESS, "Tests of corrupted hybrid form and infinity.", kaBadHybrid, kaBadInfinity));
+
+                kaTests.add(CompoundTest.all(Result.ExpectedValue.SUCCESS, "KeyAgreement tests of " + CardUtil.getKATypeString(kaType) + ".", thisTests.toArray(new Test[0])));
             }
             compressionTests.addAll(kaTests);
             if (cfg.cleanup) {
@@ -137,12 +121,7 @@ public class CardCompressionSuite extends CardTestSuite {
         for (EC_Key.Public key : compressionKeys) {
             EC_Curve curve = EC_Store.getInstance().getObject(EC_Curve.class, key.getCurve());
             List<Test> tests = new LinkedList<>();
-            Test allocate = runTest(CommandTest.expect(new Command.Allocate(this.card, CardConsts.KEYPAIR_LOCAL, curve.getBits(), curve.getField()), Result.ExpectedValue.SUCCESS));
-            if (!allocate.ok()) {
-                doTest(CompoundTest.all(Result.ExpectedValue.SUCCESS, "No support for non-residue test on " + curve.getBits() + "b " + curve.getId() + ".", allocate));
-                continue;
-            }
-            tests.add(allocate);
+            tests.add(CommandTest.expect(new Command.Allocate(this.card, CardConsts.KEYPAIR_LOCAL, curve.getBits(), curve.getField()), Result.ExpectedValue.SUCCESS));
             tests.add(CommandTest.expect(new Command.Set(this.card, CardConsts.KEYPAIR_LOCAL, EC_Consts.CURVE_external, curve.getParams(), curve.flatten()), Result.ExpectedValue.SUCCESS));
             tests.add(CommandTest.expect(new Command.Generate(this.card, CardConsts.KEYPAIR_LOCAL), Result.ExpectedValue.SUCCESS));
             byte[] pointData = ECUtil.toX962Compressed(key.getParam(EC_Consts.PARAMETER_W));
diff --git a/reader/src/main/java/cz/crcs/ectester/reader/test/CardDefaultSuite.java b/reader/src/main/java/cz/crcs/ectester/reader/test/CardDefaultSuite.java
index ebb1d3f..c365d52 100644
--- a/reader/src/main/java/cz/crcs/ectester/reader/test/CardDefaultSuite.java
+++ b/reader/src/main/java/cz/crcs/ectester/reader/test/CardDefaultSuite.java
@@ -13,7 +13,7 @@ import cz.crcs.ectester.reader.command.Command;
 
 import java.util.LinkedList;
 import java.util.List;
-import java.util.Random;
+import java.util.function.Consumer;
 import java.util.function.Function;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
@@ -44,19 +44,13 @@ public class CardDefaultSuite extends CardTestSuite {
         short[] keySizes = field == EC_Consts.ALG_EC_FP ? EC_Consts.FP_SIZES : EC_Consts.F2M_SIZES;
         short domain = field == EC_Consts.ALG_EC_FP ? EC_Consts.PARAMETERS_DOMAIN_FP : EC_Consts.PARAMETERS_DOMAIN_F2M;
         for (short keyLength : keySizes) {
-
             List<Test> supportTests = new LinkedList<>();
-            Test allocateFirst = runTest(CommandTest.expect(new Command.Allocate(this.card, CardConsts.KEYPAIR_BOTH, keyLength, field), ExpectedValue.SUCCESS));
-            if (!allocateFirst.ok()) {
-                doTest(CompoundTest.all(ExpectedValue.SUCCESS, "No support for " + keyLength + "b " + CardUtil.getKeyTypeString(field) + ".", allocateFirst));
-                continue;
-            }
+            Test allocateFirst = CommandTest.expect(new Command.Allocate(this.card, CardConsts.KEYPAIR_BOTH, keyLength, field), ExpectedValue.SUCCESS);
+            Test genDefault = CommandTest.expect(new Command.Generate(this.card, CardConsts.KEYPAIR_BOTH), ExpectedValue.SUCCESS);
+            Test allocateSecond = CommandTest.expect(new Command.Allocate(this.card, CardConsts.KEYPAIR_BOTH, keyLength, field), ExpectedValue.SUCCESS);
+            Test setCustom = CommandTest.expect(new Command.Set(this.card, CardConsts.KEYPAIR_BOTH, EC_Consts.getCurve(keyLength, field), domain, null), ExpectedValue.SUCCESS);
+            Test genCustom = CommandTest.expect(new Command.Generate(this.card, CardConsts.KEYPAIR_BOTH), ExpectedValue.SUCCESS);
             supportTests.add(allocateFirst);
-
-            Test genDefault = runTest(CommandTest.expect(new Command.Generate(this.card, CardConsts.KEYPAIR_BOTH), ExpectedValue.SUCCESS));
-            Test allocateSecond = runTest(CommandTest.expect(new Command.Allocate(this.card, CardConsts.KEYPAIR_BOTH, keyLength, field), ExpectedValue.SUCCESS));
-            Test setCustom = runTest(CommandTest.expect(new Command.Set(this.card, CardConsts.KEYPAIR_BOTH, EC_Consts.getCurve(keyLength, field), domain, null), ExpectedValue.SUCCESS));
-            Test genCustom = runTest(CommandTest.expect(new Command.Generate(this.card, CardConsts.KEYPAIR_BOTH), ExpectedValue.SUCCESS));
             supportTests.add(genDefault);
             supportTests.add(allocateSecond);
             supportTests.add(setCustom);
@@ -64,68 +58,77 @@ public class CardDefaultSuite extends CardTestSuite {
 
             List<Test> kaTests = new LinkedList<>();
             for (byte kaType : EC_Consts.KA_TYPES) {
-                Test allocate = runTest(CommandTest.expect(new Command.AllocateKeyAgreement(this.card, kaType), ExpectedValue.SUCCESS));
-                if (allocate.ok()) {
-                    Command ecdh = new Command.ECDH(this.card, CardConsts.KEYPAIR_LOCAL, CardConsts.KEYPAIR_REMOTE, CardConsts.EXPORT_FALSE, EC_Consts.TRANSFORMATION_NONE, kaType);
-                    Test ka = runTest(CommandTest.expect(ecdh, ExpectedValue.SUCCESS));
-                    Test kaCompressed = runTest(CommandTest.expect(new Command.ECDH(this.card, CardConsts.KEYPAIR_LOCAL, CardConsts.KEYPAIR_REMOTE, CardConsts.EXPORT_FALSE, EC_Consts.TRANSFORMATION_COMPRESS, kaType), ExpectedValue.SUCCESS));
+                Test allocate = CommandTest.expect(new Command.AllocateKeyAgreement(this.card, kaType), ExpectedValue.SUCCESS);
+                Command ecdh = new Command.ECDH(this.card, CardConsts.KEYPAIR_LOCAL, CardConsts.KEYPAIR_REMOTE, CardConsts.EXPORT_FALSE, EC_Consts.TRANSFORMATION_NONE, kaType);
+                Test ka = CommandTest.expect(ecdh, ExpectedValue.SUCCESS);
+                Test kaCompressed = CommandTest.expect(new Command.ECDH(this.card, CardConsts.KEYPAIR_LOCAL, CardConsts.KEYPAIR_REMOTE, CardConsts.EXPORT_FALSE, EC_Consts.TRANSFORMATION_COMPRESS, kaType), ExpectedValue.SUCCESS);
 
-                    String kaDesc = "Test of the " + CardUtil.getKATypeString(kaType) + " KeyAgreement.";
-                    Function<Test[], Result> kaCallback = (tests) -> {
-                        if (tests[1].ok() || tests[2].ok()) {
-                            return new Result(Value.SUCCESS, "Some ECDH is supported.");
+                String kaDesc = "Test of the " + CardUtil.getKATypeString(kaType) + " KeyAgreement.";
+                Function<Test[], Result> kaCallback = (tests) -> {
+                    if (tests[1].ok() || tests[2].ok()) {
+                        return new Result(Value.SUCCESS, "Some ECDH is supported.");
+                    } else {
+                        return new Result(Value.FAILURE, "ECDH failed.");
+                    }
+                };
+
+                Consumer<Test[]> runCallback = tests -> {
+                    for (Test t : tests) {
+                        if (t instanceof PerformanceTest) {
+                            if (tests[0].ok() && tests[1].ok()) {
+                                t.run();
+                            }
                         } else {
-                            return new Result(Value.FAILURE, "ECDH failed.");
+                            t.run();
                         }
-                    };
-
-                    Test compound;
-                    if (ka.ok()) {
-                        Test perfTest = runTest(PerformanceTest.repeat(this.card, ecdh, 10));
-                        compound = runTest(CompoundTest.function(kaCallback, kaDesc, allocate, ka, kaCompressed, perfTest));
-                    } else {
-                        compound = runTest(CompoundTest.function(kaCallback, kaDesc, allocate, ka, kaCompressed));
                     }
+                };
 
-                    kaTests.add(compound);
-                } else {
-                    runTest(allocate);
-                    kaTests.add(allocate);
-                }
+                Test perfTest = PerformanceTest.repeat(this.card, ecdh, 10);
+                Test compound = CompoundTest.function(kaCallback, runCallback, kaDesc, allocate, ka, kaCompressed, perfTest);
+                kaTests.add(compound);
             }
-            Test kaTest = runTest(CompoundTest.any(ExpectedValue.SUCCESS, "KeyAgreement tests.", kaTests.toArray(new Test[0])));
+            Test kaTest = CompoundTest.any(ExpectedValue.SUCCESS, "KeyAgreement tests.", kaTests.toArray(new Test[0]));
             supportTests.add(kaTest);
 
             List<Test> signTests = new LinkedList<>();
             for (byte sigType : EC_Consts.SIG_TYPES) {
-                Test allocate = runTest(CommandTest.expect(new Command.AllocateSignature(this.card, sigType), ExpectedValue.SUCCESS));
-                if (allocate.ok()) {
-                    Command ecdsa = new Command.ECDSA(this.card, CardConsts.KEYPAIR_LOCAL, sigType, CardConsts.EXPORT_FALSE, null);
-                    Test expect = runTest(CommandTest.expect(ecdsa, ExpectedValue.SUCCESS));
+                Test allocate = CommandTest.expect(new Command.AllocateSignature(this.card, sigType), ExpectedValue.SUCCESS);
+                Command ecdsa = new Command.ECDSA(this.card, CardConsts.KEYPAIR_LOCAL, sigType, CardConsts.EXPORT_FALSE, null);
+                Test sign = CommandTest.expect(ecdsa, ExpectedValue.SUCCESS);
 
-                    String signDesc = "Test of the " + CardUtil.getSigTypeString(sigType) + " signature.";
+                String signDesc = "Test of the " + CardUtil.getSigTypeString(sigType) + " signature.";
 
-                    Random rand = new Random();
-                    byte[] sigData = new byte[64];
-                    rand.nextBytes(sigData);
+                byte[] sigData = new byte[]{(byte) domain, sigType};
 
-                    Test compound;
-                    if (expect.ok()) {
-                        Command ecdsaSign = new Command.ECDSA_sign(this.card, CardConsts.KEYPAIR_LOCAL, sigType, CardConsts.EXPORT_TRUE, sigData);
-                        PerformanceTest signTest = runTest(PerformanceTest.repeat(this.card, "Sign", ecdsaSign, 10));
-                        byte[] signature = signTest.getResponses()[0].getParam(0);
-                        Command ecdsaVerify = new Command.ECDSA_verify(this.card, CardConsts.KEYPAIR_LOCAL, sigType, sigData, signature);
-                        PerformanceTest verifyTest = runTest(PerformanceTest.repeat(this.card, "Verify", ecdsaVerify, 10));
-                        compound = runTest(CompoundTest.all(ExpectedValue.SUCCESS, signDesc, allocate, expect, signTest, verifyTest));
+                Function<Test[], Result> sigCallback = (tests) -> {
+                    if (tests[1].ok()) {
+                        return new Result(Value.SUCCESS, "Some ECDSA is supported.");
                     } else {
-                        compound = runTest(CompoundTest.all(ExpectedValue.SUCCESS, signDesc, allocate, expect));
+                        return new Result(Value.FAILURE, "ECDSA failed.");
+                    }
+                };
+                Consumer<Test[]> runCallback = tests -> {
+                    for (Test t : tests) {
+                        if (t instanceof PerformanceTest) {
+                            if (tests[0].ok() && tests[1].ok()) {
+                                t.run();
+                            }
+                        } else {
+                            t.run();
+                        }
                     }
-                    signTests.add(compound);
-                } else {
-                    signTests.add(allocate);
-                }
+                };
+
+                Command ecdsaSign = new Command.ECDSA_sign(this.card, CardConsts.KEYPAIR_LOCAL, sigType, CardConsts.EXPORT_TRUE, sigData);
+                PerformanceTest signTest = PerformanceTest.repeat(this.card, "Sign", ecdsaSign, 10);
+
+                CommandTestable.FunctionCommandTestable verifyTestable = new CommandTestable.FunctionCommandTestable(() -> new Command.ECDSA_verify(this.card, CardConsts.KEYPAIR_LOCAL, sigType, sigData, signTest.getResponses()[0].getParam(0)));
+                PerformanceTest verifyTest = PerformanceTest.repeat(this.card, "Verify", verifyTestable, 10);
+                Test compound = CompoundTest.function(sigCallback, runCallback, signDesc, allocate, sign, signTest, verifyTest);
+                signTests.add(compound);
             }
-            Test signTest = runTest(CompoundTest.any(ExpectedValue.SUCCESS, "Signature tests.", signTests.toArray(new Test[0])));
+            Test signTest = CompoundTest.any(ExpectedValue.SUCCESS, "Signature tests.", signTests.toArray(new Test[0]));
             supportTests.add(signTest);
             ExpectedValue[] testExpects = {ExpectedValue.SUCCESS, ExpectedValue.ANY, ExpectedValue.SUCCESS, ExpectedValue.SUCCESS, ExpectedValue.SUCCESS, ExpectedValue.SUCCESS, ExpectedValue.SUCCESS};
             List<ExpectedValue> expects = Stream.of(testExpects).collect(Collectors.toList());
diff --git a/reader/src/main/java/cz/crcs/ectester/reader/test/CardDegenerateSuite.java b/reader/src/main/java/cz/crcs/ectester/reader/test/CardDegenerateSuite.java
index e2c07da..c731416 100644
--- a/reader/src/main/java/cz/crcs/ectester/reader/test/CardDegenerateSuite.java
+++ b/reader/src/main/java/cz/crcs/ectester/reader/test/CardDegenerateSuite.java
@@ -36,11 +36,7 @@ public class CardDegenerateSuite extends CardTestSuite {
             EC_Curve curve = e.getKey();
             List<EC_Key.Public> keys = e.getValue();
 
-            Test allocate = runTest(CommandTest.expect(new Command.Allocate(this.card, CardConsts.KEYPAIR_BOTH, curve.getBits(), curve.getField()), Result.ExpectedValue.SUCCESS));
-            if (!allocate.ok()) {
-                doTest(CompoundTest.all(Result.ExpectedValue.SUCCESS, "No support for " + curve.getId() + ".", allocate));
-                continue;
-            }
+            Test allocate = CommandTest.expect(new Command.Allocate(this.card, CardConsts.KEYPAIR_BOTH, curve.getBits(), curve.getField()), Result.ExpectedValue.SUCCESS);
             Test set = CommandTest.expect(new Command.Set(this.card, CardConsts.KEYPAIR_BOTH, EC_Consts.CURVE_external, curve.getParams(), curve.flatten()), Result.ExpectedValue.SUCCESS);
             Test generate = CommandTest.expect(new Command.Generate(this.card, CardConsts.KEYPAIR_LOCAL), Result.ExpectedValue.SUCCESS);
 
diff --git a/reader/src/main/java/cz/crcs/ectester/reader/test/CardEdgeCasesSuite.java b/reader/src/main/java/cz/crcs/ectester/reader/test/CardEdgeCasesSuite.java
index 0a82da3..fb24e30 100644
--- a/reader/src/main/java/cz/crcs/ectester/reader/test/CardEdgeCasesSuite.java
+++ b/reader/src/main/java/cz/crcs/ectester/reader/test/CardEdgeCasesSuite.java
@@ -143,15 +143,11 @@ public class CardEdgeCasesSuite extends CardTestSuite {
         curves.add(EC_Store.getInstance().getObject(EC_Curve.class, "cofactor/cofactor160p4"));
         Random rand = new Random();
         for (EC_Curve curve : curves) {
-            Test key = runTest(CommandTest.expect(new Command.Allocate(this.card, CardConsts.KEYPAIR_BOTH, curve.getBits(), EC_Consts.ALG_EC_FP), Result.ExpectedValue.SUCCESS));
-            if (!key.ok()) {
-                doTest(CompoundTest.all(Result.ExpectedValue.FAILURE, "No support for " + curve.getBits() + "b " + curve.getId() + ".", key));
-                continue;
-            }
+            Test key = CommandTest.expect(new Command.Allocate(this.card, CardConsts.KEYPAIR_BOTH, curve.getBits(), EC_Consts.ALG_EC_FP), Result.ExpectedValue.SUCCESS);
             Test set = CommandTest.expect(new Command.Set(this.card, CardConsts.KEYPAIR_BOTH, EC_Consts.CURVE_external, curve.getParams(), curve.flatten()), Result.ExpectedValue.SUCCESS);
             Test generate = CommandTest.expect(new Command.Generate(this.card, CardConsts.KEYPAIR_LOCAL), Result.ExpectedValue.SUCCESS);
             CommandTest export = CommandTest.expect(new Command.Export(this.card, CardConsts.KEYPAIR_LOCAL, EC_Consts.KEY_PUBLIC, EC_Consts.PARAMETER_W), Result.ExpectedValue.SUCCESS);
-            Test setup = runTest(CompoundTest.all(Result.ExpectedValue.SUCCESS, "KeyPair setup.", key, set, generate, export));
+            Test setup = CompoundTest.all(Result.ExpectedValue.SUCCESS, "KeyPair setup.", key, set, generate, export);
 
             /*
             byte[] pParam = curve.getParam(EC_Consts.PARAMETER_FP)[0];
@@ -268,11 +264,7 @@ public class CardEdgeCasesSuite extends CardTestSuite {
         Arrays.sort(ps);
         Arrays.sort(zeros);
 
-        Test key = runTest(CommandTest.expect(new Command.Allocate(this.card, CardConsts.KEYPAIR_BOTH, secp160r1.getBits(), EC_Consts.ALG_EC_FP), Result.ExpectedValue.SUCCESS));
-        if (!key.ok()) {
-            doTest(CompoundTest.all(Result.ExpectedValue.FAILURE, "No support for " + secp160r1.getBits() + "b secp160r1.", key));
-            return;
-        }
+        Test key = CommandTest.expect(new Command.Allocate(this.card, CardConsts.KEYPAIR_BOTH, secp160r1.getBits(), EC_Consts.ALG_EC_FP), Result.ExpectedValue.SUCCESS);
         Test set = CommandTest.expect(new Command.Set(this.card, CardConsts.KEYPAIR_BOTH, EC_Consts.CURVE_external, secp160r1.getParams(), secp160r1.flatten()), Result.ExpectedValue.SUCCESS);
         Test generate = CommandTest.expect(new Command.Generate(this.card, CardConsts.KEYPAIR_LOCAL), Result.ExpectedValue.SUCCESS);
         Test setup = CompoundTest.all(Result.ExpectedValue.SUCCESS, "KeyPair setup.", key, set, generate);
diff --git a/reader/src/main/java/cz/crcs/ectester/reader/test/CardInvalidSuite.java b/reader/src/main/java/cz/crcs/ectester/reader/test/CardInvalidSuite.java
index 4657de0..2fd457d 100644
--- a/reader/src/main/java/cz/crcs/ectester/reader/test/CardInvalidSuite.java
+++ b/reader/src/main/java/cz/crcs/ectester/reader/test/CardInvalidSuite.java
@@ -40,11 +40,7 @@ public class CardInvalidSuite extends CardTestSuite {
             EC_Curve curve = e.getKey();
             List<EC_Key.Public> keys = e.getValue();
 
-            Test allocate = runTest(CommandTest.expect(new Command.Allocate(this.card, CardConsts.KEYPAIR_BOTH, curve.getBits(), curve.getField()), ExpectedValue.SUCCESS));
-            if (!allocate.ok()) {
-                doTest(CompoundTest.all(Result.ExpectedValue.SUCCESS, "No support for " + curve.getId() + ".", allocate));
-                continue;
-            }
+            Test allocate = CommandTest.expect(new Command.Allocate(this.card, CardConsts.KEYPAIR_BOTH, curve.getBits(), curve.getField()), ExpectedValue.SUCCESS);
             Test set = CommandTest.expect(new Command.Set(this.card, CardConsts.KEYPAIR_BOTH, EC_Consts.CURVE_external, curve.getParams(), curve.flatten()), ExpectedValue.SUCCESS);
             Test generate = CommandTest.expect(new Command.Generate(this.card, CardConsts.KEYPAIR_LOCAL), ExpectedValue.SUCCESS);
 
diff --git a/reader/src/main/java/cz/crcs/ectester/reader/test/CardMiscSuite.java b/reader/src/main/java/cz/crcs/ectester/reader/test/CardMiscSuite.java
index da4c0b5..3ffe07c 100644
--- a/reader/src/main/java/cz/crcs/ectester/reader/test/CardMiscSuite.java
+++ b/reader/src/main/java/cz/crcs/ectester/reader/test/CardMiscSuite.java
@@ -16,6 +16,7 @@ import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;
 import java.util.Map;
+import java.util.function.Function;
 
 /**
  * @author Jan Jancar johny@neuromancer.sk
@@ -49,23 +50,36 @@ public class CardMiscSuite extends CardTestSuite {
     }
 
     private void testCurve(EC_Curve curve, String catName, Result.ExpectedValue expected) {
-        Test allocateFirst = runTest(CommandTest.expect(new Command.Allocate(this.card, CardConsts.KEYPAIR_BOTH, curve.getBits(), curve.getField()), Result.ExpectedValue.SUCCESS));
-        if (!allocateFirst.ok()) {
-            doTest(CompoundTest.all(Result.ExpectedValue.SUCCESS, "No support for " + curve.getBits() + "b " + catName + " curve: " + curve.getId() + ".", allocateFirst));
-            return;
-        }
-
+        Test allocateFirst = CommandTest.expect(new Command.Allocate(this.card, CardConsts.KEYPAIR_BOTH, curve.getBits(), curve.getField()), Result.ExpectedValue.SUCCESS);
         Test set = CommandTest.expect(new Command.Set(this.card, CardConsts.KEYPAIR_BOTH, EC_Consts.CURVE_external, curve.getParams(), curve.flatten()), Result.ExpectedValue.SUCCESS);
-        Test generate = setupKeypairs(curve, Result.ExpectedValue.ANY, CardConsts.KEYPAIR_BOTH);
+        Test generate = setupKeypairs(curve, Result.ExpectedValue.SUCCESS, CardConsts.KEYPAIR_BOTH);
         Test ka = CommandTest.expect(new Command.ECDH(this.card, CardConsts.KEYPAIR_REMOTE, CardConsts.KEYPAIR_LOCAL, CardConsts.EXPORT_FALSE, EC_Consts.TRANSFORMATION_NONE, EC_Consts.KeyAgreement_ALG_EC_SVDP_DH), expected);
         Test sig = CommandTest.expect(new Command.ECDSA_sign(this.card, CardConsts.KEYPAIR_LOCAL, EC_Consts.Signature_ALG_ECDSA_SHA, CardConsts.EXPORT_FALSE, null), expected);
         Test perform = CompoundTest.all(Result.ExpectedValue.SUCCESS, "Perform ECDH and ECDSA.", ka, sig);
 
+        Function<Test[], Result> callback = (tests) -> {
+            if (!tests[0].ok()) {
+                return new Result(Result.Value.FAILURE, "Could not allocate keypairs.");
+            }
+            if (!tests[1].ok()) {
+                return new Result(Result.Value.FAILURE, "Could not set curve data.");
+            }
+            if (!tests[2].ok()) {
+                return new Result(Result.Value.FAILURE, "Could not generate keypairs.");
+            }
+            for (int i = 3; i < tests.length; i++) {
+                if (!tests[i].ok() && !(tests[i] instanceof CompoundTest)) {
+                    return new Result(Result.Value.FAILURE, "ECDH or ECDSA did not work.");
+                }
+            }
+            return new Result(Result.Value.SUCCESS, "OK");
+        };
+
         if (cfg.cleanup) {
             Test cleanup = CommandTest.expect(new Command.Cleanup(this.card), Result.ExpectedValue.ANY);
-            doTest(CompoundTest.greedyAll(Result.ExpectedValue.SUCCESS, "Tests over " + curve.getBits() + "b " + catName + " curve: " + curve.getId() + ".", allocateFirst, set, generate, perform, cleanup));
+            doTest(CompoundTest.function(callback, "Tests over " + curve.getBits() + "b " + catName + " curve: " + curve.getId() + ".", allocateFirst, set, generate, perform, cleanup));
         } else {
-            doTest(CompoundTest.greedyAll(Result.ExpectedValue.SUCCESS, "Tests over " + curve.getBits() + "b " + catName + " curve: " + curve.getId() + ".", allocateFirst, set, generate,  perform));
+            doTest(CompoundTest.function(callback, "Tests over " + curve.getBits() + "b " + catName + " curve: " + curve.getId() + ".", allocateFirst, set, generate, perform));
         }
     }
 
diff --git a/reader/src/main/java/cz/crcs/ectester/reader/test/CardTestVectorSuite.java b/reader/src/main/java/cz/crcs/ectester/reader/test/CardTestVectorSuite.java
index 07b38d0..4c222cb 100644
--- a/reader/src/main/java/cz/crcs/ectester/reader/test/CardTestVectorSuite.java
+++ b/reader/src/main/java/cz/crcs/ectester/reader/test/CardTestVectorSuite.java
@@ -63,13 +63,7 @@ public class CardTestVectorSuite extends CardTestSuite {
                 throw new IOException("Test vector keys couldn't be located.");
             }
             List<Test> testVector = new LinkedList<>();
-            Test allocate = runTest(CommandTest.expect(new Command.Allocate(this.card, CardConsts.KEYPAIR_BOTH, curve.getBits(), curve.getField()), ExpectedValue.SUCCESS));
-            if (!allocate.ok()) {
-                doTest(CompoundTest.all(ExpectedValue.SUCCESS, "No support for " + curve.getBits() + "b " + CardUtil.getKeyTypeString(curve.getField()) + ".", allocate));
-                continue;
-            }
-
-            testVector.add(allocate);
+            testVector.add(CommandTest.expect(new Command.Allocate(this.card, CardConsts.KEYPAIR_BOTH, curve.getBits(), curve.getField()), ExpectedValue.SUCCESS));
             testVector.add(CommandTest.expect(new Command.Set(this.card, CardConsts.KEYPAIR_BOTH, EC_Consts.CURVE_external, curve.getParams(), curve.flatten()), ExpectedValue.SUCCESS));
             testVector.add(CommandTest.expect(new Command.Set(this.card, CardConsts.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, CardConsts.KEYPAIR_REMOTE, EC_Consts.CURVE_external, EC_Consts.PARAMETER_W, otherkey.flatten(EC_Consts.PARAMETER_W)), ExpectedValue.SUCCESS));
@@ -112,12 +106,7 @@ public class CardTestVectorSuite extends CardTestSuite {
         testCurves.addAll(EC_Store.getInstance().getObjects(EC_Curve.class, "brainpool").values().stream().filter((curve) -> curve.getField() == EC_Consts.ALG_EC_FP).collect(Collectors.toList()));
         for (EC_Curve curve : testCurves) {
             List<Test> testVector = new LinkedList<>();
-            Test allocate = runTest(CommandTest.expect(new Command.Allocate(this.card, CardConsts.KEYPAIR_BOTH, curve.getBits(), curve.getField()), ExpectedValue.SUCCESS));
-            if (!allocate.ok()) {
-                doTest(CompoundTest.all(ExpectedValue.SUCCESS, "No support for " + curve.getBits() + "b " + CardUtil.getKeyTypeString(curve.getField()) + ".", allocate));
-                continue;
-            }
-            testVector.add(allocate);
+            testVector.add(CommandTest.expect(new Command.Allocate(this.card, CardConsts.KEYPAIR_BOTH, curve.getBits(), curve.getField()), ExpectedValue.SUCCESS));
             testVector.add(CommandTest.expect(new Command.Set(this.card, CardConsts.KEYPAIR_BOTH, EC_Consts.CURVE_external, curve.getParams(), curve.flatten()), ExpectedValue.SUCCESS));
             testVector.add(CommandTest.expect(new Command.Generate(this.card, CardConsts.KEYPAIR_BOTH), ExpectedValue.SUCCESS));
             CommandTest exportLocal = CommandTest.expect(new Command.Export(this.card, CardConsts.KEYPAIR_LOCAL, EC_Consts.KEY_PUBLIC, EC_Consts.PARAMETER_W), ExpectedValue.ANY);
diff --git a/reader/src/main/java/cz/crcs/ectester/reader/test/CardTwistSuite.java b/reader/src/main/java/cz/crcs/ectester/reader/test/CardTwistSuite.java
index 5c35be7..ea127e0 100644
--- a/reader/src/main/java/cz/crcs/ectester/reader/test/CardTwistSuite.java
+++ b/reader/src/main/java/cz/crcs/ectester/reader/test/CardTwistSuite.java
@@ -34,11 +34,7 @@ public class CardTwistSuite extends CardTestSuite {
             EC_Curve curve = e.getKey();
             List<EC_Key.Public> keys = e.getValue();
 
-            Test allocate = runTest(CommandTest.expect(new Command.Allocate(this.card, CardConsts.KEYPAIR_BOTH, curve.getBits(), curve.getField()), Result.ExpectedValue.SUCCESS));
-            if (!allocate.ok()) {
-                doTest(CompoundTest.all(Result.ExpectedValue.SUCCESS, "No support for " + curve.getId() + ".", allocate));
-                continue;
-            }
+            Test allocate = CommandTest.expect(new Command.Allocate(this.card, CardConsts.KEYPAIR_BOTH, curve.getBits(), curve.getField()), Result.ExpectedValue.SUCCESS);
             Test set = CommandTest.expect(new Command.Set(this.card, CardConsts.KEYPAIR_BOTH, EC_Consts.CURVE_external, curve.getParams(), curve.flatten()), Result.ExpectedValue.SUCCESS);
             Test generate = CommandTest.expect(new Command.Generate(this.card, CardConsts.KEYPAIR_LOCAL), Result.ExpectedValue.SUCCESS);
 
diff --git a/reader/src/main/java/cz/crcs/ectester/reader/test/CardWrongSuite.java b/reader/src/main/java/cz/crcs/ectester/reader/test/CardWrongSuite.java
index 8ce74ee..605b2ec 100644
--- a/reader/src/main/java/cz/crcs/ectester/reader/test/CardWrongSuite.java
+++ b/reader/src/main/java/cz/crcs/ectester/reader/test/CardWrongSuite.java
@@ -42,24 +42,17 @@ public class CardWrongSuite extends CardTestSuite {
         for (Map.Entry<String, EC_Curve> e : curves.entrySet()) {
             EC_Curve curve = e.getValue();
             List<Test> tests = new LinkedList<>();
-            Test key = runTest(CommandTest.expect(new Command.Allocate(this.card, CardConsts.KEYPAIR_BOTH, curve.getBits(), curve.getField()), ExpectedValue.SUCCESS));
-            if (!key.ok()) {
-                doTest(CompoundTest.all(ExpectedValue.FAILURE, "No support for " + curve.getBits() + "b " + CardUtil.getKeyTypeString(curve.getField()), key));
-                continue;
-            }
-            tests.add(key);
-            Test set = runTest(CommandTest.expect(new Command.Set(this.card, CardConsts.KEYPAIR_BOTH, EC_Consts.CURVE_external, curve.getParams(), curve.flatten()), ExpectedValue.FAILURE));
-            Test generate = runTest(setupKeypairs(curve, ExpectedValue.SUCCESS, CardConsts.KEYPAIR_BOTH));
-            Test setup = runTest(CompoundTest.any(ExpectedValue.SUCCESS, "Set wrong curve and generate keypairs.", set, generate));
+            Test key = CommandTest.expect(new Command.Allocate(this.card, CardConsts.KEYPAIR_BOTH, curve.getBits(), curve.getField()), ExpectedValue.SUCCESS);
+            Test set = CommandTest.expect(new Command.Set(this.card, CardConsts.KEYPAIR_BOTH, EC_Consts.CURVE_external, curve.getParams(), curve.flatten()), ExpectedValue.FAILURE);
+            Test generate = setupKeypairs(curve, ExpectedValue.SUCCESS, CardConsts.KEYPAIR_BOTH);
+            Test setup = CompoundTest.any(ExpectedValue.SUCCESS, "Set wrong curve and generate keypairs.", key, set, generate);
             tests.add(setup);
 
             for (byte kaType : EC_Consts.KA_TYPES) {
-                Test allocate = runTest(CommandTest.expect(new Command.AllocateKeyAgreement(this.card, kaType), ExpectedValue.SUCCESS));
-                if (allocate.ok()) {
-                    Test ka = runTest(CommandTest.expect(new Command.ECDH(this.card, CardConsts.KEYPAIR_REMOTE, CardConsts.KEYPAIR_LOCAL, CardConsts.EXPORT_FALSE, EC_Consts.TRANSFORMATION_NONE, kaType), ExpectedValue.FAILURE));
-                    Test kaTest = runTest(CompoundTest.all(ExpectedValue.SUCCESS, "Allocate and perform KA.", allocate, ka));
-                    tests.add(kaTest);
-                }
+                Test allocate = CommandTest.expect(new Command.AllocateKeyAgreement(this.card, kaType), ExpectedValue.SUCCESS);
+                Test ka = CommandTest.expect(new Command.ECDH(this.card, CardConsts.KEYPAIR_REMOTE, CardConsts.KEYPAIR_LOCAL, CardConsts.EXPORT_FALSE, EC_Consts.TRANSFORMATION_NONE, kaType), ExpectedValue.FAILURE);
+                Test kaTest = CompoundTest.all(ExpectedValue.SUCCESS, "Allocate and perform KA.", allocate, ka);
+                tests.add(kaTest);
             }
             doTest(CompoundTest.function((tsts) -> {
                 for (int i = 0; i < tsts.length; ++i) {
@@ -82,11 +75,7 @@ public class CardWrongSuite extends CardTestSuite {
         Random r = new Random();
         for (short keyLength : EC_Consts.FP_SIZES) {
             byte curve = EC_Consts.getCurve(keyLength, EC_Consts.ALG_EC_FP);
-            Test key = runTest(CommandTest.expect(new Command.Allocate(this.card, CardConsts.KEYPAIR_BOTH, keyLength, EC_Consts.ALG_EC_FP), ExpectedValue.SUCCESS));
-            if (!key.ok()) {
-                doTest(CompoundTest.all(ExpectedValue.FAILURE, "No support for " + keyLength + "b ALG_EC_FP.", key));
-                continue;
-            }
+            Test key = CommandTest.expect(new Command.Allocate(this.card, CardConsts.KEYPAIR_BOTH, keyLength, EC_Consts.ALG_EC_FP), ExpectedValue.SUCCESS);
             Test set = CommandTest.expect(new Command.Set(this.card, CardConsts.KEYPAIR_BOTH, curve, EC_Consts.PARAMETERS_DOMAIN_FP, null), ExpectedValue.SUCCESS);
             Test setup = CompoundTest.all(ExpectedValue.SUCCESS, "KeyPair setup.", key, set);
 
@@ -162,11 +151,7 @@ public class CardWrongSuite extends CardTestSuite {
          */
         for (short keyLength : EC_Consts.F2M_SIZES) {
             byte curve = EC_Consts.getCurve(keyLength, EC_Consts.ALG_EC_F2M);
-            Test key = runTest(CommandTest.expect(new Command.Allocate(this.card, CardConsts.KEYPAIR_BOTH, keyLength, EC_Consts.ALG_EC_F2M), ExpectedValue.SUCCESS));
-            if (!key.ok()) {
-                doTest(CompoundTest.all(ExpectedValue.FAILURE, "No support for " + keyLength + "b ALG_EC_F2M.", key));
-                continue;
-            }
+            Test key = CommandTest.expect(new Command.Allocate(this.card, CardConsts.KEYPAIR_BOTH, keyLength, EC_Consts.ALG_EC_F2M), ExpectedValue.SUCCESS);
             Test set = CommandTest.expect(new Command.Set(this.card, CardConsts.KEYPAIR_BOTH, curve, EC_Consts.PARAMETERS_DOMAIN_F2M, null), ExpectedValue.SUCCESS);
             Test setup = CompoundTest.all(ExpectedValue.SUCCESS, "KeyPair setup.", key, set);
 
diff --git a/reader/src/main/java/cz/crcs/ectester/reader/test/CommandTestable.java b/reader/src/main/java/cz/crcs/ectester/reader/test/CommandTestable.java
index f670534..7733e11 100644
--- a/reader/src/main/java/cz/crcs/ectester/reader/test/CommandTestable.java
+++ b/reader/src/main/java/cz/crcs/ectester/reader/test/CommandTestable.java
@@ -6,13 +6,14 @@ import cz.crcs.ectester.reader.command.Command;
 import cz.crcs.ectester.reader.response.Response;
 
 import javax.smartcardio.CardException;
+import java.util.function.Supplier;
 
 /**
  * @author Jan Jancar johny@neuromancer.sk
  */
 public class CommandTestable extends BaseTestable {
-    private Command command;
-    private Response response;
+    protected Command command;
+    protected Response response;
 
     public CommandTestable(Command command) {
         this.command = command;
@@ -41,4 +42,19 @@ public class CommandTestable extends BaseTestable {
             ok = true;
         }
     }
+
+    public static class FunctionCommandTestable extends CommandTestable {
+        private Supplier<Command> supplier;
+
+        public FunctionCommandTestable(Supplier<Command> supplier) {
+            super(null);
+            this.supplier = supplier;
+        }
+
+        @Override
+        public void run() {
+            this.command = supplier.get();
+            super.run();
+        }
+    }
 }
diff --git a/reader/src/main/java/cz/crcs/ectester/reader/test/PerformanceTest.java b/reader/src/main/java/cz/crcs/ectester/reader/test/PerformanceTest.java
index a725dc2..1171154 100644
--- a/reader/src/main/java/cz/crcs/ectester/reader/test/PerformanceTest.java
+++ b/reader/src/main/java/cz/crcs/ectester/reader/test/PerformanceTest.java
@@ -26,26 +26,38 @@ public class PerformanceTest extends SimpleTest<CommandTestable> {
     private int count;
     private String desc;
 
+    private PerformanceTest(CardMngr cardManager, CommandTestable testable, TestCallback<CommandTestable> callback, int count, String desc) {
+        super(testable, callback);
+        this.cardManager = cardManager;
+        this.count = count;
+        this.desc = desc;
+    }
+
     private PerformanceTest(CardMngr cardManager, CommandTestable testable, int count, String desc) {
-        super(testable, new TestCallback<CommandTestable>() {
+        this(cardManager, testable, new TestCallback<CommandTestable>() {
             @Override
             public Result apply(CommandTestable testable) {
                 return new Result(Result.Value.SUCCESS);
             }
-        });
-        this.cardManager = cardManager;
-        this.count = count;
-        this.desc = desc;
+        }, count, desc);
     }
 
     public static PerformanceTest repeat(CardMngr cardManager, Command cmd, int count) {
         return new PerformanceTest(cardManager, new CommandTestable(cmd), count, null);
     }
 
+    public static PerformanceTest repeat(CardMngr cardManager, CommandTestable testable, int count) {
+        return new PerformanceTest(cardManager, testable, count, null);
+    }
+
     public static PerformanceTest repeat(CardMngr cardManager, String desc, Command cmd, int count) {
         return new PerformanceTest(cardManager, new CommandTestable(cmd), count, desc);
     }
 
+    public static PerformanceTest repeat(CardMngr cardManager, String desc, CommandTestable testable, int count) {
+        return new PerformanceTest(cardManager, testable, count, desc);
+    }
+
     @Override
     public String getDescription() {
         String rest = String.format("Mean = %d ns, Median = %d ns, Mode = %d ns", mean, median, mode);