constants 0.1.0 → 0.1.1

data/MIT-LICENSE

@@ -1,6 +1,4 @@
 Copyright (c) 2006-2008, Regents of the University of Colorado.
-Developer:: Simon Chiang, Biomolecular Structure Program
-Support:: CU Denver School of Medicine Deans Academic Enrichment Fund
 
 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

data/Rakefile

@@ -12,6 +12,7 @@ desc 'Run tests.'
 Rake::TestTask.new(:test) do |t|
   t.libs << 'lib'
   t.pattern = File.join('test', ENV['subset'] || '', ENV['pattern'] || '**/*_test.rb')
+  t.warning = true
   t.verbose = true
 end
 
@@ -25,35 +26,35 @@ def gemspec
   Thread.new { spec = eval("$SAFE = 3\n#{data}") }.join
   spec
 end
-
-Rake::GemPackageTask.new(gemspec) do |pkg|
-  pkg.need_tar = true
-end
 
-task :print_manifest do
-  # collect files from the gemspec, labeling 
-  # with true or false corresponding to the
-  # file existing or not
-  files = gemspec.files.inject({}) do |files, file|
-    files[File.expand_path(file)] = [File.exists?(file), file]
-    files
-  end
-  
-  # gather non-rdoc/pkg files for the project
-  # and add to the files list if they are not
-  # included already (marking by the absence
-  # of a label)
-  Dir.glob("**/*").each do |file|
-    next if file =~ /^(rdoc|pkg)/ || File.directory?(file)
-    
-    path = File.expand_path(file)
-    files[path] = ["", file] unless files.has_key?(path)
-  end
-  
-  # sort and output the results
-  files.values.sort_by {|exists, file| file }.each do |entry| 
-    puts "%-5s : %s" % entry
-  end
+Rake::GemPackageTask.new(gemspec) do |pkg|
+  pkg.need_tar = true
+end
+
+task :print_manifest do
+  # collect files from the gemspec, labeling 
+  # with true or false corresponding to the
+  # file existing or not
+  files = gemspec.files.inject({}) do |files, file|
+    files[File.expand_path(file)] = [File.exists?(file), file]
+    files
+  end
+  
+  # gather non-rdoc/pkg files for the project
+  # and add to the files list if they are not
+  # included already (marking by the absence
+  # of a label)
+  Dir.glob("**/*").each do |file|
+    next if file =~ /^(rdoc|pkg)/ || File.directory?(file)
+    
+    path = File.expand_path(file)
+    files[path] = ["", file] unless files.has_key?(path)
+  end
+  
+  # sort and output the results
+  files.values.sort_by {|exists, file| file }.each do |entry| 
+    puts "%-5s : %s" % entry
+  end
 end
 
 desc 'Generate documentation.'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: constants
 version: !ruby/object:Gem::Version 
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors: 
 - Simon Chiang
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-08-11 00:00:00 -06:00
+date: 2008-10-13 00:00:00 -06:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -22,6 +22,16 @@ dependencies:
       - !ruby/object:Gem::Version 
         version: 1.1.3
     version: 
+- !ruby/object:Gem::Dependency 
+  name: tap
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.10.8
+    version: 
 description: 
 email: simon.a.chiang@gmail.com
 executables: []
@@ -44,16 +54,6 @@ files:
 - lib/constants/stash.rb
 - lib/constants/uncertainty.rb
 - lib/constants.rb
-- test/constants/constant_library_test.rb
-- test/constants/constant_test.rb
-- test/constants/libraries/element_test.rb
-- test/constants/libraries/particle_test.rb
-- test/constants/libraries/physical_test.rb
-- test/constants/library_test.rb
-- test/constants/stash_test.rb
-- test/constants_test_helper.rb
-- test/constants_test_suite.rb
-- test/readme_doc_test.rb
 has_rdoc: true
 homepage: http://bioactive.rubyforge.org/constants/
 post_install_message: 
@@ -80,5 +80,5 @@ rubygems_version: 1.2.0
 signing_key: 
 specification_version: 2
 summary: Libraries of constants.  Includes libraries for elements, particles, and physical constants.
-test_files: 
-- test/constants_test_suite.rb
+test_files: []
+

data/test/constants/constant_library_test.rb

