From 9c4183fe8071100ffbe0a6d4d58859895924f5a9 Mon Sep 17 00:00:00 2001
From: Craig Thomas <craig.thomas@gmail.com>
Date: Thu, 3 Oct 2019 15:32:56 -0400
Subject: [PATCH] Add new unit test framework.

Add unit tests for get_value.

Split out assembler from statement class.

New structure for source files.

Fix test import, update README.

Move assembler to main directory.

Refactor functions for Statement plus unit tests.

Fixed all bugs.

Fix failing unit tests.

Added more unit tests, and updated coverage ignores.
---
 .gitignore              |   2 +
 .travis.yml             |  14 ++
 README.md               | 115 +++++----
 assembler.py            |  67 ++++++
 chip8asm/chip8asm.py    | 499 ----------------------------------------
 chip8asm/exceptions.py  |  37 +++
 chip8asm/program.py     | 126 ++++++++++
 chip8asm/statement.py   | 371 +++++++++++++++++++++++++++++
 codecov.yml             |  22 ++
 requirements.txt        |   2 +
 test/__init__.py        |   0
 test/test_exceptions.py |  45 ++++
 test/test_program.py    |  42 ++++
 test/test_statement.py  | 290 +++++++++++++++++++++++
 14 files changed, 1084 insertions(+), 548 deletions(-)
 create mode 100644 .gitignore
 create mode 100644 .travis.yml
 create mode 100644 assembler.py
 delete mode 100644 chip8asm/chip8asm.py
 create mode 100644 chip8asm/exceptions.py
 create mode 100644 chip8asm/program.py
 create mode 100644 chip8asm/statement.py
 create mode 100644 codecov.yml
 create mode 100644 requirements.txt
 create mode 100644 test/__init__.py
 create mode 100644 test/test_exceptions.py
 create mode 100644 test/test_program.py
 create mode 100644 test/test_statement.py

diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..b32d8aa
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,2 @@
+*.pyc
+.idea
\ No newline at end of file
diff --git a/.travis.yml b/.travis.yml
new file mode 100644
index 0000000..af23d59
--- /dev/null
+++ b/.travis.yml
@@ -0,0 +1,14 @@
+language: python
+sudo: false
+python:
+  - 3.6
+addons:
+  apt:
+    packages:
+      - python-dev
+virtalenv:
+  system_site_packages: true
+script:
+  - coverage run -m nose
+after_success:
+  - bash <(curl -s https://codecov.io/bash) || echo "Codecov did not collect coverage reports"
diff --git a/README.md b/README.md
index 7d93721..07fca94 100644
--- a/README.md
+++ b/README.md
@@ -1,6 +1,10 @@
 # (Super) Chip 8 Assembler
 
-[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
+[![Build Status](https://img.shields.io/travis/craigthomas/Chip8Assembler?style=flat-square)](https://travis-ci.org/craigthomas/Chip8Assembler) 
+[![Codecov](https://img.shields.io/codecov/c/gh/craigthomas/Chip8Assembler?style=flat-square)](https://codecov.io/gh/craigthomas/Chip8Assembler) 
+[![Codacy Badge](https://img.shields.io/codacy/grade/f100b6deb9bf4729a2c55ef12fb695c9?style=flat-square)](https://www.codacy.com/app/craig-thomas/Chip8Assembler?utm_source=github.com&amp;utm_medium=referral&amp;utm_content=craigthomas/Chip8Python&amp;utm_campaign=Badge_Grade)
+[![Dependencies](https://img.shields.io/librariesio/github/craigthomas/Chip8Assembler?style=flat-square)](https://libraries.io/github/craigthomas/Chip8Assembler)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg?style=flat-square)](https://opensource.org/licenses/MIT)
 
 ## Table of Contents
 
@@ -8,9 +12,9 @@
 2. [Requirements](#requirements)
 3. [Installation](#installation)
 4. [Usage](#usage)
-    1. [Print Symbol Table](#print-symbol-table)
-    2. [Print Assembled Statements](#print-assembled-statements)
-    3. [Input Format](#input-format)
+    1. [Input Format](#input-format)
+    2. [Print Symbol Table](#print-symbol-table)
+    3. [Print Assembled Statements](#print-assembled-statements)
 5. [Mnemonic Table](#mnemonic-table)
     1. [Chip 8 Mnemonics](#chip-8-mnemonics)
     2. [Super Chip 8 Mnemonics](#super-chip-8-mnemonics)
@@ -21,70 +25,40 @@
 
 ## What is it?
 
-This project is a (Super) Chip 8 assembler written in Python 2.7. The assembler will
+This project is a (Super) Chip 8 assembler written in Python 3.6. The assembler will
 take valid Super Chip 8 assembly statements and generate a binary file containing
 the correct machine instructions.
 
 
 ## Requirements
 
-The only requirements for this project is:
-
-* [Python 2.7](http://www.python.org)
+In order to run the assembler, you will need to use Python 3.6 or greater. If you wish
+to clone the repository for development, you will need Git.
 
 
 ## Installation
 
-To install the source files, simply clone the repository in the directory
-of your choice:
+To install the source files, download the latest release from the 
+[releases](https://github.com/craigthomas/Chip8Assembler/releases) section of 
+the repository and unzip the contents in a directory of your choice. Or, 
+clone the repository in the directory of your choice with:
 
     git clone https://github.com/craigthomas/Chip8Assembler.git
+    
+Next, you will need to install the required packages for the file:
+
+    pip install -r requirements.txt
 
 
 ## Usage
 
 To run the assembler:
 
-    python chip8asm/chip8asm.py input_file -o output_file
+    python assembler.py input_file --output output_file
 
 This will assemble the instructions found in file `input_file` and will generate
 the associated Chip 8 machine instructions in binary format in `output_file`.
 
-### Print Symbol Table
-
-To print the symbol table that is generated during assembly, use the `-s` switch:
-
-    python chip8asm/chip8asm.py test.asm -s
-
-Which will have the following output:
-
-    -- Symbol Table --
-    start 0x200
-    data1 0x209
-    data 0x208
-
-### Print Assembled Statements
-
-To print out the assembled version of the program, use the `-p` switch:
-
-    python chip8asm/chip8asm.py test.asm -p
-
-Which will have the following output:
-
-    -- Assembled Statements --
-    0x0200 6100      start  LOAD           r1,$0  # Clear contents of register 1            
-    0x0202 7101              ADD           r1,$1  # Add 1 to the register                   
-    0x0204 310A              SKE           r1,$A  # Check to see if we are at 10            
-    0x0206 1200             JUMP           start  # Jump back to the start                  
-    0x0208 1208        end  JUMP             end  # Loop forever
-
-With this output, the first column is the offset in hex where the statement starts,
-the second column contains the full machine-code operand, the third column is the
-user-supplied label for the statement, the forth column is the mnemonic, the fifth
-column is the register values of other numeric or label data the operation will
-work on, and the fifth column is the comment string.
-
-
 ### Input Format
 
 The input file needs to follow the format below:
@@ -94,9 +68,9 @@ The input file needs to follow the format below:
 Where:
 
 * `LABEL` is a 15 character label for the statement
-* `MNEMONIC` is a Chip 8 operation mnemonic from the table below
-* `OPERANDS` are registers, values or labels, as described in detail below
-* `COMMENT` is a 30 character comment describing the statement
+* `MNEMONIC` is a Chip 8 operation mnemonic from the [Mnemonic Table](#mnemonic-table) below
+* `OPERANDS` are registers, values or labels, as described in the [Operands](#operands) section
+* `COMMENT` is a 30 character comment describing the statement (may have a `#` preceding it)
 
 An example file:
 
@@ -111,6 +85,49 @@ An example file:
     data1    FDB     $FBEE     Two byte piece of data
 
 
+### Print Symbol Table
+
+To print the symbol table that is generated during assembly, use the `--symbols` 
+switch:
+
+    python assembler.py test.asm --symbols
+
+Which will have the following output:
+
+    -- Symbol Table --
+    0x0200 clear
+    0x0202 start
+    0x020A end
+    0x020C data
+    0x020E data1
+
+
+### Print Assembled Statements
+
+To print out the assembled version of the program, use the `--print` switch:
+
+    python assembler.py test.asm --print
+
+Which will have the following output:
+
+    -- Assembled Statements --
+    0x0200 0000                                   # A comment line that contains nothing    
+    0x0200 00E0      clear   CLR                  #                                         
+    0x0202 6100      start  LOAD           r1,$0  # Clear contents of register 1            
+    0x0204 7101              ADD           r1,$1  # Add 1 to the register                   
+    0x0206 310A              SKE           r1,$A  # Check to see if we are at 10            
+    0x0208 1202             JUMP           start  # Jump back to the start                  
+    0x020A 120A        end  JUMP             end  # Loop forever                            
+    0x020C 001A       data   FCB             $1A  # One byte piece of data                  
+    0x020E FBEE      data1   FDB           $FBEE  # Two byte piece of data           
+
+With this output, the first column is the offset in hex where the statement starts,
+the second column contains the full machine-code operand, the third column is the
+user-supplied label for the statement, the forth column is the mnemonic, the fifth
+column is the register values of other numeric or label data the operation will
+work on, and the fifth column is the comment string.
+
+
 ## Mnemonic Table
 
 The assembler supports mnemonics for both the Chip 8 and Super Chip 8 language
diff --git a/assembler.py b/assembler.py
new file mode 100644
index 0000000..da46025
--- /dev/null
+++ b/assembler.py
@@ -0,0 +1,67 @@
+"""
+Copyright (C) 2014-2018 Craig Thomas
+This project uses an MIT style license - see LICENSE for details.
+
+A Chip 8 assembler - see the README.md file for details.
+"""
+# I M P O R T S ###############################################################
+
+import argparse
+
+from chip8asm.program import Program
+
+# F U N C T I O N S ###########################################################
+
+
+def parse_arguments():
+    """
+    Parses the command-line arguments passed to the assembler.
+    """
+    parser = argparse.ArgumentParser(
+        description="Assemble or disassemble "
+        "machine language code for the Chip8. See README.md for more "
+        "information, and LICENSE for terms of use."
+    )
+    parser.add_argument("filename", help="the name of the file to examine")
+    parser.add_argument(
+        "--symbols", action="store_true", help="print out the symbol table"
+    )
+    parser.add_argument(
+        "--print", action="store_true",
+        help="print out the assembled statements when finished"
+    )
+    parser.add_argument(
+        "--output", metavar="FILE", help="stores the assembled program in FILE")
+    return parser.parse_args()
+
+
+def main(args):
+    """
+    Runs the assembler with the specified arguments.
+
+    @param args: the arguments to the main function
+    @type: namedtuple
+    """
+    program = Program()
+    program.parse_file(args.filename)
+    program.translate_statements()
+    program.set_addresses()
+    program.fix_opcodes()
+
+    if args.symbols:
+        print("-- Symbol Table --")
+        for symbol, value in program.get_symbol_table().items():
+            print("0x{} {}".format(value[2:].rjust(4, '0').upper(), symbol))
+
+    if args.print:
+        print("-- Assembled Statements --")
+        for statement in program.get_statements():
+            print(statement)
+
+    if args.output:
+        program.save_binary_file(args.output)
+
+
+main(parse_arguments())
+
+# E N D   O F   F I L E #######################################################
diff --git a/chip8asm/chip8asm.py b/chip8asm/chip8asm.py
deleted file mode 100644
index 2673879..0000000
--- a/chip8asm/chip8asm.py
+++ /dev/null
@@ -1,499 +0,0 @@
-"""
-Copyright (C) 2014-2018 Craig Thomas
-This project uses an MIT style license - see LICENSE for details.
-
-A Chip 8 assembler - see the README.md file for details.
-"""
-# I M P O R T S ###############################################################
-
-import argparse
-import re
-import sys
-
-# C O N S T A N T S ###########################################################
-
-LABEL = "label"
-OP = "op"
-OPERANDS = "operands"
-COMMENT = "comment"
-SOURCE = "source"
-TARGET = "target"
-NUMERIC = "numeric"
-SOURCE_REG = "s"
-TARGET_REG = "t"
-NUMERIC_REG = "n"
-
-# Opcode translation
-OPERATIONS = {
-    "SYS":
-        {OP: "0nnn", OPERANDS: 1, SOURCE: 0, TARGET: 0, NUMERIC: 3},
-    "CLR":
-        {OP: "00E0", OPERANDS: 0, SOURCE: 0, TARGET: 0, NUMERIC: 0},
-    "RTS":
-        {OP: "00EE", OPERANDS: 0, SOURCE: 0, TARGET: 0, NUMERIC: 0},
-    "JUMP":
-        {OP: "1nnn", OPERANDS: 1, SOURCE: 0, TARGET: 0, NUMERIC: 3},
-    "CALL":
-        {OP: "2nnn", OPERANDS: 1, SOURCE: 0, TARGET: 0, NUMERIC: 3},
-    "SKE":
-        {OP: "3snn", OPERANDS: 2, SOURCE: 1, TARGET: 0, NUMERIC: 2},
-    "SKNE":
-        {OP: "4snn", OPERANDS: 2, SOURCE: 1, TARGET: 0, NUMERIC: 2},
-    "SKRE":
-        {OP: "5st0", OPERANDS: 2, SOURCE: 1, TARGET: 1, NUMERIC: 0},
-    "LOAD":
-        {OP: "6snn", OPERANDS: 2, SOURCE: 1, TARGET: 0, NUMERIC: 2},
-    "ADD":
-        {OP: "7snn", OPERANDS: 2, SOURCE: 1, TARGET: 0, NUMERIC: 2},
-    "MOVE":
-        {OP: "8st0", OPERANDS: 2, SOURCE: 1, TARGET: 1, NUMERIC: 0},
-    "OR":
-        {OP: "8st1", OPERANDS: 2, SOURCE: 1, TARGET: 1, NUMERIC: 0},
-    "AND":
-        {OP: "8st2", OPERANDS: 2, SOURCE: 1, TARGET: 1, NUMERIC: 0},
-    "XOR":
-        {OP: "8st3", OPERANDS: 2, SOURCE: 1, TARGET: 1, NUMERIC: 0},
-    "ADDR":
-        {OP: "8st4", OPERANDS: 2, SOURCE: 1, TARGET: 1, NUMERIC: 0},
-    "SUB":
-        {OP: "8st5", OPERANDS: 2, SOURCE: 1, TARGET: 1, NUMERIC: 0},
-    "SHR":
-        {OP: "8st6", OPERANDS: 1, SOURCE: 1, TARGET: 1, NUMERIC: 0},
-    "SUBN":
-        {OP: "8st7", OPERANDS: 2, SOURCE: 1, TARGET: 1, NUMERIC: 0},
-    "SHL":
-        {OP: "8stE", OPERANDS: 1, SOURCE: 1, TARGET: 1, NUMERIC: 0},
-    "SKRNE":
-        {OP: "9st0", OPERANDS: 2, SOURCE: 1, TARGET: 1, NUMERIC: 0},
-    "LOADI":
-        {OP: "Annn", OPERANDS: 1, SOURCE: 0, TARGET: 0, NUMERIC: 3},
-    "JUMPI":
-        {OP: "Bnnn", OPERANDS: 1, SOURCE: 0, TARGET: 0, NUMERIC: 3},
-    "RAND":
-        {OP: "Ctnn", OPERANDS: 2, SOURCE: 0, TARGET: 1, NUMERIC: 2},
-    "DRAW":
-        {OP: "Dstn", OPERANDS: 3, SOURCE: 1, TARGET: 1, NUMERIC: 1},
-    "SKPR":
-        {OP: "Es9E", OPERANDS: 1, SOURCE: 1, TARGET: 0, NUMERIC: 0},
-    "SKUP":
-        {OP: "EsA1", OPERANDS: 1, SOURCE: 1, TARGET: 0, NUMERIC: 0},
-    "MOVED":
-        {OP: "Ft07", OPERANDS: 1, SOURCE: 0, TARGET: 1, NUMERIC: 0},
-    "KEYD":
-        {OP: "Ft0A", OPERANDS: 1, SOURCE: 0, TARGET: 1, NUMERIC: 0},
-    "LOADD":
-        {OP: "Fs15", OPERANDS: 1, SOURCE: 1, TARGET: 0, NUMERIC: 0},
-    "LOADS":
-        {OP: "Fs18", OPERANDS: 1, SOURCE: 1, TARGET: 0, NUMERIC: 0},
-    "ADDI":
-        {OP: "Fs1E", OPERANDS: 1, SOURCE: 1, TARGET: 0, NUMERIC: 0},
-    "LDSPR":
-        {OP: "Fs29", OPERANDS: 1, SOURCE: 1, TARGET: 0, NUMERIC: 0},
-    "BCD":
-        {OP: "Fs33", OPERANDS: 1, SOURCE: 1, TARGET: 0, NUMERIC: 0},
-    "STOR":
-        {OP: "Fs55", OPERANDS: 1, SOURCE: 1, TARGET: 0, NUMERIC: 0},
-    "READ":
-        {OP: "Fs65", OPERANDS: 1, SOURCE: 1, TARGET: 0, NUMERIC: 0},
-    # Super Chip 8 Instructions
-    "SCRD":
-        {OP: "00Cn", OPERANDS: 1, SOURCE: 0, TARGET: 0, NUMERIC: 1},
-    "SCRR":
-        {OP: "00FB", OPERANDS: 0, SOURCE: 0, TARGET: 0, NUMERIC: 0},
-    "SCRL":
-        {OP: "00FC", OPERANDS: 0, SOURCE: 0, TARGET: 0, NUMERIC: 0},
-    "EXIT":
-        {OP: "00FD", OPERANDS: 0, SOURCE: 0, TARGET: 0, NUMERIC: 0},
-    "EXTD":
-        {OP: "00FE", OPERANDS: 0, SOURCE: 0, TARGET: 0, NUMERIC: 0},
-    "EXTE":
-        {OP: "00FF", OPERANDS: 0, SOURCE: 0, TARGET: 0, NUMERIC: 0},
-    "SRPL":
-        {OP: "Fs75", OPERANDS: 1, SOURCE: 1, TARGET: 0, NUMERIC: 0},
-    "LRPL":
-        {OP: "Fs85", OPERANDS: 1, SOURCE: 1, TARGET: 0, NUMERIC: 0}
-}
-
-# Pseudo operations
-FCB = "FCB"
-FDB = "FDB"
-PSEUDO_OPERATIONS = [FCB, FDB]
-
-# Pattern to parse a single line
-ASM_LINE_REGEX = re.compile(
-    r"(?P<label>\w*)\s+(?P<op>\w*)\s+(?P<operands>[\w#$,+-]*)\s+(?P<comment>.*)"
-)
-
-# Pattern to match a register
-REG_LINE_REGEX = re.compile("[rR][0-9a-fA-F]$")
-
-# C L A S S E S ###############################################################
-
-
-class TranslationError(Exception):
-    """
-    Translation errors occur when the translate function is called from
-    within the Statement class. Translation errors usually refer to the fact
-    that an invalid mnemonic or invalid register was specified.
-    """
-    def __init__(self, value):
-        super(TranslationError, self).__init__()
-        self.value = value
-
-    def __str__(self):
-        return repr(self.value)
-
-
-class Statement(object):
-    """
-    The Statement class represents a single line of assembly language. Each
-    statement is constructed from a single line that has the following format:
-
-        LABEL   MNEMONIC   OPERANDS    COMMENT
-
-    The statement can be parsed and translated to its Chip8 machine code
-    equivalent.
-    """
-    def __init__(self):
-        self.opcode = ""
-        self.operation = ""
-        self.label = ""
-        self.operands = None
-        self.comment = ""
-        self.size = 0
-        self.source = ""
-        self.target = ""
-        self.numeric = ""
-        self.operation = None
-        self.address = ""
-
-    def __str__(self):
-        return "0x{} {} {} {} {}  # {}".format(
-            self.address[2:].upper().rjust(4, '0'),
-            self.opcode.upper().rjust(4, '0'),
-            self.label.rjust(10, ' '),
-            self.operation.rjust(5, ' '),
-            self.operands.rjust(15, ' '),
-            self.comment.ljust(40, ' ')
-        )
-
-    def parse_line(self, line):
-        """
-        Parse a line of assembly language text.
-        """
-        data = ASM_LINE_REGEX.match(line)
-        if data:
-            self.label = data.group(LABEL)
-            self.operation = data.group(OP)
-            self.operands = data.group(OPERANDS)
-            self.comment = data.group(COMMENT)
-
-    def translate(self):
-        """
-        Translate the text into an actual opcode.
-        """
-        if self.operation in PSEUDO_OPERATIONS:
-            self.source = 0
-            self.target = 0
-            self.numeric = 0
-            return
-
-        if self.operation not in OPERATIONS:
-            error = "Invalid mnemonic '{}'".format(self.operation)
-            raise TranslationError(error)
-
-        operation = self.get_operation()
-        self.opcode = operation[OP]
-        if self.operands:
-            operands = self.operands.split(",")
-
-            if len(operands) != operation[OPERANDS]:
-                error = "Expected {} operand(s), but got {}".format(
-                    operation[OPERANDS], len(operands)
-                )
-                raise TranslationError(error)
-
-            counter = 0
-            for operand_type in [SOURCE, TARGET, NUMERIC]:
-                if operation[operand_type] != 0:
-                    self.set_value(operand_type, operands[counter])
-                    counter += 1
-
-    def set_value(self, operand_type, operand):
-        """
-        Given the type of operand we expect, as well as an operand value,
-        set the operand to the correct value, checking to make sure that
-        the value type matches what we expect.
-
-        @param operand_type: the type of the operand we expect
-        @type: [ str ]
-
-        @param operand: the value of the operand we are passing in
-        @type: str
-        """
-        if operand_type == SOURCE or operand_type == TARGET:
-            setattr(self, operand_type, self.get_register(operand))
-        else:
-            setattr(self, operand_type, self.get_value(operand))
-
-    @staticmethod
-    def is_register(string):
-        """
-        Checks to see if a register is specified. Registers start with 'r' or
-        'R'. All registers are specified in hex - R0 through RF.
-
-        :param string: a string representing the operand
-        :return: True if the string is a register, False otherwise
-        """
-        return REG_LINE_REGEX.match(string) is not None
-
-    @staticmethod
-    def get_value(string):
-        """
-        Return the hex representation of the value if it starts with a '$'.
-        Otherwise, just return the value itself, since it is likely a label.
-
-        :param string: the string to scan
-        :return: the hex representation of the value, or the label
-        """
-        if string.startswith("$"):
-            return hex(int(string[1:], 16))
-        return string
-
-    def get_register(self, string):
-        """
-        Returns the register number specified.
-
-        @param string: the string representation of the register
-        @type string: str
-        """
-        if not self.is_register(string):
-            error = "Expected register in r0-rF, but got [{}]".format(string)
-            raise TranslationError(error)
-        if len(string) > 2:
-            error = "Invalid register [{}]".format(string)
-            raise TranslationError(error)
-        return hex(int(string[1:], 16))
-
-    def get_operation(self):
-        """
-        Returns the operation dictionary based upon the mnemonic.
-
-        :return: the operation dictionary based on the mnemonic
-        """
-        if self.is_pseudo_op():
-            return self.operation
-        return OPERATIONS[self.operation]
-
-    def is_pseudo_op(self):
-        """
-        Returns true if the assembly language statement is actually a pseudo op.
-
-        :return: True if the statement is a pseudo op, False otherwise
-        """
-        if self.operation in PSEUDO_OPERATIONS:
-            return True
-        return False
-
-    def is_empty(self):
-        """
-        Returns True if there is no label that is contained within the
-        statement.
-
-        :return: True if the statement is empty, False otherwise
-        """
-        return self.operation == ""
-
-    def get_label(self):
-        """
-        Returns the label associated with this statement.
-
-        :return: the label for this statement
-        """
-        return self.label
-
-    def replace_label(self, label, value):
-        """
-        Given a label and a value, replace the source, target, or numeric
-        values with the given value if they are a label.
-
-        @param label: the label to replace
-        @type label: str
-
-        @param value: the value to replace the label with
-        @type value: str
-        """
-        if self.source == label:
-            self.source = value
-        if self.target == label:
-            self.target = value
-        if self.numeric == label:
-            self.numeric = value
-
-    def fix_values(self):
-        """
-        Translate the source, target, and numeric values into the appropriate
-        parts of the opcode. For pseudo operations, simply copy the value to
-        the opcode.
-        """
-        if self.is_pseudo_op():
-            if self.operation == FCB or self.operation == FDB:
-                if not self.operands.startswith("$"):
-                    error = "Error: expected value starting with $, but got "\
-                        "{}".format(self.operands)
-                    raise TranslationError(error)
-                self.opcode = self.get_value(self.operands)[2:]
-        else:
-            operation = self.get_operation()
-            if operation[SOURCE] == 1:
-                source = self.source[2:]
-                if len(source) > 1:
-                    error = "Error: expected source in (0x0,0xF), but got {}"\
-                        .format(hex(int(self.source)))
-                    raise TranslationError(error)
-                self.opcode = self.opcode.replace(SOURCE_REG, source)
-            if operation[TARGET] == 1:
-                target = self.target[2:]
-                if len(target) > 1:
-                    error = "Error: expected target in (0x0,0xF), but got {}"\
-                        .format(hex(int(self.target)))
-                    raise TranslationError(error)
-                self.opcode = self.opcode.replace(TARGET_REG, target)
-            if operation[NUMERIC] != 0:
-                numeric = self.numeric[2:]
-                length = operation[NUMERIC]
-                if len(numeric) > length:
-                    error = "Error: expected numeric of length {}, but was {}"\
-                        .format(length, len(numeric))
-                    raise TranslationError(error)
-                numeric = numeric.zfill(length)
-                numeric_string = NUMERIC_REG * length
-                self.opcode = self.opcode.replace(numeric_string, numeric)
-
-    def set_address(self, address):
-        """
-        Set the address of the current operation in hex.
-
-        @param address: the address of the operation
-        @type address: str
-        """
-        self.address = address
-
-
-# F U N C T I O N S ###########################################################
-
-def parse_arguments():
-    """
-    Parses the command-line arguments passed to the assembler.
-    """
-    parser = argparse.ArgumentParser(
-        description="Assemble or disassemble "
-        "machine language code for the Chip8. See README.md for more "
-        "information, and LICENSE for terms of use."
-    )
-    parser.add_argument("filename", help="the name of the file to examine")
-    parser.add_argument(
-        "-s", action="store_true", help="print out the symbol table"
-    )
-    parser.add_argument(
-        "-p", action="store_true", help="print out the assembled statements when finished"
-    )
-    parser.add_argument(
-        "-o", metavar="FILE", help="stores the assembled program in FILE")
-    return parser.parse_args()
-
-
-def throw_error(error, statement):
-    """
-    Prints out an error message.
-
-    :param error: the error message to throw
-    :param statement: the assembly statement that caused the error
-    """
-    print error.value
-    print "Line: {}".format(str(statement))
-    sys.exit(1)
-
-
-def main(args):
-    """
-    Runs the assembler with the specified arguments.
-
-    @param args: the arguments to the main function
-    @type: namedtuple
-    """
-    symbol_table = dict()
-    statements = []
-    address = 0x200
-
-    # Pass 1: parse all of the statements in the file, but do not attempt
-    # to resolve any of the labels or locations
-    with open(args.filename) as infile:
-        for line in infile:
-            statement = Statement()
-            statement.parse_line(line)
-            if not statement.is_empty():
-                statements.append(statement)
-
-    # Pass 2: translate the statements into their respective opcodes
-    for index in xrange(len(statements)):
-        statement = statements[index]
-        try:
-            statement.translate()
-        except TranslationError as error:
-            throw_error(error, statement)
-        label = statement.get_label()
-        if label:
-            if label in symbol_table:
-                error = TranslationError("label [" + label + "] redefined")
-                throw_error(error, statement)
-            symbol_table[label] = index
-
-    # Pass 3: determine label addresses
-    for statement in statements:
-        label = statement.get_label()
-        if label:
-            symbol_table[label] = hex(address)
-        statement.set_address(hex(address))
-        if statement.operation == FCB:
-            address += 1
-        else:
-            address += 2
-
-    # Pass 4: translate operands into respective opcodes
-    for statement in statements:
-        for label, value in symbol_table.iteritems():
-            statement.replace_label(label, value)
-        try:
-            statement.fix_values()
-        except TranslationError as error:
-            throw_error(error, statement)
-
-    # Check to see if the user wanted to print the symbol table
-    if args.s:
-        print "-- Symbol Table --"
-        for symbol, value in symbol_table.iteritems():
-            print "{} {}".format(symbol, value)
-
-    # Check to see if the user wanted a print out of the assembly
-    if args.p:
-        print "-- Assembled Statements --"
-        for statement in statements:
-            print statement
-
-    # Check to see if the user wants to save the binary file
-    if args.o:
-        machine_codes = []
-        for statement in statements:
-            for index in xrange(0, len(statement.opcode), 2):
-                machine_codes.append(int(statement.opcode[index:index+2], 16))
-        with open(args.o, "wb") as outfile:
-            outfile.write(bytearray(machine_codes))
-
-# M A I N #####################################################################
-
-
-if __name__ == "__main__":
-    main(parse_arguments())
-
-# E N D   O F   F I L E #######################################################
diff --git a/chip8asm/exceptions.py b/chip8asm/exceptions.py
new file mode 100644
index 0000000..1237371
--- /dev/null
+++ b/chip8asm/exceptions.py
@@ -0,0 +1,37 @@
+"""
+Copyright (C) 2014-2019 Craig Thomas
+This project uses an MIT style license - see LICENSE for details.
+
+This file contains Exceptions for the Chip 8 Assembler.
+"""
+# C L A S S E S ###############################################################
+
+
+class TranslationError(Exception):
+    """
+    Translation errors occur when the translate function is called from
+    within the Statement class. Translation errors usually refer to the fact
+    that an invalid mnemonic or invalid register was specified.
+    """
+    def __init__(self, value):
+        super().__init__()
+        self.value = value
+
+    def __str__(self):
+        return repr(self.value)
+
+
+class ParseError(Exception):
+    """
+    Parse errors occur when the parse function is called from
+    within the Statement class. Parse errors usually refer to the fact
+    that an invalid line of assembly code was encountered.
+    """
+    def __init__(self, value):
+        super().__init__()
+        self.value = value
+
+    def __str__(self):
+        return repr(self.value)
+
+# E N D   O F   F I L E #######################################################
diff --git a/chip8asm/program.py b/chip8asm/program.py
new file mode 100644
index 0000000..21a2311
--- /dev/null
+++ b/chip8asm/program.py
@@ -0,0 +1,126 @@
+"""
+Copyright (C) 2014-2019 Craig Thomas
+This project uses an MIT style license - see LICENSE for details.
+
+This file contains the main Program class for the Chip 8 Assembler.
+"""
+# I M P O R T S ###############################################################
+
+import sys
+
+from chip8asm.exceptions import TranslationError
+from chip8asm.statement import Statement, FCB
+
+# C L A S S E S ###############################################################
+
+
+class Program(object):
+    """
+    The Program class represents an actual Chip 8 program. Each Program
+    contains a list of statements. Additionally, a Program keeps track of all
+    the user-defined symbols in the program.
+    """
+    def __init__(self):
+        self.symbol_table = dict()
+        self.statements = []
+        self.address = 0x200
+
+    def parse_file(self, filename):
+        """
+        Parses all of the lines in a file, and transforms each one into
+        a Statement.
+
+        :param filename: the name of the file to parse
+        """
+        with open(filename) as infile:
+            for line in infile:
+                statement = Statement()
+                statement.parse_line(line)
+                if not statement.is_empty():
+                    self.statements.append(statement)
+
+    def translate_statements(self):
+        """
+        Translates all the parsed statements into their respective
+        opcodes.
+        """
+        for index, statement in enumerate(self.statements):
+            try:
+                statement.translate()
+            except TranslationError as error:
+                self.throw_error(error, statement)
+            label = statement.get_label()
+            if label:
+                if label in self.symbol_table:
+                    error = TranslationError("label [" + label + "] redefined")
+                    self.throw_error(error, statement)
+                self.symbol_table[label] = index
+
+    def set_addresses(self):
+        """
+        Determines the address that each label refers to.
+        """
+        for statement in self.statements:
+            label = statement.get_label()
+            if label:
+                self.symbol_table[label] = hex(self.address)
+            statement.set_address(hex(self.address))
+            if not statement.comment_only and not statement.is_empty():
+                self.address += 1 if statement.operation == FCB else 2
+
+    def fix_opcodes(self):
+        """
+        Calculates the final opcode for each statement in the program.
+        """
+        for statement in self.statements:
+            for label, value in self.symbol_table.items():
+                statement.replace_label(label, value[2:])
+            try:
+                statement.fix_values()
+            except TranslationError as error:
+                self.throw_error(error, statement)
+
+    def get_symbol_table(self):
+        """
+        Returns the symbol table dictionary for the parsed program.
+
+        :return: the symbol table for the program
+        """
+        return self.symbol_table
+
+    def get_statements(self):
+        """
+        Returns the statements that make up the program.
+
+        :return: the statements for the program
+        """
+        return self.statements
+
+    def save_binary_file(self, filename):
+        """
+        Writes out the assembled statements to the specified file
+        name.
+
+        :param filename: the name of the file to save statements
+        """
+        machine_codes = []
+        for statement in self.statements:
+            if not statement.is_empty() and not statement.comment_only:
+                for index in range(0, len(statement.op_code), 2):
+                    machine_codes.append(int(statement.op_code[index:index + 2], 16))
+        with open(filename, "wb") as outfile:
+            outfile.write(bytearray(machine_codes))
+
+    @staticmethod
+    def throw_error(error, statement):
+        """
+        Prints out an error message.
+
+        :param error: the error message to throw
+        :param statement: the assembly statement that caused the error
+        """
+        print(error.value)
+        print("line: {}".format(str(statement)))
+        sys.exit(1)
+
+# E N D   O F   F I L E #######################################################
diff --git a/chip8asm/statement.py b/chip8asm/statement.py
new file mode 100644
index 0000000..ca16764
--- /dev/null
+++ b/chip8asm/statement.py
@@ -0,0 +1,371 @@
+"""
+Copyright (C) 2014-2019 Craig Thomas
+This project uses an MIT style license - see LICENSE for details.
+
+This file contains Exceptions for the Chip 8 Assembler.
+"""
+# I M P O R T S ###############################################################
+
+import re
+
+from collections import namedtuple
+from copy import copy
+
+from chip8asm.exceptions import TranslationError, ParseError
+
+# C O N S T A N T S ###########################################################
+
+SOURCE = "source"
+TARGET = "target"
+NUMERIC = "numeric"
+SOURCE_REG = "s"
+TARGET_REG = "t"
+NUMERIC_REG = "n"
+
+Operation = namedtuple('Operation', ['mnemonic', 'op', 'operands', 'source', 'target', 'numeric'])
+
+OPERATIONS = [
+    Operation(op="0nnn", operands=1, source=0, target=0, numeric=3, mnemonic="SYS"),
+    Operation(op="00E0", operands=0, source=0, target=0, numeric=0, mnemonic="CLR"),
+    Operation(op="00EE", operands=0, source=0, target=0, numeric=0, mnemonic="RTS"),
+    Operation(op="1nnn", operands=1, source=0, target=0, numeric=3, mnemonic="JUMP"),
+    Operation(op="2nnn", operands=1, source=0, target=0, numeric=3, mnemonic="CALL"),
+    Operation(op="3snn", operands=2, source=1, target=0, numeric=2, mnemonic="SKE"),
+    Operation(op="4snn", operands=2, source=1, target=0, numeric=2, mnemonic="SKNE"),
+    Operation(op="5st0", operands=2, source=1, target=1, numeric=0, mnemonic="SKRE"),
+    Operation(op="6snn", operands=2, source=1, target=0, numeric=2, mnemonic="LOAD"),
+    Operation(op="7snn", operands=2, source=1, target=0, numeric=2, mnemonic="ADD"),
+    Operation(op="8st0", operands=2, source=1, target=1, numeric=0, mnemonic="MOVE"),
+    Operation(op="8st1", operands=2, source=1, target=1, numeric=0, mnemonic="OR"),
+    Operation(op="8st2", operands=2, source=1, target=1, numeric=0, mnemonic="AND"),
+    Operation(op="8st3", operands=2, source=1, target=1, numeric=0, mnemonic="XOR"),
+    Operation(op="8st4", operands=2, source=1, target=1, numeric=0, mnemonic="ADDR"),
+    Operation(op="8st5", operands=2, source=1, target=1, numeric=0, mnemonic="SUB"),
+    Operation(op="8st6", operands=1, source=1, target=1, numeric=0, mnemonic="SHR"),
+    Operation(op="8st7", operands=2, source=1, target=1, numeric=0, mnemonic="SUBN"),
+    Operation(op="8stE", operands=1, source=1, target=1, numeric=0, mnemonic="SHL"),
+    Operation(op="9st0", operands=2, source=1, target=1, numeric=0, mnemonic="SKRNE"),
+    Operation(op="Annn", operands=1, source=0, target=0, numeric=3, mnemonic="LOADI"),
+    Operation(op="Bnnn", operands=1, source=0, target=0, numeric=3, mnemonic="JUMPI"),
+    Operation(op="Ctnn", operands=2, source=0, target=1, numeric=2, mnemonic="RAND"),
+    Operation(op="Dstn", operands=3, source=1, target=1, numeric=1, mnemonic="DRAW"),
+    Operation(op="Es9E", operands=1, source=1, target=0, numeric=0, mnemonic="SKPR"),
+    Operation(op="EsA1", operands=1, source=1, target=0, numeric=0, mnemonic="SKUP"),
+    Operation(op="Ft07", operands=1, source=0, target=1, numeric=0, mnemonic="MOVED"),
+    Operation(op="Ft0A", operands=1, source=0, target=1, numeric=0, mnemonic="KEYD"),
+    Operation(op="Fs15", operands=1, source=1, target=0, numeric=0, mnemonic="LOADD"),
+    Operation(op="Fs18", operands=1, source=1, target=0, numeric=0, mnemonic="LOADS"),
+    Operation(op="Fs1E", operands=1, source=1, target=0, numeric=0, mnemonic="ADDI"),
+    Operation(op="Fs29", operands=1, source=1, target=0, numeric=0, mnemonic="LDSPR"),
+    Operation(op="Fs33", operands=1, source=1, target=0, numeric=0, mnemonic="BCD"),
+    Operation(op="Fs55", operands=1, source=1, target=0, numeric=0, mnemonic="STOR"),
+    Operation(op="Fs65", operands=1, source=1, target=0, numeric=0, mnemonic="READ"),
+    # Super Chip 8 Instructions
+    Operation(op="00Cn", operands=1, source=0, target=0, numeric=1, mnemonic="SCRD"),
+    Operation(op="00FB", operands=0, source=0, target=0, numeric=0, mnemonic="SCRR"),
+    Operation(op="00FC", operands=0, source=0, target=0, numeric=0, mnemonic="SCRL"),
+    Operation(op="00FD", operands=0, source=0, target=0, numeric=0, mnemonic="EXIT"),
+    Operation(op="00FE", operands=0, source=0, target=0, numeric=0, mnemonic="EXTD"),
+    Operation(op="00FF", operands=0, source=0, target=0, numeric=0, mnemonic="EXTE"),
+    Operation(op="Fs75", operands=1, source=1, target=0, numeric=0, mnemonic="SRPL"),
+    Operation(op="Fs85", operands=1, source=1, target=0, numeric=0, mnemonic="LRPL")
+]
+
+# Pseudo operations
+FCB = "FCB"
+FDB = "FDB"
+PSEUDO_OPERATIONS = [FCB, FDB]
+
+# Pattern to recognize a blank line
+BLANK_LINE_REGEX = re.compile(r"^\s*$")
+
+# Pattern to parse a comment line
+COMMENT_LINE_REGEX = re.compile(r"^\s*#\s*(?P<comment>.*)$")
+
+# Pattern to parse a single line
+ASM_LINE_REGEX = re.compile(
+    r"^(?P<label>\w*)\s+(?P<mnemonic>\w*)\s+(?P<operands>[\w$,+-]*)\s*[#]*\s*(?P<comment>.*)$"
+)
+
+# Pattern to match a register
+REG_LINE_REGEX = re.compile("[rR][0-9a-fA-F]$")
+
+# C L A S S E S ###############################################################
+
+
+class Statement(object):
+    """
+    The Statement class represents a single line of assembly language. Each
+    statement is constructed from a single line that has the following format:
+
+        LABEL   MNEMONIC   OPERANDS    COMMENT
+
+    The statement can be parsed and translated to its Chip8 machine code
+    equivalent.
+    """
+    def __init__(self):
+        self.empty = True
+        self.comment_only = False
+        self.operation = None
+        self.label = None
+        self.operands = None
+        self.comment = None
+        self.size = 0
+        self.address = None
+        self.mnemonic = None
+        self.op_code = None
+        self.source = None
+        self.target = None
+        self.numeric = None
+
+    def __str__(self):
+        return "0x{} {} {} {} {}  # {}".format(
+            self.get_address()[2:].upper().rjust(4, '0'),
+            self.get_op_code().upper().rjust(4, '0'),
+            self.get_label().rjust(10, ' '),
+            self.get_mnemonic().rjust(5, ' '),
+            self.get_operands().rjust(15, ' '),
+            self.get_comment().ljust(40, ' ')
+        )
+
+    @staticmethod
+    def is_register(string):
+        """
+        Checks to see if a register is specified. Registers start with 'r' or
+        'R'. All registers are specified in hex - R0 through RF.
+
+        :param string: a string representing the operand
+        :return: True if the string is a register, False otherwise
+        """
+        return REG_LINE_REGEX.match(string) is not None
+
+    @staticmethod
+    def get_value(string):
+        """
+        Return the hex representation of the value if it starts with a '$'.
+        Otherwise, just return the value itself, since it is likely a label.
+
+        :param string: the string to scan
+        :return: the hex representation of the value, or the label
+        """
+        return hex(int(string[1:], 16))[2:].upper() if string.startswith("$") else string
+
+    @staticmethod
+    def get_register(string):
+        """
+        Returns the register number specified.
+
+        :param string: the hex representation of the register number
+        """
+        if not Statement.is_register(string):
+            raise TranslationError("expected register in r0-rF, but got [{}]".format(string))
+        if len(string) > 2:
+            raise TranslationError("invalid register [{}]".format(string))
+        return hex(int(string[1:], 16))[-1].upper()
+
+    def is_pseudo_op(self):
+        """
+        Returns true if the assembly language statement is actually a pseudo op.
+
+        :return: True if the statement is a pseudo op, False otherwise
+        """
+        return self.mnemonic in PSEUDO_OPERATIONS
+
+    def has_comment(self):
+        """
+        Returns True if there is a comment for the statement.
+
+        :return: True if there is a comment, False otherwise
+        """
+        return self.comment is not None
+
+    def is_empty(self):
+        """
+        Returns True if there is no operation that is contained within the
+        statement.
+
+        :return: True if the statement is empty, False otherwise
+        """
+        return self.empty
+
+    def get_label(self):
+        """
+        Returns the label associated with this statement.
+
+        :return: the label for this statement
+        """
+        return self.label or ""
+
+    def get_comment(self):
+        """
+        Returns the comment for this statement.
+
+        :return: the comment for this statement
+        """
+        return self.comment or ""
+
+    def get_address(self):
+        """
+        Returns the address for this statement.
+
+        :return: the address for this statement
+        """
+        return self.address or ""
+
+    def set_address(self, address):
+        """
+        Set the address of the current operation in hex.
+
+        :param address: the address of the operation
+        """
+        self.address = address
+
+    def get_mnemonic(self):
+        """
+        Returns the mnemonic for this statement.
+
+        :return: the mnemonic for this statement
+        """
+        return self.mnemonic or ""
+
+    def get_op_code(self):
+        """
+        Returns the operation code for this statement.
+
+        :return: the operation code for this statement
+        """
+        return self.op_code or ""
+
+    def get_operands(self):
+        """
+        Returns the operands for this statement.
+
+        :return: the operands for this statement
+        """
+        return self.operands or ""
+
+    def parse_line(self, line):
+        """
+        Parse a line of assembly language text.
+        """
+        if BLANK_LINE_REGEX.search(line):
+            return
+
+        data = COMMENT_LINE_REGEX.match(line)
+        if data:
+            self.empty = False
+            self.comment_only = True
+            self.comment = data.group("comment").strip()
+            return
+
+        data = ASM_LINE_REGEX.match(line)
+        if data:
+            self.label = data.group("label") or None
+            self.mnemonic = data.group("mnemonic") or None
+            self.operands = data.group("operands") or None
+            self.comment = data.group("comment").strip() or None
+            self.empty = False
+            return
+
+        raise ParseError("could not parse line [{}]".format(line))
+
+    def translate(self):
+        """
+        Translate the mnemonic into an actual operation.
+        """
+        if self.comment_only:
+            return
+
+        if self.is_pseudo_op():
+            if not self.operands:
+                raise TranslationError(
+                    "pseudo operation [{}] requires 1 operand".format(
+                        self.mnemonic
+                    )
+                )
+            return
+
+        for operation in OPERATIONS:
+            if operation.mnemonic == self.mnemonic:
+                self.operation = copy(operation)
+                break
+
+        if not self.operation:
+            raise TranslationError("invalid mnemonic [{}]'".format(self.mnemonic))
+
+        operands = self.operands.split(",") if self.operands else []
+        num_operands = len(operands)
+        if num_operands != self.operation.operands:
+            raise TranslationError(
+                "expected {} operand(s), but got {}".format(
+                    self.operation.operands, num_operands
+                )
+            )
+
+        operand_counter = 0
+        if self.operation.source != 0:
+            self.source = self.get_register(operands[operand_counter])
+            operand_counter += 1
+
+        if self.operation.target != 0:
+            self.target = self.get_register(operands[operand_counter])
+            operand_counter += 1
+
+        if self.operation.numeric != 0:
+            self.numeric = self.get_value(operands[operand_counter])
+
+    def replace_label(self, label, value):
+        """
+        Given a label and a value, replace the source, target, or numeric
+        values with the given value if they are a label.
+
+        :param label: the label to replace
+        :param value: the value to replace the label with
+        """
+        self.source = value if self.source == label else self.source
+        self.target = value if self.target == label else self.target
+        self.numeric = value if self.numeric == label else self.numeric
+
+    def fix_values(self):
+        """
+        Translate the source, target, and numeric values into the appropriate
+        parts of the op code. For pseudo operations, simply copy the value to
+        the op code.
+        """
+        if self.comment_only:
+            return
+
+        if self.is_pseudo_op():
+            if not self.operands.startswith("$"):
+                raise TranslationError(
+                    "expected value starting with $, but got {}".format(
+                        self.operands
+                    )
+                )
+            self.op_code = self.get_value(self.operands)
+            return
+
+        self.op_code = self.operation.op
+        if self.operation.source == 1:
+            if len(self.source) > 1:
+                raise TranslationError(
+                    "expected source in 0-F, but got {}".format(self.source)
+                )
+            self.op_code = self.op_code.replace(SOURCE_REG, self.source)
+        if self.operation.target == 1:
+            if len(self.target) > 1:
+                raise TranslationError(
+                    "expected target in 0-F, but got {}".format(self.target)
+                )
+            self.op_code = self.op_code.replace(TARGET_REG, self.target)
+        if self.operation.numeric != 0:
+            if len(self.numeric) > self.operation.numeric:
+                raise TranslationError("expected numeric of length {}, but was length {} [{}]".format(
+                    self.operation.numeric, len(self.numeric), self.numeric)
+                )
+            numeric = self.numeric.zfill(self.operation.numeric)
+            numeric_string = NUMERIC_REG * self.operation.numeric
+            self.op_code = self.op_code.replace(numeric_string, numeric)
+
+
+# E N D   O F   F I L E #######################################################
diff --git a/codecov.yml b/codecov.yml
new file mode 100644
index 0000000..e0071a2
--- /dev/null
+++ b/codecov.yml
@@ -0,0 +1,22 @@
+coverage:
+  precision: 2
+  round: down
+  range: "70...100"
+
+  status:
+    project:
+      default: on
+    patch:
+      default: on
+    changes:
+      default: off
+
+comment:
+  layout: "header, reach, diff, flags, files, footer"
+  behavior: default
+  require_changes: no
+  require_base: no
+  require_head: yes
+
+ignore:
+  - "test/.*"
\ No newline at end of file
diff --git a/requirements.txt b/requirements.txt
new file mode 100644
index 0000000..e0d7513
--- /dev/null
+++ b/requirements.txt
@@ -0,0 +1,2 @@
+nose
+coverage
\ No newline at end of file
diff --git a/test/__init__.py b/test/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/test/test_exceptions.py b/test/test_exceptions.py
new file mode 100644
index 0000000..31cb777
--- /dev/null
+++ b/test/test_exceptions.py
@@ -0,0 +1,45 @@
+"""
+Copyright (C) 2012-2019 Craig Thomas
+This project uses an MIT style license - see LICENSE for details.
+
+A Chip 8 assembler - see the README.md file for details.
+"""
+# I M P O R T S ###############################################################
+
+import unittest
+
+from chip8asm.exceptions import TranslationError, ParseError
+
+# C L A S S E S ###############################################################
+
+
+class TestTranslationError(unittest.TestCase):
+    """
+    A test class for the Chip 8 TranslationError class.
+    """
+    def setUp(self):
+        """
+        Common setup routines needed for all unit tests.
+        """
+        pass
+
+    def test_string_representation(self):
+        translation_error = TranslationError("translation error")
+        self.assertEqual("'translation error'", str(translation_error))
+
+
+class TestParseError(unittest.TestCase):
+    """
+    A test class for the Chip 8 ParseError class.
+    """
+    def setUp(self):
+        """
+        Common setup routines needed for all unit tests.
+        """
+        pass
+
+    def test_string_representation(self):
+        parse_error = ParseError("parse error")
+        self.assertEqual("'parse error'", str(parse_error))
+
+# E N D   O F   F I L E #######################################################
diff --git a/test/test_program.py b/test/test_program.py
new file mode 100644
index 0000000..c7106e3
--- /dev/null
+++ b/test/test_program.py
@@ -0,0 +1,42 @@
+"""
+Copyright (C) 2012-2019 Craig Thomas
+This project uses an MIT style license - see LICENSE for details.
+
+A Chip 8 assembler - see the README.md file for details.
+"""
+# I M P O R T S ###############################################################
+
+import unittest
+
+from chip8asm.program import Program
+from chip8asm.statement import Statement
+
+# C L A S S E S ###############################################################
+
+
+class TestProgram(unittest.TestCase):
+    """
+    A test class for the Chip 8 Program class.
+    """
+    def setUp(self):
+        """
+        Common setup routines needed for all unit tests.
+        """
+        pass
+
+    def test_get_symbol_table_correct(self):
+        program = Program()
+        self.assertEqual(dict(), program.get_symbol_table())
+        program.symbol_table = dict(test="blah")
+        self.assertEqual(dict(test="blah"), program.get_symbol_table())
+
+    def test_get_statements_correct(self):
+        program = Program()
+        statement = Statement()
+
+        self.assertEqual([], program.get_statements())
+        program.statements.append(statement)
+        self.assertEqual([statement], program.get_statements())
+
+
+# E N D   O F   F I L E #######################################################
diff --git a/test/test_statement.py b/test/test_statement.py
new file mode 100644
index 0000000..394389b
--- /dev/null
+++ b/test/test_statement.py
@@ -0,0 +1,290 @@
+"""
+Copyright (C) 2012-2019 Craig Thomas
+This project uses an MIT style license - see LICENSE for details.
+
+A Chip 8 assembler - see the README.md file for details.
+"""
+# I M P O R T S ###############################################################
+
+import unittest
+
+from chip8asm.statement import Statement, OPERATIONS
+from chip8asm.exceptions import ParseError, TranslationError
+
+# C L A S S E S ###############################################################
+
+
+class TestStatement(unittest.TestCase):
+    """
+    A test class for the Chip 8 Statement class.
+    """
+    def setUp(self):
+        """
+        Common setup routines needed for all unit tests.
+        """
+        pass
+
+    def test_is_register_recognizes_only_registers(self):
+        self.assertTrue(Statement.is_register("r0"))
+        self.assertTrue(Statement.is_register("r1"))
+        self.assertTrue(Statement.is_register("r2"))
+        self.assertTrue(Statement.is_register("r3"))
+        self.assertTrue(Statement.is_register("r4"))
+        self.assertTrue(Statement.is_register("r5"))
+        self.assertTrue(Statement.is_register("r6"))
+        self.assertTrue(Statement.is_register("r7"))
+        self.assertTrue(Statement.is_register("r8"))
+        self.assertTrue(Statement.is_register("r9"))
+        self.assertTrue(Statement.is_register("ra"))
+        self.assertTrue(Statement.is_register("rb"))
+        self.assertTrue(Statement.is_register("rc"))
+        self.assertTrue(Statement.is_register("rd"))
+        self.assertTrue(Statement.is_register("re"))
+        self.assertTrue(Statement.is_register("rf"))
+
+        self.assertTrue(Statement.is_register("rA"))
+        self.assertTrue(Statement.is_register("rB"))
+        self.assertTrue(Statement.is_register("rC"))
+        self.assertTrue(Statement.is_register("rD"))
+        self.assertTrue(Statement.is_register("rE"))
+        self.assertTrue(Statement.is_register("rF"))
+
+        self.assertTrue(Statement.is_register("R0"))
+        self.assertTrue(Statement.is_register("R1"))
+        self.assertTrue(Statement.is_register("R2"))
+        self.assertTrue(Statement.is_register("R3"))
+        self.assertTrue(Statement.is_register("R4"))
+        self.assertTrue(Statement.is_register("R5"))
+        self.assertTrue(Statement.is_register("R6"))
+        self.assertTrue(Statement.is_register("R7"))
+        self.assertTrue(Statement.is_register("R8"))
+        self.assertTrue(Statement.is_register("R9"))
+        self.assertTrue(Statement.is_register("Ra"))
+        self.assertTrue(Statement.is_register("Rb"))
+        self.assertTrue(Statement.is_register("Rc"))
+        self.assertTrue(Statement.is_register("Rd"))
+        self.assertTrue(Statement.is_register("Re"))
+        self.assertTrue(Statement.is_register("Rf"))
+
+        self.assertTrue(Statement.is_register("RA"))
+        self.assertTrue(Statement.is_register("RB"))
+        self.assertTrue(Statement.is_register("RC"))
+        self.assertTrue(Statement.is_register("RD"))
+        self.assertTrue(Statement.is_register("RE"))
+        self.assertTrue(Statement.is_register("RF"))
+
+    def test_is_register_rejects_bad_register_names(self):
+        self.assertFalse(Statement.is_register("R11"))
+        self.assertFalse(Statement.is_register("r11"))
+        self.assertFalse(Statement.is_register("R"))
+        self.assertFalse(Statement.is_register("r"))
+        self.assertFalse(Statement.is_register("register"))
+
+    def test_get_value_returns_hex(self):
+        self.assertEqual('10', Statement.get_value("$10"))
+
+    def test_get_register_correct(self):
+        self.assertEqual('0', Statement.get_register("r0"))
+        self.assertEqual('1', Statement.get_register("r1"))
+        self.assertEqual('2', Statement.get_register("r2"))
+        self.assertEqual('3', Statement.get_register("r3"))
+        self.assertEqual('4', Statement.get_register("r4"))
+        self.assertEqual('5', Statement.get_register("r5"))
+        self.assertEqual('6', Statement.get_register("r6"))
+        self.assertEqual('7', Statement.get_register("r7"))
+        self.assertEqual('8', Statement.get_register("r8"))
+        self.assertEqual('9', Statement.get_register("r9"))
+        self.assertEqual('A', Statement.get_register("rA"))
+        self.assertEqual('B', Statement.get_register("rB"))
+        self.assertEqual('C', Statement.get_register("rC"))
+        self.assertEqual('D', Statement.get_register("rD"))
+        self.assertEqual('E', Statement.get_register("rE"))
+        self.assertEqual('F', Statement.get_register("rF"))
+        self.assertEqual('0', Statement.get_register("R0"))
+        self.assertEqual('1', Statement.get_register("R1"))
+        self.assertEqual('2', Statement.get_register("R2"))
+        self.assertEqual('3', Statement.get_register("R3"))
+        self.assertEqual('4', Statement.get_register("R4"))
+        self.assertEqual('5', Statement.get_register("R5"))
+        self.assertEqual('6', Statement.get_register("R6"))
+        self.assertEqual('7', Statement.get_register("R7"))
+        self.assertEqual('8', Statement.get_register("R8"))
+        self.assertEqual('9', Statement.get_register("R9"))
+        self.assertEqual('A', Statement.get_register("RA"))
+        self.assertEqual('B', Statement.get_register("RB"))
+        self.assertEqual('C', Statement.get_register("RC"))
+        self.assertEqual('D', Statement.get_register("RD"))
+        self.assertEqual('E', Statement.get_register("RE"))
+        self.assertEqual('F', Statement.get_register("RF"))
+
+    def test_get_register_bad_register(self):
+        with self.assertRaises(TranslationError):
+            Statement.get_register("r11")
+
+    def test_is_pseudo_op_correct(self):
+        statement = Statement()
+        statement.mnemonic = "FDB"
+        self.assertTrue(statement.is_pseudo_op())
+        statement.mnemonic = "FCB"
+        self.assertTrue(statement.is_pseudo_op())
+        statement.mnemonic = "BLAH"
+        self.assertFalse(statement.is_pseudo_op())
+
+    def test_has_comment_correct(self):
+        statement = Statement()
+        self.assertFalse(statement.has_comment())
+        statement.comment = "blah"
+        self.assertTrue(statement.has_comment())
+
+    def test_is_empty_correct(self):
+        statement = Statement()
+        self.assertTrue(statement.is_empty())
+        statement.empty = False
+        self.assertFalse(statement.is_empty())
+
+    def test_get_label_correct(self):
+        statement = Statement()
+        self.assertEquals("", statement.get_label())
+        statement.label = "label"
+        self.assertEqual("label", statement.get_label())
+
+    def test_get_comment_correct(self):
+        statement = Statement()
+        self.assertEquals("", statement.get_comment())
+        statement.comment = "comment"
+        self.assertEqual("comment", statement.get_comment())
+
+    def test_get_mnemonic_correct(self):
+        statement = Statement()
+        self.assertEquals("", statement.get_mnemonic())
+        statement.mnemonic = "mnemonic"
+        self.assertEqual("mnemonic", statement.get_mnemonic())
+
+    def test_get_op_code_correct(self):
+        statement = Statement()
+        self.assertEquals("", statement.get_op_code())
+        statement.op_code = "op_code"
+        self.assertEqual("op_code", statement.get_op_code())
+
+    def test_get_operands_correct(self):
+        statement = Statement()
+        self.assertEquals("", statement.get_operands())
+        statement.operands = "operands"
+        self.assertEqual("operands", statement.get_operands())
+
+    def test_get_address_correct(self):
+        statement = Statement()
+        self.assertEquals("", statement.get_address())
+        statement.address = "address"
+        self.assertEqual("address", statement.get_address())
+
+    def test_set_address_correct(self):
+        statement = Statement()
+        self.assertEquals("", statement.get_address())
+        statement.set_address("address")
+        self.assertEqual("address", statement.get_address())
+
+    def test_parsing_recognizes_blank_line(self):
+        statement = Statement()
+        statement.parse_line("    ")
+        self.assertFalse(statement.has_comment())
+        self.assertIsNone(statement.comment)
+        self.assertIsNone(statement.operation)
+        self.assertIsNone(statement.label)
+        self.assertIsNone(statement.operands)
+        self.assertIsNone(statement.address)
+        self.assertIsNone(statement.mnemonic)
+        self.assertEqual(0, statement.size)
+
+    def test_parsing_recognizes_comment_line(self):
+        statement = Statement()
+        statement.parse_line("# This is a comment")
+        self.assertTrue(statement.has_comment())
+        self.assertEqual("This is a comment", statement.comment)
+        self.assertIsNone(statement.operation)
+        self.assertIsNone(statement.label)
+        self.assertIsNone(statement.operands)
+        self.assertIsNone(statement.address)
+        self.assertIsNone(statement.mnemonic)
+        self.assertEqual(0, statement.size)
+
+    def test_parsing_correct_asm_line(self):
+        statement = Statement()
+        statement.parse_line("label mnemonic operands # comment")
+        self.assertTrue(statement.has_comment())
+        self.assertEqual("comment", statement.comment)
+        self.assertIsNone(statement.operation)
+        self.assertEqual("label", statement.label)
+        self.assertEqual("operands", statement.operands)
+        self.assertIsNone(statement.address)
+        self.assertEqual("mnemonic", statement.mnemonic)
+        self.assertEqual(0, statement.size)
+
+    def test_parse_bad_line_raises_error(self):
+        statement = Statement()
+        with self.assertRaises(ParseError):
+            statement.parse_line("bad")
+
+    def test_translate_pseudo_op_does_nothing(self):
+        statement = Statement()
+        statement.parse_line("    FDB $FFEE")
+        statement.translate()
+        self.assertFalse(statement.has_comment())
+        self.assertIsNone(statement.comment)
+        self.assertIsNone(statement.operation)
+        self.assertIsNone(statement.label)
+        self.assertEqual("FDB", statement.mnemonic)
+        self.assertEqual("$FFEE", statement.operands)
+        self.assertIsNone(statement.address)
+        self.assertEqual(0, statement.size)
+
+    def test_translate_pseudo_bad_num_operands_raises_error(self):
+        statement = Statement()
+        statement.parse_line("    FDB")
+        with self.assertRaises(TranslationError):
+            statement.translate()
+
+    def test_translate_valid_line_correct(self):
+        statement = Statement()
+        statement.parse_line("label SKRNE r1,r2 # comment")
+        statement.translate()
+        self.assertTrue(statement.has_comment())
+        self.assertEqual("comment", statement.comment)
+        self.assertEqual(OPERATIONS[19], statement.operation)
+        self.assertEqual("label", statement.label)
+        self.assertEqual("SKRNE", statement.mnemonic)
+        self.assertEqual("r1,r2", statement.operands)
+        self.assertIsNone(statement.address)
+        self.assertEqual(0, statement.size)
+
+    def test_translate_bad_mnemonic_raises_error(self):
+        statement = Statement()
+        statement.parse_line("label BLAH r1,r2 # comment")
+        with self.assertRaises(TranslationError):
+            statement.translate()
+
+    def test_translate_bad_num_operands_raises_error(self):
+        statement = Statement()
+        statement.parse_line("label JUMP  # comment")
+        with self.assertRaises(TranslationError):
+            statement.translate()
+
+    def test_replace_label_correct(self):
+        statement = Statement()
+        statement.source = "source"
+        statement.target = "target"
+        statement.numeric = "numeric"
+        statement.replace_label("source", "replaced source")
+        self.assertEqual("replaced source", statement.source)
+        self.assertEqual("target", statement.target)
+        self.assertEqual("numeric", statement.numeric)
+        statement.replace_label("target", "replaced target")
+        self.assertEqual("replaced source", statement.source)
+        self.assertEqual("replaced target", statement.target)
+        self.assertEqual("numeric", statement.numeric)
+        statement.replace_label("numeric", "replaced numeric")
+        self.assertEqual("replaced source", statement.source)
+        self.assertEqual("replaced target", statement.target)
+        self.assertEqual("replaced numeric", statement.numeric)
+
+# E N D   O F   F I L E #######################################################