diff --git a/compile_all.py b/compile_all.py
index a0be5aa..e310851 100755
--- a/compile_all.py
+++ b/compile_all.py
@@ -5,7 +5,6 @@ import sys
 import stat
 import argparse
 import shutil
-import random
 import subprocess
 import shutil
 
@@ -15,7 +14,7 @@ def build(algo_dir, template_dir, build_dir):
         return None
 
     print("Building in %s" % build_dir)
-   
+
     # copy all the files from the submitted algorithm into the build directory
     shutil.copytree(algo_dir, build_dir)
 
@@ -68,7 +67,6 @@ def build(algo_dir, template_dir, build_dir):
             p.wait()
             assert p.returncode == 0
 
-
     finally:
         sys.stdout.flush()
         sys.stderr.flush()
@@ -122,7 +120,8 @@ def main(argv):
     # get all the submissions by looking for files named "api.h"
     subfiles = []
     for submission in subs:
-        implementations_dir = os.path.join(submissions_dir, submission, "Implementations", "crypto_aead")
+        implementations_dir = os.path.join(
+            submissions_dir, submission, "Implementations", "crypto_aead")
 
         if not os.path.isdir(implementations_dir):
             continue
@@ -164,19 +163,17 @@ def main(argv):
         pieces = f.split(os.sep)
         n = pieces[1] + "." + ".".join(pieces[4:-1])
         print(n)
-        
+
         # if include_list was provided, skip elements not in the list
         if include_list is not None:
-            if not n in include_list:
+            if n not in include_list:
                 continue
 
         # Put all in a tuple and count
         files.append((t, d, n))
 
-
-
     # For testing, we only do the first 1
-    #files = files[:1]
+    # files = files[:1]
     print("%d algorithms will be compiled" % len(files))
 
     if not os.path.isdir(build_root_dir):
@@ -198,8 +195,10 @@ def main(argv):
                 b = build(d, template_dir, build_dir)
                 if b is None:
                     continue
