rails-units 1.3.1

data/spec/spec_helper.rb

@@ -0,0 +1,4 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'rspec/core'
+require File.dirname(__FILE__) + "/../lib/ruby-units"

data/test/test_cache.rb

@@ -0,0 +1,26 @@
+require 'rubygems'
+require 'test/unit'
+require 'ruby-units'
+
+class TestCache < Test::Unit::TestCase
+  def setup
+    Unit::Cache.clear
+  end
+  
+  def test_clear
+    Unit::Cache.set("m", "m".unit)
+    Unit::Cache.clear
+    assert_nil(Unit::Cache.get('m'))
+  end
+  
+  def test_set_cache
+    assert_nothing_raised { Unit::Cache.set("m", "m".unit) }
+    assert Unit::Cache.get.keys.include?('m')
+  end
+  
+  def test_get_cache
+    Unit::Cache.set("m", "m".unit)
+    assert_equal("m".unit, Unit::Cache.get['m'])
+  end
+  
+end

data/test/test_ruby-units.rb

@@ -0,0 +1,1011 @@
+require 'rubygems'
+require 'test/unit'
+require 'ruby-units'
+require 'yaml'
+begin
+	require 'chronic'
+rescue LoadError
+	warn "Can't test Chronic integration unless gem 'chronic' is installed"
+end
+begin 
+	require 'uncertain'
+rescue LoadError
+	warn "Can't test Uncertain Units unless 'Uncertain' gem is installed"
+end
+
+
+class Unit < Numeric
+  @@USER_DEFINITIONS = {'<inchworm>' =>  [%w{inworm inchworm}, 0.0254, :length, %w{<meter>} ],
+                        '<habenero>'   => [%w{degH}, 100, :temperature, %w{<celsius>}]}
+  Unit.setup
+end
+
+class Time
+  @@forced_now = nil
+  @@forced_gmt = nil
+  class << self
+    alias :unforced_now :now
+    def forced_now
+      @@forced_now.nil? ? unforced_now : @@forced_now
+    end
+    alias :now :forced_now
+    
+    def forced_now=(now)
+      @@forced_now = now
+    end
+  end
+    
+  alias :unforced_gmt :gmt_offset
+  def forced_gmt
+    @@forced_gmt.nil? ? unforced_gmt : @@forced_gmt
+  end
+  alias :gmt_offset :forced_gmt
+
+  def forced_gmt=(gmt)
+    @@forced_gmt = now
+  end
+    
+end
+
+class DateTime
+  @@forced_now = nil
+  class << self
+    alias :unforced_now :now
+    def forced_now
+      return @@forced_now ? @@forced_now : unforced_now
+    end
+    alias :now :forced_now
+    
+    def forced_now=(now)
+      @@forced_now = now
+    end
+    
+  end
+end
+
+class Dummy
+  def to_unit
+    '1 mm'.unit
+  end
+end
+
+class TestRubyUnits < Test::Unit::TestCase
+ 
+  def setup
+    @april_fools = Time.at 1143910800
+    @april_fools_datetime = DateTime.parse('2006-04-01T12:00:00-05:00')
+    Time.forced_now = @april_fools
+    DateTime.forced_now = @april_fools_datetime 
+    #Unit.clear_cache
+  end
+  
+  def teardown
+    Time.forced_now = nil
+    DateTime.forced_now = nil
+  end
+  
+  def test_to_yaml
+    unit = "1 mm".u
+    if RUBY_PLATFORM == "java"
+      # apparently jruby's implementation of yaml has some white space differences
+      assert_equal "--- !ruby/object:Unit \nscalar: 1\nnumerator: \n  - <milli>\n  - <meter>\ndenominator: \n  - <1>\nsignature: 1\nbase_scalar: !ruby/object:Rational \n  denominator: 1000\n  numerator: 1\n", unit.to_yaml
+    else
+      assert_equal "--- !ruby/object:Unit \nscalar: 1\nnumerator: \n- <milli>\n- <meter>\ndenominator: \n- <1>\nsignature: 1\nbase_scalar: !ruby/object:Rational \n  denominator: 1000\n  numerator: 1\n", unit.to_yaml
+    end
+  end
+
+  def test_time
+    a = Time.now
+    assert_equal "s", a.to_unit.units
+    assert_equal a + 3600, a + "1 h".unit
+    assert_equal a - 3600, a - "1 h".unit
+    assert_in_delta Time.now - "1 h".unit, "1 h".ago, 1
+    assert_in_delta Time.now + 3600, "1 h".from_now, 1
+    assert_in_delta Time.now + "1 h".unit, "1 h".from_now, 1
+    assert_in_delta Time.now - 3600, "1 h".before_now, 1
+    assert_equal "60 min", "min".until(Time.now + 3600).to_s
+    assert_equal "01:00", "min".since(Time.now - 3600).to_s("%H:%M")
+    assert_in_delta Time.now, "now".time, 1
+  end
+  
+	def test_from_now
+		assert_equal "1 day".from_now, @april_fools + 86400
+	end
+	
+	def test_from
+		assert_equal "1 day".from("now"), @april_fools + 86400
+	end
+
+	def test_ago
+		assert_equal "1 day".ago, @april_fools - 86400
+	end
+	
+	def test_before_now
+		assert_equal "1 day".before_now, @april_fools - 86400
+	end
+	
+	def test_before
+		assert_equal '1 days'.before('now'), @april_fools - 86400
+	end
+
+	def test_since
+    assert_equal 'days'.since(@april_fools - 86400), "1 day".unit
+    assert_equal 'days'.since('2006-3-31 12:00:00 -5:00'), "1 day".unit
+    assert_equal 'days'.since(DateTime.parse('2006-3-31 12:00 -5:00')), "1 day".unit		
+    assert_raises(ArgumentError) { 'days'.since(1) }
+	end
+
+	def test_until
+    assert_equal 'days'.until('2006-04-2 12:00:00 -5:00'), '1 day'.unit		
+    assert_raises(ArgumentError) { 'days'.until(1) }
+	end
+
+  def test_time_helpers
+    assert_equal @april_fools, Time.now
+    assert_equal @april_fools_datetime, DateTime.now
+    assert_equal Time.now, 'now'.time
+    assert_equal DateTime.now, 'now'.datetime
+    assert_equal 1143910800, Unit.new(Time.now).scalar
+    assert_equal @april_fools.unit.to_time, @april_fools
+    assert_equal Time.in('1 day'), @april_fools + 86400
+    assert_equal "2006-04-01T12:00:00-05:00", @april_fools_datetime.inspect
+    assert_equal "2006-04-01T00:00:00+00:00", '2453826.5 days'.unit.to_datetime.to_s 
+  end
+  
+  def test_string_helpers
+    assert_equal '1 mm'.to('in'), Unit('1 mm').to('in')
+  end
+
+  [:sin, :cos, :tan, :sinh, :cosh, :tanh].each do |trig|
+		define_method("test_#{trig}") do
+			assert_equal Math.send(trig, Math::PI), Math.send(trig, "180 deg".unit)
+		end
+	end
+	
+  def test_clone
+    unit1= "1 mm".unit
+    unit2 = unit1.clone
+    assert_not_equal unit1.numerator.object_id, unit2.numerator.object_id
+    assert_not_equal unit1.denominator.object_id, unit2.denominator.object_id
+    assert unit1 === unit2
+  end 
+  
+  def test_unary_minus
+    unit1 = Unit.new("1 mm^2")
+    unit2 = Unit.new("-1 mm^2")
+    assert_equal unit1, -unit2
+  end
+  
+  def test_unary_plus
+    unit1 = Unit.new("1 mm")
+    assert_equal unit1, +unit1
+  end
+
+  def test_create_unit_only
+    unit1 = Unit.new("m")
+    assert_equal ['<meter>'], unit1.numerator
+    assert_equal 1.0, unit1.scalar
+  end
+  
+  def test_to_base
+    unit1 = Unit.new("100 cm")
+    assert_in_delta 1, unit1.to_base.scalar, 0.001
+    unit2 = Unit("1 mm^2 ms^-2")
+    assert_in_delta 1,  unit2.to_base.scalar, 0.001 
+  end
+  
+  def test_to_unit
+    unit1 = "1 mm".to_unit
+    assert_equal unit1, unit1.to_unit
+    assert Unit === unit1
+    unit2 = Unit("1 mm")
+    assert Unit === unit1
+    assert unit1 == unit2
+    unit1 = "2.54 cm".to_unit("in")
+    assert_in_delta 1, unit1.scalar, 0.001 
+    assert_equal ['<inch>'], unit1.numerator
+    unit1 = "2.54 cm".unit("in")
+    assert_in_delta 1, unit1.scalar, 0.001
+    assert_equal ['<inch>'], unit1.numerator
+    unit1 = 1.unit
+    assert_in_delta 1, unit1.scalar, 0.001
+    assert_equal ['<1>'], unit1.numerator
+    unit1 = [1,'mm'].unit
+    assert_in_delta 1, unit1.scalar, 0.001
+    assert_equal ['<milli>','<meter>'], unit1.numerator
+  end
+  
+  def test_create_unitless
+    unit1 = Unit("1")
+    assert_equal 1, unit1.to_f
+    assert_equal ['<1>'],unit1.numerator
+    assert_equal ['<1>'],unit1.denominator
+    unit1 = Unit.new("1.5")
+    assert_equal 1.5,unit1.to_f
+    assert_equal ['<1>'],unit1.numerator
+    assert_equal ['<1>'],unit1.denominator
+  end
+  
+  def test_create_simple
+    unit1 = Unit.new("1 m")
+    assert_equal 1,unit1.scalar
+    assert_equal ['<meter>'], unit1.numerator
+    assert_equal ['<1>'],unit1.denominator
+  end
+  
+  def test_create_compound
+    unit1 = Unit.new("1 N*m")
+    assert_equal 1,unit1.scalar 
+    assert_equal ['<newton>','<meter>'],unit1.numerator
+    assert_equal ['<1>'],unit1.denominator
+  end
+  
+  def test_create_with_denominator
+    unit1 = Unit.new("1 m/s")
+    assert_equal 1, unit1.scalar
+    assert_equal ['<meter>'],unit1.numerator
+    assert_equal ['<second>'],unit1.denominator
+  end
+  
+  def test_create_with_powers
+    unit1 = Unit.new("1 m^2/s^2")
+    assert_equal 1, unit1.scalar
+    assert_equal ['<meter>','<meter>'],unit1.numerator
+    assert_equal ['<second>','<second>'],unit1.denominator
+    unit1 = Unit.new("1 m^2 kg^2 J^2/s^2")
+    assert_equal 1, unit1.scalar
+    assert_equal ['<meter>','<meter>','<kilogram>','<kilogram>','<joule>','<joule>'],unit1.numerator
+    assert_equal ['<second>','<second>'],unit1.denominator
+    
+  end
+
+  def test_create_with_zero_power
+    unit1 = Unit.new("1 m^0")
+    assert_equal 1,unit1.scalar
+    assert_equal ['<1>'],unit1.numerator
+    assert_equal ['<1>'],unit1.denominator
+  end
+
+  def test_create_with_negative_powers
+    unit1 = Unit.new("1 m^2 s^-2")
+    assert_equal 1, unit1.scalar
+    assert_equal ['<meter>','<meter>'],unit1.numerator
+    assert_equal ['<second>','<second>'],unit1.denominator
+  end
+  
+  def test_create_from_array
+    unit1 = Unit.new(1, "mm^2", "ul^2")
+    assert_equal 1, unit1.scalar
+    assert_equal ['<milli>','<meter>','<milli>','<meter>'], unit1.numerator
+    assert_equal ['<micro>','<liter>','<micro>','<liter>'], unit1.denominator
+  end
+  
+  def test_bad_create
+    assert_raises(ArgumentError) { Unit.new(nil)}
+    assert_raises(ArgumentError) { Unit.new(true)}
+    assert_raises(ArgumentError) { Unit.new(false)}
+    assert_raises(ArgumentError) { Unit.new(/(.+)/)}
+  end
+  
+  def test_convert
+    unit1 = Unit.new("1 attoparsec/microfortnight")
+    assert_nothing_raised {
+      unit2 = unit1 >> "in/s"
+      assert_equal ['<inch>'],unit2.numerator
+      assert_equal ['<second>'],unit2.denominator
+      assert_in_delta 1.0043269330917,unit2.scalar,0.00001 
+    }
+  end
+  
+  def test_add_operator
+    a = '0 mm'.unit
+    b = '10 cm'.unit
+    c = '1 in'.unit
+    d = '1 ml'.unit
+    
+    assert_equal((a+b), b)
+    assert_equal((a+b).units, b.units)
+    assert_equal((b+a), b)
+    assert_equal((b+a).units, b.units)
+    assert_in_delta((b+c).scalar, 12.54, 0.01)
+    assert_equal((b+c).units, 'cm')
+    assert_raises(ArgumentError) {
+      b + d
+    }
+  end
+  
+  def test_subtract_operator
+    a = '0 mm'.unit
+    b = '10 cm'.unit
+    c = '1 in'.unit
+    d = '1 ml'.unit
+    
+    assert_equal((a-b), -b)
+    assert_equal((a-b).units, b.units)
+    assert_equal((b-a), b)
+    assert_equal((b-a).units, b.units)
+    assert_in_delta((b-c).scalar, 7.46, 0.01)
+    assert_equal((b-c).units, 'cm')
+    assert_raises(ArgumentError) {
+      b - d
+    }
+  end
+  
+  def test_convert_to
+    unit1 = Unit.new("1 mm")
+    unit2 = Unit.new("1 ft")
+    assert_nothing_raised {
+      unit3 = unit1 >> unit2
+      assert_equal ['<foot>'], unit3.numerator
+      assert_equal ['<1>'],unit3.denominator
+      unit3 = unit1 >> "ft"
+      assert_equal ['<foot>'], unit3.numerator
+      assert_equal ['<1>'],unit3.denominator
+    }
+    assert_raises(ArgumentError) { unit1 >> 5.0}
+    assert_equal unit1, unit1.to(true)
+    assert_equal unit1, unit1.to(false)
+    assert_equal unit1, unit1.to(nil)
+  end
+  
+  def test_compare 
+    unit1 = "1 mm".unit
+    unit2 = "1 mm".unit
+    unit3 = unit2 >> "in"
+    assert unit1 === unit2
+    assert !(unit1 === unit3)
+    assert unit1 === "1 mm"
+  end
+  
+  def test_matched_units
+    unit1 = Unit.new("1 m*kg/s")
+    unit2 = Unit.new("1 in*pound/min")
+    assert unit1 =~ unit2
+  end
+  
+  def test_matched_units_using_string
+    unit1 = Unit.new("1 m*kg/s")
+    assert unit1 =~ "in*pound/min"
+  end
+  
+  def test_unmatched_units
+    unit1 = Unit.new("1 m*kg/s")
+    unit2 = Unit.new("1 mm")
+    assert unit1 !~ unit2
+  end
+  
+  def test_comparison_like_units
+    unit1 = Unit.new("1 in")
+    unit2 = Unit.new("1 mm")
+    assert_nothing_raised {
+      assert unit1 > unit2
+    }
+  end
+  
+  def test_comparison_unlike_units
+    unit1 = Unit.new("1 kg")
+    unit2 = Unit.new("1 mm")
+    assert_raise(ArgumentError) { unit1 > unit2 }
+  end
+  
+  def test_add_like_units
+    unit1 = Unit.new("1 mm")
+    unit2 = Unit.new("2 mm")
+    assert_nothing_raised {  
+      assert_equal 3.0, (unit1+unit2).scalar
+      }
+  end
+  
+  def test_add_similar_units
+    unit1 = Unit.new("1 cm")
+    unit2 = Unit.new("1 in")
+    assert_nothing_raised {
+      unit3 = unit1 + unit2
+      assert_in_delta 3.54, unit3.scalar, 0.01
+      }
+  end
+
+  def test_subtract_similar_units
+    unit1 = Unit.new("1 cm")
+    unit2 = Unit.new("1 in")
+    assert_nothing_raised {
+      unit3 = unit1 - unit2
+      assert_in_delta(-1.54, unit3.scalar, 0.01)
+      }
+  end
+  
+  def test_add_unlike_units
+    unit1 = Unit.new("1 mm")
+    unit2 = Unit.new("2 ml")
+    assert_raise(ArgumentError) {(unit1+unit2).scalar}
+  end
+  
+  def test_add_coerce
+    unit1 = "1 mm".unit
+    assert_nothing_raised {
+      unit2 = unit1 + "1 mm"
+      assert_equal "2 mm".unit, unit2
+    }
+    assert_nothing_raised {
+      unit2 = unit1 + [1,"mm"]
+      assert_equal "2 mm".unit, unit2
+    }
+    assert_nothing_raised {
+      unit2 = "1".unit + 1
+      assert_equal "2".unit, unit2
+    }
+    assert_raises(ArgumentError) {
+      "1".unit + nil
+    }
+  end
+
+  def test_subtract_coerce
+    unit1 = "1 mm".unit
+    assert_nothing_raised {
+      unit2 = unit1 - "1 mm"
+      assert_equal "0 mm".unit, unit2
+    }
+  end
+  def test_multiply_coerce
+    unit1 = "1 mm".unit
+    assert_nothing_raised {
+      unit2 = unit1 * "1 mm"
+      assert_equal "1 mm^2".unit, unit2
+    }
+  end
+  def test_divide_coerce
+    unit1 = "1 mm".unit
+    assert_nothing_raised {
+      unit2 = unit1 / "1 mm"
+      assert_equal "1".unit, unit2
+    }
+  end
+  
+  def test_signature #"1 m s deg K kg A mol cd byte rad
+    unit1 = Unit.new("1 m*s*degK*kg*A*mol*cd*byte*rad*dollar")
+    assert_equal unit1.signature, (0..9).inject(0) {|product, n| product + 20**n}
+  end
+  
+  def test_subtract_like_units
+    unit1 = Unit.new("1 mm")
+    unit2 = Unit.new("2 mm")
+    assert_nothing_raised {
+      assert_equal(-1, (unit1-unit2).scalar)
+      }
+  end
+  
+  def test_subtract_unlike_units
+    unit1 = Unit.new("1 mm")
+    unit2 = Unit.new("2 ml")
+    assert_raise(ArgumentError) {(unit1-unit2).scalar}
+  end
+  
+  def test_multiply
+    unit1 = Unit.new("1 m/ms")
+    unit2 = Unit.new("1 m/ms")
+    assert_nothing_raised {
+      unit3 = unit1 * unit2
+      assert_equal Unit.new("1 m^2/ms^2"), unit3    
+    }
+    assert_equal unit1 * 0, '0 m/ms'.unit
+  end
+  
+  def test_divide
+    unit1 = Unit.new("200 M*g/mol")
+    unit2 = Unit.new("200 g/mole")
+    assert_nothing_raised {
+      unit3 = unit1 / unit2
+      assert_equal Unit.new("1 M"), unit3
+      }
+    assert_equal unit2 / 1, unit2
+    unit3 = '0 s'.unit
+    assert_raises(ZeroDivisionError) {
+      unit1 / unit3
+    }
+    
+    assert_raises(ZeroDivisionError) {
+      unit1 / 0
+    }
+  end
+  
+  def test_inverse
+    unit1 = Unit.new("1 m")
+    unit2 = Unit.new("1 1/m")
+    assert_equal unit2, unit1.inverse
+    assert_raises((ZeroDivisionError)) { 0.unit.inverse }
+  end
+  
+  def test_exponentiate_positive
+    unit1 = Unit.new("1 mm")
+    unit2 = Unit.new("1 mm^2")
+    assert_nothing_raised {
+      assert_equal unit2, unit1**2
+      }
+  end
+  
+  def test_exponentiate_float
+    unit1 = Unit.new("1 mm")
+    assert_raise(ArgumentError) {unit1**2.5}
+  end
+   
+  def test_exponentiate_negative
+    unit1 = Unit.new("1 m")
+    unit2 = Unit.new("1 m^-2")
+    assert_nothing_raised {
+      assert_equal unit2, unit1**-2
+      }
+    assert_raises(ZeroDivisionError) {
+      "0 mm".unit**-1
+    }
+  end
+
+  def test_exponentiate_zero
+    unit1 = Unit.new("10 mm")
+    unit2 = Unit.new("1")
+    assert_nothing_raised {
+      assert_equal unit2, unit1**0
+    }
+    assert_equal 1, "0 mm".unit**0
+  end
+  
+  def test_abs
+    unit1 = Unit.new("-1 mm")
+    assert_equal "1 mm".unit, unit1.abs
+  end
+  
+  def test_ceil
+    unit1 = Unit.new("1.1 mm")
+    unit2 = Unit.new("2 mm")
+    assert_equal unit2, unit1.ceil
+    assert_equal(('1 mm'.unit / '1 mm'.unit).ceil, 1)  
+    assert_equal("11 kg*m".unit, ("1003 kg*m".unit / 100).ceil)
+  end
+  
+  def test_floor
+    unit1 = Unit.new("1.1 mm")
+    unit2 = Unit.new("1 mm")
+    assert_equal unit2, unit1.floor
+    assert_equal(('1 mm'.unit / '1 mm'.unit).floor, 1)
+  end
+  
+  def test_to_int
+    assert_raises(RuntimeError)  {Unit.new("1.1 mm").to_i}
+    assert_nothing_raised {Unit.new(10.5).to_i}
+  end
+  
+  def test_truncate
+    unit1 = Unit.new("1.1 mm")
+    unit2 = Unit.new("1 mm")
+    assert_equal unit2, unit1.truncate
+    assert_equal((unit1/unit2).truncate, 1)
+  end
+  
+  def test_round
+    unit1 = Unit.new("1.1 mm")
+    unit2 = Unit.new("1 mm")
+    assert_equal unit2, unit1.round
+    assert_equal((unit1/unit2).round, 1)
+  end
+  
+  def test_zero?
+    unit1 = Unit.new("0")
+    assert unit1.zero?
+  end
+  
+  def test_nonzero?
+    unit1 = Unit.new("0")
+    unit2 = Unit.new("1 mm")
+    assert_nil unit1.nonzero?
+    assert_equal unit2, unit2.nonzero?
+  end
+  
+  def test_equality
+    unit1 = Unit.new("1 cm")
+    unit2 = Unit.new("10 mm")
+    assert unit1 == unit2
+  end
+  
+  def test_temperature_conversions
+    assert_raises(ArgumentError) { '-1 tempK'.unit}
+    assert_raises(ArgumentError) { '-1 tempR'.unit}
+    assert_raises(ArgumentError) { '-1000 tempC'.unit}
+    assert_raises(ArgumentError) { '-1000 tempF'.unit}
+    
+    assert_in_delta '32 tempF'.unit.base_scalar, '0 tempC'.unit.base_scalar, 0.01
+    assert_in_delta '0 tempC'.unit.base_scalar, '32 tempF'.unit.base_scalar, 0.01
+    assert_in_delta '0 tempC'.unit.base_scalar, '273.15 tempK'.unit.base_scalar, 0.01
+    assert_in_delta '0 tempC'.unit.base_scalar, '491.67 tempR'.unit.base_scalar, 0.01
+    
+    a = '10 degC'.unit
+    assert_equal a >> 'tempC', '-263.15 tempC'.unit
+    assert_equal a >> 'tempK', '10 tempK'.unit
+    assert_equal a >> 'tempR', '18 tempR'.unit
+    assert_equal a >> 'tempF', '-441.67 tempF'.unit
+    
+    unit1 = '37 tempC'.unit
+    assert_equal unit1 >> 'tempF' >> 'tempK' >> 'tempR' >> 'tempC', unit1
+    
+    a = '100 tempF'.unit
+    b = '10 degC'.unit
+    c = '50 tempF'.unit
+    d = '18 degF'.unit
+    assert_equal('118 tempF'.unit,a+b)
+    assert_equal b+a, '118 tempF'.unit
+    assert_equal a-b, '82 tempF'.unit
+    assert_in_delta((a-c).scalar, '50 degF'.unit.scalar, 0.01)
+    assert_in_delta '20 degC'.unit.scalar, (b+d).scalar, 0.01
+    assert_raises(ArgumentError) { a * b }
+    assert_raises(ArgumentError) { a / b }
+    assert_raises(ArgumentError) { a ** 2 }
+    assert_raises(ArgumentError) { c - '400 degK'.unit}
+    assert_equal a, a.to('tempF')
+  end
+  
+  def test_feet
+    unit1 = Unit.new("6'6\"")
+    assert_in_delta 6.5, unit1.scalar, 0.01
+    unit2 = "6'".unit
+    assert_equal unit2, '6 feet'.unit
+    unit3 = '6"'.unit
+    assert_equal unit3, '6 inch'.unit
+
+  end
+  
+  def test_pounds
+    unit1 = Unit.new("8 pounds, 8 ounces")
+    assert_in_delta 8.5, unit1.scalar, 0.01
+    assert_equal '150#'.unit, '150 lbs'.unit
+  end
+  
+  # these units are 'ambiguous' and could be mis-parsed
+  def test_parse_tricky_units
+    unit1 = Unit.new('1 mm')      #sometimes parsed as 'm*m'
+    assert_equal ['<milli>','<meter>'], unit1.numerator
+    unit2 = Unit.new('1 cd')      # could be a 'centi-day' instead of a candela
+    assert_equal ['<candela>'], unit2.numerator
+    unit3 = Unit.new('1 min')      # could be a 'milli-inch' instead of a minute
+    assert_equal ['<minute>'], unit3.numerator
+    unit4 = Unit.new('1 ft')      # could be a 'femto-ton' instead of a foot
+    assert_equal ['<foot>'], unit4.numerator  
+    unit5 = "1 atm".unit
+    assert_equal ['<atm>'], unit5.numerator
+    unit6 = "1 doz".unit
+    assert_equal ['<dozen>'], unit6.numerator
+  end
+   
+  def test_to_s
+    unit1 = Unit.new("1")
+    assert_equal "1", unit1.to_s
+    unit2 = Unit.new("mm")
+    assert_equal "1 mm", unit2.to_s
+    assert_equal "0.04 in", unit2.to_s("%0.2f in")
+    assert_equal "1/10 cm", unit2.to_s("cm")
+    unit3 = Unit.new("1 mm")
+    assert_equal "1 mm", unit3.to_s
+    assert_equal "0.04 in", unit3.to_s("%0.2f in")
+    unit4 = Unit.new("1 mm^2")
+    assert_equal "1 mm^2", unit4.to_s
+    unit5 = Unit.new("1 mm^2 s^-2")
+    assert_equal "1 mm^2/s^2", unit5.to_s
+    unit6= Unit.new("1 kg*m/s")
+    assert_equal "1 kg*m/s", unit6.to_s
+    unit7= Unit.new("1 1/m")
+    assert_equal "1 1/m", unit7.to_s
+    assert_equal("1.5 mm", Unit.new("1.5 mm").to_s)
+    assert_equal("1.5 mm", "#{Unit.new('1.5 mm')}")
+  end
+  
+  def test_to_feet_inches
+    unit1 = Unit.new("6'5\"")
+    assert_equal "6'5\"", unit1.to_s(:ft)
+    assert_raises(ArgumentError) {
+      unit1 = Unit.new("1 kg")
+      unit1.to_s(:ft)
+    }
+  end
+  
+  def test_to_lbs_oz
+    unit1 = Unit.new("8 lbs 8 oz")
+    assert_equal "8 lbs, 8 oz", unit1.to_s(:lbs)
+    assert_raises(ArgumentError) {
+      unit1 = Unit.new("1 m")
+      unit1.to_s(:lbs)
+    }
+  end
+  
+  def test_add_units
+    a = Unit.new("1 inchworm")
+    assert_equal "1 inworm", a.to_s
+  end
+  
+  def test_ideal_gas_law
+    p = Unit "100 kPa"
+    v = Unit "1 m^3"
+    n = Unit "1 mole"
+    r = Unit "8.31451 J/mol*degK"
+    t = ((p*v)/(n*r)).to('tempK')
+    assert_in_delta 12027.16,t.base_scalar, 0.1
+  end
+  
+  
+  def test_eliminate_terms
+    a = ['<meter>','<meter>','<kelvin>','<second>']
+    b = ['<meter>','<meter>','<second>']
+    h = Unit.eliminate_terms(1,a,b)
+    assert_equal ['<kelvin>'], h[:numerator]
+  end
+  
+  def test_to_base_consistency
+    a = "1 W*m/J*s".unit
+    assert_equal a.signature, a.to_base.signature
+  end
+  
+  def test_unit_roots
+    unit1 = Unit "2 m*J*kg"
+    unit2 = Unit "4 m^2*J^2*kg^2"
+    unit3 = Unit "8 m^3*J^3*kg^3"
+    assert_equal unit2**(1/2), unit1
+    assert_equal unit3**(1/3), unit1
+  end
+  
+  def test_inspect
+    unit1 = Unit "1 mm"
+    assert_equal "1 mm", unit1.inspect
+    assert_not_equal "1.0 mm", unit1.inspect(:dump)
+  end
+  
+  def test_to_f
+    assert_equal 1, 1.unit.to_f
+    assert_raises(RuntimeError) {
+      assert_equal 1, "1 mm".unit.to_f
+    }
+  end
+  
+  def test_exponentiate_float2
+    assert_equal "2 m".unit, "4 m^2".unit**(0.5) 
+    assert_raises(ArgumentError) { "1 mm".unit**(2/3)}
+    assert_raises(ArgumentError) { "1 mm".unit**("A")}
+    
+  end
+  
+  def test_range
+    a = Unit "1 mm"
+    b = Unit "3 mm"
+    c = (a..b).to_a
+    assert_equal ["1 mm".unit, "2 mm".unit, "3 mm".unit], c
+  end
+  
+  def test_scientific
+    a = Unit "1e6 cells"
+    assert_equal 1e6, a.scalar
+    assert_equal "cells", a.units
+  end
+  
+	if defined?(Uncertain)
+		def test_uncertain
+			a = '1 +/- 1 mm'.unit
+			assert_equal a.to_s, '1 +/- 1 mm' 
+		end  
+	end
+  
+  def test_format
+    assert_equal "%0.2f" % "1 mm".unit, "1.00 mm" 
+  end
+  
+  def test_bad_units
+    assert_raises(ArgumentError) { '1 doohickey / thingamabob'.unit}
+    assert_raises(ArgumentError) { '1 minimeter'.unit}
+  end
+  
+  def test_currency
+    assert_nothing_raised {"$1".unit}
+  end
+  
+  def test_kind
+    a = "1 mm".unit
+    assert_equal a.kind, :length
+  end
+  
+  def test_percent
+      assert_nothing_raised {
+      	"1 percent".unit
+        "1%".unit
+        "0.01%".unit
+      }
+      a = '100 ml'.unit
+      b = '50%'.unit
+      c = a*b >> 'ml'
+      assert c =~ a
+      assert_in_delta '50 ml'.unit.scalar, c.scalar, 0.0001
+  end
+  
+  def test_parse
+    assert_nothing_raised { "1 1/m".unit }
+    assert_raises(ArgumentError) { "3 s/s/ft".unit }
+    assert_raises(ArgumentError) { "3 s**2|,s**2".unit }
+    assert_raises(ArgumentError) { "3 s**2 4s s**2".unit }
+    assert_raises(ArgumentError) { "3 s 5^6".unit }
+    assert_raises(ArgumentError) { "".unit }
+    assert_raises(ArgumentError) { " ".unit }
+    assert_raises(ArgumentError) { "\t".unit }
+    assert_raises(ArgumentError) { "\t\t".unit }
+    assert_raises(ArgumentError) { "\n".unit }
+  end
+  
+  def test_inline_conversions
+    assert_equal "60 s".unit, Unit.parse("1 min to seconds")
+    assert_equal "60 s".unit, Unit.parse("1 min as seconds")
+    assert_equal "60 s".unit, Unit.parse("1 min in seconds")
+  end
+  
+  def test_time_conversions
+    today = 'now'.to_time
+    assert_equal today,@april_fools
+    last_century = today - '150 years'.unit
+    assert_equal last_century.to_date, '1856-04-01'.to_date
+  end
+  
+  def test_coercion
+    assert_nothing_raised { 1.0 * '1 mm'.unit}
+    assert_nothing_raised { '1 mm'.unit * 1.0}
+  end
+  
+  def test_zero
+    assert_nothing_raised { Unit.new(0) }
+  end
+  
+  def test_divide_results_in_unitless
+    a = '10 mg/ml'.unit
+    b = '10 mg/ml'.unit
+    assert_equal a/b, 1
+  end
+
+  def test_wt_percent
+    a = '1 wt%'.unit
+    b = '1 g/dl'.unit
+    assert_equal a,b
+  end
+  
+  def test_parse_durations
+    assert_equal "1:00".unit, '1 hour'.unit
+    assert_equal "1:30".unit, "1.5 hour".unit
+    assert_equal "1:30:30".unit, "1.5 hour".unit + '30 sec'.unit
+    assert_equal "1:30:30,200".unit, "1.5 hour".unit + '30 sec'.unit + '200 usec'.unit
+  end
+  
+  def test_coercion_2
+    a = Dummy.new
+    b = '1 mm'.unit
+    assert_equal '2 mm'.unit, b + a
+  end
+  
+  def test_create_with_other_unit
+    a = '1 g'.unit
+    b = 0.unit(a)
+    assert_equal b, '0 g'.unit
+  end
+  
+  def test_sqrt
+    a = '-9 mm^2'.unit
+    b = a**(0.5)
+    assert_in_delta Math.sqrt(a).to_unit.scalar.real, b.scalar.real, 0.00001
+		# ruby 1.8.x uses .image while 1.9.x uses .imaginary
+		if Complex.instance_methods.include?(:imaginary)
+    	assert_in_delta Math.sqrt(a).to_unit.scalar.imaginary, b.scalar.imaginary, 0.00001
+		else
+			assert_in_delta Math.sqrt(a).to_unit.scalar.image, b.scalar.image, 0.00001
+		end
+  end
+
+	def test_div
+		assert_equal 11,"23 m".unit.div('2 m'.unit)
+	end
+	
+	def test_divmod
+		assert_equal [277,1], 555.unit('mm').divmod(2.unit('mm'))
+		assert_equal [277, 0.0010000000000000373], '0.555 m'.unit.divmod('2 mm'.unit)
+		assert_raises(ArgumentError) { '1 m'.unit.divmod('1 kg'.unit) }
+	end
+
+	if Math.respond_to?(:cbrt)
+		def test_cbrt
+			assert_in_delta '2 mm'.to_unit, Math.cbrt('8 mm^3'.to_unit), 0.0001
+		end
+	end
+  
+  def test_hypot
+    assert_equal Math.hypot('3 mm'.unit,'4 mm'.unit), '5 mm'.unit
+    assert_raises(ArgumentError) { Math.hypot('3 mm'.unit, '4 kg'.unit)}
+  end
+  
+  def test_complex
+    assert_equal '1+1i mm'.unit.scalar, Complex(1,1)
+    assert_equal '1+1i'.unit.scalar, Complex(1,1)
+    assert_raises(RuntimeError) { '1+1i mm'.unit.to_c}
+  end
+
+  def test_atan2
+    assert_equal Math.atan2('1 mm'.unit,'1 mm'.unit), Math.atan2(1,1)
+    assert_raises(ArgumentError) {Math.atan2('1 mm'.unit, '1 lb'.unit)}
+    assert_raises(RuntimeError) {Math.atan2('1 mm'.unit, 1)}
+  end
+
+  def test_rational_units
+    assert_equal '1/4 cup'.unit, '0.25 cup'.unit
+    assert_equal '1/4 in/s'.unit, '0.25 in/s'.unit
+    assert_equal '1/4'.unit, 0.25
+  end
+  
+  def test_to_date
+    a = Time.now
+    assert_equal a.send(:to_date), Date.today
+  end
+  
+  def test_natural_language
+    assert_equal Unit.parse("10 mm in cm"), '10 mm'.unit.to('cm')
+  end
+  
+  def test_round_pounds
+    assert_equal '1 lbs'.unit, '1.1 lbs'.unit.round
+  end
+
+  def test_explicit_init
+    assert_equal '1 lbf'.unit, '1 <pound-force>'.unit
+    assert_equal '1 lbs'.unit, '1 <pound>'.unit
+    assert_equal('1 kg*m'.unit, '1 <kilogram>*<meter>'.unit)
+  end
+  
+  def test_format_nil_string
+    assert_nothing_raised {"" % nil}
+    assert_nothing_raised {"" % false}
+  end
+  
+  def test_to_s_cache
+    Unit.clear_cache
+    a = Unit.new('1 mm')
+    a.to_s                # cache the conversion to itself
+    b = Unit.new('2 mm')
+    assert_equal('2 mm', b.to_s)
+    assert_equal('1/1000 m', a.to_s('m'))
+    assert_equal('1/1000 m', a.output['m'])
+  end
+    
+  def test_version
+    assert_equal('1.3.0.a', Unit::VERSION)
+  end
+  
+  def test_negation
+    a = 1.to_unit
+    assert_equal(a.class, (1-a).class)
+  end
+  
+  def test_degree
+    assert "100 tempF".unit.degree?
+    assert "100 degC".unit.degree?
+    assert !"1 mm".unit.degree?
+  end
+
+  def test_temperature
+    assert "100 tempF".unit.temperature?
+    assert !"100 degC".unit.temperature?
+    assert !"1 mm".unit.temperature?    
+  end
+  
+  def test_parse_into_numbers_and_units
+    assert_equal([1,"m"], Unit.parse_into_numbers_and_units("1 m"))
+    assert_equal([1.0,"m"], Unit.parse_into_numbers_and_units("1.0 m"))
+    assert_equal([0.1,"m"], Unit.parse_into_numbers_and_units("0.1 m"))
+    assert_equal([0.1,"m"], Unit.parse_into_numbers_and_units(".1 m"))
+    assert_equal([-1.23E-3,"m"], Unit.parse_into_numbers_and_units("-1.23E-3 m"))
+    assert_equal([1/4,"m"], Unit.parse_into_numbers_and_units("1/4 m"))
+    assert_equal([-1/4,"m"], Unit.parse_into_numbers_and_units("-1/4 m"))
+    assert_equal([1,"m"], Unit.parse_into_numbers_and_units("1   m"))
+    assert_equal([1,"m"], Unit.parse_into_numbers_and_units("m"))
+    assert_equal([10,""], Unit.parse_into_numbers_and_units("10"))
+    assert_equal([10.0,""], Unit.parse_into_numbers_and_units("10.0"))
+    assert_equal([(1/4),""], Unit.parse_into_numbers_and_units("1/4"))
+    assert_equal([Complex(1,1),""], Unit.parse_into_numbers_and_units("1+1i"))
+  end
+
+end
+