@@ -1,304 +0,0 @@
-require File.join(File.dirname(__FILE__), '../constants_test_helper.rb') 
-require 'constants/constant_library'
-
-class ConstantLibraryTest < Test::Unit::TestCase
-  include Constants
-
-  attr_accessor :lib
-  
-  def setup
-    @lib = ConstantLibrary.new 'one', 'two', :one
-  end
-  
-  #
-  # documentation test
-  #
-  
-  def test_documentation
-    lib = ConstantLibrary.new('one', 'two', :three)
-    lib.index_by('upcase') {|value| value.to_s.upcase }
-    assert_equal({'ONE' => 'one', 'TWO' => 'two', 'THREE' => :three}, lib.indicies['upcase'])
-  
-    lib.collect("string") {|value| value.to_s }
-    assert_equal(['one', 'two', 'three'], lib.collections['string'])
-  end
-  
-  #
-  # initialize test
-  #
-  
-  def test_initialize
-    lib = ConstantLibrary.new 
-    
-    assert_equal([], lib.values)
-    assert_equal({}, lib.indicies)
-    assert_equal({}, lib.collections)
-  end
-  
-  def test_initialize_with_values
-    assert_equal(['one', 'two', :one], lib.values)
-  end
-  
-  def test_initialize_removes_duplicate_values
-    lib = ConstantLibrary.new 'one', 'two', 'one'
-    assert_equal(['one', 'two'], lib.values)
-  end
-
-  # 
-  # index_by test
-  #
-  
-  def test_index_by_documentation
-    lib = ConstantLibrary.new('one', 'two', :one)
-    lib.index_by("string") {|value| value.to_s }
-    assert_equal({
-      'one' => ['one', :one],
-      'two' => 'two'},
-    lib.indicies['string'])
-
-    lib = ConstantLibrary.new(1,2,nil)                          
-    assert_raise(ArgumentError) { lib.index_by("error", false, nil) {|value| value } }
-
-
-    obj = Object.new
-    index = lib.index_by("ok", false, obj) {|value| value }
-    assert_equal 1, index[1]
-    assert_equal nil, index[nil]
-
-    assert_equal obj, index['non-existant']
-  end
-
-  def test_index_by_creates_a_new_index_for_the_specified_inputs
-    block = lambda {|v| }
-    lib.index_by("name", "nil", "nil_value", &block)
-    
-    assert lib.indicies.has_key?('name')
-    index = lib.indicies['name']
-    
-    assert_equal ConstantLibrary::Index, index.class
-    assert_equal "nil", index.exclusion_value
-    assert_equal "nil_value", index.nil_value
-    assert_equal block, index.block
-  end
-  
-  def test_index_by_uses_name_as_indicies_key
-    lib.index_by(:sym) {|v| v.to_s }
-    assert lib.indicies.has_key?(:sym)
-    assert !lib.indicies.has_key?('sym')
-    
-    lib.index_by('str') {|v| v.to_s }
-    assert !lib.indicies.has_key?(:str)
-    assert lib.indicies.has_key?('str')
-  end
-  
-  def test_index_stashes_values_by_block
-    lib.index_by("string") {|v| v.to_s }
-    assert_equal({'one' => ['one', :one], 'two' => 'two'}, lib.indicies["string"])
-  end
-  
-  def test_index_stashes_key_value_pairs_if_returned
-    lib.index_by("pairs") {|v| [v, v.to_s.upcase] }
-    assert_equal({'one' => 'ONE', :one => 'ONE', 'two' => 'TWO'}, lib.indicies["pairs"])
-  end
-  
-  def test_index_excludes_values_which_return_the_exclusion_value
-    lib.index_by("exclusion", nil) do |v| 
-      v.kind_of?(String) ? nil : [v, v.to_s.upcase]
-    end
-    
-    assert_equal({:one => 'ONE'}, lib.indicies["exclusion"])
-  end
-  
-  def test_index_by_default_exclusion_value_is_nil
-    lib.index_by("name") {|v|}
-    assert_equal nil, lib.indicies['name'].exclusion_value
-  end
-  
-  def test_index_by_raises_error_for_no_block_given
-    assert_raise(ArgumentError) { lib.index_by('name') }
-  end
-  
-  def test_index_by_returns_index
-    result = lib.index_by("name") {|v|}
-    assert_equal(lib.indicies['name'], result)
-  end
-  
-  # 
-  # index_by_attribute test
-  #
-  
-  def test_index_by_attribute_stashes_values_by_method_value
-    lib.index_by_attribute("to_s")
-    assert_equal({'one' => ['one', :one], 'two' => 'two'}, lib.indicies["to_s"])
-  end
-  
-  def test_index_by_attribute_returns_index
-    result = lib.index_by_attribute("object_id")
-    assert_equal(lib.indicies['object_id'], result)
-  end
-  
-  def test_index_by_attribute_raises_error_if_objects_dont_respond_to_attribute
-    assert_raise(NoMethodError) { lib.index_by_attribute("non_existant") }
-  end
-  
-  # 
-  # collect test
-  #
-  
-  def test_collect_documentation
-    lib = ConstantLibrary.new('one', 'two', :three)
-    lib.collect("string") {|value| value.to_s }
-    assert_equal ['one', 'two', 'three'], lib.collections['string'] 
-  
-    lib.collect("length") {|value| [value, value.to_s.length] }
-    assert_equal [nil, nil, nil, ['one', 'two'], nil, :three], lib.collections['length']
-  end
-  
-  def test_collect_creates_a_new_collection_for_the_specified_inputs
-    block = lambda {|v| }
-    lib.collect("name", &block)
-    
-    assert lib.collections.has_key?('name')
-    collection = lib.collections['name']
-    
-    assert_equal ConstantLibrary::Collection, collection.class
-    assert_equal nil, collection.nil_value
-    assert_equal block, collection.block
-  end
-
-  def test_collect_uses_name_as_collections_key
-    lib.collect(:sym) {|v| v.to_s }
-    assert lib.collections.has_key?(:sym)
-    assert !lib.collections.has_key?('sym')
-    
-    lib.collect('str') {|v| v.to_s }
-    assert !lib.collections.has_key?(:str)
-    assert lib.collections.has_key?('str')
-  end
-  
-  def test_collection_stashes_block_value
-    lib.collect("string") {|v| v.to_s }
-    assert_equal(['one', 'two', 'one'], lib.collections["string"])
-  end
-
-  def test_collection_stashes_values_index_pairs_if_returned
-    map = {'one' => 2, 'two' => 0}
-
-    lib.collect("pairs") {|v| [v, map[v.to_s]] }
-    assert_equal(['two', nil, ['one', :one]], lib.collections["pairs"])
-  end
-
-  def test_collection_excludes_values_which_return_nil
-    lib.collect("exclusion") do |v| 
-      v.kind_of?(String) ? nil : v
-    end
-    assert_equal([:one], lib.collections["exclusion"])
-  end
-
-  def test_collect_raises_error_for_no_block_given
-    assert_raise(ArgumentError) { lib.collect('name') }
-  end
-
-  def test_collect_returns_collection
-    result = lib.collect("name") {|v|}
-    assert_equal(lib.collections['name'], result)
-  end
-  
-  # 
-  # collect_attribute test
-  #
-  
-  def test_collect_attribute_collects_attribute_values
-    lib.collect_attribute("to_s")
-    assert_equal(['one', 'two', 'one'], lib.collections["to_s"])
-  end
-
-  #
-  # [] test
-  #
- 
-  def test_get_searches_all_indicies_match
-    lib.index_by("string") {|v| v.to_s }
-    lib.index_by("strlen") {|v| v.to_s.length }
-    
-    assert_equal ['one', :one], lib['one']
-    assert_equal ['one', 'two', :one], lib[3]
-  end
-  
-  def test_get_returns_nil_if_no_matches_are_found
-    assert_equal nil, lib['three']
-  end
-  
-  def test_get_returns_first_match_only
-    lib.index_by("str1") {|v| v.to_s }
-    lib.index_by("str2") {|v| [v.to_s, v.to_s.upcase] }
-    
-    assert lib.indicies['str1'].has_key?('one')
-    assert lib.indicies['str2'].has_key?('one')
-    
-    assert_not_equal lib.indicies['str1']['one'], lib.indicies['str2']['one']
-    assert_equal lib.indicies['str1']['one'], lib['one']
-  end
-  
-  #
-  # clear test
-  #
-  
-  def test_clear_clears_all_values_from_lib_indicies_and_collections
-    lib.index_by("str") {|v| v.to_s }
-    lib.collect("str") {|v| v.to_s }
-    
-    assert !lib.values.empty?
-    assert !lib.indicies['str'].empty?
-    assert !lib.collections['str'].empty?
-    
-    lib.clear
-    
-    assert lib.values.empty?
-    assert lib.indicies['str'].empty?
-    assert lib.collections['str'].empty?
-  end
-  
-  def test_clear_only_removes_indicies_and_collections_if_specified
-    lib.index_by("str") {|v| v.to_s }
-    lib.collect("str") {|v| v.to_s }
-    
-    lib.clear
-    
-    assert !lib.indicies.empty?
-    assert !lib.collections.empty?
-    
-    lib.clear(true)
-    
-    assert lib.indicies.empty?
-    assert lib.collections.empty?
-  end
-  
-  #
-  # add test
-  #
-  
-  def test_add_adds_new_values
-    lib.add(:two, 'three')
-    assert_equal ['one', 'two', :one, :two, 'three'], lib.values
-  end
-  
-  def test_add_does_not_add_duplicate_values
-    lib.add(:one, :two, 'two', 'three')
-    assert_equal ['one', 'two', :one, :two, 'three'], lib.values
-  end
-  
-  def test_add_returns_newly_added_values
-    assert_equal [:two, 'three'], lib.add(:one, :two, 'two', 'three')
-  end
-  
-  def test_add_incorporates_new_values_into_existing_indicies_and_collections
-    lib.index_by("str") {|v| v.to_s }
-    lib.collect("length") {|v| [v, v.to_s.length] }
-    
-    lib.add(:one, :two, 'two', 'three')
-    assert_equal({'one' => ['one', :one], 'two' => ['two', :two], 'three' => 'three'}, lib.indicies['str'])
-    assert_equal([nil,nil,nil,['one', 'two', :one, :two], nil, 'three'], lib.collections['length'])
-  end
-  
-end