-                test_script.write("\n\necho \"TEST NUMBER %03d: TESTING %s\"\n" % (i, d))
-                test_script.write("python3 -u ./test.py %s %s 2> %s | tee %s\n" % (
+                test_script.write(
+                    "\n\necho \"TEST NUMBER %03d: TESTING %s\"\n" % (i, d))
+                test_script.write(
+                    "python3 -u ./test.py %s %s 2> %s | tee %s\n" % (
                         t,
                         os.path.join(b, 'test'),
                         os.path.join(b, 'test_stderr.log'),
diff --git a/templates/bluepill/openocd.cfg b/templates/bluepill/openocd.cfg
index d70df06..d0732b8 100644
--- a/templates/bluepill/openocd.cfg
+++ b/templates/bluepill/openocd.cfg
@@ -21,6 +21,6 @@ source [find target/stm32f1x.cfg]
 
 #tpiu config internal swodump.stm32f103-generic.log uart off 72000000
 
-#reset_config srst_only srst_push_pull srst_nogate connect_assert_srst
-reset_config none srst_push_pull srst_nogate
+reset_config srst_only srst_push_pull srst_nogate connect_assert_srst
+#reset_config none srst_push_pull srst_nogate
 
diff --git a/templates/bluepill/test b/templates/bluepill/test
index 7550a6e..9114b6d 100755
--- a/templates/bluepill/test
+++ b/templates/bluepill/test
@@ -2,197 +2,126 @@
 
 import os
 import sys
-import time
-import struct
-import serial
 import subprocess
+import serial.tools.list_ports
+from test_common import (
+    LogicMultiplexerTimeMeasurements,
+    parse_nist_aead_test_vectors,
+    DeviceUnderTestAeadUARTP,
+    compare_dumps,
+    eprint,
+    run_nist_aead_test_line,
+)
 
 
+def get_serial():
+    ports = serial.tools.list_ports.comports()
+    devices = [
+        p.device
+        for p in ports
+        if p.serial_number == 'FT2XCRZ1'
+    ]
+    devices.sort()
+    return serial.Serial(
+        devices[0],
+        baudrate=115200,
+        timeout=5)
+
+
+class BluePill(DeviceUnderTestAeadUARTP):
+    RAM_SIZE = 0x5000
+
+    def __init__(self, build_dir):
+        DeviceUnderTestAeadUARTP.__init__(self, get_serial())
+
+        self.firmware_path = os.path.join(
+            build_dir, '.pio/build/bluepill_f103c8/firmware.elf')
+        self.ram_pattern_path = os.path.join(
+            build_dir, 'empty_ram.bin')
+        self.ram_dump_path = os.path.join(
+            build_dir, 'ram_dump.bin')
+        self.openocd_cfg_path = os.path.join(
+            build_dir, 'openocd.cfg')
+
+    def flash(self):
+        # pipe = subprocess.PIPE
+        cmd = [
+            'openocd', '-f', 'openocd.cfg', '-c',
+            'program %s verify reset exit' % self.firmware_path]
+        p = subprocess.Popen(
+            cmd, stdout=sys.stderr, stdin=sys.stdout)
+        stdout, stderr = p.communicate("")
+        eprint("Firmware flashed.")
+
+        cmd = [
+            'openocd', '-f', self.openocd_cfg_path, '-c',
+            'program %s reset exit 0x20000000' % self.ram_pattern_path]
+        p = subprocess.Popen(
+            cmd, stdout=sys.stderr, stdin=sys.stdout)
+        stdout, stderr = p.communicate("")
+        eprint("RAM flashed.")
+
+    def dump_ram(self):
+        cmd = [
+            'openocd', '-f', self.openocd_cfg_path,
+            '-c', 'init',
+            '-c', 'halt',
+            '-c', 'dump_image %s 0x20000000 0x%x' % (
+                self.ram_dump_path, BluePill.RAM_SIZE),
+            '-c', 'resume',
+            '-c', 'exit']
+        p = subprocess.Popen(
+            cmd, stdout=sys.stderr, stdin=sys.stdout)
+        stdout, stderr = p.communicate("")
+        eprint("RAM dumped.")
+        with open(self.ram_dump_path, 'rb') as ram:
+            ram = ram.read()
+            if len(ram) != BluePill.RAM_SIZE:
+                raise Exception(
+                    "RAM dump was %d bytes instead of %d" %
+                    (len(ram), BluePill.RAM_SIZE))
+            return ram
 
-def eprint(*args, **kargs):
-    print(*args, file=sys.stderr, **kargs)
 
+def main(argv):
+    if len(argv) != 3:
+        print("Usage: test LWC_AEAD_KAT.txt build_dir")
+        return 1
 
-def flash():
-    pipe = subprocess.PIPE
-    cmd = ['openocd', '-f', 'openocd.cfg', '-c' 'program ' +
-           '.pio/build/bluepill_f103c8/firmware.elf verify reset exit']
-    p = subprocess.Popen(cmd,
-            stdout=sys.stderr, stdin=sys.stdout)
-    stdout, stderr = p.communicate("")
+    kat = list(parse_nist_aead_test_vectors(argv[1]))
+    build_dir = argv[2]
 
+    dut = BluePill(build_dir)
 
-def fill_ram():
-    pipe = subprocess.PIPE
-    cmd = ['openocd', '-f', 'openocd.cfg', '-c' 'program ' +
-           'empty_ram.bin reset exit 0x20000000']
-    p = subprocess.Popen(cmd,
-            stdout=sys.stderr, stdin=sys.stdout)
-    stdout, stderr = p.communicate("")
+    try:
+        tool = LogicMultiplexerTimeMeasurements(0x0003)
+        tool.begin_measurement()
 
+        dut.flash()
+        dut.prepare()
+        sys.stdout.write("Board prepared\n")
+        sys.stdout.flush()
 
-def get_serial():
-    import serial.tools.list_ports
-    ports = serial.tools.list_ports.comports()
-    devices = [ p.device for p in ports ]
-    devices.sort()
-    return devices[-1]
-
-
-class UARTP:
-    def __init__(self, ser):
-        UARTP.SYN = 0xf9
-        UARTP.FIN = 0xf3
-        self.ser = ser
-
-    def uart_read(self):
-        r = self.ser.read(1)
-        if len(r) != 1:
-            raise Exception("Serial read error")
-        return r[0]
-
-    def uart_write(self, c):
-        b = struct.pack("B", c)
-        r = self.ser.write(b)
-        if r != len(b):
-            raise Exception("Serial write error")
-        return r
-
-    def send(self, buf):
-        self.uart_write(UARTP.SYN)
-        len_ind_0 = 0xff & len(buf)
-        len_ind_1 = 0xff & (len(buf) >> 7)
-        if len(buf) < 128:
-            self.uart_write(len_ind_0)
-        else:
-            self.uart_write(len_ind_0 | 0x80)
-            self.uart_write(len_ind_1)
-        fcs = 0
-        for i in range(len(buf)):
-            info = buf[i]
-            fcs = (fcs + info) & 0xff
-            self.uart_write(buf[i])
-        fcs = (0xff - fcs) & 0xff
-        self.uart_write(fcs)
-        self.uart_write(UARTP.FIN)
-        eprint("sent frame '%s'" % buf.hex())
-
-    def recv(self):
-        tag_old = UARTP.FIN
-        while 1:
-            tag = tag_old
-            while 1:
-                if tag_old == UARTP.FIN:
-                    if tag == UARTP.SYN:
-                        break
-                tag_old = tag
-                tag = self.uart_read()
-            tag_old = tag
-            
-            l = self.uart_read()
-            if l & 0x80:
-                l &= 0x7f
-                l |= self.uart_read() << 7
-
-            fcs = 0
-            buf = []
-            for i in range(l):
-                info = self.uart_read()
-                buf.append(info)
-                fcs = (fcs + info) & 0xff
-            fcs = (fcs + self.uart_read()) & 0xff
-
-            tag = self.uart_read()
-            if fcs == 0xff:
-                if tag == UARTP.FIN:
-                    buf = bytes(buf)
-                    eprint("rcvd frame '%s'" % buf.hex())
-                    if len(buf) >= 1 and buf[0] == 0xde:
-                        sys.stderr.buffer.write(buf[1:])
-                        sys.stderr.flush()
-                    else:
-                        return buf
+        dump_a = dut.dump_ram()
 
-def main(argv):
-    eprint(argv[0])
-    script_dir = os.path.split(argv[0])[0]
-    if len(script_dir) > 0:
-        os.chdir(script_dir)
-
-    dev = get_serial()
-    ser = serial.Serial(dev, baudrate=115200, timeout=5)
-    uartp = UARTP(ser)
-
-    flash()
-    fill_ram()
-    eprint("Flashed")
-    time.sleep(0.1)
-
-    ser.setDTR(False)  # IO0=HIGH
-    ser.setRTS(True)   # EN=LOW, chip in reset
-    time.sleep(0.1)
-    ser.setDTR(False)  # IO0=HIGH
-    ser.setRTS(False)  # EN=HIGH, chip out of reset
-    time.sleep(1)
-
-    def stdin_read(n):
-        b = sys.stdin.buffer.read(n)
-        if len(b) != n:
-            sys.exit(1)
-        return b
-
-    def stdin_readvar():
-        l = stdin_read(4)
-        (l, ) = struct.unpack("<I", l)
-        v = stdin_read(l)
-        return v
-
-    exp_hello = b"Hello, World!"
-    hello = ser.read(ser.in_waiting)
-    if hello[-13:] != exp_hello:
-        eprint("Improper board initialization message: %s" % hello)
-        return 1
-    eprint("Board initialized properly")
-    sys.stdout.write("Hello, World!\n")
-    sys.stdout.flush()
-
-    while 1:
-        action = stdin_read(1)[0]
-        eprint("Command %c from stdin" % action)
-
-        if action in b"ackmps":
-            v = stdin_readvar()
-            uartp.send(struct.pack("B", action) + v)
-            ack = uartp.recv()
-            if len(ack) != 1 or ack[0] != action:
-                raise Exception("Unacknowledged variable transfer")
-            eprint("Var %c successfully sent to board" % action)
-
-        elif action in b"ACKMPS":
-            c = struct.pack("B", action)
-            uartp.send(c)
-            v = uartp.recv()
-            if len(v) < 1 or v[0] != action:
-                raise Exception("Could not obtain variable from board")
-            v = v[1:]
-            eprint("Var %c received from board: %s" % (action, v.hex()))
-            l = struct.pack("<I", len(v))
-            sys.stdout.buffer.write(l + v)
-            sys.stdout.flush()
-
-        elif action in b"ed":
-            c = struct.pack("B", action)
-            uartp.send(c)
-            ack = uartp.recv()
-            if len(ack) != 1 or ack[0] != action:
-                raise Exception("Unacknowledged variable transfer")
-            eprint("Operation %c completed successfully" % action)
-
-        else:
-            raise Exception("Unknown action %c" % action)
-        
-    
-    return 0
+        for i, m, ad, k, npub, c in kat:
+            tool.arm()
+            run_nist_aead_test_line(dut, i, m, ad, k, npub, c)
+            tool.unarm()
+
+            if i == 1:
+                dump_b = dut.dump_ram()
+                longest = compare_dumps(dump_a, dump_b)
+                print("  longest chunk of untouched memory = %d" % longest)
+
+    except Exception as ex:
+        print("TEST FAILED")
+        raise ex
+
+    finally:
+        tool.end_measurement()
+        sys.stdout.flush()
+        sys.stderr.flush()
 
 
 if __name__ == "__main__":
diff --git a/templates/esp32/test b/templates/esp32/test
index b6a2cff..91aede8 100755
--- a/templates/esp32/test
+++ b/templates/esp32/test
@@ -3,186 +3,99 @@
 import os
 import sys
 import time
-import struct
-import serial
 import subprocess
+import serial.tools.list_ports
+from test_common import (
+    LogicMultiplexerTimeMeasurements,
+    parse_nist_aead_test_vectors,
+    DeviceUnderTestAeadUARTP,
+    eprint,
+    run_nist_aead_test_line,
+)
 
 
+def get_serial():
+    ports = serial.tools.list_ports.comports()
+    devices = [
+        p.device
+        for p in ports
+        if (p.vid == 4292 and p.pid == 60000)
+    ]
+    devices.sort()
+    return devices[0]
 
-def eprint(*args, **kargs):
-    print(*args, file=sys.stderr, **kargs)
 
+class ESP32(DeviceUnderTestAeadUARTP):
 
-def flash(tty=None):
-    pipe = subprocess.PIPE
-    cmd = ['platformio', 'run', '-e', 'esp32dev', '--target', 'upload']
-    if tty is not None:
-        cmd.extend(['--upload-port', tty])
-    p = subprocess.Popen(cmd,
-            stdout=sys.stderr, stdin=pipe)
-    stdout, stderr = p.communicate("") 
+    def __init__(self, build_dir):
+        DeviceUnderTestAeadUARTP.__init__(self)
+
+        self.build_dir = build_dir
+
+    def flash(self):
+        pipe = subprocess.PIPE
+        previous_dir = os.path.abspath(os.curdir)
+        os.chdir(self.build_dir)
+        cmd = ['platformio', 'run', '-e', 'esp32dev', '--target', 'upload']
+        cmd.extend(['--upload-port', get_serial()])
+        cmd.extend(['--upload-port', get_serial()])
+        p = subprocess.Popen(
+            cmd, stdout=sys.stderr, stdin=pipe)
+        stdout, stderr = p.communicate("")
+        eprint("Firmware flashed.")
+        os.chdir(previous_dir)
+
+    def dump_ram(self):
+        return None
 
-def get_serial():
-    import serial.tools.list_ports
-    ports = serial.tools.list_ports.comports()
-    devices = [ p.device for p in ports ]
-    devices.sort()
-    return devices[-1]
-
-
-class UARTP:
-    def __init__(self, ser):
-        UARTP.SYN = 0xf9
-        UARTP.FIN = 0xf3
-        self.ser = ser
-
-    def uart_read(self):
-        r = self.ser.read(1)
-        if len(r) != 1:
-            raise Exception("Serial read error")
-        return r[0]
-
-    def uart_write(self, c):
-        b = struct.pack("B", c)
-        r = self.ser.write(b)
-        if r != len(b):
-            raise Exception("Serial write error")
-        return r
-
-    def send(self, buf):
-        self.uart_write(UARTP.SYN)
-        len_ind_0 = 0xff & len(buf)
-        len_ind_1 = 0xff & (len(buf) >> 7)
-        if len(buf) < 128:
-            self.uart_write(len_ind_0)
-        else:
-            self.uart_write(len_ind_0 | 0x80)
-            self.uart_write(len_ind_1)
-        fcs = 0
-        for i in range(len(buf)):
-            info = buf[i]
-            fcs = (fcs + info) & 0xff
-            self.uart_write(buf[i])
-        fcs = (0xff - fcs) & 0xff
-        self.uart_write(fcs)
-        self.uart_write(UARTP.FIN)
-        eprint("sent frame '%s'" % buf.hex())
-
-    def recv(self):
-        tag_old = UARTP.FIN
-        while 1:
-            tag = tag_old
-            while 1:
-                if tag_old == UARTP.FIN:
-                    if tag == UARTP.SYN:
-                        break
-                tag_old = tag
-                tag = self.uart_read()
-            tag_old = tag
-            
-            l = self.uart_read()
-            if l & 0x80:
-                l &= 0x7f
-                l |= self.uart_read() << 7
-
-            fcs = 0
-            buf = []
-            for i in range(l):
-                info = self.uart_read()
-                buf.append(info)
-                fcs = (fcs + info) & 0xff
-            fcs = (fcs + self.uart_read()) & 0xff
-
-            tag = self.uart_read()
-            if fcs == 0xff:
-                if tag == UARTP.FIN:
-                    buf = bytes(buf)
-                    eprint("rcvd frame '%s'" % buf.hex())
-                    if len(buf) >= 1 and buf[0] == 0xde:
-                        sys.stderr.buffer.write(buf[1:])
-                        sys.stderr.flush()
-                    else:
-                        return buf
 
 def main(argv):
-    eprint(argv[0])
-    script_dir = os.path.split(argv[0])[0]
-    if len(script_dir) > 0:
-        os.chdir(script_dir)
-
-    dev = get_serial()
-    flash(dev)
-    eprint("Flashed")
-    time.sleep(0.1)
-
-    ser = serial.Serial(dev, baudrate=500000, timeout=5)
-    uartp = UARTP(ser)
-
-    ser.setDTR(False)  # IO0=HIGH
-    ser.setRTS(True)   # EN=LOW, chip in reset
-    time.sleep(0.1)
-    ser.setDTR(False)  # IO0=HIGH
-    ser.setRTS(False)  # EN=HIGH, chip out of reset
-    time.sleep(1)
-
-    def stdin_read(n):
-        b = sys.stdin.buffer.read(n)
-        if len(b) != n:
-            sys.exit(1)
-        return b
-
-    def stdin_readvar():
-        l = stdin_read(4)
-        (l, ) = struct.unpack("<I", l)
-        v = stdin_read(l)
-        return v
-
-    exp_hello = b"Hello, World!"
-    hello = ser.read(ser.in_waiting)
-    if hello[-13:] != exp_hello:
-        eprint("Improper board initialization message: %s" % hello)
+    if len(argv) != 3:
+        print("Usage: test LWC_AEAD_KAT.txt build_dir")
         return 1
-    eprint("Board initialized properly")
-    sys.stdout.write("Hello, World!\n")
-    sys.stdout.flush()
-
-    while 1:
-        action = stdin_read(1)[0]
-        eprint("Command %c from stdin" % action)
-
-        if action in b"ackmps":
-            v = stdin_readvar()
-            uartp.send(struct.pack("B", action) + v)
-            ack = uartp.recv()
-            if len(ack) != 1 or ack[0] != action:
-                raise Exception("Unacknowledged variable transfer")
-            eprint("Var %c successfully sent to board" % action)
-
-        elif action in b"ACKMPS":
-            c = struct.pack("B", action)
-            uartp.send(c)
-            v = uartp.recv()
-            if len(v) < 1 or v[0] != action:
-                raise Exception("Could not obtain variable from board")
-            v = v[1:]
-            eprint("Var %c received from board: %s" % (action, v.hex()))
-            l = struct.pack("<I", len(v))
-            sys.stdout.buffer.write(l + v)
-            sys.stdout.flush()
-
-        elif action in b"ed":
-            c = struct.pack("B", action)
-            uartp.send(c)
-            ack = uartp.recv()
-            if len(ack) != 1 or ack[0] != action:
-                raise Exception("Unacknowledged variable transfer")
-            eprint("Operation %c completed successfully" % action)
-
-        else:
-            raise Exception("Unknown action %c" % action)
-        
-    
-    return 0
+
+    kat = list(parse_nist_aead_test_vectors(argv[1]))
+    build_dir = argv[2]
+
+    dut = ESP32(build_dir)
+
+    try:
+        tool = LogicMultiplexerTimeMeasurements(0x0030)
+        tool.begin_measurement()
+
+        dut.flash()
+
+        ser = serial.Serial(
+            get_serial(),
+            baudrate=500000,
+            timeout=5)
+
+        ser.setDTR(False)  # IO0=HIGH
+        ser.setRTS(True)   # EN=LOW, chip in reset
+        time.sleep(0.1)
+        ser.setDTR(False)  # IO0=HIGH
+        ser.setRTS(False)  # EN=HIGH, chip out of reset
+        time.sleep(1)
+
+        dut.ser = ser
+
+        dut.prepare()
+        sys.stdout.write("Board prepared\n")
+        sys.stdout.flush()
+
+        for i, m, ad, k, npub, c in kat:
+            tool.arm()
+            run_nist_aead_test_line(dut, i, m, ad, k, npub, c)
+            tool.unarm()
+
+    except Exception as ex:
+        print("TEST FAILED")
+        raise ex
+
+    finally:
+        tool.end_measurement()
+        sys.stdout.flush()
+        sys.stderr.flush()
 
 
 if __name__ == "__main__":
diff --git a/templates/f7/test b/templates/f7/test
index 27cada9..a264297 100755
--- a/templates/f7/test
+++ b/templates/f7/test
@@ -2,245 +2,98 @@
 
 import os
 import sys
-import time
-import struct
-import serial
-import subprocess
+import pylink
+import serial.tools.list_ports
+from test_common import (
+    LogicMultiplexerTimeMeasurements,
+    parse_nist_aead_test_vectors,
+    DeviceUnderTestAeadUARTP,
+    compare_dumps,
+    eprint,
+    run_nist_aead_test_line,
+)
 
 
-RAM_SIZE = 0x50000
+def get_serial():
+    ports = serial.tools.list_ports.comports()
+    devices = [
+        p.device
+        for p in ports
+        if p.serial_number == 'FT2XA9MY'
+    ]
+    devices.sort()
+    return serial.Serial(
+        devices[0],
+        baudrate=115200,
+        timeout=5)
 
-def eprint(*args, **kargs):
-    print(*args, file=sys.stderr, **kargs)
 
+class F7(DeviceUnderTestAeadUARTP):
+    RAM_SIZE = 0x50000
 
-def popen_jlink():
-    pipe = subprocess.PIPE
-    cmd = ['JLinkExe']
-    cmd.extend(['-autoconnect', '1'])
-    cmd.extend(['-device', 'STM32F746ZG'])
-    cmd.extend(['-if', 'swd'])
-    cmd.extend(['-speed', '4000'])
-    return subprocess.Popen(cmd, stdout=sys.stderr, stdin=pipe)
+    def __init__(self, firmware_path, ram_pattern_path):
+        DeviceUnderTestAeadUARTP.__init__(self, get_serial())
+        self.jlink = pylink.JLink()
+        self.jlink.open(779340002)
+        self.firmware_path = firmware_path
+        self.ram_pattern_path = ram_pattern_path
 
+    def flash(self):
+        jlink = self.jlink
+        jlink.connect('STM32F746ZG')
+        jlink.flash_file(self.firmware_path, 0x8000000)
+        eprint("Firmware flashed.")
+        jlink.flash_file(self.ram_pattern_path, 0x20000000)
+        eprint("RAM flashed.")
+        jlink.reset()
+        jlink.restart()
 
-def flash():
-    p = popen_jlink()
-    return p.communicate(("""
-loadbin build/f7.bin 0x8000000
-r
-g
-exit
-    """).encode('ascii'))
+    def dump_ram(self):
+        jlink = self.jlink
+        return bytes(jlink.memory_read8(0x20000000, F7.RAM_SIZE))
 
 
-def fill_ram():
-    p = popen_jlink()
-    return p.communicate(("""
-h
-loadbin ram_pattern.bin 0x20000000
-savebin ram_copy.bin 0x20000000 0x%x
-r
-g
-exit
-    """ % RAM_SIZE).encode('ascii'))
+def main(argv):
+    if len(argv) != 3:
+        print("Usage: test LWC_AEAD_KAT.txt build_dir")
+        return 1
 
+    kat = list(parse_nist_aead_test_vectors(argv[1]))
+    build_dir = argv[2]
 
-def dump_ram():
-    p = popen_jlink()
-    return p.communicate(("""
-h
-savebin ram_dump.bin 0x20000000 0x%x
-exit
-    """ % RAM_SIZE).encode('ascii'))
+    dut = F7(
+        os.path.join(build_dir, 'build', 'f7.bin'),
+        os.path.join(build_dir, 'ram_pattern.bin'))
 
+    try:
+        tool = LogicMultiplexerTimeMeasurements(0x000c)
+        tool.begin_measurement()
 
-def get_serial():
-    import serial.tools.list_ports
-    ports = serial.tools.list_ports.comports()
-    devices = [ p.device for p in ports ]
-    devices.sort()
-    return devices[-1]
-
-
-class UARTP:
-    def __init__(self, ser):
-        UARTP.SYN = 0xf9
-        UARTP.FIN = 0xf3
-        self.ser = ser
-
-    def uart_read(self):
-        r = self.ser.read(1)
-        if len(r) != 1:
-            raise Exception("Serial read error")
-        return r[0]
-
-    def uart_write(self, c):
-        b = struct.pack("B", c)
-        r = self.ser.write(b)
-        if r != len(b):
-            raise Exception("Serial write error")
-        return r
-
-    def send(self, buf):
-        self.uart_write(UARTP.SYN)
-        len_ind_0 = 0xff & len(buf)
-        len_ind_1 = 0xff & (len(buf) >> 7)
-        if len(buf) < 128:
-            self.uart_write(len_ind_0)
-        else:
-            self.uart_write(len_ind_0 | 0x80)
-            self.uart_write(len_ind_1)
-        fcs = 0
-        for i in range(len(buf)):
-            info = buf[i]
-            fcs = (fcs + info) & 0xff
-            self.uart_write(buf[i])
-        fcs = (0xff - fcs) & 0xff
-        self.uart_write(fcs)
-        self.uart_write(UARTP.FIN)
-        eprint("sent frame '%s'" % buf.hex())
-
-    def recv(self):
-        tag_old = UARTP.FIN
-        while 1:
-            tag = tag_old
-            while 1:
-                if tag_old == UARTP.FIN:
-                    if tag == UARTP.SYN:
-                        break
-                tag_old = tag
-                tag = self.uart_read()
-            tag_old = tag
-            
-            l = self.uart_read()
-            if l & 0x80:
-                l &= 0x7f
-                l |= self.uart_read() << 7
-
-            fcs = 0
-            buf = []
-            for i in range(l):
-                info = self.uart_read()
-                buf.append(info)
-                fcs = (fcs + info) & 0xff
-            fcs = (fcs + self.uart_read()) & 0xff
-
-            tag = self.uart_read()
-            if fcs == 0xff:
-                if tag == UARTP.FIN:
-                    buf = bytes(buf)
-                    eprint("rcvd frame '%s'" % buf.hex())
-                    if len(buf) >= 1 and buf[0] == 0xde:
-                        sys.stderr.buffer.write(buf[1:])
-                        sys.stderr.flush()
-                    else:
-                        return buf
+        dut.flash()
+        dut.prepare()
+        sys.stdout.write("Board prepared\n")
+        sys.stdout.flush()
 
-def main(argv):
-    eprint(argv[0])
-    script_dir = os.path.split(argv[0])[0]
-    if len(script_dir) > 0:
-        os.chdir(script_dir)
-
-    dev = get_serial()
-    ser = serial.Serial(dev, baudrate=115200, timeout=5)
-    uartp = UARTP(ser)
-
-    flash()
-    fill_ram()
-    eprint("Flashed")
-    time.sleep(0.1)
-
-    def stdin_read(n):
-        b = sys.stdin.buffer.read(n)
-        if len(b) != n:
-            sys.exit(1)
-        return b
-
-    def stdin_readvar():
-        l = stdin_read(4)
-        (l, ) = struct.unpack("<I", l)
-        v = stdin_read(l)
-        return v
-
-    exp_hello = b"Hello, World!"
-    hello = ser.read(ser.in_waiting)
-    if hello[-13:] != exp_hello:
-        eprint("Improper board initialization message: %s" % hello)
-        return 1
-    eprint("Board initialized properly")
-    sys.stdout.write("Hello, World!\n")
-    sys.stdout.flush()
-
-    while 1:
-        action = stdin_read(1)[0]
-        eprint("Command %c from stdin" % action)
-
-        if action in b"ackmps":
-            v = stdin_readvar()
-            uartp.send(struct.pack("B", action) + v)
-            ack = uartp.recv()
-            if len(ack) != 1 or ack[0] != action:
-                raise Exception("Unacknowledged variable transfer")
-            eprint("Var %c successfully sent to board" % action)
-
-        elif action in b"ACKMPS":
-            c = struct.pack("B", action)
-            uartp.send(c)
-            v = uartp.recv()
-            if len(v) < 1 or v[0] != action:
-                raise Exception("Could not obtain variable from board")
-            v = v[1:]
-            eprint("Var %c received from board: %s" % (action, v.hex()))
-            l = struct.pack("<I", len(v))
-            sys.stdout.buffer.write(l + v)
-            sys.stdout.flush()
-
-        elif action in b"ed":
-            c = struct.pack("B", action)
-            uartp.send(c)
-            ack = uartp.recv()
-            if len(ack) != 1 or ack[0] != action:
-                raise Exception("Unacknowledged variable transfer")
-            eprint("Operation %c completed successfully" % action)
-
-        elif action in b"u":
-            dump_ram()
-            with open("ram_copy.bin", 'rb') as dump:
-                dump_a = dump.read()
-            with open("ram_dump.bin", 'rb') as dump:
-                dump_b = dump.read()
-            
-            if len(dump_a) != RAM_SIZE or len(dump_b) != RAM_SIZE:
-                raise Exception("Wrong dump sizes: 0x%x, 0x%x" % (len(dump_a), len(dump_b)))
-           
-            streaks = []
-            streak_beg = 0
-            streak_end = 0
-            for i in range(len(dump_a)):
-                if dump_a[i] == dump_b[i]:
-                    streak_end = i
-                else:
-                    if streak_end != streak_beg:
-                        streaks.append((streak_beg, streak_end))
-                    streak_beg = i
-                    streak_end = i
-
-            for b, e in streaks:
-                eprint("equal bytes from 0x%x to 0x%x (length: %d)" % (b, e, e-b))
-
-            b, e = max(streaks, key=lambda a: a[1]-a[0])
-            eprint("longest equal bytes streak from 0x%x to 0x%x (length: %d)" % (b, e, e-b))
-            v = struct.pack("<II", 4, e-b)
-            sys.stdout.buffer.write(v)
-            sys.stdout.flush()
-
-        else:
-            raise Exception("Unknown action %c" % action)
-        
-    
-    return 0
+        dump_a = dut.dump_ram()
+
+        for i, m, ad, k, npub, c in kat:
+            tool.arm()
+            run_nist_aead_test_line(dut, i, m, ad, k, npub, c)
+            tool.unarm()
+
+            if i == 1:
+                dump_b = dut.dump_ram()
+                longest = compare_dumps(dump_a, dump_b)
+                print("  longest chunk of untouched memory = %d" % longest)
+
+    except Exception as ex:
+        print("TEST FAILED")
+        raise ex
+
+    finally:
+        tool.end_measurement()
+        sys.stdout.flush()
+        sys.stderr.flush()
 
 
 if __name__ == "__main__":
diff --git a/templates/maixduino/test b/templates/maixduino/test
index 846fe40..4e0dab5 100755
--- a/templates/maixduino/test
+++ b/templates/maixduino/test
@@ -3,191 +3,105 @@
 import os
 import sys
 import time
-import struct
-import serial
 import subprocess
+import serial.tools.list_ports
+from test_common import (
+    LogicMultiplexerTimeMeasurements,
+    parse_nist_aead_test_vectors,
+    DeviceUnderTestAeadUARTP,
+    eprint,
+    run_nist_aead_test_line,
+)
 
 
+def get_serial():
+    import serial.tools.list_ports
+    ports = serial.tools.list_ports.comports()
+    ports = [
+        c
+        for c in ports
+        if c.product == 'Sipeed-Debug'
+    ]
+    ports.sort(key=lambda d: d.location)
+    return ports[0].device
 
-def eprint(*args, **kargs):
-    print(*args, file=sys.stderr, **kargs)
 
+class Maixduino(DeviceUnderTestAeadUARTP):
 
-def flash(tty=None):
-    pipe = subprocess.PIPE
-    cmd = ['platformio', 'run', '--target', 'upload']
-    if tty is not None:
-        cmd.extend(['--upload-port', tty])
-    p = subprocess.Popen(cmd,
-            stdout=sys.stderr, stdin=pipe)
-    stdout, stderr = p.communicate("") 
+    def __init__(self, build_dir):
+        DeviceUnderTestAeadUARTP.__init__(self)
 
-def get_serial():
-    import serial.tools.list_ports
-    ports = serial.tools.list_ports.comports()
-    sipeed_devices = [ c.device
-            for c in ports
-            if c.product == 'Sipeed-Debug']
-    sipeed_devices.sort()
-    return sipeed_devices[0]
-
-
-class UARTP:
-    def __init__(self, ser):
-        UARTP.SYN = 0xf9
-        UARTP.FIN = 0xf3
-        self.ser = ser
-
-    def uart_read(self):
-        r = self.ser.read(1)
-        if len(r) != 1:
-            raise Exception("Serial read error")
-        return r[0]
-
-    def uart_write(self, c):
-        b = struct.pack("B", c)
-        r = self.ser.write(b)
-        if r != len(b):
-            raise Exception("Serial write error")
-        return r
-
-    def send(self, buf):
-        self.uart_write(UARTP.SYN)
-        len_ind_0 = 0xff & len(buf)
-        len_ind_1 = 0xff & (len(buf) >> 7)
-        if len(buf) < 128:
-            self.uart_write(len_ind_0)
-        else:
-            self.uart_write(len_ind_0 | 0x80)
-            self.uart_write(len_ind_1)
-        fcs = 0
-        for i in range(len(buf)):
-            info = buf[i]
-            fcs = (fcs + info) & 0xff
-            self.uart_write(buf[i])
-        fcs = (0xff - fcs) & 0xff
-        self.uart_write(fcs)
-        self.uart_write(UARTP.FIN)
-        eprint("sent frame '%s'" % buf.hex())
-
-    def recv(self):
-        tag_old = UARTP.FIN
-        while 1:
-            tag = tag_old
-            while 1:
-                if tag_old == UARTP.FIN:
-                    if tag == UARTP.SYN:
-                        break
-                tag_old = tag
-                tag = self.uart_read()
-            tag_old = tag
-            
-            l = self.uart_read()
-            if l & 0x80:
-                l &= 0x7f
-                l |= self.uart_read() << 7
-
-            fcs = 0
-            buf = []
-            for i in range(l):
-                info = self.uart_read()
-                buf.append(info)
-                fcs = (fcs + info) & 0xff
-            fcs = (fcs + self.uart_read()) & 0xff
-
-            tag = self.uart_read()
-            if fcs == 0xff:
-                if tag == UARTP.FIN:
-                    buf = bytes(buf)
-                    eprint("rcvd frame '%s'" % buf.hex())
-                    if len(buf) >= 1 and buf[0] == 0xde:
-                        sys.stderr.buffer.write(buf[1:])
-                        sys.stderr.flush()
-                    else:
-                        return buf
-
-
-def stdin_read(n):
-    b = sys.stdin.buffer.read(n)
-    if len(b) != n:
-        sys.exit(1)
-    return b
-
-
-def stdin_readvar():
-    l = stdin_read(4)
-    (l, ) = struct.unpack("<I", l)
-    v = stdin_read(l)
-    return v
+        self.build_dir = build_dir
+
+    def flash(self):
+        pipe = subprocess.PIPE
+        previous_dir = os.path.abspath(os.curdir)
+        os.chdir(self.build_dir)
+        cmd = ['platformio', 'run', '-e', 'sipeed-maixduino']
+        cmd.extend(['--target', 'upload'])
+        cmd.extend(['--upload-port', get_serial()])
+        cmd.extend(['--upload-port', get_serial()])
+        p = subprocess.Popen(
+            cmd, stdout=sys.stderr, stdin=pipe)
+        stdout, stderr = p.communicate("")
+        eprint("Firmware flashed.")
+        os.chdir(previous_dir)
+
+    def dump_ram(self):
+        return None
 
 
 def main(argv):
-    eprint(argv[0])
-    script_dir = os.path.split(argv[0])[0]
-    if len(script_dir) > 0:
-        os.chdir(script_dir)
-
-
-    dev = get_serial()
-    flash(dev)
-    eprint("Flashed")
-    time.sleep(0.1)
-    ser = serial.Serial(dev, baudrate=1500000, timeout=5)
-    uartp = UARTP(ser)
-    
-    ser.setRTS(True)
-    time.sleep(0.1)
-    ser.setRTS(False)
-    time.sleep(0.1)
-    ser.setRTS(True)
-    time.sleep(1)
-
-    exp_hello = b"Hello, World!"
-    hello = ser.read(len(exp_hello))
-    if hello != exp_hello:
-        eprint("Improper board initialization message: ")
+    if len(argv) != 3:
+        print("Usage: test LWC_AEAD_KAT.txt build_dir")
         return 1
-    eprint("Board initialized properly")
-    sys.stdout.write("Hello, World!\n")
-    sys.stdout.flush()
-
-    while 1:
-        action = stdin_read(1)[0]
-        eprint("Command %c from stdin" % action)
-
-        if action in b"ackmps":
-            v = stdin_readvar()
-            uartp.send(struct.pack("B", action) + v)
-            ack = uartp.recv()
-            if len(ack) != 1 or ack[0] != action:
-                raise Exception("Unacknowledged variable transfer")
-            eprint("Var %c successfully sent to board" % action)
-
-        elif action in b"ACKMPS":
-            c = struct.pack("B", action)
-            uartp.send(c)
-            v = uartp.recv()
-            if len(v) < 1 or v[0] != action:
-                raise Exception("Could not obtain variable from board")
-            v = v[1:]
-            eprint("Var %c received from board: %s" % (action, v.hex()))
-            l = struct.pack("<I", len(v))
-            sys.stdout.buffer.write(l + v)
-            sys.stdout.flush()
-
-        elif action in b"ed":
-            c = struct.pack("B", action)
-            uartp.send(c)
-            ack = uartp.recv()
-            if len(ack) < 1 or ack[0] != action:
-                raise Exception("Unacknowledged variable transfer")
-            eprint("Operation %c completed successfully" % action)
-
-        else:
-            raise Exception("Unknown action %c" % action)
-        
-    
-    return 0
+
+    kat = list(parse_nist_aead_test_vectors(argv[1]))
+    build_dir = argv[2]
+
+    dut = Maixduino(build_dir)
+
+    try:
+        tool = LogicMultiplexerTimeMeasurements(0x00c0)
+        tool.begin_measurement()
+
+        dut.flash()
+
+        ser = serial.Serial(
+            get_serial(),
+            baudrate=1500000,
+            timeout=5)
+
+        ser.setRTS(True)
+        time.sleep(0.1)
+        ser.setRTS(False)
+        time.sleep(0.1)
+        ser.setRTS(True)
+        time.sleep(1)
+
+        dut.ser = ser
+
+        dut.prepare()
+        sys.stdout.write("Board prepared\n")
+        sys.stdout.flush()
+
+        for i, m, ad, k, npub, c in kat:
+            tool.arm()
+            run_nist_aead_test_line(dut, i, m, ad, k, npub, c)
+            tool.unarm()
+
+    except Exception as ex:
+        print("TEST FAILED")
+        raise ex
+
+    finally:
+        tool.end_measurement()
+        sys.stdout.flush()
+        sys.stderr.flush()
+
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv))
 
 
 if __name__ == "__main__":
diff --git a/templates/uno/test b/templates/uno/test
index ecfdc5b..f11b503 100755
--- a/templates/uno/test
+++ b/templates/uno/test
@@ -3,187 +3,97 @@
 import os
 import sys
 import time
-import struct
-import serial
 import subprocess
+import serial.tools.list_ports
+from test_common import (
+    LogicMultiplexerTimeMeasurements,
+    parse_nist_aead_test_vectors,
+    DeviceUnderTestAeadUARTP,
+    eprint,
+    run_nist_aead_test_line,
+)
 
 
+def get_serial():
+    ports = serial.tools.list_ports.comports()
+    devices = [
+        p.device
+        for p in ports
+        if (p.vid == 0x1A86 and p.pid == 0x7523)
+    ]
+    devices.sort()
+    return devices[0]
 
-def eprint(*args, **kargs):
-    print(*args, file=sys.stderr, **kargs)
 
+class Uno(DeviceUnderTestAeadUARTP):
 
-def flash(tty=None):
-    pipe = subprocess.PIPE
-    cmd = ['platformio', 'run', '-e', 'uno', '--target', 'upload']
-    if tty is not None:
-        cmd.extend(['--upload-port', tty])
-    p = subprocess.Popen(cmd,
-            stdout=sys.stderr, stdin=pipe)
-    stdout, stderr = p.communicate("") 
+    def __init__(self, build_dir):
+        DeviceUnderTestAeadUARTP.__init__(self)
 
-def get_serial():
-    import serial.tools.list_ports
-    ports = serial.tools.list_ports.comports()
-    devices = [ p.device for p in ports ]
-    devices.sort()
-    return devices[-1]
-
-
-class UARTP:
-    def __init__(self, ser):
-        UARTP.SYN = 0xf9
-        UARTP.FIN = 0xf3
-        self.ser = ser
-
-    def uart_read(self):
-        r = self.ser.read(1)
-        if len(r) != 1:
-            raise Exception("Serial read error")
-        return r[0]
-
-    def uart_write(self, c):
-        b = struct.pack("B", c)
-        r = self.ser.write(b)
-        if r != len(b):
-            raise Exception("Serial write error")
-        return r
-
-    def send(self, buf):
-        self.uart_write(UARTP.SYN)
-        len_ind_0 = 0xff & len(buf)
-        len_ind_1 = 0xff & (len(buf) >> 7)
-        if len(buf) < 128:
-            self.uart_write(len_ind_0)
-        else:
-            self.uart_write(len_ind_0 | 0x80)
-            self.uart_write(len_ind_1)
-        fcs = 0
-        for i in range(len(buf)):
-            info = buf[i]
-            fcs = (fcs + info) & 0xff
-            self.uart_write(buf[i])
-        fcs = (0xff - fcs) & 0xff
-        self.uart_write(fcs)
-        self.uart_write(UARTP.FIN)
-        eprint("sent frame '%s'" % buf.hex())
-
-    def recv(self):
-        tag_old = UARTP.FIN
-        while 1:
-            tag = tag_old
-            while 1:
-                if tag_old == UARTP.FIN:
-                    if tag == UARTP.SYN:
-                        break
-                tag_old = tag
-                tag = self.uart_read()
-            tag_old = tag
-            
-            l = self.uart_read()
-            if l & 0x80:
-                l &= 0x7f
-                l |= self.uart_read() << 7
-
-            fcs = 0
-            buf = []
-            for i in range(l):
-                info = self.uart_read()
-                buf.append(info)
-                fcs = (fcs + info) & 0xff
-            fcs = (fcs + self.uart_read()) & 0xff
-
-            tag = self.uart_read()
-            if fcs == 0xff:
-                if tag == UARTP.FIN:
-                    buf = bytes(buf)
-                    eprint("rcvd frame '%s'" % buf.hex())
-                    if len(buf) >= 1 and buf[0] == 0xde:
-                        sys.stderr.buffer.write(buf[1:])
-                        sys.stderr.flush()
-                    else:
-                        return buf
-
-
-def stdin_read(n):
-    b = sys.stdin.buffer.read(n)
-    if len(b) != n:
-        sys.exit(1)
-    return b
-
-
-def stdin_readvar():
-    l = stdin_read(4)
-    (l, ) = struct.unpack("<I", l)
-    v = stdin_read(l)
-    return v
+        self.build_dir = build_dir
+
+    def flash(self):
+        pipe = subprocess.PIPE
+        previous_dir = os.path.abspath(os.curdir)
+        os.chdir(self.build_dir)
+        cmd = ['platformio', 'run', '-e', 'uno', '--target', 'upload']
+        cmd.extend(['--upload-port', get_serial()])
+        cmd.extend(['--upload-port', get_serial()])
+        p = subprocess.Popen(
+            cmd, stdout=sys.stderr, stdin=pipe)
+        stdout, stderr = p.communicate("")
+        eprint("Firmware flashed.")
+        os.chdir(previous_dir)
+
+    def dump_ram(self):
+        return None
 
 
 def main(argv):
-    eprint(argv[0])
-    script_dir = os.path.split(argv[0])[0]
-    if len(script_dir) > 0:
-        os.chdir(script_dir)
-
-    dev = get_serial()
-    flash(dev)
-    eprint("Flashed")
-    time.sleep(0.1)
-
-    ser = serial.Serial(dev, baudrate=115200, timeout=5)
-    uartp = UARTP(ser)
-    
-    ser.setDTR(True)
-    time.sleep(0.01)
-    ser.setDTR(False)
-    time.sleep(1)
-
-    exp_hello = b"Hello, World!"
-    hello = ser.read(len(exp_hello))
-    if hello != exp_hello:
-        eprint("Improper board initialization message: ")
+    if len(argv) != 3:
+        print("Usage: test LWC_AEAD_KAT.txt build_dir")
         return 1
-    eprint("Board initialized properly")
-    sys.stdout.write("Hello, World!\n")
-    sys.stdout.flush()
-
-    while 1:
-        action = stdin_read(1)[0]
-        eprint("Command %c from stdin" % action)
-
-        if action in b"ackmps":
-            v = stdin_readvar()
-            uartp.send(struct.pack("B", action) + v)
-            ack = uartp.recv()
-            if len(ack) != 1 or ack[0] != action:
-                raise Exception("Unacknowledged variable transfer")
-            eprint("Var %c successfully sent to board" % action)
-
-        elif action in b"ACKMPS":
-            c = struct.pack("B", action)
-            uartp.send(c)
-            v = uartp.recv()
-            if len(v) < 1 or v[0] != action:
-                raise Exception("Could not obtain variable from board")
-            v = v[1:]
-            eprint("Var %c received from board: %s" % (action, v.hex()))
-            l = struct.pack("<I", len(v))
-            sys.stdout.buffer.write(l + v)
-            sys.stdout.flush()
-
-        elif action in b"ed":
-            c = struct.pack("B", action)
-            uartp.send(c)
-            ack = uartp.recv()
-            if len(ack) < 1 or ack[0] != action:
-                raise Exception("Unacknowledged variable transfer")
-            eprint("Operation %c completed successfully" % action)
-
-        else:
-            raise Exception("Unknown action %c" % action)
-        
-    
-    return 0
+
+    kat = list(parse_nist_aead_test_vectors(argv[1]))
+    build_dir = argv[2]
+
+    dut = Uno(build_dir)
+
+    try:
+        tool = LogicMultiplexerTimeMeasurements(0x0c00)
+        tool.begin_measurement()
+
+        dut.flash()
+
+        ser = serial.Serial(
+            get_serial(),
+            baudrate=115200,
+            timeout=5)
+
+        ser.setDTR(True)
+        time.sleep(0.01)
+        ser.setDTR(False)
+        time.sleep(1)
+
+        dut.ser = ser
+
+        dut.prepare()
+        sys.stdout.write("Board prepared\n")
+        sys.stdout.flush()
+
+        for i, m, ad, k, npub, c in kat:
+            tool.arm()
+            run_nist_aead_test_line(dut, i, m, ad, k, npub, c)
+            tool.unarm()
+
+    except Exception as ex:
+        print("TEST FAILED")
+        raise ex
+
+    finally:
+        tool.end_measurement()
+        sys.stdout.flush()
+        sys.stderr.flush()
 
 
 if __name__ == "__main__":
diff --git a/test.py b/test.py
deleted file mode 100755
index d19a447..0000000
--- a/test.py
+++ /dev/null
@@ -1,188 +0,0 @@
-#!/usr/bin/env python3
-
-import re
-import os
-import sys
-import struct
-from subprocess import Popen, PIPE
-
-
-def main(argv):
-    speed_test = True
-
-    if len(argv) < 3:
-        print("Usage: test.py LWC_AEAD_KAT.txt program [arguments]")
-
-    cmd = argv[2:]
-
-    for attempt in range(3):
-        print("beginning test %d of '%s' using test vectors '%s'" % (attempt, ' '.join(cmd), argv[1]))
-        try:
-            if speed_test:
-                measurements = begin_measurement()
-            try:
-                test(argv[1], cmd)
-            finally:
-                if speed_test:
-                    end_measurement(measurements)
-            print("TEST SUCCESSFUL")
-            return 0
-
-        except Exception as ex:
-            print(str(ex))
-            print("TEST FAILED")
-        finally:
-            sys.stdout.flush()
-            sys.stderr.flush()
-
-    return 1
-
-def test(test_file, cmd, ram_test=False):
-
-    test_file = open(test_file, 'r')
-    p = Popen(cmd, bufsize=0, stdin=PIPE, stdout=PIPE)
-
-    def write(data):
-        l = p.stdin.write(data)
-        if len(data) != l:
-            raise Exception("could not write %d bytes of data (put %d)" % (len(data), l))
-
-    def read(l):
-        if l == 0:
-            return b""
-        data = p.stdout.read(l)
-        if len(data) == 0:
-            print("Unexpected end of stream", file=sys.stderr)
-            #sys.exit(1)
-        if len(data) != l:
-            raise Exception("could not read %d bytes of data (got %d)" % (l, len(data)))
-        return data
-
-    def submit(action, data):
-        h = struct.pack("<BI", ord(action), len(data))
-        write(h)
-        write(data)
-
-    def obtain():
-        l = read(4)
-        (l, ) = struct.unpack("<I", l)
-        return read(l)
-
-    output = read(14)
-    if output != b"Hello, World!\n":
-        raise Exception("Unexpected output: %s" % output)
-    print("Ready")
-
-    m = b""
-    ad = b""
-    k = b""
-    npub = b""
-    i = 0
-    lineprog = re.compile(r"^\s*([A-Z]+)\s*=\s*(([0-9a-f])*)\s*$", re.IGNORECASE)
-    for line in test_file.readlines():
-        line = line.strip()
-        res = lineprog.match(line)
-        if line == "":
-            print()
-            print("Count = %d" % i)
-            print("   m = %s" % m.hex())
-            print("  ad = %s" % ad.hex())
-            print("npub = %s" % npub.hex())
-            print("   k = %s" % k.hex())
-            print("   c = %s" % c.hex())
-
-            submit('c', b"\0" * (len(m) + 32))
-            submit('s', b"")
-
-            submit('m', m)
-            submit('a', ad)
-            submit('k', k)
-            submit('p', npub)
-            write(b'e')
-            write(b'C')
-            output = obtain()
-            print("   c = %s" % output.hex())
-            if c != output:
-                raise Exception("output of encryption is different from expected ciphertext")
-
-            submit('m', b"\0" * len(c))
-            submit('s', b"")
-
-            submit('c', c)
-            submit('a', ad)
-            submit('k', k)
-            submit('p', npub)
-            write(b'd')
-            write(b'M')
-            output = obtain()
-            print("   m = %s" % output.hex())
-            if m != output:
-                raise Exception("output of encryption is different from expected ciphertext")
-            
-            if ram_test:
-                # RAM test only tests the first test vector
-                write(b'u')
-                output = obtain()
-                print("  untouched memory = %d" % struct.unpack("<I", output))
-                break
-
-        elif res is not None:
-            if res[1].lower() == 'count':
-                i = int(res[2], 10)
-            elif res[1].lower() == 'key':
-                k = bytes.fromhex(res[2])
-            elif res[1].lower() == 'nonce':
-                npub = bytes.fromhex(res[2])
-            elif res[1].lower() == 'pt':
-                m = bytes.fromhex(res[2])
-            elif res[1].lower() == 'ad':
-                ad = bytes.fromhex(res[2])
-            elif res[1].lower() == 'ct':
-                c = bytes.fromhex(res[2])
-            else:
-                raise Exception("ERROR: unparsed line in test vectors file: '%s'" % res)
-        else:
-            raise Exception("ERROR: unparsed line in test vectors file: '%s'" % line)
-
-def begin_measurement():
-    import saleae
-    import time
-    sal = saleae.Saleae()
-    # Channel 0 is reset
-    # Channel 1 is crypto_busy
-    sal.set_active_channels([0, 1], [])
-    sal.set_sample_rate(sal.get_all_sample_rates()[0])
-    sal.set_capture_seconds(6000)
-    sal.capture_start()
-    time.sleep(1)
-    if sal.is_processing_complete():
-        raise Exception("Capture didn't start successfully")
-    return sal
-
-def end_measurement(sal):
-    import time
-    if sal.is_processing_complete():
-        raise Exception("Capture finished before expected")
-    time.sleep(1)
-    sal.capture_stop();
-    time.sleep(.1)
-    for attempt in range(3):
-        if not sal.is_processing_complete():
-            print("Waiting for capture to complete...")
-            time.sleep(1)
-            continue
-        outfile = "measurement_%s.csv" % time.strftime("%Y%m%d-%H%M%S")
-        outfile = os.path.join("measurements", outfile)
-        if os.path.isfile(outfile):
-            os.unlink(outfile)
-        sal.export_data2(os.path.abspath(outfile))
-        print("Measurements written to '%s'" % outfile)
-        mdbfile = os.path.join("measurements", "measurements.txt")
-        mdbfile = open(mdbfile, "a")
-        mdbfile.write("%s > %s\n" % (' '.join(sys.argv), outfile))
-        mdbfile.close()
-        return 0
-    raise Exception("Capture didn't complete successfully")
-
-if __name__ == "__main__":
-    sys.exit(main(sys.argv))
diff --git a/test_common.py b/test_common.py
new file mode 100644
index 0000000..384c276
--- /dev/null
+++ b/test_common.py
@@ -0,0 +1,414 @@
+#!/usr/bin/env python3
+
+import os
+import re
+import sys
+import time
+import struct
+import serial
+
+
+def eprint(*args, **kargs):
+    print(*args, file=sys.stderr, **kargs)
+
+
+class DeviceUnderTest:
+    def __init__(self):
+        pass
+
+    def flash(self):
+        """
+        This method should be overridden to flash the DUT.
+        """
+        pass
+
+    def dump_ram(self):
+        """
+        This should be overridden to return the RAM dump as a bytes string.
+        """
+        return None
+
+
+class DeviceUnderTestAeadUARTP(DeviceUnderTest):
+    def __init__(self, ser=None):
+        self.ser = ser
+
+    def prepare(self):
+        exp_hello = b"Hello, World!"
+        time.sleep(0.1)
+        if self.ser.in_waiting < 13:
+            time.sleep(2)
+        hello = self.ser.read(self.ser.in_waiting)
+        if hello[-13:] != exp_hello:
+            raise Exception(
+                "Improper board initialization message: %s" % hello)
+        self.uartp = UARTP(self.ser)
+
+    def send_var(self, key, value):
+        self.uartp.send(struct.pack("B", key) + value)
+        ack = self.uartp.recv()
+        if len(ack) != 1 or ack[0] != key:
+            raise Exception("Unacknowledged variable transfer")
+
+    def obtain_var(self, key):
+        c = struct.pack("B", key)
+        self.uartp.send(c)
+        v = self.uartp.recv()
+        if len(v) < 1 or v[0] != key:
+            raise Exception("Could not obtain variable from board")
+        return v[1:]
+
+    def do_cmd(self, action):
+        c = struct.pack("B", action)
+        self.uartp.send(c)
+        ack = self.uartp.recv()
+        if len(ack) != 1 or ack[0] != action:
+            raise Exception("Unacknowledged command")
+
+
+class UARTP:
+    def __init__(self, ser):
+        UARTP.SYN = 0xf9
+        UARTP.FIN = 0xf3
+        self.ser = ser
+
+    def uart_read(self):
+        r = self.ser.read(1)
+        if len(r) != 1:
+            raise Exception("Serial read error")
+        return r[0]
+
+    def uart_write(self, c):
+        b = struct.pack("B", c)
+        r = self.ser.write(b)
+        if r != len(b):
+            raise Exception("Serial write error")
+        return r
+
+    def send(self, buf):
+        self.uart_write(UARTP.SYN)
+        len_ind_0 = 0xff & len(buf)
+        len_ind_1 = 0xff & (len(buf) >> 7)
+        if len(buf) < 128:
+            self.uart_write(len_ind_0)
+        else:
+            self.uart_write(len_ind_0 | 0x80)
+            self.uart_write(len_ind_1)
+        fcs = 0
+        for i in range(len(buf)):
+            info = buf[i]
+            fcs = (fcs + info) & 0xff
+            self.uart_write(buf[i])
+        fcs = (0xff - fcs) & 0xff
+        self.uart_write(fcs)
+        self.uart_write(UARTP.FIN)
+        # eprint("sent frame '%s'" % buf.hex())
+
+    def recv(self):
+        tag_old = UARTP.FIN
+        while 1:
+            tag = tag_old
+            while 1:
+                if tag_old == UARTP.FIN:
+                    if tag == UARTP.SYN:
+                        break
+                tag_old = tag
+                tag = self.uart_read()
+            tag_old = tag
+
+            pkt = self.uart_read()
+            if pkt & 0x80:
+                pkt &= 0x7f
+                pkt |= self.uart_read() << 7
+
+            fcs = 0
+            buf = []
+            for i in range(pkt):
+                info = self.uart_read()
+                buf.append(info)
+                fcs = (fcs + info) & 0xff
+            fcs = (fcs + self.uart_read()) & 0xff
+
+            tag = self.uart_read()
+            if fcs == 0xff:
+                if tag == UARTP.FIN:
+                    buf = bytes(buf)
+                    # eprint("rcvd frame '%s'" % buf.hex())
+                    if len(buf) >= 1 and buf[0] == 0xde:
+                        sys.stderr.buffer.write(buf[1:])
+                        sys.stderr.flush()
+                    else:
+                        return buf
+
+
+def run_nist_aead_test_line(dut, i, m, ad, k, npub, c):
+    eprint()
+    eprint("Count = %d" % i)
+    eprint("   m = %s" % m.hex())
+    eprint("  ad = %s" % ad.hex())
+    eprint("npub = %s" % npub.hex())
+    eprint("   k = %s" % k.hex())
+    eprint("   c = %s" % c.hex())
+
+    dut.send_var(ord('c'), b"\0" * (len(m) + 32))
+    dut.send_var(ord('s'), b"")
+
+    dut.send_var(ord('m'), m)
+    dut.send_var(ord('a'), ad)
+    dut.send_var(ord('k'), k)
+    dut.send_var(ord('p'), npub)
+
+    dut.do_cmd(ord('e'))
+    output = dut.obtain_var(ord('C'))
+    print("   c = %s" % output.hex())
+    if c != output:
+        raise Exception("output of encryption is different from " +
+                        "expected ciphertext")
+
+    dut.send_var(ord('m'), b"\0" * len(c))
+    dut.send_var(ord('s'), b"")
+
+    dut.send_var(ord('c'), c)
+    dut.send_var(ord('a'), ad)
+    dut.send_var(ord('k'), k)
+    dut.send_var(ord('p'), npub)
+
+    dut.do_cmd(ord('d'))
+    output = dut.obtain_var(ord('M'))
+    print("   m = %s" % output.hex())
+    if m != output:
+        raise Exception("output of encryption is different from " +
+                        "expected ciphertext")
+
+
+def compare_dumps(dump_a, dump_b):
+    """
+    Gets the length of the longes streaks of equal bytes in two RAM dumps
+    """
+    streaks = []
+    streak_beg = 0
+    streak_end = 0
+    for i in range(len(dump_a)):
+        if dump_a[i] == dump_b[i]:
+            streak_end = i
+        else:
+            if streak_end != streak_beg:
+                streaks.append((streak_beg, streak_end))
+            streak_beg = i
+            streak_end = i
+
+    for b, e in streaks:
+        eprint("equal bytes from 0x%x to 0x%x (length: %d)" %
+               (b, e, e-b))
+
+    b, e = max(streaks, key=lambda a: a[1]-a[0])
+    eprint(
+        "longest equal bytes streak from 0x%x to 0x%x (length: %d)" %
+        (b, e, e-b))
+    return e-b
+
+
+def parse_nist_aead_test_vectors(test_file_path):
+    with open(test_file_path, 'r') as test_file:
+        lineprog = re.compile(
+            r"^\s*([A-Z]+)\s*=\s*(([0-9a-f])*)\s*$",
+            re.IGNORECASE)
+        m = b""
+        ad = b""
+        k = b""
+        npub = b""
+        c = b""
+        i = -1
+        for line in test_file.readlines():
+            line = line.strip()
+            res = lineprog.match(line)
+            if line == "":
+                yield i, m, ad, k, npub, c
+                m = b""
+                ad = b""
+                k = b""
+                npub = b""
+                c = b""
+            elif res is not None:
+                if res[1].lower() == 'count':
+                    i = int(res[2], 10)
+                elif res[1].lower() == 'key':
+                    k = bytes.fromhex(res[2])
+                elif res[1].lower() == 'nonce':
+                    npub = bytes.fromhex(res[2])
+                elif res[1].lower() == 'pt':
+                    m = bytes.fromhex(res[2])
+                elif res[1].lower() == 'ad':
+                    ad = bytes.fromhex(res[2])
+                elif res[1].lower() == 'ct':
+                    c = bytes.fromhex(res[2])
+                else:
+                    raise Exception(
+                        "ERROR: unparsed line in test vectors file: '%s'"
+                        % res)
+            else:
+                raise Exception(
+                    "ERROR: unparsed line in test vectors file: '%s'" % line)
+
+
+class TimeMeasurementTool:
+    def begin_measurement(self):
+        pass
+
+    def arm(self):
+        pass
+
+    def unarm(self):
+        pass
+
+    def end_measurement(self):
+        pass
+
+
+class LogicMultiplexerTimeMeasurements(TimeMeasurementTool):
+
+    def __init__(self, mask=0xffffffffffffffff):
+        self.mask = mask
+        self.sock = None
+        self.capture = []
+
+    def recv_samples(self):
+        import socket
+
+        capture = []
+        while 1:
+            try:
+                rcvd = self.sock.recv(16)
+            except socket.timeout:
+                break
+            except BlockingIOError:
+                break
+            if len(rcvd) != 16:
+                raise Exception("Could not receive 16 bytes of logic sample!")
+
+            time, value = struct.unpack("<dQ", rcvd)
+            eprint("%16.10f: %016x" % (time, value))
+            capture.append((time, value))
+        return capture
+
+    def begin_measurement(self):
+        import socket
+
+        server_addr = os.path.expandvars('$XDG_RUNTIME_DIR/lwc-logic-socket')
+        self.sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+        self.sock.settimeout(0)
+        self.server_addr = server_addr
+        self.sock.connect(self.server_addr)
+        self.sock.send(struct.pack("<Q", self.mask))
+
+    def arm(self):
+        self.capture.extend(self.recv_samples())
+
+    def unarm(self):
+        self.capture.extend(self.recv_samples())
+
+    def end_measurement(self):
+        time.sleep(1)
+        self.capture.extend(self.recv_samples())
+        self.sock.close()
+
+
+class SaleaeTimeMeasurements(TimeMeasurementTool):
+    __slots__ = ['sal']
+
+    def __init__(self, channels=[0, 1]):
+        import saleae
+        sal = saleae.Saleae()
+        sal.set_active_channels(self.channels, [])
+        sal.set_sample_rate(sal.get_all_sample_rates()[0])
+        sal.set_capture_seconds(6000)
+        self.sal = sal
+
+    def begin_measurement(self):
+        # Channel 0 is reset
+        # Channel 1 is crypto_busy
+        import time
+        sal = self.sal
+
+        sal.capture_start()
+        time.sleep(1)
+        if sal.is_processing_complete():
+            raise Exception("Capture didn't start successfully")
+
+    def end_measurement(self):
+        import time
+        sal = self.sal
+
+        if sal.is_processing_complete():
+            raise Exception("Capture finished before expected")
+        time.sleep(1)
+        sal.capture_stop()
+        time.sleep(.1)
+        for attempt in range(3):
+            if not sal.is_processing_complete():
+                print("Waiting for capture to complete...")
+                time.sleep(1)
+                continue
+            outfile = "measurement_%s.csv" % time.strftime("%Y%m%d-%H%M%S")
+            outfile = os.path.join("measurements", outfile)
+            if os.path.isfile(outfile):
+                os.unlink(outfile)
+            sal.export_data2(os.path.abspath(outfile))
+            print("Measurements written to '%s'" % outfile)
+            mdbfile = os.path.join("measurements", "measurements.txt")
+            mdbfile = open(mdbfile, "a")
+            mdbfile.write("%s > %s\n" % (' '.join(sys.argv), outfile))
+            mdbfile.close()
+            return 0
+        raise Exception("Capture didn't complete successfully")
+
+
+def main(argv):
+    if len(argv) < 3:
+        print("Usage: test_common.py port LWC_AEAD_KAT.txt")
+
+    eprint(argv[0])
+    script_dir = os.path.split(argv[0])[0]
+    if len(script_dir) > 0:
+        os.chdir(script_dir)
+
+    kat = list(parse_nist_aead_test_vectors(argv[2]))
+
+    dev = argv[1]
+    ser = serial.Serial(dev, baudrate=115200, timeout=5)
+    dut = DeviceUnderTestAeadUARTP(ser)
+
+    try:
+        tool = SaleaeTimeMeasurements()
+        tool.begin_measurement()
+        dut.flash()
+        eprint("Flashed")
+        dut.prepare()
+        eprint("Prepared")
+        sys.stdout.write("Hello, World!\n")
+        sys.stdout.flush()
+
+        dump_a = dut.dump_ram()
+
+        for i, m, ad, k, npub, c in kat:
+            tool.arm()
+            run_nist_aead_test_line(dut, i, m, ad, k, npub, c)
+            tool.unarm()
+
+            if dump_a is not None and i == 1:
+                dump_b = dut.dump_ram()
+                longest = compare_dumps(dump_a, dump_b)
+                print("  longest chunk of untouched memory = %d" % longest)
+
+    except Exception as ex:
+        print("TEST FAILED")
+        raise ex
+
+    finally:
+        tool.end_measurement()
+        sys.stdout.flush()
+        sys.stderr.flush()
+
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv))