Създаване на хеш чрез map

Програмиране с Ruby

Курс във Факултета по Математика и Информатика към СУ

Решение на Четвърта задача - Unit тестване от Владимир Алексиев

Обратно към всички решения

Към профила на Владимир Алексиев

Резултати

  • 5 точки от тестове
  • 0 бонус точки
  • 5 точки общо
  • 16 успешни тест(а)
  • 3 неуспешни тест(а)

Код

RSpec.describe 'Version' do
describe '#initialize' do
it 'initializes correctly with empty version' do
expect { Version.new }.not_to raise_error
end
it 'initializes correctly with valid version string' do
expect { Version.new('0.1.3') }.not_to raise_error
end
it 'raises if invalid version is passed to the contructor' do
expect { Version.new('.1.3') }.to raise_error(ArgumentError)
end
it 'raises if invalid version is passed with a nice message' do
message = "Invalid version string '.1.3'"
expect { Version.new('.1.3') }.to raise_error(ArgumentError, message)
end
end
describe '#to_s' do
it 'drops unneded zeros' do
expect(Version.new('1.1.0').to_s).to eq('1.1')
end
it 'returns the version as string' do
expect(Version.new('1.2.3').to_s).to eq('1.2.3')
end
end
describe '#components' do
let (:version) { Version.new('1.2.3.4.0') }
it 'positions param is optional' do
expect { version.components }.not_to raise_error
end
it 'returns as many positions as required' do
expect(version.components(2).size).to eq(2)
end
it 'skips unneded zeroes' do
expect(version.components.size).to eq(4)
end
it 'returns the components' do
expect(version.components).to match_array([1, 2, 3, 4])
end
end
describe '#<=>' do
it '> returns false if the left version is smaller' do
expect(Version.new('1') > Version.new('2.0')).to be false
end
it '> returns true if the left version is bigger' do
expect(Version.new('3.0') > Version.new('2')).to be true
end
it '< returns false if the left version is bigger' do
expect(Version.new('4.0') < Version.new('2')).to be false
end
it '< returns true if the left version is smaller' do
expect(Version.new('1') < Version.new('2.0.0.0.0')).to be true
end
it '>= returns false if the left version is smaller' do
expect(Version.new('1') >= Version.new('2.0')).to be false
end
it '>= returns true if the left version is bigger' do
expect(Version.new('3.0') >= Version.new('2')).to be true
end
it '>= returns true if the version are the same' do
expect(Version.new('3.0') >= Version.new('3')).to be true
end
it '<= returns false if the left version is bigger' do
expect(Version.new('4.0') <= Version.new('2')).to be false
end
it '<= returns true if the left version is smaller' do
expect(Version.new('1') <= Version.new('2.0.0.0.0')).to be true
end
it '<= returns true if the versions are the same' do
expect(Version.new('2') <= Version.new('2.0.0.0.0')).to be true
end
it '== returns true if the version are the same' do
expect(Version.new('3.0') == Version.new('3')).to be true
end
it '== returns false if the versions are different' do
expect(Version.new('2.1') == Version.new('2')).to be false
end
it '!= returns false if the version are the same' do
expect(Version.new('3.0') != Version.new('3')).to be false
end
it '!= returns true if the versions are different' do
expect(Version.new('2.1') != Version.new('2')).to be true
end
it '<=> returns -1 if the left version is smaller' do
expect(Version.new('3.0') <=> Version.new('3.0.0.1')).to be -1
end
it '<=> returns 0 if the versions are the same' do
expect(Version.new('2.1') <=> Version.new('2.1.0')).to be 0
end
it '<=> returns 1 if right version is smaller' do
expect(Version.new('2.1') <=> Version.new('2.0.1')).to be 1
end
it '<=> works with string as left version' do
expect('3.0' <=> Version.new('3.0.0.1')).to be -1
end
it '<=> works with string as right version' do
expect(Version.new('2.1') <=> '2.1').to be 0
end
end
describe Range do
let (:range) { Version::Range.new('0.1', '1') }
describe '#initialize' do
it 'can not be initialized without versions' do
expect { Version::Range.new }.to raise_error(ArgumentError)
end
it 'can not be initialized with only one version' do
expect { Version::Range.new(12) }.to raise_error(ArgumentError)
end
it 'can not be initialized with one invalid version' do
msg = "Invalid version string '.1.3'"
err = ArgumentError
expect { Version::Range.new('.1.3', '0.12') }.to raise_error(err, msg)
end
it 'can not be initialized with two invalid versions' do
msg = "Invalid version string '.1.13'"
err = ArgumentError
expect { Version::Range.new('.1.13', '.0.12') }.to raise_error(err, msg)
end
it 'initializes correctly with mixed versions' do
expect do
Version::Range.new('0.1.3', Version.new('0.1.9'))
end.not_to raise_error
end
it 'initializes correctly with two Version instances' do
expect do
Version::Range.new(Version.new('0.1.3'), Version.new('0.1.9'))
end.not_to raise_error
end
end
describe '#to_a' do
let (:versions) do
(1..9).map do |minor|
(0..9).map do |patch|
Version.new("0.#{minor}.#{patch}")
end
end.flatten
end
it 'returns correct number of versions' do
expect(range.to_a.size).to eq(90)
end
it 'returns the correct versions' do
expect(range.to_a).to eq(versions)
end
end
describe '#include?' do
it 'works with string versions' do
expect { range.include?('0.2') }.not_to raise_error
end
['0.1.1', '0.9.9', '0.3.5'].each do |version|
it "returns true if passed string version (#{version}) is in range" do
expect(range.include?(version)).to be true
end
it "returns true if passed Version isntance (#{version}) is in range" do
expect(range.include?(Version.new(version))).to be true
end
end
['2.1.1', '1.9.9', '3.3.5'].each do |ver|
it "returns false if passed string ver (#{ver}) is not in range" do
expect(range.include?(ver)).to be false
end
it "returns false if passed ver instance (#{ver}) is not in range" do
expect(range.include?(Version.new(ver))).to be false
end
end
end
end
end