data/test/constants/constant_test.rb

@@ -1,77 +0,0 @@
-require File.join(File.dirname(__FILE__), '../constants_test_helper.rb') 
-require 'constants/constant'
-
-class ConstantTest < Test::Unit::TestCase
-  include Constants
-  
-  #
-  # parse test
-  #
-  
-  def test_parse_documentation
-    assert_equal [1.0, 0.2], Constant.parse("1.0(2)").to_a
-    assert_equal [1.0078250321, 1/2500000000], Constant.parse("1.007 825 032 1(4)").to_a
-    assert_equal [6.62606896, nil], Constant.parse("6.626 068 96").to_a
-  end
-  
-  def test_parse
-    assert_equal [1.0, nil], Constant.parse("1.0").to_a
-    assert_equal [1.0, 0], Constant.parse("1.0(0)").to_a
-    assert_equal [1.0, 0.1], Constant.parse("1.0(1)").to_a
-    assert_equal [100, 1], Constant.parse("100(1)").to_a
-    assert_equal [100, 11], Constant.parse("100(11)").to_a
-    assert_equal [1234.54789, 0.00011], Constant.parse("1234.54789(11)").to_a
-    assert_equal [1234.54789, 0.00011], Constant.parse("1234.547 89 (11)").to_a
-    assert_equal [1000, 100], Constant.parse("1.0(1)e3").to_a
-    assert_equal [0.001, 0.0001], Constant.parse("1.0(1)e-3").to_a
-  end
-  
-  #
-  # == test
-  #
-  
-  def test_equal_compares_Numerics_with_value
-    c = Constant.new(1.23)
-    assert c == 1.23
-    assert c != 1.24
-    
-    assert_equal 1.23, c
-    assert_not_equal 1.24, c
-  end
-  
-  def test_equal_compares_non_Numerics_directly
-    c1 = Constant.new(1.23)
-    c2 = Constant.new(1.23)
-    c3 = Constant.new(1.24)
-    
-    assert c1 == c2
-    assert c1 != c3
-  end
-  
-  #
-  # <=> test
-  #
-  
-  def test_compare_compares_on_value
-    c1 = Constant.new(1.23)
-    c2 = Constant.new(1.23)
-    c3 = Constant.new(1.24)
-    
-    assert_equal 0, c1 <=> c2
-    assert_equal -1, c1 <=> c3
-    assert_equal 1, c3 <=> c1
-  end
-  
-  #
-  # to_a test
-  #
-  
-  def test_to_a_returns_value_uncertainty_array
-    c = Constant.new(1.23)
-    assert_equal [1.23, nil], c.to_a
-    
-    c = Constant.new(1.23, nil, 0.03)
-    assert_equal [1.23, 0.03], c.to_a
-  end
- 
-end

