nano-fast-sys 0.0.1

data/ffaker-2.25.0/test/test_animal_es.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestAnimalsES < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(FFaker::AnimalES, :common_name)
+
+  def setup
+    @tester = FFaker::AnimalES
+  end
+
+  def test_name
+    assert_include @tester::COMMON_NAMES, @tester.common_name
+  end
+end

data/ffaker-2.25.0/test/test_animal_pl.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestAnimalsPL < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(FFaker::AnimalPL, :common_name)
+
+  def setup
+    @tester = FFaker::AnimalPL
+  end
+
+  def test_name
+    assert_include(@tester::COMMON_NAMES, @tester.common_name)
+  end
+end

data/ffaker-2.25.0/test/test_animal_us.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestAnimalsUS < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(FFaker::AnimalUS, :common_name)
+
+  def setup
+    @tester = FFaker::AnimalUS
+  end
+
+  def test_name
+    assert_include @tester::COMMON_NAMES, @tester.common_name
+  end
+end

data/ffaker-2.25.0/test/test_array_utils.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+require 'set'
+
+class TestArrayUtils < Test::Unit::TestCase
+  include DeterministicHelper
+
+  def setup
+    @array = FFaker::ArrayUtils.const_array('a'..'c')
+    @elems = Set.new('a'..'c')
+  end
+
+  def test_provides_a_way_of_freezing_the_elements_and_itself
+    assert @array.respond_to?(:freeze_all)
+    @array.freeze_all
+    assert @array.frozen?
+    @array.each { |e| assert e.frozen? }
+  end
+
+  def test_provides_a_way_of_getting_a_random_element
+    set = Set.new
+    1000.times { set << @array.sample }
+    assert set == @elems
+  end
+
+  def test_provides_a_way_of_getting_n_random_elements
+    assert_equal @array.sample(3).sort, @array.sort
+
+    1.upto(3) do |n|
+      1000.times do
+        new_arr = @array.sample(n)
+        assert_equal n, new_arr.length
+        new_arr.each do |e|
+          assert @elems.include? e
+        end
+      end
+    end
+  end
+
+  def test_provides_a_way_of_shuffling_the_array
+    assert_equal @array.shuffle.sort, @array.sort
+
+    different_arrangements = 0
+
+    1000.times do
+      new_arr = @array.shuffle
+      assert new_arr.to_set == @elems
+      different_arrangements += 1 if new_arr != @array
+    end
+
+    assert different_arrangements.positive?
+  end
+
+  def test_self_random_pick_is_deterministic
+    supress_warn_output do
+      array = Array.new(10) { rand(0..9) }
+      assert_deterministic { FFaker::ArrayUtils.random_pick(array, 3) }
+    end
+  end
+
+  def test_self_rand_is_deterministic
+    supress_warn_output do
+      array = Array.new(10) { rand(0..9) }
+      assert_deterministic { FFaker::ArrayUtils.rand(array) }
+    end
+  end
+
+  def test_self_shuffle_is_deterministic
+    array = Array.new(10) { rand(0..9) }
+    assert_deterministic { FFaker::ArrayUtils.shuffle(array) }
+  end
+
+  def test_rand_is_deterministic
+    supress_warn_output do
+      assert_deterministic { @array.rand }
+    end
+  end
+
+  def test_random_pick_is_deterministic
+    supress_warn_output do
+      assert_deterministic { @array.random_pick(2) }
+    end
+  end
+
+  def test_shuffle_is_deterministic
+    assert_deterministic { @array.shuffle }
+  end
+
+  private
+
+  # Suppress the deprecation warning that some methods output, so we get less
+  # noise in our test run.
+  def supress_warn_output
+    original_verbosity = $VERBOSE
+    $VERBOSE = nil
+    yield
+    $VERBOSE = original_verbosity
+  end
+end

