logic 0.0.1

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Bryan Ash
+ 
+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.rdoc

@@ -0,0 +1,42 @@
+= logic
+
+== Usage
+
+Truth tables are easy:
+
+  logic truth_table '(a or b) and (c or d)'
+
+Gives you:
+
+      a b c d | output
+   1) 0 0 0 0 |   0
+   2) 0 0 0 1 |   0
+   3) 0 0 1 0 |   0
+   4) 0 0 1 1 |   0
+   5) 0 1 0 0 |   0
+   6) 0 1 0 1 |   1
+   7) 0 1 1 0 |   1
+   8) 0 1 1 1 |   1
+   9) 1 0 0 0 |   0
+  10) 1 0 0 1 |   1
+  11) 1 0 1 0 |   1
+  12) 1 0 1 1 |   1
+  13) 1 1 0 0 |   0
+  14) 1 1 0 1 |   1
+  15) 1 1 1 0 |   1
+  16) 1 1 1 1 |   1
+
+MC/DC test case pairs can also be found:
+
+  logic mcdc_pairs '(a or b) and (c or d)'
+
+Gives you:
+
+  a => [[2, 10], [3, 11], [4, 12]]
+  b => [[2, 6], [3, 7], [4, 8]]
+  c => [[5, 7], [9, 11], [13, 15]]
+  d => [[5, 6], [9, 10], [13, 14]]
+
+== Copyright
+
+Copyright (c) 2010 Bryan Ash. See LICENSE for details.

data/bin/logic

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+$LOAD_PATH.unshift(File.dirname(__FILE__) + "/lib")
+
+require 'rubygems'
+require 'treetop'
+require 'logic_parser'
+require 'logic_operations'
+
+parser = LogicParser.new
+decision = parser.parse ARGV[1]
+
+if ARGV[0] == 'truth_table'
+  puts decision.truth_table
+end
+
+if ARGV[0] == 'mcdc_pairs'
+  puts decision.mcdc_pairs
+end  

data/features/mcdc_pairs.feature

@@ -0,0 +1,37 @@
+Feature: MC/DC Pairs
+
+  In order to reduce the number of tests required for a logic statment
+  as an engineer
+  I want to see the MC/DC test pairs
+
+  Scenario: a single condition
+    When I run logic mcdc_pairs 'a'
+    Then I should see:
+      """
+      a => [[1, 2]]
+      """
+
+  Scenario: 'a and b' decision
+    When I run logic mcdc_pairs 'a and b'
+    Then I should see:
+      """
+      a => [[2, 4]]
+      b => [[3, 4]]
+      """
+
+  Scenario: 'a or b' decision
+    When I run logic mcdc_pairs 'a or b'
+    Then I should see:
+      """
+      a => [[1, 3]]
+      b => [[1, 2]]
+      """
+
+  Scenario: 'a and (b or c)' decision
+    When I run logic mcdc_pairs 'a and (b or c)'
+    Then I should see:
+      """
+      a => [[2, 6], [3, 7], [4, 8]]
+      b => [[5, 7]]
+      c => [[5, 6]]
+      """

data/features/step_definitions/logic_testing_steps.rb

@@ -0,0 +1,3 @@
+When /^I run (.+) (.+) '(.+)'$/ do |ruby_file, command, decision|
+  When "I run \"ruby #{APP_PATH}/#{ruby_file}.rb #{command} '#{decision}'\""
+end

data/features/support/env.rb

@@ -0,0 +1,7 @@
+APP_PATH = File.expand_path(File.dirname(__FILE__) + '/../..')
+
+$LOAD_PATH.unshift("#{APP_PATH}/lib")
+
+require 'aruba'
+require 'fileutils'
+require 'spec/expectations'

data/features/truth_table.feature

