m9t 0.3.3 → 0.3.4

data/test/base_test.rb

@@ -1,55 +0,0 @@
-# encoding: utf-8
-
-require File.expand_path( 'test_helper', File.dirname( __FILE__ ) )
-
-class SomeMeasurement
-  DEFAULT_OPTIONS = {:units => :foos, :abbreviated => false, :decimals => 1}
-  CONVERSIONS     = {:foos =>      1.0,
-                     :bars => 1 / 42.0}
-
-  include M9t::Base
-end
-
-class SomeDerivedMeasurement < SomeMeasurement
-end
-
-class TestM9tBase < Test::Unit::TestCase
-
-  def setup
-    I18n.locale = :en
-    SomeMeasurement.reset_options!
-  end
-
-  # class methods
-
-  def test_class_method_missing_for_known_units
-    assert_in_delta(0.0714, SomeMeasurement.foos_to_bars(3.0), 0.001)
-  end
-
-  def test_class_method_missing_fails_on_unknown_units
-    assert_raise(RuntimeError) do
-      SomeMeasurement.bazs_to_bars(3.0)
-    end
-  end
-
-  # instance methods
-
-  def test_instance_method_missing_for_known_units
-    some = SomeMeasurement.new(3.0)
-    assert_in_delta(0.0714, some.to_bars(3.0), 0.001)
-  end
-
-  def test_instance_method_missing_fails_on_unknown_units
-    some = SomeMeasurement.new(3.0)
-    assert_raise(RuntimeError) do
-      some.to_bazs(3.0)
-    end
-  end
-
-  # derived classes
-
-  def test_derived_class_gets_options
-    assert_equal(SomeMeasurement.options, SomeDerivedMeasurement.options)
-  end
-
-end

data/test/direction_test.rb

@@ -1,106 +0,0 @@
-# encoding: utf-8
-
-require File.expand_path( 'test_helper', File.dirname( __FILE__ ) )
-
-class TestM9tDirection < Test::Unit::TestCase
-
-  def setup
-    I18n.locale = :en
-    M9t::Direction.reset_options!
-  end
-
-  # Basic use
-  def test_degrees
-    assert_equal(45, M9t::Direction.new(45).value)
-  end
-
-  # Class methods
-
-  # Base class
-
-  def test_measurement_name
-    assert_equal('direction', M9t::Direction.measurement_name)
-  end
-
-  def test_normalize
-    assert_equal(5, M9t::Direction.normalize(725))
-    assert_equal(5, M9t::Direction.normalize(-355))
-  end
-
-  def test_default_options_set
-    assert_not_nil(M9t::Direction.options)
-  end
-
-  def test_default_option_abbreviated
-    assert(! M9t::Direction.options[:abbreviated])
-  end
-
-  def test_default_option_units
-    assert_equal(:degrees, M9t::Direction.options[:units])
-  end
-
-  def test_to_degrees_identity
-    assert_equal(45, M9t::Direction.degrees_to_degrees(45))
-  end
-
-  def test_degrees_to_compass
-    assert_equal('N', M9t::Direction.degrees_to_compass(0))
-    assert_equal('NE', M9t::Direction.degrees_to_compass(42)) # Rounding up
-    assert_equal('E', M9t::Direction.degrees_to_compass(93)) # Rounding down
-    assert_equal('ESE', M9t::Direction.degrees_to_compass(113)) # 16ths
-    I18n.locale = :it
-    assert_equal('O', M9t::Direction.degrees_to_compass(270))
-  end
-
-  def test_compass
-    assert_equal(0, M9t::Direction.compass('N').value)
-    assert_equal(247.5, M9t::Direction.compass('WSW').value)
-  end
-
-  def test_compass_to_degrees
-    assert_equal(247.5, M9t::Direction.compass_to_degrees('WSW'))
-  end
-
-  # Instance methods
-
-  def test_to_s_not_abbreviated_singular
-    direction = M9t::Direction.new( 1 )
-
-    assert_equal '1 degree', direction.to_s
-    I18n.locale = :it
-    assert_equal '1 grado', direction.to_s
-  end
-
-  def test_to_s_not_abbreviated_plural
-    direction = M9t::Direction.new( 135 )
-
-    assert_equal '135 degrees', direction.to_s
-    I18n.locale = :it
-    assert_equal '135 gradi', direction.to_s
-  end
-
-  def test_to_s_abbreviated
-    direction = M9t::Direction.new( 135 )
-
-    assert_equal '135°', direction.to_s( :abbreviated => true )
-  end
-
-  def test_compass_units
-    direction = M9t::Direction.new( 225 )
-
-    assert_equal 'SW', direction.to_s( :units => :compass )
-    I18n.locale = :it
-    assert_equal 'SO', direction.to_s( :units => :compass )
-  end
-
-  def test_handles_string_leading_zero
-    assert_equal(10, M9t::Direction.new('010').value)
-  end
-
-  def test_to_compass
-    direction = M9t::Direction.new(0)
-
-    assert_equal('N', direction.to_compass)
-  end
-
-end

data/test/distance_test.rb