Лог от изпълнението

.........FF.....F..

Failures:

  1) spec Version tests #components with more components than present
     Failure/Error: expect(@solution).to_not pass_tests
       expected this solution to not pass the tests:
       
         class Version
           VALID_VERSION_REGEXP = /\A\z|\A[0-9]+(\.[0-9]+)*\z/
         
           include Comparable
         
           def initialize(version = '')
             unless VALID_VERSION_REGEXP.match(version.to_s)
               raise ArgumentError, "Invalid version string '#{version}'"
             end
         
             @components = version.to_s
               .split('.')
               .map(&:to_i)
               .reverse
               .drop_while(&:zero?)
               .reverse
           end
         
           def <=>(other)
             @components <=> Version.new(other).internal_components
           end
         
           def internal_components(positions = 0)
             padding_size = positions - @components.size
         
             if padding_size > 0
               @components + [0] * padding_size
             elsif positions != 0
               @components.take(positions)
             else
               @components.dup
             end
           end
         
           def components(positions = 0)
             padding_size = positions - @components.size
           
             if padding_size > 0
               [42, 42, 42, 42, 42]
             elsif positions != 0
               @components.take(positions)
             else
               @components.dup
             end
           end
         
           def to_s
             @components.join('.')
           end
         
           class Range
             include Enumerable
         
             def initialize(start_version, end_version)
               @start_version = Version.new(start_version)
               @end_version   = Version.new(end_version)
             end
         
             def include?(version)
               (@start_version <=> version) < 1 && (@end_version <=> version) == 1
             end
         
             def each
               current_version = @start_version
         
               while (current_version <=> @end_version) == -1
                 yield current_version
         
                 current_version = increment_version(current_version)
               end
             end
         
             private
         
             def increment_version(version)
               components = version.internal_components(3)
         
               components[2] += 1
         
               components.to_enum.with_index.reverse_each do |_, index|
                 component = components[index]
         
                 if component >= 10 && components[index - 1]
                   components[index]      = 0
                   components[index - 1] += 1
                 end
               end
         
               Version.new(components.join('.'))
             end
           end
         end
     # /tmp/d20161119-19072-1nli0v0/spec.rb:438:in `block (3 levels) in <top (required)>'
     # ./lib/language/ruby/run_with_timeout.rb:7:in `block (3 levels) in <top (required)>'
     # ./lib/language/ruby/run_with_timeout.rb:7:in `block (2 levels) in <top (required)>'

  2) spec Version tests that #components cannot be used to modify the version
     Failure/Error: expect(@solution).to_not pass_tests
       expected this solution to not pass the tests:
       
         class Version
           VALID_VERSION_REGEXP = /\A\z|\A[0-9]+(\.[0-9]+)*\z/
         
           include Comparable
         
           def initialize(version = '')
             unless VALID_VERSION_REGEXP.match(version.to_s)
               raise ArgumentError, "Invalid version string '#{version}'"
             end
         
             @components = version.to_s
               .split('.')
               .map(&:to_i)
               .reverse
               .drop_while(&:zero?)
               .reverse
           end
         
           def <=>(other)
             @components <=> Version.new(other).internal_components
           end
         
           def internal_components(positions = 0)
             padding_size = positions - @components.size
         
             if padding_size > 0
               @components + [0] * padding_size
             elsif positions != 0
               @components.take(positions)
             else
               @components.dup
             end
           end
         
           def components(positions = 0)
             padding_size = positions - @components.size
           
             if padding_size > 0
               @components + [0] * padding_size
             elsif positions != 0
               @components.take(positions)
             else
               @components
             end
           end
         
           def to_s
             @components.join('.')
           end
         
           class Range
             include Enumerable
         
             def initialize(start_version, end_version)
               @start_version = Version.new(start_version)
               @end_version   = Version.new(end_version)
             end
         
             def include?(version)
               (@start_version <=> version) < 1 && (@end_version <=> version) == 1
             end
         
             def each
               current_version = @start_version
         
               while (current_version <=> @end_version) == -1
                 yield current_version
         
                 current_version = increment_version(current_version)
               end
             end
         
             private
         
             def increment_version(version)
               components = version.internal_components(3)
         
               components[2] += 1
         
               components.to_enum.with_index.reverse_each do |_, index|
                 component = components[index]
         
                 if component >= 10 && components[index - 1]
                   components[index]      = 0
                   components[index - 1] += 1
                 end
               end
         
               Version.new(components.join('.'))
             end
           end
         end
     # /tmp/d20161119-19072-1nli0v0/spec.rb:456:in `block (3 levels) in <top (required)>'
     # ./lib/language/ruby/run_with_timeout.rb:7:in `block (3 levels) in <top (required)>'
     # ./lib/language/ruby/run_with_timeout.rb:7:in `block (2 levels) in <top (required)>'

  3) spec Version::Range tests include? with versions lower than the start one
     Failure/Error: expect(@solution).to_not pass_tests
       expected this solution to not pass the tests:
       
         class Version
           VALID_VERSION_REGEXP = /\A\z|\A[0-9]+(\.[0-9]+)*\z/
         
           include Comparable
         
           def initialize(version = '')
             unless VALID_VERSION_REGEXP.match(version.to_s)
               raise ArgumentError, "Invalid version string '#{version}'"
             end
         
             @components = version.to_s
               .split('.')
               .map(&:to_i)
               .reverse
               .drop_while(&:zero?)
               .reverse
           end
         
           def <=>(other)
             @components <=> Version.new(other).internal_components
           end
         
           def internal_components(positions = 0)
             padding_size = positions - @components.size
         
             if padding_size > 0
               @components + [0] * padding_size
             elsif positions != 0
               @components.take(positions)
             else
               @components.dup
             end
           end
         
           def components(positions = 0)
             padding_size = positions - @components.size
         
             if padding_size > 0
               @components + [0] * padding_size
             elsif positions != 0
               @components.take(positions)
             else
               @components.dup
             end
           end
         
           def to_s
             @components.join('.')
           end
         
           class Range
             include Enumerable
         
             def initialize(start_version, end_version)
               @start_version = Version.new(start_version)
               @end_version   = Version.new(end_version)
             end
         
             def include?(version)
               @end_version > version
             end
         
             def each
               current_version = @start_version
         
               while (current_version <=> @end_version) == -1
                 yield current_version
         
                 current_version = increment_version(current_version)
               end
             end
         
             private
         
             def increment_version(version)
               components = version.internal_components(3)
         
               components[2] += 1
         
               components.to_enum.with_index.reverse_each do |_, index|
                 component = components[index]
         
                 if component >= 10 && components[index - 1]
                   components[index]      = 0
                   components[index - 1] += 1
                 end
               end
         
               Version.new(components.join('.'))
             end
           end
         end
     # /tmp/d20161119-19072-1nli0v0/spec.rb:522:in `block (3 levels) in <top (required)>'
     # ./lib/language/ruby/run_with_timeout.rb:7:in `block (3 levels) in <top (required)>'
     # ./lib/language/ruby/run_with_timeout.rb:7:in `block (2 levels) in <top (required)>'