data/test/constants/libraries/element_test.rb

@@ -1,207 +0,0 @@
-require File.join(File.dirname(__FILE__), '../../constants_test_helper.rb') 
-require 'constants/libraries/element'
-
-class ElementTest < Test::Unit::TestCase
-  include Constants::Libraries
-  
-  #
-  # documentation test
-  #
-  
-  def test_documentation
-    e = Element::He
-    assert_equal "Helium", e.name
-    assert_equal "He", e.symbol
-    assert_equal 2, e.atomic_number
-    assert_equal 4.0026032497, e.mass
-    assert_equal [3, 4], e.isotopes
-    assert_equal [0.000137, 99.999863], e.abundances
-  end
-  
-  #
-  # initialize test
-  #
-  
-  def test_initialize
-    c = Element::C
-    
-    assert_equal "C", c.symbol
-    assert_equal "Carbon", c.name
-    assert_equal 6, c.atomic_number
-    assert_equal [12, 13], c.isotopes
-    assert_equal [[12.0, 0], [13.0033548378, 0.000000001]], c.masses.collect {|m| m.to_a}
-    assert_equal [[98.93, 0.08], [1.07, 0.08]], c.abundances.collect {|m| m.to_a}
-    assert_equal 0, c.index_max_abundance
-  end
-  
-  #
-  # lookup test
-  #
-  
-  def test_lookup
-    c = Element::C
-    assert_equal c, Element['C']
-    assert_equal c, Element['Carbon']
-    assert_equal c, Element[6]
-  end
-  
-  def test_lookup_is_nil_for_undefined_elements
-    assert_nil Element['Q']
-    assert_nil Element["Madeupium"]
-    assert_nil Element[102]
-  end
-  
-  #
-  # methods test
-  #
-  
-  def test_has_isotope?
-    assert Element::C.has_isotope?(12)
-    assert Element::C.has_isotope?(13)
-    assert !Element::C.has_isotope?(8)
-  end
-
-  def test_index_isotope
-    assert_equal 0, Element::C.index_isotope(12)
-    assert_equal 1, Element::C.index_isotope(13)
-    assert_equal nil, Element::C.index_isotope(8)
-  end
-  
-  def test_mass
-    assert_equal 12, Element::C.mass
-    assert_equal 12, Element::C.mass(12)
-    assert_equal 13.0033548378, Element::C.mass(13)
-    assert_equal nil, Element::C.mass(8)
-  end
-  
-  def test_abundance
-    assert_equal 98.93, Element::C.abundance
-    assert_equal 98.93, Element::C.abundance(12)
-    assert_equal 1.07, Element::C.abundance(13)
-    assert_equal nil, Element::C.abundance(8)
-  end
-  
-  # vs the Proteome Commons Atom Reference, 2008-01-11
-  # http://www.proteomecommons.org/archive/1129086318745/docs/atom-reference.html
-  #
-  # The website states 'These values are taken from the NIST's list, http://physics.nist.gov'
-  def test_mass_values_vs_proteome_commons
-    str = %Q{
-H 1.0078250321  0.999885
-H2  2.014101778 1.15E-4
-O 15.9949146221 0.9975700000000001
-O17 16.9991315  3.7999999999999997E-4
-O18 17.9991604  0.0020499999999999997
-N14 14.0030740052 0.9963200000000001
-N15 15.0001088984 0.00368
-C12 12.0  0.9893000000000001
-C13 13.0033548378 0.010700000000000001
-P31 30.97376151 1.0
-S32 31.97207069 0.9493
-S33 32.9714585  0.0076
-S34 33.96786683 0.0429
-S36 35.96708088 2.0E-4}
-
-    atoms = str.split(/\n/)
-    atoms.each do |atom_str|
-      next if atom_str.empty?
-      
-      name, mass, abundance = atom_str.split(/\s+/)
-      name =~ /(\w)(\d*)/
-      symbol = $1
-      isotope = $2.empty? ? nil : $2.to_i
-      mass = mass.to_f
-      abundance = abundance.to_f * 100
-      
-      element = Element[symbol]
-      assert_not_nil element, atom_str
-      assert element.has_isotope?(isotope), atom_str unless isotope == nil
-      
-      assert_in_delta mass, element.mass(isotope), delta_mass, atom_str 
-      assert_in_delta abundance, element.abundance(isotope), delta_abundance, atom_str 
-    end
-  end
-  
-  # vs the Unimod Symbols and Mass Values, 2008-01-11
-  # http://www.unimod.org/masses.html
-  #
-  # The website states 'All mass values in Unimod are calculated 
-  # from the IUPAC atomic weights and isotopic abundances 
-  # tabulated by WebElements'
-  #
-  def test_mass_values_vs_unimod
-    str = %Q{
-H Hydrogen  1.007825035 1.00794
-2H  Deuterium 2.014101779 2.014101779
-Li  Lithium 7.016003  6.941
-C Carbon  12  12.0107
-13C Carbon13  13.00335483 13.00335483
-N Nitrogen  14.003074 14.0067
-15N Nitrogen15  15.00010897 15.00010897
-O Oxygen  15.99491463 15.9994
-18O Oxygen18  17.9991603  17.9991603
-F Fluorine  18.99840322 18.9984032
-Na  Sodium  22.9897677  22.98977
-P Phosphorous 30.973762 30.973761
-S Sulfur  31.9720707  32.065
-Cl  Chlorine  34.96885272 35.453
-K Potassium 38.9637074  39.0983
-Ca  Calcium 39.9625906  40.078
-Fe  Iron  55.9349393  55.845
-Ni  Nickel  57.9353462  58.6934
-Cu  Copper  62.9295989  63.546
-Zn  Zinc  63.9291448  65.409
-Br  Bromine 78.9183361  79.904
-Se  Selenium  79.9165196  78.96
-Mo  Molybdenum  97.9054073  95.94
-Ag  Silver  106.905092  107.8682
-I Iodine  126.904473  126.90447
-Au  Gold  196.966543  196.96655
-Hg  Mercury 201.970617  200.59}
-
-    atoms = str.split(/\n/)
-    atoms.each do |atom_str|
-      next if atom_str.empty?
-      
-      symbol, name, monoisotopic, average = atom_str.split(/\s+/)
-      symbol =~ /(\d*)(\w+)/
-      isotope = $1.empty? ? nil : $1.to_i
-      symbol = $2
-      monoisotopic = monoisotopic.to_f
-      average = average.to_f
-      
-      element = Element[symbol]
-      assert_not_nil element, atom_str
-      assert element.has_isotope?(isotope), atom_str unless isotope == nil
-
-      assert_in_delta monoisotopic, element.mass(isotope), delta_mass, atom_str 
-      # TODO -- check average mass
-    end
-  end
-
-  # vs the VG Analytical Organic Mass Spectrometry reference, reference date unknown (prior to 2005)
-  # the data from the data sheet was copied manually to doc/VG Analytical DataSheet.txt
-  def test_mass_values_vs_vg_analytical
-    str = %Q{
-H 1.0078250 1.00794
-C 12 12.011
-N 14.0030740 14.0067
-O 15.9949146 15.9994
-S 31.9720718 32.06}
-
-    atoms = str.split(/\n/)
-    atoms.each do |atom_str|
-      next if atom_str.empty?
-      
-      symbol, monoisotopic, average = atom_str.split(/\s+/)
-      monoisotopic = monoisotopic.to_f
-      average = average.to_f
-      
-      element = Element[symbol]
-      assert_not_nil element, atom_str
-      assert_in_delta monoisotopic, element.mass, delta_mass, atom_str 
-      # TODO -- check average mass
-    end    
-  end
-  
-end