@@ -1,161 +0,0 @@
-# encoding: utf-8
-
-require File.expand_path( 'test_helper', File.dirname( __FILE__ ) )
-
-class TestM9tDistance < Test::Unit::TestCase
-
-  def setup
-    I18n.locale = :en
-    M9t::Distance.reset_options!
-  end
-
-  # Basic use
-  def test_singular
-    distance = M9t::Distance.new( 1 )
-    I18n.locale = :en
-
-    assert_equal('1 meter', distance.to_s( :precision => 0 ) )
-  end
-
-  def test_plural
-    distance = M9t::Distance.new( 10 )
-
-    I18n.locale = :en
-    assert_equal( '10 meters', distance.to_s( :precision => 0 ) )
-    I18n.locale = :it
-    assert_equal( '10 metri', distance.to_s( :precision => 0 ) )
-  end
-
-  # Class methods
-
-  # Base class
-
-  def test_unit_name
-    assert_equal('distance', M9t::Distance.measurement_name)
-  end
-
-  # Construction
-  # ...from meters
-  def test_new
-    assert_equal(0.3, M9t::Distance.new(0.3).to_f)
-  end
-
-  def test_class_meters
-    assert_equal(0.3, M9t::Distance.meters(0.3).to_f)
-  end
-
-  # ...from other units
-  def test_class_kilometers
-    assert_in_delta(300.0, M9t::Distance.kilometers(0.3).to_f, 0.00001)
-  end
-
-  def test_class_miles
-    assert_in_delta(1609.344, M9t::Distance.miles(1).to_f, 0.00001)
-    assert_in_delta(42194.988, M9t::Distance.miles(26.21875).to_f, 0.00001)
-  end
-
-  # Conversion class methods
-  # ...to other units
-  def test_class_meters_to_kilometers
-    assert_equal(0.0003, M9t::Distance.meters_to_kilometers(0.3))
-  end
-
-  def test_class_miles_to_kilometers
-    assert_in_delta(42.194988, M9t::Distance.miles_to_kilometers(26.21875), 0.00001)
-  end
-
-  # Default options
-
-  def test_default_options_set
-    assert_not_nil(M9t::Distance.options)
-  end
-
-  def test_default_option_abbreviated
-    assert(! M9t::Distance.options[:abbreviated])
-  end
-
-  def test_default_option_units
-    assert_equal(:meters, M9t::Distance.options[:units])
-  end
-
-  def test_default_option_decimals
-    assert_equal(5, M9t::Distance.options[:precision])
-  end
-
-  # Instance methods
-
-  # Conversion
-  def test_instance_to_meters
-    assert_equal(0.3, M9t::Distance.new(0.3).to_meters)
-  end
-
-  def test_instance_to_kilometers
-    assert_equal(0.0003, M9t::Distance.new(0.3).to_kilometers)
-  end
-
-  def test_instance_to_kilometers
-    assert_in_delta(0.98425, M9t::Distance.new(0.3).to_feet, 0.00001)
-  end
-
-  # to_s
-  def test_to_s_singular
-    assert_equal('1.00000 meter', M9t::Distance.new(1).to_s)
-  end
-
-  def test_to_s_plural
-    assert_equal('0.30000 meters', M9t::Distance.new(0.3).to_s)
-  end
-
-  # i18n
-  def test_to_s_plural_abbreviated
-    distance = M9t::Distance.new( 10 )
-    I18n.locale = :en
-    assert_equal( '10m', distance.to_s( :abbreviated => true,
-                                        :precision   => 0 ) )
-    I18n.locale = :it
-    assert_equal( '10m', distance.to_s( :abbreviated => true,
-                                        :precision   => 0 ) )
-  end
-
-  def test_to_s_abbreviated
-    distance = M9t::Distance.new( 0.3 )
-
-    assert_equal( '0.30000m', distance.to_s( :abbreviated => true ) )
-  end
-
-  def test_to_s_precision
-    distance = M9t::Distance.new( 0.3 )
-
-    assert_equal( '0.3m', distance.to_s( :precision   => 1,
-                                         :abbreviated => true ) )
-  end
-
-  def test_to_s_kilometers
-    distance = M9t::Distance.new( 156003 )
-
-    assert_equal( '156.0 kilometers', distance.to_s( :precision => 1,
-                                                     :units     => :kilometers ) )
-  end
-
-  def test_miles_singular
-    marathon = M9t::Distance.miles( 26.21875 )
-    I18n.locale = :en
-    assert_equal( '26 miles', marathon.to_s( :units     => :miles,
-                                             :precision => 0 ) )
-    I18n.locale = :it
-    assert_equal( '26 miglia', marathon.to_s( :units     => :miles,
-                                              :precision => 0 ) )
-  end
-
-  def test_to_s_miles_plural
-    ten_km = M9t::Distance.new( 10000 )
-
-    I18n.locale = :en
-    assert_equal( '6.2 miles', ten_km.to_s( :units     => :miles,
-                                            :precision => 1 ) )
-    I18n.locale = :it
-    assert_equal( '6,2 miglia', ten_km.to_s( :units     => :miles,
-                                             :precision => 1 ) )
-  end
-
-end

