/test/test_key.rb

# $Id$

require 'test/unit'
require "yaml"

require "key"
require "crypto_helper"

# ==  TestKey
#
class TestKey < Test::Unit::TestCase

  # === setup
  #
  def setup
    File.open("test/test_key.yaml") do |fh|
      @data = YAML.load(fh)
    end
  end # -- setup
  
  # === test_init
  #
  def test_init
    @data.keys.each do |word|
      key = Key::Key.new(word)

      assert_not_nil key
      assert_equal key.key, word.upcase
    end
  end # -- test_init
  
  # === test_params
  #
  def test_params
    assert_raise(ArgumentError) { Key::Key.new(nil)}
    assert_raise(ArgumentError) { Key::Key.new(Array.new) }
    assert_nothing_raised(ArgumentError) { Key::Key.new(3) }
    assert_nothing_raised(ArgumentError) { Key::Key.new("") }
    assert_nothing_raised(ArgumentError) { Key::Key.new("FOOBAR") }
    assert_raise(RangeError) { Key::Key.new(42) }
  end # -- test_params
  
  # === test_condensed1
  #
  def test_condensed
    @data.keys.each do |word|
      key = Key::Key.new(word)

      assert_not_nil key
      assert_equal key.condensed, @data[word]["condensed"]
    end
  end # -- test_condensed

  # === test_length
  #
  def test_length
    @data.keys.each do |word|
      key = Key::Key.new(word)

      assert_not_nil key
      assert_equal key.length, word.length
    end
  end # -- test_length
  
end # --  TestKey

# == TestTKey
#
class TestTKey < Test::Unit::TestCase

  # === setup
  #
  def setup
    @data = Hash.new
    File.open("test/test_tkey.yaml") do |fh|
      @data = YAML.load(fh)
    end
  end # -- setup
  
  # === test_init
  #
  def test_init
    @data.keys.each do |word|
      key = Key::TKey.new(word)

      assert_not_nil key
      assert_equal key.key, word.upcase
    end
  end # -- test_init
  
  # === test_to_numeric
  #
  def test_to_numeric
    @data.keys.each do |word|
      key = Key::TKey.new(word)

      assert_equal @data[word]["num"], key.to_numeric
    end
  end # -- test_to_numeric
end # --  TestTKey

# ==  TestSKey
#
class TestSKey < Test::Unit::TestCase
  
  # === test_alpha
  #
  def test_presence_of_alpha
    word = "arabesque"
    key = Key::SKey.new(word)

    assert_not_nil key      
    assert_not_nil key.alpha
    assert_not_nil key.ralpha
  end # -- test_presence_of_alpha

  # === test_encode_decode
  #
  def test_encode_decode
    key = Key::SKey.new("")
    
    assert_equal "P", key.decode("P")
    assert_equal "P", key.encode("P")
  end # -- test_encode_decode

end # --  TestSKey

# ==  TestKeyCaesar
#
class TestKeyCaesar < Test::Unit::TestCase
  
  # === setup
  #
  def setup
    word = 3
    @key = Key::Caesar.new(word)
    assert_not_nil @key
    assert_not_nil @key.offset
    assert_equal word, @key.offset
  end # -- setup
  
  # === test_alpha
  #
  def test_presence_of_alpha
    assert_not_nil @key.alpha
    assert_not_nil @key.ralpha
  end # -- test_presence_of_alpha
  
  # === test_alpha
  #
  def test_alpha
    @key.alpha.keys.each do |r|
      assert r =~ /[A-Z]/
    end
  end # -- test_alpha
  
  # === test_ralpha
  #
  def test_ralpha
    @key.ralpha.keys.each do |r|
      assert r =~ /[A-Z]/
    end
  end # -- test_alpha
  
  # === test_encode
  #
  def test_encode
    pt = "A"
    ct = @key.encode(pt)

    assert_not_nil ct
    assert_equal ct, "D"
    
    pt = "Y"
    ct = @key.encode(pt)

    assert_not_nil ct
    assert_equal ct, "B"
  end # -- test_encode
  
  # === test_decode
  #
  def test_decode
    ct = "D"
    pt = @key.decode(ct)

    assert_not_nil pt
    assert_equal pt, "A"
    
    ct = "C"
    pt = @key.decode(ct)

    assert_not_nil pt
    assert_equal pt, "Z"
  end # -- test_decode