data/test/constants/libraries/particle_test.rb

@@ -1,43 +0,0 @@
-require File.join(File.dirname(__FILE__), '../../constants_test_helper.rb') 
-require 'constants/libraries/particle'
-
-class ParticleTest < Test::Unit::TestCase
-  include Constants::Libraries
-  
-  #
-  # initialize test
-  #
-  
-  def test_initialize
-    c = Particle::CHARM
-
-    assert_equal "Charm", c.name
-    assert_equal "Fermion", c.family
-    assert_equal "Quark", c.group
-    assert_equal "Second", c.generation
-    assert_equal 2.0/3, c.charge
-    assert_equal 0.5, c.spin
-
-    t = Particle::ANTITAU
-
-    assert_equal "Anti-Tau", t.name
-    assert_equal "Fermion", t.family
-    assert_equal "Lepton", t.group
-    assert_equal "Third", t.generation
-    assert_equal -1, t.charge
-    assert_equal 0.5, t.spin
-  end
-  
-  #
-  # lookup test
-  #
-  
-  def test_lookup
-    c = Particle::CHARM
-    assert_equal c, Particle['Charm']
-  end
-  
-  def test_lookup_is_nil_for_undefined_particles
-    assert_nil Particle['Blop']
-  end
-end

data/test/constants/libraries/physical_test.rb

