ffaker 2.23.0 → 2.25.0

data/lib/ffaker/guid.rb

@@ -5,8 +5,14 @@ module FFaker
     extend ModuleUtils
     extend self
 
+    # Because this method uses arbitrary hexadecimal characters it is likely to
+    # generate invalid UUIDs--UUIDs must have a version (1-8) at bits 48-51,
+    # and bits 64-65 must be 0b10.
+    #
+    # @deprecated Often generates invalid UUIDs. Use {UUID} instead.
     def guid
-      FFaker.hexify('########-####-####-####-############')
+      warn '[guid] is deprecated. Use the UUID.uuidv4 method instead.'
+      FFaker::UUID.uuidv4.upcase
     end
   end
 end

data/lib/ffaker/identification_fi.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module FFaker
+  module IdentificationFI
+    extend ModuleUtils
+    extend self
+
+    CHECK_DIGITS = '0123456789ABCDEFHJKLMNPRSTUVWXY'
+    # Number ranges in real use
+    POSSIBLY_REAL_FEMALE_INDIVIDUAL_NUMBERS = (2..898).step(2).to_a.freeze
+    POSSIBLY_REAL_MALE_INDIVIDUAL_NUMBERS = (3..899).step(2).to_a.freeze
+    # Number ranges not in real use
+    FAKE_FEMALE_INDIVIDUAL_NUMBERS = (900..998).step(2).to_a.freeze
+    FAKE_MALE_INDIVIDUAL_NUMBERS = (901..999).step(2).to_a.freeze
+
+    def identity_number(gender: FFaker::Gender.binary, birthday: FFaker::Date.birthday, fake: true)
+      day = fetch_formatted_day(birthday)
+      month = fetch_formatted_month(birthday)
+      year = fetch_formatted_year(birthday)
+      separator = fetch_separator(birthday)
+      individual_number = fetch_individual_number(gender, fake)
+      check_digit = calculate_check_digit(birthday, individual_number)
+      "#{day}#{month}#{year}#{separator}#{individual_number}#{check_digit}"
+    end
+
+    private
+
+    def fetch_formatted_day(birthday)
+      format('%.2d', birthday.day)
+    end
+
+    def fetch_formatted_month(birthday)
+      format('%.2d', birthday.month)
+    end
+
+    def fetch_formatted_year(birthday)
+      check_birth_year(birthday.year)
+      birthday.strftime('%y')
+    end
+
+    def fetch_separator(birthday)
+      case birthday.year
+      when ..1899
+        '+'
+      when 1900..1999
+        '-'
+      else
+        'A'
+      end
+    end
+
+    def fetch_individual_number(gender, fake)
+      numbers_range = if gender == 'female'
+                        fake ? FAKE_FEMALE_INDIVIDUAL_NUMBERS : POSSIBLY_REAL_FEMALE_INDIVIDUAL_NUMBERS
+                      else
+                        fake ? FAKE_MALE_INDIVIDUAL_NUMBERS : POSSIBLY_REAL_MALE_INDIVIDUAL_NUMBERS
+                      end
+      format('%.3d', fetch_sample(numbers_range))
+    end
+
+    def calculate_check_digit(birthday, individual_number)
+      digit = "#{birthday.day}#{fetch_formatted_month(birthday)}#{fetch_formatted_year(birthday)}#{individual_number}"
+              .to_i % 31
+      CHECK_DIGITS[digit]
+    end
+
+    def check_birth_year(birth_year)
+      return if birth_year.between?(1799, 2100)
+
+      raise ArgumentError, "Birth year: #{birth_year} is not between supported 1799 and 2100 range"
+    end
+  end
+end

data/lib/ffaker/identification_mx.rb

@@ -27,7 +27,7 @@ module FFaker
     def rfc_persona_moral
       consonants_n_amp = CONSONANTS + ['Ñ', '&']
       all_letters = consonants_n_amp + VOWELS
-      [fetch_sample(all_letters, count: 3), date, fetch_sample(HOMOCLAVE, count: 3)].flatten.join
+      [*fetch_sample(all_letters, count: 3), date, *fetch_sample(HOMOCLAVE, count: 3)].join
     end
 
     # http://es.wikipedia.org/wiki/Registro_Federal_de_Contribuyentes_(M%C3%A9xico)

data/lib/ffaker/job_tw.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module FFaker
+  module JobTW
+    extend ModuleUtils
+    extend self
+
+    def title
+      fetch_sample(JOB_NOUNS)
+    end
+  end
+end

data/lib/ffaker/lorem_tw.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module FFaker
+  module LoremTW
+    extend ModuleUtils
+    extend self
+
+    def word
+      fetch_sample(WORDS)
+    end
+
+    def words(num = 3)
+      fetch_sample(WORDS, count: num)
+    end
+
+    def sentence(word_count = 4)
+      s = words(word_count + rand(0..5))
+      s = s.join
+      "#{s},"
+    end
+
+    def sentences(sentence_count = 3)
+      s = (1..sentence_count).map { sentence }
+      def s.to_s
+        result = join(' ')
+        result[-1] = '。'
+        result
+      end
+      s
+    end
+
+    def paragraph(sentence_count = 3)
+      sentences(sentence_count + rand(0..2)).to_s
+    end
+
+    def paragraphs(paragraph_count = 3)
+      (1..paragraph_count).map { paragraph }
+    end
+  end
+end

data/lib/ffaker/name_pl.rb

@@ -90,9 +90,9 @@ module FFaker
 
     def name_for_gender(name_type, gender) # :nodoc:
       raise(ArgumentError, "Gender must be one of: #{GENDERS}") unless GENDERS.include?(gender)
-      return send("#{gender}_#{name_type}") unless gender == :random
+      return send(:"#{gender}_#{name_type}") unless gender == :random
 
-      fetch_sample([send("female_#{name_type}"), send("male_#{name_type}")])
+      fetch_sample([send(:"female_#{name_type}"), send(:"male_#{name_type}")])
     end
   end
 end

data/lib/ffaker/tweet.rb

@@ -19,7 +19,7 @@ module FFaker
       }.merge(args)
 
       my_reply = options[:reply] ? "#{mention} " : ''