end # --  TestKeyCaesar

# ==  TestSCKey
#
class TestSCKey < Test::Unit::TestCase
  
  # === setup
  #
  def setup
    File.open("test/test_sckey.yaml") do |fh|
      @data = YAML.load(fh)
    end
  end # -- setup
  
  # === test_alpha
  #
  def test_presence_of_alpha
    word = "arabesque"
    key = Key::SCKey.new(word)

    assert_not_nil key
    assert_equal Key::SCKey, key.class
    assert_not_nil key.alpha
    assert_not_nil key.ralpha
    assert_equal Key::SCKey::BASE.length, key.alpha.length
    assert_equal Key::SCKey::BASE.length, key.ralpha.length
  end # -- test_presence_of_alpha

  # === test_checkerboard
  #
  def test_checkerboard
    @data.keys.each do |word|
      key = Key::SCKey.new(word)

      assert_not_nil key
      assert_not_nil key.full_key
      assert_equal Key::SCKey::BASE.length, key.full_key.length
      assert_equal @data[word]["full_key"], key.full_key
    end
  end # -- test_checkerboard
  
  # === test_gen_rings
  #
  def test_gen_rings
    @data.keys.each do |word|
      key = Key::SCKey.new(word)
    
      assert_not_nil key
      assert_equal @data[word]["alpha"], key.alpha
      assert_equal @data[word]["ralpha"], key.ralpha
    end
  end # -- test_gen_rings

  # === test_is_long
  #
  def test_is_long
    key = Key::SCKey.new("arabesque")

    assert_not_nil key
    assert !key.is_long?(0)
    assert key.is_long?(9)
  end # -- test_is_long
  
  # === test_encode
  #
  def test_encode
    @data.keys.each do |word|
      key = Key::SCKey.new(word)

      assert_not_nil key
      
      test = @data[word]["encode"]
      encode_in = test["in"]
      encode_out = test["out"]
      encode_in.each do |c|
        assert_equal encode_out.shift, key.encode(c)
      end
    end
  end # -- test_encode
  
  # === test_decode
  #
  def test_decode
    @data.keys.each do |word|
      key = Key::SCKey.new(word)

      assert_not_nil key
      
      test = @data[word]["encode"]
      decode_in = test["out"]
      decode_out = test["in"]
      decode_in.each do |c|
        assert_equal decode_out.shift, key.decode(c)
      end
    end
  end # -- test_decode
end # --  TestSCKey

# == TestChaokey
#
class TestChaokey < Test::Unit::TestCase
  
  # === setup
  #
  def setup
    File.open("test/test_chaokey.yaml") do |fh|
      @data = YAML.load(fh)
    end
    @a = Key::ChaoKey.new("PTLNBQDEOYSFAVZKGJRIHWXUMC",
                         "HXUCZVAMDSLKPEFJRIGTWOBNYQ")
  end # -- setup

  # === test_advance
  #
  def test_advance
    @a.advance(12)
    assert_equal 26, @a.plain.length
    assert_equal 26, @a.cipher.length
    assert_equal "VZGJRIHWXUMCPKTLNBQDEOYSFA", @a.plain
    assert_equal "PFJRIGTWOBNYQEHXUCZVAMDSLK", @a.cipher
  end # -- test_advance
  
  # === test_encode
  #
  # we test two steps to ensure the "rings" turn
  #
  def test_encode
    pt = "W"
    ct = "O"
    
    nct = @a.encode(pt)
    assert_equal ct, nct
    
    pt = "E"
    ct = "A"
    nct = @a.encode(pt)
    assert_equal ct, nct
  end # -- test_encode
  
  # === test_decode
  #
  def test_decode
    pt = "W"
    ct = "O"
    
    npt = @a.decode(ct)
    assert_equal pt, npt
    
    pt = "E"
    ct = "A"
    npt = @a.decode(ct)
    assert_equal pt, npt
  end # -- test_decode