@@ -1,32 +0,0 @@
-require File.join(File.dirname(__FILE__), '../../constants_test_helper.rb') 
-require 'constants/libraries/physical'
-
-class PhysicalTest < Test::Unit::TestCase
-  include Constants::Libraries
-  
-  #
-  # initialize test
-  #
-  
-  def test_initialize
-    c = Physical::SPEED_OF_LIGHT_IN_VACUUM
-    
-    assert_equal "speed of light in vacuum", c.name
-    assert_equal 299792458, c.value
-    assert_equal 0, c.uncertainty
-    assert_equal Unit.new("m/s"), c.unit
-  end
-  
-  #
-  # lookup test
-  #
-  
-  def test_lookup
-    c = Physical::SPEED_OF_LIGHT_IN_VACUUM
-    assert_equal c, Physical["speed of light in vacuum"]
-  end
-  
-  def test_lookup_is_nil_for_undefined_constants
-    assert_nil Physical["made up blah in a blah"]
-  end
-end

data/test/constants/library_test.rb

@@ -1,125 +0,0 @@
-require File.join(File.dirname(__FILE__), '../constants_test_helper.rb') 
-require 'constants/library'
-
-class Constants::LibraryTest < Test::Unit::TestCase
-  include Constants
-  
-  #
-  # documentation test
-  #
-
-  module Color
-    RED = 'red'
-    GREEN = 'green'
-    BLUE = 'blue'
-    GREY = 'grey'
-
-    include Constants::Library
-    library.index_by('name') {|c| c }
-  end
-
-  def test_documentation 
-    ###
-    assert_equal({
-      'red' => Color::RED,
-      'blue' => Color::BLUE,
-      'green' => Color::GREEN,
-      'grey' => Color::GREY},
-    Color.index('name'))
-
-    assert_equal Color::RED, Color['red']
-
-    ###
-    Color.library.index_by_attribute 'length'
-    const_ordered_assert_equal({
-      3 => Color::RED,
-      4 => [Color::BLUE, Color::GREY],
-      5 => Color::GREEN},
-    Color.index('length'))
-
-    const_ordered_assert_equal [Color::BLUE, Color::GREY], Color[4]
-    
-    ###
-    Color.library.collect('gstar') {|c| c =~ /^g/ ? c : nil }
-    const_ordered_assert_equal [Color::GREEN, Color::GREY], Color.collection('gstar')
-
-    Color.library.collect_attribute 'length'
-    const_ordered_assert_equal [3,5,4,4], Color.collection('length')
-
-    ###
-    Color.library.add('yellow')
-    const_ordered_assert_equal({
-      3 => Color::RED,
-      4 => [Color::BLUE, Color::GREY],
-      5 => Color::GREEN,
-      6 => 'yellow'},
-    Color.index('length'))
-
-    Color.module_eval %Q{
-      ORANGE = 'orange'
-      reset_library
-    }
-
-    const_ordered_assert_equal({
-      3 => Color::RED,
-      4 => [Color::BLUE, Color::GREY],
-      5 => Color::GREEN,
-      6 => Color::ORANGE},
-    Color.index('length'))
-  end
-
-  #
-  # extend test 
-  #
-  
-  module ExtendModule
-  end
-  
-  def test_extend_initializes_library
-    ExtendModule.extend Library
-    assert ExtendModule.respond_to?(:library)
-    assert ExtendModule.library.kind_of?(ConstantLibrary)
-  end
-  
-  #
-  # include test 
-  #
-  
-  module IncludeModule
-    include Constants::Library
-  end
-  
-  def test_include_initializes_library
-    assert IncludeModule.respond_to?(:library)
-    assert IncludeModule.library.kind_of?(ConstantLibrary)
-  end
-  
-  #
-  # benchmark tests
-  #
-  
-  module BenchmarkModule
-    include Constants::Library
-    A = 'A'
-    
-    library.index_by("name") {|value| value}
-    reset_library
-  end
-
-  def test_access_speed
-    benchmark_test(24) do |x|
-      n = 100
-      x.report("#{n}k BenchmarkModule::A") do 
-        (n*10**3).times { BenchmarkModule::A }
-      end
-  
-      x.report("#{n}k ['A']") do 
-        (n*10**3).times { BenchmarkModule['A'] }
-      end
-      
-      x.report("#{n}k index('name')['A']") do 
-        (n*10**3).times { BenchmarkModule.index('name')['A'] }
-      end
-    end
-  end
-end