data/test/i18n_test.rb

@@ -1,42 +0,0 @@
-# encoding: utf-8
-
-require File.expand_path( 'test_helper', File.dirname( __FILE__ ) )
-
-class TestI18nMonkeyPatching < Test::Unit::TestCase
-  def setup
-    @old_locale = I18n.locale
-  end
-
-  def teardown
-    I18n.locale = @old_locale
-  end
-
-  def test_english_loaded
-    I18n.locale = :en
-    assert_equal('.', I18n.t('numbers.decimal_separator'))
-  end
-
-  def test_italian_loaded
-    I18n.locale = :it
-    assert_equal(',', I18n.t('numbers.decimal_separator'))
-  end
-
-  def test_german_loaded
-    I18n.locale = :de
-    assert_equal('Meile', I18n.t('units.distance.miles.full.one'))
-  end
-
-  def test_localize_float_default
-    assert_equal('1.500000', I18n.localize_float(1.5))
-  end
-
-  def test_localize_float_formatted
-    assert_equal('1.5', I18n.localize_float(1.5, {:format => '%0.1f'}))
-  end
-
-  def test_localize_float_italian
-    I18n.locale = :it
-    assert_equal('1,5', I18n.localize_float(1.5, {:format => '%0.1f'}))
-  end
-end
-

data/test/pressure_test.rb

@@ -1,25 +0,0 @@
-# encoding: utf-8
-
-require File.expand_path( 'test_helper', File.dirname( __FILE__ ) )
-
-class TestM9tDistance < Test::Unit::TestCase
-
-  def setup
-    I18n.locale = :en
-    M9t::Pressure.reset_options!
-  end
-
-  # Basic use
-  def test_bar
-    assert_equal(1.0, M9t::Pressure.new(1.0).value)
-  end
-
-  def test_hectopascals
-    assert_equal(0.001, M9t::Pressure.hectopascals(1.0).value)
-  end
-
-  def test_inches_of_mercury
-    assert_in_delta(0.03386, M9t::Pressure.inches_of_mercury(1.0).value, 0.00001)
-  end
-
-end

data/test/speed_test.rb

@@ -1,104 +0,0 @@
-# encoding: utf-8
-
-require File.expand_path( 'test_helper', File.dirname( __FILE__ ) )
-
-class TestM9tSpeed < Test::Unit::TestCase
-
-  def setup
-    I18n.locale = :en
-    M9t::Speed.reset_options!
-  end
-
-  # Basic use
-  def test_new
-    assert_equal(45, M9t::Speed.new(45).value)
-  end
-
-  # Class methods
-
-  # Base class
-
-  def test_measurement_name
-    assert_equal('speed', M9t::Speed.measurement_name)
-  end
-
-  # conversion constants
-
-  def test_knot_conversion
-    assert_in_delta(1.9438, M9t::Speed::KNOTS, 0.0001)
-  end
-
-  # input conversions
-
-  def test_class_kilometers_per_hour
-    assert_in_delta(0.2778, M9t::Speed.kilometers_per_hour(1).value, 0.0001)
-  end
-
-  def test_class_miles_per_hour
-    assert_in_delta(0.447, M9t::Speed.miles_per_hour(1).value, 0.0001)
-  end
-
-  def test_class_knots
-    assert_in_delta 0.5144, M9t::Speed.knots(1).value, 0.0001
-  end
-
-  # output conversions
-
-  def test_class_to_miles_per_hour
-    assert_in_delta(100.6621, M9t::Speed.meters_per_second_to_miles_per_hour(45), 0.0001)
-  end
-
-  # Instance methods
-
-  # new
-
-  def test_unknown_units
-    speed = M9t::Speed.new( '010' )
-
-    assert_raises( M9t::UnitError ) do
-      speed.to_s( :units => :foos )
-    end
-  end
-
-  # output conversions
-
-  def test_kmh
-    assert_equal(162, M9t::Speed.new(45).to_kilometers_per_hour)
-  end
-
-  def test_mph
-    assert_in_delta(100.6621, M9t::Speed.new(45).to_miles_per_hour, 0.0001)
-  end
-
-  # to_s
-
-  def test_to_s
-    assert_equal '135.00000 meters per second', M9t::Speed.new(135).to_s
-    I18n.locale = :it
-    assert_equal '135,00000 metri al second', M9t::Speed.new(135).to_s
-  end
-
-  def test_to_s_precision
-    speed = M9t::Speed.new( 135 )
-
-    assert_equal '135 meters per second', speed.to_s( :precision => 0 )
-  end
-
-  def test_to_s_abbreviated
-    speed = M9t::Speed.new( 135 )
-
-    assert_equal '135m/s', speed.to_s( :abbreviated => true,
-                                       :precision   => 0 )
-  end
-
-  def test_to_s_knots
-    speed = M9t::Speed.new( 135 )
-
-    assert_equal '262 knots', speed.to_s( :units     => :knots,
-                                          :precision => 0 )
-    I18n.locale = :it
-    assert_equal '262 nodi',  speed.to_s( :units     => :knots,
-                                          :precision => 0 )
-  end
-
-end