data/ffaker-2.25.0/test/test_avatar.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestAvatar < Test::Unit::TestCase
+  include DeterministicHelper
+
+  ROBOHASH = 'https://robohash.org'
+
+  assert_methods_are_deterministic(FFaker::Avatar, :image)
+
+  def setup
+    @tester = FFaker::Avatar
+  end
+
+  def test_avatar
+    assert_match(%r{\Ahttps://robohash\.org/.+\.png\?size=300x300\z},
+                 @tester.image)
+  end
+
+  def test_image_output_with_keyword_arguments
+    output = capture_output do
+      @tester.image(format: 'jpg')
+    end
+
+    assert_equal ['', ''], output
+  end
+
+  def test_image_with_slug_as_positional_argument
+    assert_equal("#{ROBOHASH}/foobar.png?size=300x300", @tester.image('foobar'))
+  end
+
+  def test_image_output_with_positional_arguments
+    output = capture_output do
+      @tester.image('foobar')
+    end
+
+    assert_equal(
+      ['', "Positional arguments for Avatar#image are deprecated. Please use keyword arguments.\n"],
+      output
+    )
+  end
+
+  def test_avatar_with_param
+    assert_equal("#{ROBOHASH}/faker.png?size=300x300", @tester.image(slug: 'faker'))
+  end
+
+  def test_avatar_with_correct_size
+    assert_equal("#{ROBOHASH}/faker.png?size=150x320",
+                 @tester.image(slug: 'faker', size: '150x320'))
+  end
+
+  def test_avatar_with_incorrect_size
+    assert_raise ArgumentError do
+      @tester.image(size: '150x320z')
+    end
+  end
+
+  def test_avatar_with_supported_format
+    assert_equal("#{ROBOHASH}/faker.jpg?size=300x300",
+                 @tester.image(slug: 'faker', size: '300x300', format: 'jpg'))
+  end
+
+  def test_avatar_with_incorrect_format
+    assert_raise ArgumentError do
+      @tester.image(size: '300x300', format: 'wrong_format')
+    end
+  end
+
+  def test_avatar_with_correct_background
+    assert_equal("#{ROBOHASH}/faker.png?size=300x300&bgset=bg1",
+                 @tester.image(slug: 'faker', size: '300x300', format: 'png', bgset: '1'))
+  end
+
+  def test_avatar_with_incorrect_background
+    assert_raise ArgumentError do
+      @tester.image(slug: 'faker', size: '300x300', format: 'png', bgset: 'not_a_number')
+    end
+  end
+end

data/ffaker-2.25.0/test/test_aws.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestAWS < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(FFaker::AWS, :instance_type)
+
+  def test_instance_type
+    assert_match(/\A[a-z]+\d\.\d*[a-z]+/, FFaker::AWS.instance_type)
+  end
+
+  def test_offering_type
+    assert_match(/\A[ a-zA-Z]+\z/i, FFaker::AWS.offering_type)
+  end
+
+  def test_instance_tenancy
+    assert_match(/\A(?:default|dedicated|host)+\z/i, FFaker::AWS.instance_tenancy)
+  end
+
+  def test_product_description
+    assert_match(%r{\A[ /a-zA-Z()]+\z}i, FFaker::AWS.product_description)
+  end
+end

data/ffaker-2.25.0/test/test_bacon_ipsum.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestBaconIpsum < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFaker::BaconIpsum,
+    :paragraph, :sentence, :paragraphs, :sentences, :words, :word
+  )
+
+  def test_paragraph
+    assert_match(/1\+|[ a-z]+/i, FFaker::BaconIpsum.paragraph)
+  end
+
+  def test_sentence
+    assert_match(/1\+|[ a-z]+/i, FFaker::BaconIpsum.sentence)
+  end
+
+  def test_paragraphs
+    assert_match(/1\+|[ a-z]+/i, FFaker::BaconIpsum.paragraphs.join(' '))
+  end
+
+  def test_sentences
+    assert_match(/1\+|[ a-z]+/i, FFaker::BaconIpsum.sentences.join(' '))
+  end
+
+  def test_words
+    assert_match(/1\+|[ a-z]+/i, FFaker::BaconIpsum.words.join(' '))
+  end
+
+  def test_word
+    assert_match(/1\+|[a-z]+/i, FFaker::BaconIpsum.word)
+  end
+end