@@ -0,0 +1,70 @@
+Feature: Truth Table
+
+  In order to appreciate the complexity of a logic statement
+  as an engineer
+  I want to see the truth table
+
+  Scenario: a single condition
+    When I run logic truth_table 'a'
+    Then I should see:
+      """
+          a | output
+       1) 0 |   0
+       2) 1 |   1
+      """
+
+  Scenario: 'a or b' decision
+    When I run logic truth_table 'a or b'
+    Then I should see:
+      """
+          a b | output
+       1) 0 0 |   0
+       2) 0 1 |   1
+       3) 1 0 |   1
+       4) 1 1 |   1
+      """
+
+  Scenario: 'a or b or c' decision
+    When I run logic truth_table 'a or b or c'
+    Then I should see:
+      """
+          a b c | output
+       1) 0 0 0 |   0
+       2) 0 0 1 |   1
+       3) 0 1 0 |   1
+       4) 0 1 1 |   1
+       5) 1 0 0 |   1
+       6) 1 0 1 |   1
+       7) 1 1 0 |   1
+       8) 1 1 1 |   1
+      """
+
+  Scenario: 'a and b and c' decision
+    When I run logic truth_table 'a and b and c'
+    Then I should see:
+      """
+          a b c | output
+       1) 0 0 0 |   0
+       2) 0 0 1 |   0
+       3) 0 1 0 |   0
+       4) 0 1 1 |   0
+       5) 1 0 0 |   0
+       6) 1 0 1 |   0
+       7) 1 1 0 |   0
+       8) 1 1 1 |   1
+      """
+
+  Scenario: '(a and b) or c' decision
+    When I run logic truth_table '(a and b) or c'
+    Then I should see:
+      """
+          a b c | output
+       1) 0 0 0 |   0
+       2) 0 0 1 |   1
+       3) 0 1 0 |   0
+       4) 0 1 1 |   1
+       5) 1 0 0 |   0
+       6) 1 0 1 |   1
+       7) 1 1 0 |   1
+       8) 1 1 1 |   1
+      """

data/lib/integer.rb