data/test/constants/stash_test.rb

@@ -1,99 +0,0 @@
-require File.join(File.dirname(__FILE__), '../constants_test_helper.rb') 
-require 'constants/stash'
-
-class StashTest < Test::Unit::TestCase
-  include Constants
-  
-  class StashingHash < Hash
-    include Constants::Stash
-
-    def initialize(*args)
-      super(*args)
-      @nil_value = nil
-    end
-  end
-  
-  attr_reader :s
-  
-  def setup
-    @s = StashingHash.new
-  end
-  
-  #
-  # documentation test
-  #
-  
-  def test_documentation
-    s = StashingHash.new
-  
-    s.stash('key', 'one')
-    assert_equal 'one', s['key']
-   
-    s.stash('key', 'two')
-    assert_equal ['one' , 'two'], s['key']
-    assert_equal Constants::Stash::StashArray, s['key'].class
-  
-    ###
-    s = StashingHash.new
-    assert_nil s['key']
-    assert_nil s.nil_value
-
-    s.stash('key', 1)
-    assert_equal 1, s['key']
-
-    s.stash('key', 2)
-    assert_equal [1, 2], s['key']
-  
-    ###
-    assert_raise(ArgumentError) { s.stash('key', nil) }
-  end
-  
-  #
-  # initialization test
-  #
-  
-  def test_initialization_sets_nil_value
-    s = StashingHash.new
-    assert_equal({}, s)
-    assert_equal(nil, s.nil_value)
-  end
-  
-  #
-  # stash test
-  #
-  
-  def test_stash_stores_new_values_at_key
-    s.stash('key', 'one')
-    assert_equal({'key' => 'one'}, s)
-  end
-  
-  def test_stash_stores_addition_values_in_a_StashArray
-    s.stash('key', 'one')
-    s.stash('key', 'two')
-    s.stash('key', 'three')
-    
-    assert_equal({'key' => ['one', 'two', 'three']}, s)
-    assert_equal Constants::Stash::StashArray, s['key'].class
-  end
-  
-  def test_stash_handles_array_values_properly
-    s.stash('key', ['one'])
-    assert_equal({'key' => ['one']}, s)
-    
-    s.stash('key', ['two'])
-    assert_equal({'key' => [['one'], ['two']]}, s)
-    
-    s.stash('key', ['three'])
-    assert_equal({'key' => [['one'], ['two'], ['three']]}, s)
-  end
-  
-  def test_stash_raises_error_for_nil_value_and_StashArray_values
-    assert_raise(ArgumentError) { s.stash('key', s.nil_value) }
-    assert_raise(ArgumentError) { s.stash('key', Stash::StashArray.new) }
-  end
-  
-  def test_stash_returns_self
-    assert_equal s, s.stash('key', 'value')
-  end
-  
-end