end # -- TestChaokey

# ==  TestSQKey
#
class TestSQKey < Test::Unit::TestCase

  # === setup
  #
  def setup
    File.open("test/test_sqkey.yaml") do |fh|
      @data = YAML.load(fh)
    end
  end # -- setup

  # === test_init
  #
  def test_init
    @data.keys.each do |word|
      key = Key::SQKey.new(word, @data[word]["type"])

      assert_not_nil key
      assert_equal @data[word]["full_key"], key.full_key
    end
  end # -- test_init
  
  # === test_gen_rings
  #
  def test_gen_rings
    @data.keys.each do |word|
      key = Key::SQKey.new(word, @data[word]["type"])

      assert_not_nil key
      assert_equal Key::SQKey, key.class
      assert_equal @data[word]["alpha"], key.alpha
      assert_equal @data[word]["ralpha"], key.ralpha
    end
  end # -- test_gen_rings

  # === test_encode
  #
  def test_encode
    @data.keys.each do |word|
      key = Key::SQKey.new(word, @data[word]["type"])

      assert_not_nil key
      
      test = @data[word]["encode"]
      encode_in = test["in"]
      encode_out = test["out"]
      encode_in.each do |c|
        assert_equal encode_out.shift, key.encode(c), "#{word}"
      end
    end
  end # -- test_encode
  
  # === test_decode
  #
  def test_decode
    @data.keys.each do |word|
      key = Key::SQKey.new(word, @data[word]["type"])

      assert_not_nil key
      
      test = @data[word]["encode"]
      encode_in = test["out"]
      encode_out = test["in"]
      encode_in.each do |ct|
        assert_equal encode_out.shift, key.decode(ct), "#{word}"
      end
    end
  end # -- test_decode
  
end # --  TestSQKey

# == TestPlayfair
#
class TestPlayfair_Q < Test::Unit::TestCase
  include Crypto
  
  # === setup
  #
  def setup
    File.open("test/test_playfair_q.yaml") do |fh|
      @data = YAML.load(fh)
    end
  end # -- setup

  # === test_init
  #
  def test_init
    @data.keys.each do |word|
      key = Key::Playfair.new(word)

      assert_not_nil key
      assert_equal Key::Playfair, key.class
      assert_not_nil key.alpha
      assert_not_nil key.ralpha
      assert_equal @data[word]["full_key"], key.full_key
    end
  end # -- test_init
  
  # === test_gen_rings
  #
  def test_gen_rings
    @data.keys.each do |word|
      key = Key::Playfair.new(word)

      assert_equal @data[word]["alpha"], key.alpha
      assert_equal @data[word]["ralpha"], key.ralpha
    end
  end # -- test_gen_rings
  
  # === test_encode
  #
  def test_encode
    @data.keys.each do |word|
      key = Key::Playfair.new(word)

      assert_not_nil key
      
      test = @data[word]["encode"]
      encode_in = test["in"]
      encode_out = test["out"]
      encode_in.each do |c|
        assert_equal encode_out.shift, key.encode(c), "#{word} #{c}"
      end
    end
  end # -- test_encode

  # === test_decode
  #
  def test_decode
    @data.keys.each do |word|
      key = Key::Playfair.new(word)

      assert_not_nil key
      
      test = @data[word]["encode"]
      encode_in = test["out"]
      encode_out = test["in"]
      encode_in.each do |ct|
        assert_equal encode_out.shift, key.decode(ct), "#{word} #{ct} "
      end
    end
  end # -- test_decode
end # -- TestPlayfair