@@ -0,0 +1,11 @@
+class Integer
+
+  def to_array_of_bits(width)
+    ("%0#{width}b" % self).split(//).map(&:to_i)
+  end
+
+  def negate
+    self + 1 & 1
+  end
+
+end

data/lib/logic.rb

@@ -0,0 +1,3 @@
+class Logic
+  VERSION = '1.0.0'
+end

data/lib/logic_operations.rb

@@ -0,0 +1,69 @@
+require 'truth_table'
+
+module LogicStatement
+
+  def truth_table
+    TruthTable.new(condition_count) { |conditions| evaluate(conditions) }
+  end
+
+  def mcdc_pairs
+    truth_table.mcdc_pairs
+  end
+
+  def condition_count
+    condition_identifiers.count
+  end
+
+end
+
+module Condition
+
+  include LogicStatement
+  
+  def condition_identifiers
+    [text_value]
+  end
+
+  def evaluate(conditions)
+    conditions.shift
+  end
+
+end
+
+module Decision
+
+  include LogicStatement
+  
+  def condition_identifiers
+    elements.map(&:condition_identifiers).flatten
+  end
+
+  def evaluate(conditions)
+    condition_1 = operand_1.evaluate(conditions)
+    condition_2 = operand_2.evaluate(conditions)
+    operator.apply(condition_1, condition_2)
+  end
+
+end
+
+module Parenthesized
+
+  include LogicStatement
+
+  def condition_identifiers
+    binary_condition.condition_identifiers
+  end
+
+  def evaluate(conditions)
+    binary_condition.evaluate(conditions)
+  end
+  
+end
+
+module NonCondition
+  
+  def condition_identifiers
+    []
+  end
+
+end

data/lib/logic_parser.treetop

@@ -0,0 +1,51 @@
+grammar Logic
+
+  rule decision
+    binary_condition / condition
+  end
+
+  rule binary_condition
+    operand_1:condition S operator S operand_2:decision <Decision>  
+  end
+
+  rule condition
+    parenthesized / variable
+  end
+
+  rule variable
+    [A-Za-z]+ <Condition>
+  end
+
+  rule parenthesized
+    '(' binary_condition ')' <Parenthesized>
+  end
+
+  rule operator
+    ( and / or ) <NonCondition>
+  end
+
+  rule and
+    'and' {
+      def apply(a, b)
+        a & b
+      end
+    }
+  end
+
+  rule or
+    'or' {
+      def apply(a, b)
+        a | b
+      end
+    }
+  end
+
+  rule s # Optional space
+    S?
+  end
+ 
+  rule S # Mandatory space
+    [ \t\n\r]+ <NonCondition>
+  end
+ 
+end

data/lib/test_case.rb

@@ -0,0 +1,47 @@
+require 'integer'
+
+class TestCase
+
+  def initialize(number, condition_count, decision)
+    @condition_value = number - 1
+    @condition_count = condition_count
+    @decision = decision
+  end
+
+  def initialize_copy(source)
+    super
+    @conditions = conditions.dup
+  end
+
+  def conditions
+    @conditions ||= (@condition_value).to_array_of_bits(@condition_count)
+  end
+
+  def number
+    conditions.join.to_i(base = 2) + 1
+  end
+
+  def output
+    @decision.call(conditions.dup)
+  end
+
+  def mcdc_pair(index)
+    modified_case = negate_condition_at_index(index)
+    [number, modified_case.number].sort
+  end
+
+  def is_mcdc_case_for_index?(index)
+    modified_case = negate_condition_at_index(index)
+    modified_case.output != output
+  end
+
+  def negate_condition_at_index(index)
+    dup.negate_condition_at_index!(index)
+  end
+
+  def negate_condition_at_index!(index)
+    conditions[index] = conditions[index].negate
+    self
+  end
+
+end

data/lib/truth_table.rb

@@ -0,0 +1,61 @@
+require 'test_case'
+
+class TruthTable
+
+  def initialize(condition_count, &decision)
+    @condition_count = condition_count
+    @decision = decision
+  end
+
+  def condition_identifiers
+    identifier_range.take(@condition_count)
+  end
+
+  def cases
+    case_numbers.map do |case_number|
+      TestCase.new(case_number, @condition_count, @decision)
+    end
+  end
+
+  def case_numbers
+    1..2**@condition_count
+  end
+
+  def mcdc_pairs
+    condition_identifiers.map do |condition_identifier|
+      "#{condition_identifier} => #{mcdc_pairs_for(condition_identifier)}"
+    end
+  end
+
+  def mcdc_pairs_for(condition_identifier)
+    cases.inject([]) do |mcdc_cases, test_case|
+      mcdc_pair = test_case.mcdc_pair(index_of(condition_identifier))
+      mcdc_cases << mcdc_pair if test_case.is_mcdc_case_for_index?(index_of(condition_identifier))
+      mcdc_cases
+    end.uniq
+  end
+
+  def index_of(condition_identifier)
+    identifier_range.to_a.index(condition_identifier)
+  end
+
+  def to_s
+    header + formatted_cases
+  end
+
+  def header
+    conditions = condition_identifiers.join(" ")
+    "#{conditions.rjust(conditions.length + 4)} | output\n"
+  end
+
+  def formatted_cases
+    cases.inject("") do |output, test_case|
+      output += "#{test_case.number.to_s.rjust(2)}) #{test_case.conditions.join(' ')} | #{test_case.output.to_s.rjust(3)}\n"
+    end
+  end
+
+  def identifier_range
+    'a'..'z'
+  end
+
+end

data/spec/logic_parser_spec.rb

@@ -0,0 +1,132 @@
+require 'rubygems'
+require 'treetop'
+require 'logic_parser'
+require 'logic_operations'
+
+describe LogicParser do
+
+  let(:parser) { LogicParser.new }
+
+  describe "parsing a single condition" do
+    
+    let(:decision) { parser.parse('Hello') }
+    
+    it "identifies the condition" do
+      decision.condition_identifiers.should == ['Hello']
+    end
+
+    it "has 1 condition" do
+      decision.condition_count.should == 1
+    end
+
+  end
+
+  describe "parsing 'A or B'" do
+
+    let(:decision) { parser.parse('A or B') }
+    
+    it "condition identifiers are ['A','B']" do
+      decision.condition_identifiers.should == ['A','B']
+    end
+
+    it "has 2 conditions" do
+      decision.condition_count.should == 2
+    end
+
+  end
+
+  describe "parsing 'A or B or C'" do
+
+    let(:decision) { parser.parse('A or B or C') }
+    
+    it "condition identifiers are ['A','B','C']" do
+      decision.condition_identifiers.should == ['A','B', 'C']
+    end
+
+    it "has 3 conditions" do
+      decision.condition_count.should == 3
+    end
+
+  end
+
+  describe "parsing 'A and B'" do
+
+    let(:decision) { parser.parse('A and B') }
+    
+    it "conditions are ['A','B']" do
+      decision.condition_identifiers.should == ['A','B']
+    end
+
+    it "has 2 conditions" do
+      decision.condition_count.should == 2
+    end
+
+  end
+
+  describe "parsing 'A and B and C'" do
+
+    let(:decision) { parser.parse('A and B and C') }
+    
+    it "condition identifiers are ['A','B','C']" do
+      decision.condition_identifiers.should == ['A','B', 'C']
+    end
+
+    it "has 3 conditions" do
+      decision.condition_count.should == 3
+    end
+
+  end
+
+  { 'Hello' =>
+    { [0] => 0,
+      [1] => 1
+    },
+    'A or B' =>
+    { [0, 0] => 0,
+      [0, 1] => 1,
+      [1, 0] => 1
+    },
+    'A and B' =>
+    { [1, 1] => 1,
+      [0, 1] => 0,
+      [1, 0] => 0
+    },
+    'A or B or C' =>
+    { [0, 0, 0] => 0,
+      [1, 0, 0] => 1,
+      [0, 1, 0] => 1,
+      [0, 0, 1] => 1
+    },
+    'A and B and C' =>
+    { [1, 1, 1] => 1,
+      [0, 1, 1] => 0,
+      [1, 0, 1] => 0,
+      [1, 1, 0] => 0
+    },
+    '(A and B) or C' =>
+    { [1, 1, 0] => 1,
+      [0, 1, 0] => 0,
+      [1, 0, 0] => 0,
+      [0, 0, 1] => 1
+    },
+    'A and (B or C)' =>
+    { [1, 0, 0] => 0,
+      [1, 1, 0] => 1,
+      [1, 0, 1] => 1,
+      [0, 1, 1] => 0
+    }
+  }.each do |logic, cases|
+    describe "parsing '#{logic}'" do
+
+      let(:decision) { parser.parse(logic) }
+
+      cases.each do |conditions, result|
+        it "'#{conditions}' evaluates to '#{result}'" do
+          decision.evaluate(conditions).should == result
+        end
+      end
+    end
+
+  end
+
+end

data/spec/spec.opts

@@ -0,0 +1 @@
+--color

data/spec/truth_table_spec.rb

@@ -0,0 +1,27 @@
+require 'truth_table'
+
+describe TruthTable do
+
+  describe "with 1 condition" do
+
+    let(:table) { TruthTable.new(1) }
+    
+    describe :condition_dentifiers do
+      
+      it "includes 'a'" do
+        table.condition_identifiers.should include('a')
+      end
+
+    end
+
+    describe :cases do
+
+      it "has 2 cases" do
+        table.cases.length.should == 2
+      end
+
+    end
+
+  end
+  
+end

metadata

@@ -0,0 +1,105 @@
+--- !ruby/object:Gem::Specification 
+name: logic
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Bryan Ash
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-03-18 00:00:00 -04:00
+default_executable: logic
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: treetop
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 4
+        - 2
+        version: 1.4.2
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: polyglot
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 2
+        - 9
+        version: 0.2.9
+  type: :runtime
+  version_requirements: *id002
+description: Produces truth table and MC/DC test case pairs from parsed logic statement
+email: ""
+executables: 
+- logic
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- bin/logic
+- features/mcdc_pairs.feature
+- features/step_definitions/logic_testing_steps.rb
+- features/support/env.rb
+- features/truth_table.feature
+- lib/integer.rb
+- lib/logic.rb
+- lib/logic_operations.rb
+- lib/logic_parser.treetop
+- lib/test_case.rb
+- lib/truth_table.rb
+- LICENSE
+- README.rdoc
+- spec/logic_parser_spec.rb
+- spec/spec.opts
+- spec/truth_table_spec.rb
+has_rdoc: true
+homepage: ""
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Taking the pain out of MC/DC testing
+test_files: []
+