data/test/constants_test_helper.rb

@@ -1,51 +0,0 @@
-require 'rubygems'
-require 'test/unit'
-require 'benchmark'
-require 'pp'
-
-class Test::Unit::TestCase
-  include Benchmark
-
-  #
-  # mass tests
-  #
-  
-  def delta_mass
-    10**-5
-  end
-  
-  def delta_abundance
-    10**-1
-  end
-  
-  def benchmark_test(length=10, &block) 
-    if ENV["benchmark"] =~ /true/i
-      puts
-      puts method_name
-      bm(length, &block)
-    else
-      print 'b'
-    end
-  end
-  
-  def const_ordered_assert_equal(a,b, msg=nil)
-    if RUBY_VERSION =~ /^1.8/
-      print "*"
-      
-      case a
-      when Array
-        assert_equal a.sort, b.sort, msg
-      when Hash
-        [a,b].each do |hash|
-          hash.each_pair do |key, value|
-            value.sort! if value.kind_of?(Array)
-          end
-        end
-        assert_equal a, b, msg
-      end    
-    else
-      assert_equal a, b, msg
-    end
-  end
-  
-end

data/test/constants_test_suite.rb

@@ -1,3 +0,0 @@
-$:.unshift File.join(File.dirname(__FILE__), '../lib')
-
-Dir.glob("./**/*_test.rb").each {|test| require test}

data/test/readme_doc_test.rb

@@ -1,58 +0,0 @@
-require File.join(File.dirname(__FILE__), 'constants_test_helper.rb') 
-require 'constants'
-
-class ReadMeDocTest < Test::Unit::TestCase
- 
-  include Constants::Libraries
-
-  # A library of amino acid residues.
-  class Residue
-    attr_reader :letter, :abbr, :name
-
-    def initialize(letter, abbr, name)
-      @letter = letter
-      @abbr = abbr
-      @name = name
-    end
-
-    A = Residue.new('A', "Ala", "Alanine")
-    C = Residue.new('C', "Cys", "Cysteine")
-    D = Residue.new('D', "Asp", "Aspartic Acid")
-    # ... normally you'd add the rest here ...
-
-    include Constants::Library
-
-    # add an index by an attribute or method
-    library.index_by_attribute :letter
-
-    # add an index where keys are calculated by a block
-    library.index_by 'upcase abbr' do |residue|
-      residue.abbr.upcase
-    end
-    
-    # add a collection (same basic idea, but using an array)
-    library.collect_attribute 'name'
-  end
-  
-  def test_documentation
-    # Element predefines all chemical elements
-    c = Element::C
-    assert_equal "Carbon", c.name
-    assert_equal "C", c.symbol 
-    assert_equal 6, c.atomic_number
-    assert_equal 12.0, c.mass
-    assert_equal 13.0033548378, c.mass(13)
-
-    assert c == Element['Carbon']
-    assert c == Element['C']
-    assert c == Element[6]
-  
-    ###
-    assert_equal Residue::D, Residue['D']
-    assert_equal Residue::A, Residue['ALA']
-
-    assert_equal({'ALA' => Residue::A, 'CYS' => Residue::C, 'ASP' => Residue::D}, Residue.index('upcase abbr'))
-    const_ordered_assert_equal(["Alanine", "Cysteine", "Aspartic Acid"], Residue.collection('name'))
-  end
-  
-end