Finished in 19.04 seconds
19 examples, 3 failures

Failed examples:

rspec /tmp/d20161119-19072-1nli0v0/spec.rb:423 # spec Version tests #components with more components than present
rspec /tmp/d20161119-19072-1nli0v0/spec.rb:441 # spec Version tests that #components cannot be used to modify the version
rspec /tmp/d20161119-19072-1nli0v0/spec.rb:515 # spec Version::Range tests include? with versions lower than the start one

История (2 версии и 0 коментара)

Владимир обнови решението на 18.11.2016 14:56 (преди над 8 години)

+describe Version do
+ describe '#initialize' do
+ it 'initializes correctly with empty version' do
+ expect { Version.new }.not_to raise_error
+ end
+
+ it 'initializes correctly with valid version string' do
+ expect { Version.new('0.1.3') }.not_to raise_error
+ end
+
+ it 'raises if invalid version is passed to the contructor' do
+ expect { Version.new('.1.3') }.to raise_error(ArgumentError)
+ end
+
+ it 'raises if invalid version is passed with a nice message' do
+ message = "Invalid version string '.1.3'"
+ expect { Version.new('.1.3') }.to raise_error(ArgumentError, message)
+ end
+ end
+
+ describe '#to_s' do
+ it 'drops unneded zeros' do
+ expect(Version.new('1.1.0').to_s).to eq('1.1')
+ end
+
+ it 'returns the version as string' do
+ expect(Version.new('1.2.3').to_s).to eq('1.2.3')
+ end
+ end
+
+ describe '#components' do
+ let (:version) { Version.new('1.2.3.4.0') }
+
+ it 'positions param is optional' do
+ expect { version.components }.not_to raise_error
+ end
+
+ it 'returns as many positions as required' do
+ expect(version.components(2).size).to eq(2)
+ end
+
+ it 'skips unneded zeroes' do
+ expect(version.components.size).to eq(4)
+ end
+
+ it 'returns the components' do
+ expect(version.components).to match_array([1, 2, 3, 4])
+ end
+ end
+
+ describe '#<=>' do
+ it '> returns false if the left version is smaller' do
+ expect(Version.new('1') > Version.new('2.0')).to be false
+ end
+
+ it '> returns true if the left version is bigger' do
+ expect(Version.new('3.0') > Version.new('2')).to be true
+ end
+
+ it '< returns false if the left version is bigger' do
+ expect(Version.new('4.0') < Version.new('2')).to be false
+ end
+
+ it '< returns true if the left version is smaller' do
+ expect(Version.new('1') < Version.new('2.0.0.0.0')).to be true
+ end
+
+ it '>= returns false if the left version is smaller' do
+ expect(Version.new('1') >= Version.new('2.0')).to be false
+ end
+
+ it '>= returns true if the left version is bigger' do
+ expect(Version.new('3.0') >= Version.new('2')).to be true
+ end
+
+ it '>= returns true if the version are the same' do
+ expect(Version.new('3.0') >= Version.new('3')).to be true
+ end
+
+ it '<= returns false if the left version is bigger' do
+ expect(Version.new('4.0') <= Version.new('2')).to be false
+ end
+
+ it '<= returns true if the left version is smaller' do
+ expect(Version.new('1') <= Version.new('2.0.0.0.0')).to be true
+ end
+
+ it '<= returns true if the versions are the same' do
+ expect(Version.new('2') <= Version.new('2.0.0.0.0')).to be true
+ end
+
+ it '== returns true if the version are the same' do
+ expect(Version.new('3.0') == Version.new('3')).to be true
+ end
+
+ it '== returns false if the versions are different' do
+ expect(Version.new('2.1') == Version.new('2')).to be false
+ end
+
+ it '!= returns false if the version are the same' do
+ expect(Version.new('3.0') != Version.new('3')).to be false
+ end
+
+ it '!= returns true if the versions are different' do
+ expect(Version.new('2.1') != Version.new('2')).to be true
+ end
+
+ it '<=> returns -1 if the left version is smaller' do
+ expect(Version.new('3.0') <=> Version.new('3.0.0.1')).to be -1
+ end
+
+ it '<=> returns 0 if the versions are the same' do
+ expect(Version.new('2.1') <=> Version.new('2.1.0')).to be 0
+ end
+
+ it '<=> returns 1 if right version is smaller' do
+ expect(Version.new('2.1') <=> Version.new('2.0.1')).to be 1
+ end
+
+ it '<=> works with string as left version' do
+ expect('3.0' <=> Version.new('3.0.0.1')).to be -1
+ end
+
+ it '<=> works with string as right version' do
+ expect(Version.new('2.1') <=> '2.1').to be 0
+ end
+ end
+
+ describe Range do
+ let (:range) { Version::Range.new('0.1', '1') }
+
+ describe '#initialize' do
+ it 'can not be initialized without versions' do
+ expect { Version::Range.new }.to raise_error(ArgumentError)
+ end
+
+ it 'can not be initialized with only one version' do
+ expect { Version::Range.new(12) }.to raise_error(ArgumentError)
+ end
+
+ it 'can not be initialized with one invalid version' do
+ msg = "Invalid version string '.1.3'"
+ err = ArgumentError
+ expect { Version::Range.new('.1.3', '0.12') }.to raise_error(err, msg)
+ end
+
+ it 'can not be initialized with two invalid versions' do
+ msg = "Invalid version string '.1.13'"
+ err = ArgumentError
+ expect { Version::Range.new('.1.13', '.0.12') }.to raise_error(err, msg)
+ end
+
+ it 'initializes correctly with mixed versions' do
+ expect do
+ Version::Range.new('0.1.3', Version.new('0.1.9'))
+ end.not_to raise_error
+ end
+
+ it 'initializes correctly with two Version instances' do
+ expect do
+ Version::Range.new(Version.new('0.1.3'), Version.new('0.1.9'))
+ end.not_to raise_error
+ end
+ end
+
+ describe '#to_a' do
+ let (:versions) do
+ (1..9).map do |minor|
+ (0..9).map do |patch|
+ Version.new("0.#{minor}.#{patch}")
+ end
+ end.flatten
+ end
+
+ it 'returns correct number of versions' do
+ expect(range.to_a.size).to eq(90)
+ end
+
+ it 'returns the correct versions' do
+ expect(range.to_a).to eq(versions)
+ end
+ end
+
+ describe '#include?' do
+ it 'works with string versions' do
+ expect { range.include?('0.2') }.not_to raise_error
+ end
+
+ ['0.1.1', '0.9.9', '0.3.5'].each do |version|
+ it "returns true if passed string version (#{version}) is in range" do
+ expect(range.include?(version)).to be true
+ end
+
+ it "returns true if passed Version isntance (#{version}) is in range" do
+ expect(range.include?(Version.new(version))).to be true
+ end
+ end
+
+ ['2.1.1', '1.9.9', '3.3.5'].each do |ver|
+ it "returns false if passed string ver (#{ver}) is not in range" do
+ expect(range.include?(ver)).to be false
+ end
+
+ it "returns false if passed ver instance (#{ver}) is not in range" do
+ expect(range.include?(Version.new(ver))).to be false
+ end
+ end
+ end
+ end
+end