-      my_mentions = (options[:num_mentions]).positive? ? "#{mentions(options[:num_mentions])} " : ''
+      my_mentions = options[:num_mentions].positive? ? "#{mentions(options[:num_mentions])} " : ''
       my_tags = tags(options[:num_hashtags])
 
       remaining = [

data/lib/ffaker/utils/module_utils.rb

@@ -14,7 +14,7 @@ module FFaker
 
     def const_missing(const_name)
       if const_name.match?(/[a-z]/) # Not a constant, probably a class/module name.
-        super const_name
+        super
       else
         mod_name = ancestors.first.to_s.split('::').last
         data_path = "#{FFaker::BASE_LIB_PATH}/ffaker/data/#{underscore(mod_name)}/#{underscore(const_name.to_s)}"
@@ -38,21 +38,12 @@ module FFaker
 
     # http://en.wikipedia.org/wiki/Luhn_algorithm
     def luhn_check(number)
-      multiplications = []
-
-      number.chars.each_with_index do |digit, i|
-        multiplications << i.even? ? digit.to_i * 2 : digit.to_i
-      end
-
-      sum = 0
-      multiplications.each do |num|
-        num.to_s.each_byte do |character|
-          sum += character.chr.to_i
-        end
-      end
-
-      control_digit = (sum % 10).zero? ? 0 : (((sum / 10) + 1) * 10) - sum
-      control_digit.to_s
+      sum = number.chars
+                  .map(&:to_i)
+                  .reverse
+                  .each_with_index
+                  .sum { |digit, index| index.even? ? (2 * digit).digits.sum : digit }
+      ((10 - (sum % 10)) % 10).to_s
     end
   end
 end

data/lib/ffaker/uuid.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+require 'date'
+
+module FFaker
+  # UUIDs are a 128-bit value (16 bytes), often represented as a
+  # 32-character hexadecimal string in the format
+  # `xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx`.
+  #
+  # @note This generates lowercase strings, but UUIDs are case-insensitive.
+  #
+  # @see https://www.rfc-editor.org/rfc/rfc4122#section-4
+  # @see https://datatracker.ietf.org/doc/draft-ietf-uuidrev-rfc4122bis/
+  module UUID
+    extend ModuleUtils
+    extend self
+
+    # > UUID version 4 is meant for generating UUIDs from truly-random or
+    # > pseudo-random numbers.
+    def uuidv4
+      uuid = 0
+      # random_a
+      # > The first 48 bits of the layout that can be filled with random data
+      # > as specified in Section 6.9. Occupies bits 0 through 47 (octets 0-5).
+      uuid |= rand((2**48) - 1) << 80
+      # ver
+      # > The 4 bit version field as defined by Section 4.2, set to 0b0100 (4).
+      # > Occupies bits 48 through 51 of octet 6.
+      uuid |= 0b0100 << 76
+      # random_b
+      # > 12 more bits of the layout that can be filled random data as per
+      # > Section 6.9. Occupies bits 52 through 63 (octets 6-7).
+      uuid |= rand((2**12) - 1) << 64
+      # var
+      # > The 2 bit variant field as defined by Section 4.1, set to 0b10.
+      # > Occupies bits 64 and 65 of octet 8.
+      uuid |= 0b10 << 62
+      # random_c
+      # > The final 62 bits of the layout immediately following the var field
+      # > field to be filled with random data as per Section 6.9. Occupies bits
+      # > 66 through 127 (octets 8-15).
+      uuid |= rand((2**62) - 1)
+
+      as_string(uuid)
+    end
+
+    # > UUID version 6 is a field-compatible version of UUIDv1 Section 5.1,
+    # > reordered for improved DB locality. It is expected that UUIDv6 will
+    # > primarily be used in contexts where UUIDv1 is used. Systems that do not
+    # > involve legacy UUIDv1 SHOULD use UUIDv7 instead.
+    def uuidv6
+      timestamp = rand((2**60) - 1)
+
+      uuid = 0
+      # time_high
+      # > The most significant 32 bits of the 60 bit starting timestamp.
+      # > Occupies bits 0 through 31 (octets 0-3).
+      # @note Shifts 28 bits to remove `time_mid` and `time_low`.
+      uuid |= (timestamp >> 28) << 96
+      # time_mid
+      # > The middle 16 bits of the 60 bit starting timestamp. Occupies bits 32
+      # > through 47 (octets 4-5).
+      # @note Shifts 12 bits to remove `time_low`.
+      uuid |= ((timestamp >> 12) & ((2**16) - 1)) << 80
+      # ver
+      # > The 4 bit version field as defined by Section 4.2, set to 0b0110 (6).
+      # > Occupies bits 48 through 51 of octet 6.
+      uuid |= 0b0110 << 76
+      # time_low
+      # > 12 bits that will contain the least significant 12 bits from the 60
+      # > bit starting timestamp. Occupies bits 52 through 63 (octets 6-7).
+      uuid |= (timestamp & ((2**12) - 1)) << 64
+      # var
+      # > The 2 bit variant field as defined by Section 4.1, set to 0b10.
+      # > Occupies bits 64 and 65 of octet 8.
+      uuid |= 0b10 << 62
+      # clk_seq
+      # > The 14 bits containing the clock sequence. Occupies bits 66 through
+      # > 79 (octets 8-9).
+      #
+      # (earlier in the document)
+      # > The clock sequence and node bits SHOULD be reset to a pseudo-random
+      # > value for each new UUIDv6 generated; however, implementations MAY
+      # > choose to retain the old clock sequence and MAC address behavior from
+      # > Section 5.1.
+      uuid |= rand((2**14) - 1) << 48
+      # node
+      # > 48 bit spatially unique identifier. Occupies bits 80 through 127
+      # > (octets 10-15).
+      uuid |= rand((2**48) - 1)
+
+      as_string(uuid)
+    end
+
+    # > UUID version 7 features a time-ordered value field derived from the
+    # > widely implemented and well known Unix Epoch timestamp source, the
+    # > number of milliseconds since midnight 1 Jan 1970 UTC, leap seconds
+    # > excluded. UUIDv7 generally has improved entropy characteristics over
+    # > UUIDv1 Section 5.1 or UUIDv6 Section 5.6.
+    def uuidv7
+      timestamp = rand((2**48) - 1)
+
+      uuid = 0
+      # unix_ts_ms
+      # > 48 bit big-endian unsigned number of Unix epoch timestamp in
+      # > milliseconds as per Section 6.1. Occupies bits 0 through 47 (octets
+      # > 0-5).
+      uuid |= timestamp << 80
+      # ver
+      # > The 4 bit version field as defined by Section 4.2, set to 0b0111 (7).
+      # > Occupies bits 48 through 51 of octet 6.
+      uuid |= 0b0111 << 76
+      # rand_a
+      # > 12 bits pseudo-random data to provide uniqueness as per Section 6.9
+      # > and/or optional constructs to guarantee additional monotonicity as
+      # > per Section 6.2. Occupies bits 52 through 63 (octets 6-7).
+      uuid |= rand((2**12) - 1) << 64
+      # var
+      # > The 2 bit variant field as defined by Section 4.1, set to 0b10.
+      # > Occupies bits 64 and 65 of octet 8.
+      uuid |= 0b10 << 62
+      # rand_b
+      # > The final 62 bits of pseudo-random data to provide uniqueness as per
+      # > Section 6.9 and/or an optional counter to guarantee additional
+      # > monotonicity as per Section 6.2. Occupies bits 66 through 127 (octets
+      # > 8-15).
+      uuid |= rand((2**62) - 1)
+
+      as_string(uuid)
+    end
+
+    # > UUID version 8 provides an RFC-compatible format for experimental or
+    # > vendor-specific use cases. The only requirement is that the variant and
+    # > version bits MUST be set as defined in Section 4.1 and Section 4.2.
+    # > UUIDv8's uniqueness will be implementation-specific and MUST NOT be
+    # > assumed.
+    # >
+    # > [...] To be clear: UUIDv8 is not a replacement for UUIDv4 Section 5.4
+    # > where all 122 extra bits are filled with random data.
+    def uuidv8
+      uuid = 0
+      # custom_a
+      # > The first 48 bits of the layout that can be filled as an
+      # > implementation sees fit. Occupies bits 0 through 47 (octets 0-5).
+      uuid |= rand((2**48) - 1) << 80
+      # ver
+      # > The 4 bit version field as defined by Section 4.2, set to 0b1000 (8).
+      # > Occupies bits 48 through 51 of octet 6.
+      uuid |= 0b1000 << 76
+      # custom_b
+      # > 12 more bits of the layout that can be filled as an implementation
+      # > sees fit. Occupies bits 52 through 63 (octets 6-7).
+      uuid |= rand((2**12) - 1) << 64
+      # var
+      # > The 2 bit variant field as defined by Section 4.1, set to 0b10.
+      # > Occupies bits 64 and 65 of octet 8.
+      uuid |= 0b10 << 62
+      # custom_c
+      # > The final 62 bits of the layout immediately following the var field
+      # > to be filled as an implementation sees fit. Occupies bits 66 through
+      # > 127 (octets 8-15).
+      uuid |= rand((2**62) - 1)
+
+      as_string(uuid)
+    end
+
+    private
+
+    def as_string(uuid)
+      uuid.to_s(16)
+          .rjust(32, '0')
+          .gsub(/(.{8})(.{4})(.{4})(.{4})(.{12})/, '\1-\2-\3-\4-\5')
+    end
+  end
+end

data/lib/ffaker/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module FFaker
-  VERSION = '2.23.0'
+  VERSION = '2.25.0'
 end

data/lib/ffaker.rb

@@ -76,6 +76,7 @@ module FFaker
     'ua' => 'UA',
     'uk' => 'UK',
     'us' => 'US',
+    'uuid' => 'UUID',
     'vn' => 'VN'
   }
 