data/ffaker-2.25.0/test/test_bank.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestBank < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFaker::Bank,
+    :iban, :card_number, :card_expiry_date, :card_type, :loan_interest_rate, :loan_term, :loan_amount
+  )
+
+  def setup
+    @tester = FFaker::Bank
+  end
+
+  def test_iban
+    assert_match(/[A-Z]{2}\d+([A-Z]+)?\d+/, @tester.iban)
+    assert_match(/[A-Z]{2}\d+([A-Z]+)?\d+/, @tester.iban(country_code: 'by'))
+    assert_match(/[A-Z]{2}\d+([A-Z]+)?\d+/, @tester.iban(country_code: 'BY'))
+    assert_raise ArgumentError, "Unexpected country code: 'unknown'" do
+      @tester.iban(country_code: 'unknown')
+    end
+  end
+
+  def test_card_number
+    assert_match(/\A(\d{4} ){3}\d{4}\z/, @tester.card_number)
+  end
+
+  def test_card_expiry_date
+    assert_instance_of String, @tester.card_expiry_date
+
+    date_today = ::DateTime.now
+
+    assert_random_between(
+      date_today.strftime('%y')..date_today.next_year(5).strftime('%y')
+    ) do
+      @tester.card_expiry_date.split('/').pop
+    end
+
+    year_range = 4
+    year_latest = 8
+    assert_random_between(
+      date_today.prev_year(year_latest + year_range).strftime('%y')..date_today.prev_year(year_latest).strftime('%y')
+    ) do
+      @tester.card_expiry_date(year_range: year_range, year_latest: year_latest).split('/').pop
+    end
+  end
+
+  def test_card_type
+    assert_include @tester::CARD_TYPES, @tester.card_type
+  end
+
+  def test_loan_interest_rate
+    rate = FFaker::Bank.loan_interest_rate
+    assert(rate.to_f.between?(1.5, 15.0), "Rate #{rate} is out of bounds")
+  end
+
+  def test_loan_term
+    assert_includes([12, 24, 36, 48, 60, 72, 84], FFaker::Bank.loan_term)
+  end
+
+  def test_loan_amount
+    amount = FFaker::Bank.loan_amount
+    assert(amount.between?(1_000, 100_000), "Amount #{amount} is out of bounds")
+  end
+end

data/ffaker-2.25.0/test/test_bank_us.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestBankUS < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFaker::BankUS,
+    :account_number, :routing_number
+  )
+
+  def setup
+    @tester = FFaker::BankUS
+  end
+
+  def test_account_number
+    assert_instance_of String, @tester.account_number
+    assert_match(/\A\d{8}\z/, @tester.account_number(min_digits: 8, max_digits: 8))
+    assert_match(/\A\d{12}\z/, @tester.account_number(min_digits: 12, max_digits: 12))
+  end
+
+  def test_routing_number
+    routing_number = @tester.routing_number
+    assert_match(/\A\d{9}\z/, routing_number)
+
+    assert_true(@tester::ROUTING_NUMBER_PREFIXES.include?(routing_number[0..1]))
+
+    checksum = (
+      (7 * (routing_number[0].to_i + routing_number[3].to_i + routing_number[6].to_i)) +
+        (3 * (routing_number[1].to_i + routing_number[4].to_i + routing_number[7].to_i)) +
+        (9 * (routing_number[2].to_i + routing_number[5].to_i + routing_number[8].to_i))
+    )
+
+    assert_equal(0, checksum % 10, 'The routing number\'s checksum is not a multiple of ten')
+  end
+end