# == TestWheatstone
#
class TestWheatstone < Test::Unit::TestCase
  include Crypto
  
  # === setup
  #
  def setup
    File.open("test/test_wheat.yaml") do |fh|
      @data = YAML.load(fh)
    end
  end # -- setup
  
  def test_init
    @data.keys.each do |dt|
      d = @data[dt]
      plwk = d["plwk"]
      ctwk = d["ctwk"]

      key = Key::Wheatstone.new(d["start"], plwk, ctwk)

      assert_not_nil key
      assert_equal Key::Wheatstone, key.class

      assert_equal key.aplw.size, (Key::Wheatstone::BASE.length + 1)
      assert_equal key.actw.size, (Key::Wheatstone::BASE.length)

      assert_equal d["actw"], key.actw
      assert_equal d["aplw"], key.aplw
    end
  end # -- test_init1

  def test_encode

  end # -- test_encode

  def test_decode

  end # -- test_decode
end # -- TestWheatstone

# == TestPlayfair1
#
class TestPlayfair_J < Test::Unit::TestCase
  include Crypto
  
  # === setup
  #
  def setup
    File.open("test/test_playfair_j.yaml") do |fh|
      @data = YAML.load(fh)
    end
  end # -- setup

  # === test_init
  #
  def test_init
    @data.keys.each do |word|
      key = Key::Playfair.new(word, Key::Playfair::WITH_J)

      assert_not_nil key
      assert_equal Key::Playfair, key.class
      assert_not_nil key.alpha
      assert_not_nil key.ralpha
      assert_equal @data[word]["full_key"], key.full_key
    end
  end # -- test_init
  
  # === test_gen_rings
  #
  def test_gen_rings
    @data.keys.each do |word|
      key = Key::Playfair.new(word, Key::Playfair::WITH_J)

      assert_equal @data[word]["alpha"], key.alpha
      assert_equal @data[word]["ralpha"], key.ralpha
    end
  end # -- test_gen_rings
  
  # === test_encode
  #
  def test_encode
    @data.keys.each do |word|
      key = Key::Playfair.new(word, Key::Playfair::WITH_J)

      assert_not_nil key
      
      test = @data[word]["encode"]
      encode_in = test["in"]
      encode_out = test["out"]
      encode_in.each do |c|
        assert_equal encode_out.shift, key.encode(c), "#{word} #{c}"
      end
    end
  end # -- test_encode

  # === test_decode
  #
  def test_decode
    @data.keys.each do |word|
      key = Key::Playfair.new(word, Key::Playfair::WITH_J)

      assert_not_nil key
      
      test = @data[word]["encode"]
      encode_in = test["out"]
      encode_out = test["in"]
      encode_in.each do |ct|
        assert_equal encode_out.shift, key.decode(ct), "#{word} #{ct} "
      end
    end
  end # -- test_decode
end # -- TestPlayfair_J

# ==  TestVICKey
#
class TestVICKey < Test::Unit::TestCase
  include Crypto
  
  # === setup
  #
  def setup
    File.open("test/test_vickey.yaml") do |fh|
      @data = YAML.load(fh)
    end
    @keys = @data["keys"]
  end # -- setup

  # === test_init
  #
  def test_init
    init = @data["init"]
    key = Key::VICKey.new(init["ikey"], init["phrase"], init["imsg"])
    
    assert_not_nil key
    assert_not_nil key.first
    assert_not_nil key.second
    assert_not_nil key.third
    assert_not_nil key.sc_key
    
    assert_equal Array, key.p1.class
    assert_equal Array, key.p2.class
    assert_equal Array, key.first.class
    assert(key.first.length != 0)
    
    assert_equal init["p1"], key.p1
    assert_equal init["ikey5"], key.ikey5
    assert_equal init["first"], key.first
    assert_equal init["second"], key.second
    
    assert_equal init["third"], key.third
    assert_equal init["sc_key"], key.sc_key
  end # -- test_init

end # --  TestVICKey