data/test/helper.rb

@@ -35,7 +35,7 @@ module DeterministicHelper
       end
     operator_name += '_or_equal_to' if operator[1] == '='
 
-    define_method "assert_#{operator_name}" do |got, expected|
+    define_method :"assert_#{operator_name}" do |got, expected|
       assert(
         got.public_send(operator, expected),
         "Expected #{operator} \"#{expected}\", but got #{got}"
@@ -56,8 +56,8 @@ module DeterministicHelper
   end
 
   %w[less_than_or_equal_to between].each do |method_name|
-    define_method "assert_random_#{method_name}" do |*args, &block|
-      assert_random(block) { send "assert_#{method_name}", block.call, *args }
+    define_method :"assert_random_#{method_name}" do |*args, &block|
+      assert_random(block) { send :"assert_#{method_name}", block.call, *args }
     end
   end
 
@@ -76,7 +76,7 @@ module DeterministicHelper
     #  }
     def assert_methods_are_deterministic(klass, *methods)
       Array(methods).each do |meth|
-        define_method "test_#{meth}_is_deterministic" do
+        define_method :"test_#{meth}_is_deterministic" do
           assert_deterministic(message: "Results from `#{klass}.#{meth}` are not repeatable") do
             klass.send(meth)
           end

data/test/test_address_ua.rb

@@ -41,7 +41,7 @@ class TestAddressUA < Test::Unit::TestCase
   end
 
   def test_street_address_with_secondary
-    assert_match( \
+    assert_match(
       /\Aвул\.\s[а-яА-ЯіїєґІЇЄҐ’\-\s]+,\s\d{1,3},\sкв\.\s\d{1,3}\z/,
       @tester.street_address(true)
     )

data/test/test_array_utils.rb

@@ -89,7 +89,7 @@ class TestArrayUtils < Test::Unit::TestCase
 
   private
 
-  # Supress the deprecation warning that some methods output, so we get less
+  # Suppress the deprecation warning that some methods output, so we get less
   # noise in our test run.
   def supress_warn_output
     original_verbosity = $VERBOSE

data/test/test_bank.rb

@@ -7,7 +7,7 @@ class TestBank < Test::Unit::TestCase
 
   assert_methods_are_deterministic(
     FFaker::Bank,
-    :iban, :card_number, :card_expiry_date, :card_type
+    :iban, :card_number, :card_expiry_date, :card_type, :loan_interest_rate, :loan_term, :loan_amount
   )
 
   def setup
@@ -50,4 +50,18 @@ class TestBank < Test::Unit::TestCase
   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/test/test_bank_us.rb

@@ -24,6 +24,8 @@ class TestBankUS < Test::Unit::TestCase
     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)) +