data/ffaker-2.25.0/test/test_book.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestBook < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFaker::Book,
+    :title, :genre, :author, :isbn, :description, :cover
+  )
+
+  def setup
+    @tester = FFaker::Book
+  end
+
+  def test_title
+    assert_match(/[\sa-z]+/, @tester.title)
+  end
+
+  def test_genre
+    assert_match(%r{[\w\s'/]+}, @tester.genre)
+  end
+
+  def test_author
+    assert_match(/[\sa-z]+/, @tester.author)
+  end
+
+  def test_isbn
+    assert_match(/\d+/, @tester.isbn)
+  end
+
+  def test_description
+    assert_match(/[\sa-z]+/, @tester.description)
+  end
+
+  def test_cover
+    assert_match(%r{\Ahttps://robohash\.org/.+\.png\?size=300x300\z},
+                 @tester.cover)
+  end
+
+  def test_cover_with_format
+    assert_match(%r{\Ahttps://robohash\.org/.+\.jpg\?size=300x300\z},
+                 @tester.cover(format: 'jpg'))
+  end
+
+  def test_cover_output_with_keyword_arguments
+    output = capture_output do
+      @tester.cover(format: 'jpg')
+    end
+
+    assert_equal ['', ''], output
+  end
+
+  def test_cover_with_slug_as_positional_argument
+    assert_match(%r{\Ahttps://robohash\.org/foobar\.png\?size=300x300\z},
+                 @tester.cover('foobar'))
+  end
+
+  def test_cover_output_with_positional_arguments
+    output = capture_output do
+      @tester.cover('foobar')
+    end
+
+    assert_equal(
+      ['', "Positional arguments for Book#cover are deprecated. Please use keyword arguments.\n"],
+      output
+    )
+  end
+
+  def test_orly_cover
+    assert_match(%r{\Ahttps://orly-appstore\.herokuapp\.com/generate},
+                 @tester.orly_cover)
+  end
+end

data/ffaker-2.25.0/test/test_boolean.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestBoolean < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(FFaker::Boolean, :maybe, :boolean)
+
+  def test_maybe
+    maybe = FFaker::Boolean.maybe
+    assert [true, false].include?(maybe)
+  end
+
+  def test_boolean_with_default_ratio
+    true_count = 0
+    1000.times do
+      true_count += 1 if FFaker::Boolean.boolean
+    end
+    assert_in_delta 0.5, true_count / 1000.0, 0.1
+  end
+
+  def test_boolean_with_true_ratio
+    true_ratio = 0.8
+    true_count = 0
+    1000.times do
+      true_count += 1 if FFaker::Boolean.boolean(true_ratio: true_ratio)
+    end
+    assert_in_delta true_ratio, true_count / 1000.0, 0.1
+  end
+
+  def test_boolean_with_true_ratio_zero
+    true_ratio = 0
+    100.times do
+      assert_equal false, FFaker::Boolean.boolean(true_ratio: true_ratio)
+    end
+  end
+
+  def test_boolean_with_true_ratio_one
+    true_ratio = 1
+    100.times do
+      assert_equal true, FFaker::Boolean.boolean(true_ratio: true_ratio)
+    end
+  end
+end

data/ffaker-2.25.0/test/test_cheesy_lingo.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestCheesyLingo < Test::Unit::TestCase
+  include DeterministicHelper
+
+  TEST_REGEX = /\+1|[a-z]+/i
+
+  assert_methods_are_deterministic(
+    FFaker::CheesyLingo,
+    :title, :word, :words, :sentence, :paragraph
+  )
+
+  def setup
+    @tester = FFaker::CheesyLingo
+  end
+
+  def test_title
+    assert_match(TEST_REGEX, @tester.title)
+  end
+
+  def test_word
+    assert_match(TEST_REGEX, @tester.word)
+  end
+
+  def test_words
+    assert_match(TEST_REGEX, @tester.words(3).join(' '))
+  end
+
+  def test_sentence
+    assert_match(TEST_REGEX, @tester.sentence)
+    assert_match(/1\+|[ a-zA-Z]+./, @tester.sentence)
+  end
+
+  def test_paragraph
+    assert_match(/\+|[a-zA-Z]*./, @tester.paragraph(1))
+  end
+
+  def test_paragraph_with_arg
+    assert_match(/\+1|[a-zA-Z]+./, @tester.paragraph(3))
+  end
+end

data/ffaker-2.25.0/test/test_code.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestCode < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(FFaker::Code, :ean, :npi)
+
+  def test_npi_legacy_regexp
+    assert FFaker::Code.npi(legacy: true).match(/\A(1|2)[0-9]{9}\z/)
+  end
+
+  def test_npi
+    FFaker::Random.seed = 523_456_789
+    assert FFaker::Code.npi == '7411850515'
+  end
+
+  def test_deterministic_npi
+    FFaker::Random.seed = 42
+    v = FFaker::Code.npi
+    FFaker::Random.reset!
+    assert v == FFaker::Code.npi
+  end
+
+  def test_valid_npi
+    FFaker::Random.seed = 123_456_789
+    assert FFaker::Code.npi == '2410167607'
+  end
+
+  def test_ean
+    assert FFaker::Code.ean.match(/^\d{13}$/)
+  end
+
+  def test_ean_deterministic
+    FFaker::Random.seed = 10
+    assert_equal FFaker::Code.ean, '1399378750693'
+  end
+end