Владимир обнови решението на 18.11.2016 16:24 (преди над 8 години)

-describe Version do
+RSpec.describe 'Version' do
describe '#initialize' do
it 'initializes correctly with empty version' do
expect { Version.new }.not_to raise_error
end
it 'initializes correctly with valid version string' do
expect { Version.new('0.1.3') }.not_to raise_error
end
it 'raises if invalid version is passed to the contructor' do
expect { Version.new('.1.3') }.to raise_error(ArgumentError)
end
it 'raises if invalid version is passed with a nice message' do
message = "Invalid version string '.1.3'"
expect { Version.new('.1.3') }.to raise_error(ArgumentError, message)
end
end
describe '#to_s' do
it 'drops unneded zeros' do
expect(Version.new('1.1.0').to_s).to eq('1.1')
end
it 'returns the version as string' do
expect(Version.new('1.2.3').to_s).to eq('1.2.3')
end
end
describe '#components' do
let (:version) { Version.new('1.2.3.4.0') }
it 'positions param is optional' do
expect { version.components }.not_to raise_error
end
it 'returns as many positions as required' do
expect(version.components(2).size).to eq(2)
end
it 'skips unneded zeroes' do
expect(version.components.size).to eq(4)
end
it 'returns the components' do
expect(version.components).to match_array([1, 2, 3, 4])
end
end
describe '#<=>' do
it '> returns false if the left version is smaller' do
expect(Version.new('1') > Version.new('2.0')).to be false
end
it '> returns true if the left version is bigger' do
expect(Version.new('3.0') > Version.new('2')).to be true
end
it '< returns false if the left version is bigger' do
expect(Version.new('4.0') < Version.new('2')).to be false
end
it '< returns true if the left version is smaller' do
expect(Version.new('1') < Version.new('2.0.0.0.0')).to be true
end
it '>= returns false if the left version is smaller' do
expect(Version.new('1') >= Version.new('2.0')).to be false
end
it '>= returns true if the left version is bigger' do
expect(Version.new('3.0') >= Version.new('2')).to be true
end
it '>= returns true if the version are the same' do
expect(Version.new('3.0') >= Version.new('3')).to be true
end
it '<= returns false if the left version is bigger' do
expect(Version.new('4.0') <= Version.new('2')).to be false
end
it '<= returns true if the left version is smaller' do
expect(Version.new('1') <= Version.new('2.0.0.0.0')).to be true
end
it '<= returns true if the versions are the same' do
expect(Version.new('2') <= Version.new('2.0.0.0.0')).to be true
end
it '== returns true if the version are the same' do
expect(Version.new('3.0') == Version.new('3')).to be true
end
it '== returns false if the versions are different' do
expect(Version.new('2.1') == Version.new('2')).to be false
end
it '!= returns false if the version are the same' do
expect(Version.new('3.0') != Version.new('3')).to be false
end
it '!= returns true if the versions are different' do
expect(Version.new('2.1') != Version.new('2')).to be true
end
it '<=> returns -1 if the left version is smaller' do
expect(Version.new('3.0') <=> Version.new('3.0.0.1')).to be -1
end
it '<=> returns 0 if the versions are the same' do
expect(Version.new('2.1') <=> Version.new('2.1.0')).to be 0
end
it '<=> returns 1 if right version is smaller' do
expect(Version.new('2.1') <=> Version.new('2.0.1')).to be 1
end
it '<=> works with string as left version' do
expect('3.0' <=> Version.new('3.0.0.1')).to be -1
end
it '<=> works with string as right version' do
expect(Version.new('2.1') <=> '2.1').to be 0
end
end
describe Range do
let (:range) { Version::Range.new('0.1', '1') }
describe '#initialize' do
it 'can not be initialized without versions' do
expect { Version::Range.new }.to raise_error(ArgumentError)
end
it 'can not be initialized with only one version' do
expect { Version::Range.new(12) }.to raise_error(ArgumentError)
end
it 'can not be initialized with one invalid version' do
msg = "Invalid version string '.1.3'"
err = ArgumentError
expect { Version::Range.new('.1.3', '0.12') }.to raise_error(err, msg)
end
it 'can not be initialized with two invalid versions' do
msg = "Invalid version string '.1.13'"
err = ArgumentError
expect { Version::Range.new('.1.13', '.0.12') }.to raise_error(err, msg)
end
it 'initializes correctly with mixed versions' do
expect do
Version::Range.new('0.1.3', Version.new('0.1.9'))
end.not_to raise_error
end
it 'initializes correctly with two Version instances' do
expect do
Version::Range.new(Version.new('0.1.3'), Version.new('0.1.9'))
end.not_to raise_error
end
end
describe '#to_a' do
let (:versions) do
(1..9).map do |minor|
(0..9).map do |patch|
Version.new("0.#{minor}.#{patch}")
end
end.flatten
end
it 'returns correct number of versions' do
expect(range.to_a.size).to eq(90)
end
it 'returns the correct versions' do
expect(range.to_a).to eq(versions)
end
end
describe '#include?' do
it 'works with string versions' do
expect { range.include?('0.2') }.not_to raise_error
end
['0.1.1', '0.9.9', '0.3.5'].each do |version|
it "returns true if passed string version (#{version}) is in range" do
expect(range.include?(version)).to be true
end
it "returns true if passed Version isntance (#{version}) is in range" do
expect(range.include?(Version.new(version))).to be true
end
end
['2.1.1', '1.9.9', '3.3.5'].each do |ver|
it "returns false if passed string ver (#{ver}) is not in range" do
expect(range.include?(ver)).to be false
end
it "returns false if passed ver instance (#{ver}) is not in range" do
expect(range.include?(Version.new(ver))).to be false
end
end
end
end
end