data/test/test_boolean.rb

@@ -5,10 +5,41 @@ require_relative 'helper'
 class TestBoolean < Test::Unit::TestCase
   include DeterministicHelper
 
-  assert_methods_are_deterministic(FFaker::Boolean, :maybe)
+  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/test/test_date.rb

@@ -22,16 +22,16 @@ class TestFakerDate < Test::Unit::TestCase
   def test_backward
     today = Date.today
 
-    assert_random_between(today - 365..today - 1) { @tester.backward }
-    assert_random_between(today - 30..today - 1) { @tester.backward(30) }
+    assert_random_between((today - 365)..(today - 1)) { @tester.backward }
+    assert_random_between((today - 30)..(today - 1)) { @tester.backward(30) }
     assert_instance_of Date, @tester.backward
   end
 
   def test_forward
     today = Date.today
 
-    assert_random_between(today + 1..today + 365) { @tester.forward }
-    assert_random_between(today + 1..today + 30) { @tester.forward(30) }
+    assert_random_between((today + 1)..(today + 365)) { @tester.forward }
+    assert_random_between((today + 1)..(today + 30)) { @tester.forward(30) }
     assert_instance_of Date, @tester.forward
   end
 

data/test/test_guid.rb

@@ -8,7 +8,7 @@ class TestGuid < Test::Unit::TestCase
   assert_methods_are_deterministic(FFaker::Guid, :guid)
 
   def test_guid
