lc3spec 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6d874750aeeb6b7c7659d5c68945fdf7d062d97f
+  data.tar.gz: e112c5c35204cf1e18567aaece03b4e9cc18a19a
+SHA512:
+  metadata.gz: 3589a767df9570d047bd4d7927d5cfdd78cdcf23017ec3f16e13b81366197f4d2479f247cc8a6eb46f8a97fdc693f7e1d18f6939f67c894d24fe245d7a80bdc1
+  data.tar.gz: deab9fada997b3b30cd4bbe5f8a5ea9efdd7e0fe2599899c1a9d2a1ee2c918196d45b85d7d648389466b96b7d0a8e90d4c2cd1eba3c125c5d1e7ece44442684e

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2013 Chun Yang
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,7 @@
+# LC3Spec
+
+Testing and grading suite for LC-3 assembly programs
+
+# Requirements
+
+* [lc3tools for unix](http://highered.mcgraw-hill.com/sites/0072467509/student_view0/lc-3_simulator.html)

data/lib/lc3spec/base.rb

@@ -0,0 +1,207 @@
+require 'open3'
+require 'timeout'
+
+require 'lc3spec/constants'
+require 'lc3spec/errors'
+require 'lc3spec/expectations'
+require 'lc3spec/lc3'
+require 'lc3spec/helpers'
+require 'lc3spec/reporter'
+
+module LC3Spec
+  class Test
+    include LC3Spec::Helpers
+
+    attr_accessor :pass, :reporter
+
+    def initialize(options, &block)
+      # Save src_dir
+      @src_dir = File.expand_path(Dir.pwd)
+      @reporter = Reporter.new
+      @pass = true
+
+      # Do everything inside tmp_dir
+      Dir.mktmpdir('spec') do |tmp_dir|
+        Dir.chdir(tmp_dir) do
+          @lc3 = LC3.new
+
+          begin
+            instance_eval(&block) if block_given?
+          rescue Timeout::Error => err
+            @reporter.report "Execution timed-out, likely due to an infinite loop"
+          rescue LC3Spec::DoesNotAssembleError => err
+            @reporter.report err.message
+            $stderr.puts err.message
+          end
+
+          @pass = false if @reporter.fail?
+        end
+      end
+    end
+
+    def set_register(reg, val = 0)
+      case reg
+      when Hash
+        reg.each do |r, v|
+          @lc3.set_register(r, v)
+        end
+      when Array
+        reg.each_with_index do |v, i|
+          @lc3.set_register("R#{i}", v)
+        end
+      else
+        @lc3.set_register(reg, val)
+      end
+    end
+
+    alias_method :set_registers, :set_register
+
+    def file_from_asm(asm)
+      assemble_and_load { |f| f.puts asm }
+
+      self
+    end
+
+    def file(filename)
+      ensure_present(filename)
+      ensure_assembled(filename)
+      @lc3.file(filename)
+
+      self
+    end
+
+    def continue(duration = 1.5)
+      Timeout.timeout(duration) do
+        @lc3.continue
+      end
+    end
+
+    alias_method :load_file, :file
+
+    def set_label(label, addr)
+      label = label.to_s.upcase
+
+      if @labels.include? label
+        raise "Unable to replace label #{label}"
+      end
+
+      assemble_and_load do |f|
+        f.puts ".ORIG #{normalize_to_s(addr)}\n#{label}\n.END"
+      end
+
+      self
+    end
+
+    def method_missing(method_name, *arguments, &block)
+      if @lc3.respond_to? method_name
+        @lc3.send(method_name, *arguments, &block)
+
+        self
+      elsif method_name.to_s =~ /^expect_/
+        LC3Spec::Expectations.send(method_name, @lc3, @reporter, *arguments, &block)
+
+        self
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(method_name, include_private = false)
+      if @lc3.respond_to? method_name
+        true
+      elsif method_name.to_s =~ /^expect_/
+        true
+      else
+        super
+      end
+    end
+
+    private
+
+    def assemble_and_load(name = 'lc3spec-tmp', &block)
+      return nil unless block_given?
+
+      f = Tempfile.new([name, '.asm'])
+      begin
+        yield f
+        f.close
+
+        ensure_assembled(f.path)
+        prefix = f.path.chomp(File.extname(f.path))
+        @lc3.file(prefix)
+
+      ensure
+        f.unlink
+
+        # Try not to accidentally delete all files....
+        unless prefix.nil? or prefix.empty?
+          Dir.glob(prefix + '*') do |filename|
+            File.unlink filename
+          end
+        end
+      end
+    end
+
+    def ensure_present(filename)
+      if filename.nil? or filename.empty?
+        raise DoesNotAssembleError, 'Filename nil or empty'
+      end
+
+      # Copy file to current directory if needed
+      basename = File.basename filename
+
+      if Dir.glob(basename + '*').empty?
+        if is_absolute_path?(filename)
+          Dir.glob(filename + '') do |fn|
+            FileUtils.cp(fn, '.')
+          end
+        else
+          Dir.glob(File.join(@src_dir, filename + '*')) do |fn|
+            FileUtils.cp(fn, '.')
+          end
+        end
+      end
+
+      # Check if we have the file now
+      if Dir.glob(basename + '*').empty?
+        raise DoesNotAssembleError, "Cannot find file #{basename}"
+      end
+    end
+
+    def ensure_assembled(filename)
+      if filename !~ /\.asm$/ and filename !~ /\.obj/
+        asm_file = filename + '.asm'
+        obj_file = filename + '.obj'
+
+        # Always prefer finding .asm over .obj file
+        if File.exist? asm_file
+          filename = asm_file
+        elsif File.exist? obj_file
+          filename = obj_file
+        else
+          raise DoesNotAssembleError, "Cannot find #{asm_file} or #{obj_file}"
+        end
+      end
+
+      # Check that the file assembles
+      case filename
+      when /\.asm$/
+        error, status = Open3.capture2e('lc3as', filename)
+        if not status.success?
+          raise DoesNotAssembleError,
+            "File does not assemble: #{filename}\n#{error}"
+        end
+      when /\.obj$/
+        if File.size? filename
+          success = true
+        else
+          raise DoesNotAssembleError,
+            "File has zero size or does not exist: #{filename}"
+        end
+      end
+
+      return true
+    end
+  end
+
+end

data/lib/lc3spec/constants.rb

@@ -0,0 +1,17 @@
+module LC3Spec
+  module Constants
+    R0 = :R0
+    R1 = :R1
+    R2 = :R2
+    R3 = :R3
+    R4 = :R4
+    R5 = :R5
+    R6 = :R6
+    R7 = :R7
+
+    PC = :PC
+    IR = :IR
+    PSR = :PSR
+    CC = :CC
+  end
+end

data/lib/lc3spec/dsl.rb

@@ -0,0 +1,108 @@
+module LC3Spec
+  module Dsl
+    def set(option, value = true)
+      @options ||= {
+        :output => $stdout,
+        :keep_score => false
+      }
+
+      if option == :output
+        case value
+        when File
+          if value.path =~ /\.asm$/
+            raise "Not writing output to .asm file"
+          end
+
+          @options[:output] = value
+        when String
+          if value =~ /\.asm$/
+            raise "Not writing output to .asm file"
+          end
+
+          @options[:output] = open(value, 'w')
+        else
+          @options[:output] = value
+        end
+
+        return @options[:output]
+      end
+
+      @options[option] = value
+
+    end
+
+    def configure(&block)
+      yield if block_given?
+    end
+
+    def test(description, points = 0, &block)
+      t = LC3Spec::Test.new(:options => @options,
+                            :points => points,
+                            &block)
+
+      output = @options[:output]
+
+      if t.pass
+        pass(description, points)
+      else
+        fail(description, points)
+
+        # FIXME: Ugly
+        errors = t.reporter.errors.join("\n")
+
+        output.puts errors.each_line.map { |line| '  ' + line }.join('')
+        output.puts
+      end
+    end
+
+    def pass(description, points)
+      count_points(:pass, points)
+
+      if !@options[:keep_score] || (points == 0)
+        @options[:output].puts "#{description} [OK]"
+      else
+        @options[:output].puts "#{description} #{points}/#{points}"
+      end
+    end
+
+    def fail(description, points)
+      count_points(:fail, points)
+
+      if !@options[:keep_score] || (points == 0)
+        @options[:output].puts "#{description} [FAIL]"
+      else
+        @options[:output].puts "#{description} 0/#{points}"
+      end
+    end
+
+    def count_points(result, possible)
+      @possible_points ||= 0
+      @earned_points ||= 0
+
+      @earned_points += result == :pass ? possible : 0
+      @possible_points += possible
+
+      @num_tests ||= 0
+      @num_tests += 1
+
+      @num_passed ||= 0
+      @num_passed += result == :pass ? 1 : 0
+    end
+
+    def print_score
+      return if @num_tests.nil? or (@num_tests == 0)
+
+      output = @options[:output]
+
+      if @options[:keep_score]
+        output.puts "Score: #@earned_points/#@possible_points"
+      else
+        if @num_passed == @num_tests
+          output.puts "[ALL OK]"
+        elsif @num_passed == 0
+          output.puts "[ALL FAIL]"
+        end
+      end
+    end
+  end
+end

data/lib/lc3spec/errors.rb

@@ -0,0 +1,5 @@
+module LC3Spec
+  class LC3Error < StandardError; end
+  class DoesNotAssembleError < LC3Error; end
+  class ExpectationNotMetError < LC3Error; end
+end

data/lib/lc3spec/expectations.rb

@@ -0,0 +1,68 @@
+require 'lc3spec/errors'
+require 'lc3spec/helpers'
+
+module LC3Spec
+  module Expectations
+    extend LC3Spec::Helpers
+
+    def self.expect_register(lc3, reporter, reg, val)
+      expected = normalize_to_s(val)
+      actual = lc3.get_register(reg)
+
+      unless expected == actual
+        reporter.report "Incorrect #{reg.to_s}: #{diff(expected, actual)}"
+      end
+    end
+
+    def self.expect_memory(lc3, reporter, addr, val)
+      expected = normalize_to_s(val)
+      actual = lc3.get_memory(addr)
+
+      unless expected == actual
+        reporter.report "Incorrect mem[#{addr}]: #{diff(expected, actual)}"
+      end
+    end
+
+    def self.expect_output(lc3, reporter, expected)
+      actual = lc3.get_output
+
+      unless ignore_whitespace_equal(expected, actual)
+        reporter.report "Incorrect output:\n" +
+          "  expected:\n#{strblock(expected)}\n  actual:\n#{strblock(actual)}"
+      end
+    end
+
+    def self.diff(expected, actual)
+      "expected: #{expected}, actual: #{actual}"
+    end
+
+    def self.strblock(str, indent = '    ')
+      return str if str.nil? or str.empty?
+      block = ''
+      str.each_line do |line|
+        block << indent + line
+      end
+      block
+    end
+
+    def self.ignore_whitespace_equal(lhs, rhs)
+      lhs = lhs.each_line.map do |line|
+        if line =~ /^\s*$/
+          nil
+        else
+          line.gsub(/[ \t]+/, ' ')
+        end
+      end.compact.join('').strip
+
+      rhs = rhs.each_line.map do |line|
+        if line =~ /^\s*$/
+          nil
+        else
+          line.gsub(/[ \t]+/, ' ')
+        end
+      end.compact.join('').strip
+
+      lhs == rhs
+    end
+  end
+end

data/lib/lc3spec/helpers.rb

@@ -0,0 +1,43 @@
+require 'pathname'
+
+module LC3Spec
+  module Helpers
+    def normalize_to_s(number)
+      case number
+      when String
+        if number =~ /^(?:x|0x|X|0X)?([0-9A-Fa-f]{1,4})$/
+          "x#{$1.rjust(4, '0').upcase}"
+        else
+          raise "Unable to normalize number: #{number}"
+        end
+      when Fixnum
+        "x#{([number].pack('s>*')).unpack('H*').first.upcase}"
+      end
+    end
+
+    def normalize_to_i(number)
+      case number
+      when String
+        if number =~ /^(?:x|0x|X|0X)?([0-9A-Fa-f]{1,4})$/
+          num_part = $1
+
+          if num_part[0].to_i(16) > 7
+            num_part = num_part.rjust(4, 'F')
+          else
+            num_part = num_part.rjust(4, '0')
+          end
+
+          [num_part].pack('H*').unpack('s>*').first
+        else
+          raise "Unable to normalize number: #{number}"
+        end
+      when Fixnum
+        number
+      end
+    end
+
+    def is_absolute_path?(path)
+      Pathname.new(path).absolute?
+    end
+  end
+end

data/lib/lc3spec/lc3.rb

@@ -0,0 +1,352 @@
+# lc3.rb
+# Chun Yang <yang43@illinois.edu>
+
+require 'io/wait'
+require 'logger'
+require 'socket'
+require 'tempfile'
+
+require 'lc3spec/errors'
+require 'lc3spec/helpers'
+
+# Class to provide access to LC-3 simulator instance
+class LC3
+  include LC3Spec::Helpers
+  attr_accessor :logger
+
+  def initialize
+    # Logging
+    @logger = Logger.new(STDERR)
+    @logger.level = Logger::ERROR
+    #@logger.level = Logger::DEBUG
+    @logger.formatter = proc do |severity, datetime, progname, msg|
+      "#{severity}: #{msg}\n"
+    end
+
+    # Registers
+    @registers = {}
+    [:R0, :R1, :R2, :R3, :R4, :R5, :R6, :R7, :PC, :IR, :PSR].each do |reg|
+      @registers[reg] = 'x0000'
+    end
+    @registers[:CC] = 'ZERO'
+
+    # Memory
+    @memory = Hash.new('x0000')
+    @labels = {}
+
+    initialize_lc3sim
+  end
+
+  def get_register(reg)
+    @registers[reg]
+  end
+
+  def set_register(reg, val)
+    reg = reg.upcase # Don't use ! version because it doesn't work for symbols
+
+    unless @registers.keys.include? reg.to_sym
+      raise "Invalid register: #{reg.to_s}"
+    end
+
+    if val.nil?
+      raise "Invalid register value for #{reg.to_s}: #{val}"
+    end
+
+    @io.puts "register #{reg.to_s} #{normalize_to_s(val)}"
+
+    loop do
+      msg = @io.readline
+      parse_msg msg.strip
+
+      break if msg =~ /^TOCODE/
+    end
+
+    self
+  end
+
+  def get_memory(addr)
+    if addr.respond_to?(:upcase)
+      label_addr = get_address(addr)
+      addr = label_addr unless label_addr.nil?
+    end
+
+    @memory[normalize_to_i(addr)]
+  end
+
+  def set_memory(addr, val)
+    # addr may be memory address or label
+
+    if addr.respond_to?(:upcase) and @labels.include?(addr.upcase.to_s)
+      # Is a label
+      addr = addr.upcase.to_s
+    else
+      # Not a label
+      addr = normalize_to_s(addr)
+    end
+
+    @io.puts("memory #{addr} #{normalize_to_s(val)}")
+
+    loop do
+      msg = @io.readline
+      parse_msg msg.strip
+
+      break if msg =~ /^ERR|CODE/
+    end
+
+    self
+  end
+
+  def get_address(label)
+    @labels[label.upcase.to_s]
+  end
+
+  def file(filename)
+    @io.puts "file #{filename}"
+
+    # Need to encounter 2 TOCODEs before we're done
+    tocode_counter = 2
+
+    while tocode_counter > 0
+      msg = @io.readline
+
+      parse_msg msg.strip
+
+      if msg =~ /^TOCODE/
+        tocode_counter -= 1
+      end
+
+      # ignore warning about no symbols
+      next if msg =~ /WARNING: No symbols/
+
+      # don't ignore other errors
+      break if msg =~ /^ERR/
+    end
+
+    self
+  end
+
+  def step
+    @io.puts 'step'
+
+    parse_until_print_registers
+
+    self
+  end
+
+  def continue
+    @io.puts 'continue'
+
+    parse_until_print_registers
+
+    self
+  end
+
+  def set_breakpoint(addr)
+    addr = addr.upcase.to_s if addr.respond_to? :upcase
+    if @labels.include? addr
+      @io.puts "break set #{addr}"
+    else
+      @io.puts "break set #{normalize_to_s(addr)}"
+    end
+
+    sleep(0.01)
+
+    while @io.ready?
+      msg = @io.readline
+      parse_msg msg.strip
+    end
+
+    self
+  end
+
+  def clear_breakpoint(addr)
+    if addr == :all
+      @io.puts 'break clear all'
+      return self
+    end
+
+    addr = addr.upcase.to_s if addr.respond_to? :upcase
+
+    if @labels.include? addr
+      @io.puts "break clear #{addr}"
+    else
+      @io.puts "break clear #{normalize_to_s(addr)}"
+    end
+
+    sleep(0.01)
+
+    while @io.ready?
+      msg = @io.readline
+      parse_msg msg.strip
+    end
+
+    self
+  end
+
+  def clear_breakpoints
+    clear_breakpoint :all
+  end
+
+  def get_output
+    out = ''
+
+    # There is no signal that tells the GUI that output is ready...
+    # FIXME: This is a bug waiting to happen
+    until @output.ready?
+      sleep(0.01)
+    end
+
+    while @output.ready?
+      out << @output.readpartial(1024)
+    end
+
+    out.gsub("\n\n--- halting the LC-3 ---\n\n", '')
+  end
+
+  def initialize_lc3sim
+    # Start lc3sim instance
+    @io = IO.popen(%w(lc3sim -gui), 'r+')
+
+    begin
+      # Port for output server
+      @port = (rand * 1000 + 5000).to_i
+
+      # Start server to get output
+      @server = TCPServer.new @port
+    rescue Errno::EADDRINUSE
+      retry
+    end
+
+    th = Thread.new do
+      @output = @server.accept
+    end
+
+    # Initialize lc3sim with port number
+    @io.puts @port
+
+    # Wait for lc3sim to connect with our server
+    th.join
+
+    # Read LC-3 initialization messages (mostly loading lc3os)
+    parse_until_print_registers
+
+    # Clear all the welcome messages from lc3sim output
+    while @output.ready?
+      @output.readpartial 1024
+    end
+  end
+
+  def close
+    @output.close
+    @server.close
+  end
+
+  def inspect
+    registers = @registers.map { |k, v| "#{k}=#{v}" }.join(' ')
+
+    addr_to_label = @labels.invert
+
+    memory_header = "%18s ADDR  VALUE" % "label"
+    memory = @memory.map do |addr, value|
+      "%18s %s %s" % [(addr_to_label[addr] or ''),
+                      normalize_to_s(addr), value]
+    end.join("\n")
+
+    #[memory_header, memory, registers].join("\n")
+    registers
+  end
+
+  # def to_s
+  #   @registers.map { |k, v| "#{k}=#{v}" }.join(' ')
+  # end
+
+  private
+
+  def parse_until_print_registers
+    loop do
+      msg = @io.readline
+      parse_msg msg.strip
+
+      break if msg =~ /^REG R11/
+    end
+  end
+
+  # Parse messages from lc3sim
+  def parse_msg(msg)
+    @logger.debug msg
+
+    tokens = msg.split(/ +/)
+
+    cmd = tokens.shift
+
+    if cmd =~ /^CODEP/
+      tokens.unshift(cmd.gsub('CODEP', ''))
+      cmd = 'CODEP'
+    end
+
+    case cmd
+    when 'BCLEAR'
+    when 'BREAK'
+    when 'CODE', 'CODEP'  # Line of code
+      # Address
+      addr = tokens.shift.to_i - 1
+
+      # Note: if there is a breakpoint at the current address, the last
+      # token.shift produces a string like "12289B". Luckily, #to_i just
+      # ignores the B at the end.
+
+      # Label, if present
+      if tokens.first != "x%04X" % addr
+        label = tokens.shift.upcase
+
+        # Don't overwrite label if one already exists
+        @labels[label] ||= addr
+      end
+
+      # Discard hex address
+      tokens.shift
+
+      # Value
+      val = tokens.shift
+
+      @memory[addr] = val
+
+      # Disassembly info
+      # info = tokens.join(' ')
+
+    when 'CONT'
+    when 'ERR'
+      if msg =~ /WARNING/
+        @logger.warn msg
+      else
+        @logger.error msg
+      end
+    when 'REG'            # Register value
+      # Register number
+      reg = tokens.shift
+
+      # Register value
+      val = tokens.shift
+
+      case reg
+      when /^R[0-7]$/
+        @registers[reg.to_sym] = val
+      when 'R8'
+        @registers[:PC] = val
+      when 'R9'
+        @registers[:IR] = val
+      when 'R10'
+        @registers[:PSR] = val
+      when 'R11'
+        @registers[:CC] = val
+      end
+    when 'TOCODE'
+    when 'TRANS'          # Label address translation
+      addr = normalize_to_i(tokens.shift)
+      val = tokens.shift
+    else
+      @logger.debug "Unexpected message: #{msg}"
+    end
+  end
+
+end

data/lib/lc3spec/main.rb

@@ -0,0 +1,11 @@
+require 'lc3spec/base'
+require 'lc3spec/dsl'
+require 'lc3spec/constants'
+
+#require 'lc3spec/expectations/syntax'
+
+extend LC3Spec::Dsl
+include LC3Spec::Constants
+
+#include LC3Spec::Expectations::Syntax
+#LC3Spec::Expectations::Syntax.enable_should

data/lib/lc3spec/reporter.rb

@@ -0,0 +1,23 @@
+module LC3Spec
+  class Reporter
+    def initialize
+      @reports = []
+    end
+
+    def report(msg)
+      @reports << msg
+    end
+
+    def pass?
+      @reports.empty?
+    end
+
+    def fail?
+      not @reports.empty?
+    end
+
+    def errors
+      @reports.dup
+    end
+  end
+end

data/lib/lc3spec.rb

@@ -0,0 +1,2 @@
+require 'lc3spec/base'
+require 'lc3spec/main'

metadata

@@ -0,0 +1,55 @@
+--- !ruby/object:Gem::Specification
+name: lc3spec
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Chun Yang
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-02-27 00:00:00.000000000 Z
+dependencies: []
+description: DSL for testing LC-3 assembly programs
+email: x@cyang.info
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/lc3spec.rb
+- lib/lc3spec/base.rb
+- lib/lc3spec/constants.rb
+- lib/lc3spec/dsl.rb
+- lib/lc3spec/errors.rb
+- lib/lc3spec/expectations.rb
+- lib/lc3spec/helpers.rb
+- lib/lc3spec/lc3.rb
+- lib/lc3spec/main.rb
+- lib/lc3spec/reporter.rb
+- LICENSE
+- README.md
+homepage: http://github.com/chunyang/lc3spec
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.0
+signing_key: 
+specification_version: 4
+summary: Testing and grading suite for LC-3 assembly programs
+test_files: []