-    assert_match(/[A-F0-9]{8}-[A-F0-9]{4}-[A-F0-9]{4}-[A-F0-9]{4}-[A-F0-9]{12}/,
+    assert_match(/\A[0-9A-F]{8}-[0-9A-F]{4}-4[0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}\z/,
                  FFaker::Guid.guid)
   end
 end

data/test/test_identification_fi.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestFakerIdentificationFI < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFaker::IdentificationFI,
+    :identity_number
+  )
+
+  def setup
+    @tester = FFaker::IdentificationFI
+  end
+
+  def test_identity_number
+    general_regex = /^(0[1-9]|[1-2]\d|3[01])(0[1-9]|1[0-2])(\d\d)([-+A-FU-Y])(\d\d\d)([0-9A-FHJ-NPR-Y])$/
+    assert_match(general_regex, @tester.identity_number)
+    random_far_past_date = rand(Date.civil(1700)..Date.civil(1800))
+    assert_raises ArgumentError do
+      @tester.identity_number(birthday: random_far_past_date)
+    end
+    random_far_future_date = rand(Date.civil(2100)..Date.civil(2200))
+    assert_raises ArgumentError do
+      @tester.identity_number(birthday: random_far_future_date)
+    end
+    date_match_regex = /^010100A(\d\d\d)([0-9A-FHJ-NPR-Y])$/
+    assert_match(date_match_regex, @tester.identity_number(birthday: Date.civil(2000, 1, 1)))
+    fake_number_match_regex = /^(0[1-9]|[1-2]\d|3[01])(0[1-9]|1[0-2])(\d\d)([-+A-FU-Y])9(\d\d)([0-9A-FHJ-NPR-Y])$/
+    assert_match(fake_number_match_regex, @tester.identity_number(fake: true))
+    real_number_match_regex = /^(0[1-9]|[1-2]\d|3[01])(0[1-9]|1[0-2])(\d\d)([-+A-FU-Y])([0-8])(\d\d)([0-9A-FHJ-NPR-Y])$/
+    assert_match(real_number_match_regex, @tester.identity_number(fake: false))
+    female_match_regex = /^(0[1-9]|[1-2]\d|3[01])(0[1-9]|1[0-2])(\d\d)([-+A-FU-Y])(\d\d)([02468])([0-9A-FHJ-NPR-Y])$/
+    assert_match(female_match_regex, @tester.identity_number(gender: 'female'))
+    male_match_regex = /^(0[1-9]|[1-2]\d|3[01])(0[1-9]|1[0-2])(\d\d)([-+A-FU-Y])(\d\d)([13579])([0-9A-FHJ-NPR-Y])$/
+    assert_match(male_match_regex, @tester.identity_number(gender: 'male'))
+  end
+end

data/test/test_job_tw.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestFakerJobTW < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(FFaker::JobTW, :title)
+
+  def setup
+    @tester = FFaker::JobTW
+  end
+
+  def test_title
+    assert_greater_than_or_equal_to @tester.title.length, 1
+  end
+
+  def test_nouns
+    assert_kind_of Array, @tester::JOB_NOUNS
+  end
+end

data/test/test_lorem_br.rb

@@ -10,9 +10,9 @@ class TestLoremBR < Test::Unit::TestCase
     :paragraph, :sentence, :phrase, :paragraphs, :sentences, :phrases, :words, :word, :characters
   )
 
-  CHARACTERS = /\A[A-zÀ-ü0-9]+\z/i
-  WORD = /\A[A-zÀ-ü-]+\z/i
-  WORDS = /[ A-zÀ-ü\-.]+/i
+  CHARACTERS = /\A[A-Za-zÀ-ü0-9]+\z/i
+  WORD = /\A[A-Za-zÀ-ü-]+\z/i
+  WORDS = /[ A-Za-zÀ-ü\-.]+/i
 
   def test_paragraph
     assert_match(WORDS, FFaker::LoremBR.paragraph)