ffaker 1.32.1 → 2.0.0

data/test/test_lorem_cn.rb

@@ -4,44 +4,44 @@ require 'helper'
 
 class TestLoremCN < Test::Unit::TestCase
   def test_paragraph
-    assert Faker::LoremCN.paragraph.length >= 3*4*2
+    assert FFaker::LoremCN.paragraph.length >= 3*4*2
   end
 
   def test_sentence
-    assert Faker::LoremCN.sentence.length >= 4*2
+    assert FFaker::LoremCN.sentence.length >= 4*2
   end
 
   def test_paragraphs
-    assert Faker::LoremCN.paragraphs.length >= 2
+    assert FFaker::LoremCN.paragraphs.length >= 2
   end
 
   def test_paragraphs_is_not_a_string_representation_of_an_array
-    assert !/[\[\]]+/.match([Faker::LoremCN.paragraphs].flatten.join(' '))
+    assert !/[\[\]]+/.match([FFaker::LoremCN.paragraphs].flatten.join(' '))
   end
 
   def test_paragraphs_is_an_array
-    assert Faker::LoremCN.paragraphs.class == Array
+    assert FFaker::LoremCN.paragraphs.class == Array
   end
 
   def test_sentences
-    assert Faker::LoremCN.sentences.length >= 2
+    assert FFaker::LoremCN.sentences.length >= 2
   end
 
   def test_sentences_is_an_array
-    assert Faker::LoremCN.sentences.class == Array
+    assert FFaker::LoremCN.sentences.class == Array
   end
 
   def test_sentences_via_to_s_produces_string_terminated_with_period
-    string = Faker::LoremCN.sentences.to_s
+    string = FFaker::LoremCN.sentences.to_s
     assert string.class == String
     assert string =~ /。$/
   end
 
   def test_words
-    assert Faker::LoremCN.words.length >= 2
+    assert FFaker::LoremCN.words.length >= 2
   end
 
   def test_word
-    assert Faker::LoremCN.word.length >= 1
+    assert FFaker::LoremCN.word.length >= 1
   end
 end

data/test/test_lorem_fr.rb

@@ -4,34 +4,34 @@ require 'helper'
 
 class TestLoremFR < Test::Unit::TestCase
   def test_paragraph
-    assert_match /\A[ -.àâéèêîôùûa-z]+\z/i, Faker::LoremFR.paragraph
+    assert_match /\A[ -.àâéèêîôùûa-z]+\z/i, FFaker::LoremFR.paragraph
   end
 
   def test_sentence
-    assert_match /\A[ -.àâéèêîôùûa-z]+\z/i, Faker::LoremFR.sentence
+    assert_match /\A[ -.àâéèêîôùûa-z]+\z/i, FFaker::LoremFR.sentence
   end
 
   def test_phrase
-    assert_match /\A[ -.àâéèêîôùûa-z]+\z/i, Faker::LoremFR.phrase
+    assert_match /\A[ -.àâéèêîôùûa-z]+\z/i, FFaker::LoremFR.phrase
   end
 
   def test_paragraphsLoremFR
-    assert_match /\A[ -.àâéèêîôùûa-z]+\z/i, Faker::LoremFR.paragraphs.join(" ")
+    assert_match /\A[ -.àâéèêîôùûa-z]+\z/i, FFaker::LoremFR.paragraphs.join(" ")
   end
 
   def test_sentences
-    assert_match /\A[ -.àâéèêîôùûa-z]+\z/i, Faker::LoremFR.sentences.join(" ")
+    assert_match /\A[ -.àâéèêîôùûa-z]+\z/i, FFaker::LoremFR.sentences.join(" ")
   end
 
   def test_phrases
-    assert_match /\A[ -.àâéèêîôùûa-z]+\z/i, Faker::LoremFR.phrases.join(" ")
+    assert_match /\A[ -.àâéèêîôùûa-z]+\z/i, FFaker::LoremFR.phrases.join(" ")
   end
 
   def test_words
-    assert_match /\A[ -àâéèêîôùûa-z]+\z/i, Faker::LoremFR.words.join(" ")
+    assert_match /\A[ -àâéèêîôùûa-z]+\z/i, FFaker::LoremFR.words.join(" ")
   end
 
   def test_word
-    assert_match /\A[-àâéèêîôùûa-z]+\z/i, Faker::LoremFR.word
+    assert_match /\A[-àâéèêîôùûa-z]+\z/i, FFaker::LoremFR.word
   end
 end

data/test/test_lorem_kr.rb

@@ -7,7 +7,7 @@ class TestLoremKR < Test::Unit::TestCase
   KOREAN_WORDS_MATCHER = /\A[ 가-힣]+\z/
   KOREAN_WORD_MATCHER = /\A[가-힣]+\z/
   def setup
-    @tester = Faker::LoremKR
+    @tester = FFaker::LoremKR
   end
 
   def test_paragraph
@@ -17,7 +17,7 @@ class TestLoremKR < Test::Unit::TestCase
   def test_sentence
     assert_match KOREAN_SENTENCE_MATCHER, @tester.sentence
     assert_nothing_thrown do
-      100.times { Faker::Lorem.sentence 0 }
+      100.times { FFaker::Lorem.sentence 0 }
     end
   end
 

data/test/test_module_utils.rb

@@ -5,7 +5,7 @@ require 'helper'
 class TestModuleUtils < Test::Unit::TestCase
   def test_provides_a_k_method_for_generating_constant_arrays
     obj = Object.new
-    obj.extend Faker::ModuleUtils
+    obj.extend FFaker::ModuleUtils
     result = obj.k ["1","2","3"]
 
     assert result.frozen?

data/test/test_movie.rb

@@ -4,6 +4,6 @@ require 'helper'
 
 class TestMovie < Test::Unit::TestCase
   def test_title
-    assert_match /[ a-z]+/, Faker::Movie.title
+    assert_match /[ a-z]+/, FFaker::Movie.title
   end
 end

data/test/test_name.rb

@@ -4,7 +4,7 @@ require 'helper'
 
 class TestFakerName < Test::Unit::TestCase
   def setup
-    @tester = Faker::Name
+    @tester = FFaker::Name
   end
 
   def test_name

data/test/test_name_br.rb

@@ -4,7 +4,7 @@ require 'helper'
 
 class TestFakerNameBR < Test::Unit::TestCase
   def setup
-    @tester = Faker::NameBR
+    @tester = FFaker::NameBR
   end
 
   def test_name

data/test/test_name_cn.rb

@@ -4,7 +4,7 @@ require 'helper'
 
 class TestFakerNameCN < Test::Unit::TestCase
   def setup
-    @tester = Faker::NameCN
+    @tester = FFaker::NameCN
   end
 
   def test_name

data/test/test_name_cs.rb

@@ -4,7 +4,7 @@ require 'helper'
 
 class TestFakerNameCS < Test::Unit::TestCase
   def setup
-    @tester = Faker::NameCS
+    @tester = FFaker::NameCS
   end
 
   def test_name
@@ -19,19 +19,19 @@ class TestFakerNameCS < Test::Unit::TestCase
   end
 
   def test_male_last_name
-    assert Faker::NameCS::LAST_NAMES[:male].include?(@tester.last_name(:male))
+    assert FFaker::NameCS::LAST_NAMES[:male].include?(@tester.last_name(:male))
   end
 
   def test_male_first_name
-    assert Faker::NameCS::FIRST_NAMES[:male].include?(@tester.first_name(:male))
+    assert FFaker::NameCS::FIRST_NAMES[:male].include?(@tester.first_name(:male))
   end
 
   def test_prefix
-    assert Faker::NameCS::PREFIXES.include?(@tester.prefix)
+    assert FFaker::NameCS::PREFIXES.include?(@tester.prefix)
   end
 
   def test_suffix
-    assert Faker::NameCS::SUFFIXES.include?(@tester.suffix)
+    assert FFaker::NameCS::SUFFIXES.include?(@tester.suffix)
   end
 
   def test_with_same_sex
@@ -56,7 +56,7 @@ class TestFakerNameCS < Test::Unit::TestCase
   def same_sex?(words, sex = :any)
     (sex == :any ? [:male, :female] : [sex]).any? do |sex|
       words.all? do |word|
-        [Faker::NameCS::LAST_NAMES, Faker::NameCS::FIRST_NAMES].any? do |names|
+        [FFaker::NameCS::LAST_NAMES, FFaker::NameCS::FIRST_NAMES].any? do |names|
           names[sex].include?(word)
         end
       end

data/test/test_name_de.rb

@@ -4,7 +4,7 @@ require 'helper'
 
 class TestFakerNameDE < Test::Unit::TestCase
   def setup
-    @tester = Faker::NameDE
+    @tester = FFaker::NameDE
   end
 
   def test_name

data/test/test_name_fr.rb

@@ -2,23 +2,23 @@
 
 require 'helper'
 
-# Author: PapePathe<pathe.sene@gmail.com> github.com/PapePathe 
+# Author: PapePathe<pathe.sene@gmail.com> github.com/PapePathe
 class TestFakerNameFR < Test::Unit::TestCase
 
   def setup
-    @tester = Faker::NameFR
+    @tester = FFaker::NameFR
   end
 
   def test_last_name
-    assert Faker::NameFR::LAST_NAMES.include?(@tester.last_name)
+    assert FFaker::NameFR::LAST_NAMES.include?(@tester.last_name)
   end
 
   def test_first_name
-    assert Faker::NameFR::FIRST_NAMES.include?(@tester.first_name)
+    assert FFaker::NameFR::FIRST_NAMES.include?(@tester.first_name)
   end
 
   def test_prefix
-    assert Faker::NameFR::PREFIX.include?(@tester.prefix)
+    assert FFaker::NameFR::PREFIX.include?(@tester.prefix)
   end
 
 
@@ -28,20 +28,20 @@ class TestFakerNameFR < Test::Unit::TestCase
 
     if parts.count == 3
       # the value at the index 1 should be a valid! prefix
-      assert Faker::NameFR::PREFIX.include?(parts[1])
+      assert FFaker::NameFR::PREFIX.include?(parts[1])
 
       # the value at the index 0 should be a valid! male_first_name
-      assert Faker::NameFR::FIRST_NAMES.include?(parts[0])
+      assert FFaker::NameFR::FIRST_NAMES.include?(parts[0])
 
       # the value at the index 2 should be a valid! last_name
-      assert Faker::NameFR::LAST_NAMES.include?(parts[2])
+      assert FFaker::NameFR::LAST_NAMES.include?(parts[2])
 
     elsif parts.count == 2
       # the value at the index 0 should be a valid! prefix
-      assert Faker::NameFR::FIRST_NAMES.include?(parts[0])
+      assert FFaker::NameFR::FIRST_NAMES.include?(parts[0])
 
       # the value at the index 1 should be a valid! last_name
-      assert Faker::NameFR::LAST_NAMES.include?(parts[1])
+      assert FFaker::NameFR::LAST_NAMES.include?(parts[1])
     end
   end
 

data/test/test_name_ga.rb

@@ -5,19 +5,19 @@ require 'helper'
 class TestFakerNameGa < Test::Unit::TestCase
 
   def setup
-    @tester = Faker::NameGA
+    @tester = FFaker::NameGA
   end
 
   def test_last_name
-    assert Faker::NameGA::LAST_NAMES.include?(@tester.last_name)
+    assert FFaker::NameGA::LAST_NAMES.include?(@tester.last_name)
   end
 
   def test_first_name_male
-    assert Faker::NameGA::FIRST_NAMES_MALE.include?(@tester.first_name_male)
+    assert FFaker::NameGA::FIRST_NAMES_MALE.include?(@tester.first_name_male)
   end
 
   def test_first_name_female
-    assert Faker::NameGA::FIRST_NAMES_FEMALE.include?(@tester.first_name_female)
+    assert FFaker::NameGA::FIRST_NAMES_FEMALE.include?(@tester.first_name_female)
   end
 
   def test_name_male
@@ -25,22 +25,22 @@ class TestFakerNameGa < Test::Unit::TestCase
     parts = @tester.name_male.split(' ')
 
     # the value at the index 0 should be a valid! male_prefix
-    assert Faker::NameGA::FIRST_NAMES_MALE.include?(parts[0])
+    assert FFaker::NameGA::FIRST_NAMES_MALE.include?(parts[0])
 
     # the value at the index 1 should be a valid! last_name
-    assert Faker::NameGA::LAST_NAMES.include?(parts[1])
-  end	
+    assert FFaker::NameGA::LAST_NAMES.include?(parts[1])
+  end
 
   def test_name_female
     # => split the name_male into an array of words
     parts = @tester.name_female.split(' ')
 
     # the value at the index 0 should be a valid! male_prefix
-    assert Faker::NameGA::FIRST_NAMES_FEMALE.include?(parts[0])
+    assert FFaker::NameGA::FIRST_NAMES_FEMALE.include?(parts[0])
 
     # the value at the index 1 should be a valid! last_name
-    assert Faker::NameGA::LAST_NAMES.include?(parts[1])
-  end	
+    assert FFaker::NameGA::LAST_NAMES.include?(parts[1])
+  end
 
 
   def test_name
@@ -48,9 +48,9 @@ class TestFakerNameGa < Test::Unit::TestCase
     parts = @tester.name.split(' ')
 
     # the value at the index 0 should be a valid! male_prefix
-    assert Faker::NameGA::FIRST_NAMES_FEMALE.include?(parts[0]) || Faker::NameGA::FIRST_NAMES_MALE.include?(parts[0])
+    assert FFaker::NameGA::FIRST_NAMES_FEMALE.include?(parts[0]) || FFaker::NameGA::FIRST_NAMES_MALE.include?(parts[0])
 
     # the value at the index 1 should be a valid! last_name
-    assert Faker::NameGA::LAST_NAMES.include?(parts[1])
+    assert FFaker::NameGA::LAST_NAMES.include?(parts[1])
   end
 end

data/test/test_name_it.rb

@@ -2,23 +2,23 @@
 
 require 'helper'
 
-# Author: PapePathe<pathe.sene@gmail.com> github.com/PapePathe 
+# Author: PapePathe<pathe.sene@gmail.com> github.com/PapePathe
 class TestFakerNameIT < Test::Unit::TestCase
 
   def setup
-    @tester = Faker::NameIT
+    @tester = FFaker::NameIT
   end
 
   def test_last_name
-    assert Faker::NameIT::LAST_NAMES.include?(@tester.last_name)
+    assert FFaker::NameIT::LAST_NAMES.include?(@tester.last_name)
   end
 
   def test_first_name
-    assert Faker::NameIT::FIRST_NAMES.include?(@tester.first_name)
+    assert FFaker::NameIT::FIRST_NAMES.include?(@tester.first_name)
   end
 
   def test_prefix
-    assert Faker::NameIT::PREFIX.include?(@tester.prefix)
+    assert FFaker::NameIT::PREFIX.include?(@tester.prefix)
   end
 
 
@@ -28,20 +28,20 @@ class TestFakerNameIT < Test::Unit::TestCase
 
     if parts.count == 3
       # the value at the index 0 should be a valid! prefix
-      assert Faker::NameIT::PREFIX.include?(parts[0])
+      assert FFaker::NameIT::PREFIX.include?(parts[0])
 
       # the value at the index 1 should be a valid! first_name
-      assert Faker::NameIT::FIRST_NAMES.include?(parts[1])
+      assert FFaker::NameIT::FIRST_NAMES.include?(parts[1])
 
       # the value at the index 2 should be a valid! last_name
-      assert Faker::NameIT::LAST_NAMES.include?(parts[2])
+      assert FFaker::NameIT::LAST_NAMES.include?(parts[2])
 
     elsif parts.count == 2
       # the value at the index 0 should be a valid! prefix
-      assert Faker::NameIT::FIRST_NAMES.include?(parts[0])
+      assert FFaker::NameIT::FIRST_NAMES.include?(parts[0])
 
       # the value at the index 1 should be a valid! last_name
-      assert Faker::NameIT::LAST_NAMES.include?(parts[1])
+      assert FFaker::NameIT::LAST_NAMES.include?(parts[1])
     end
   end
 

data/test/test_name_ja.rb

@@ -4,10 +4,10 @@ require 'helper'
 
 class TestFakerNameJA < Test::Unit::TestCase
   def setup
-    @tester = Faker::NameJA
+    @tester = FFaker::NameJA
   end
 
   def test_name
-    assert Faker::NameJA.name.length >= 2
+    assert FFaker::NameJA.name.length >= 2
   end
 end

data/test/test_name_kr.rb

@@ -4,7 +4,7 @@ require 'helper'
 
 class TestFakerNameKR < Test::Unit::TestCase
   def setup
-    @tester = Faker::NameKR
+    @tester = FFaker::NameKR
   end
 
   def test_name

data/test/test_name_mx.rb

@@ -6,12 +6,12 @@ require 'helper'
 class TestFakerNameMX < Test::Unit::TestCase
 
   def setup
-    @tester = Faker::NameMX
-    @all_names = Faker::NameMX::MALE_FIRST_NAMES + Faker::NameMX::FEMALE_FIRST_NAMES
+    @tester = FFaker::NameMX
+    @all_names = FFaker::NameMX::MALE_FIRST_NAMES + FFaker::NameMX::FEMALE_FIRST_NAMES
   end
 
   def test_last_name
-    assert Faker::NameMX::LAST_NAMES.include?(@tester.last_name)
+    assert FFaker::NameMX::LAST_NAMES.include?(@tester.last_name)
   end
 
   def test_first_name
@@ -27,32 +27,32 @@ class TestFakerNameMX < Test::Unit::TestCase
   end
 
   def test_prefix_male
-    assert Faker::NameMX::MALE_PREFIXES.include?(@tester.male_prefix)
+    assert FFaker::NameMX::MALE_PREFIXES.include?(@tester.male_prefix)
   end
 
   def test_prefix_female
-    assert Faker::NameMX::FEMALE_PREFIXES.include?(@tester.female_prefix)
+    assert FFaker::NameMX::FEMALE_PREFIXES.include?(@tester.female_prefix)
   end
 
   def test_prefix
-    assert Faker::NameMX::PREFIXES.include?(@tester.prefix)
+    assert FFaker::NameMX::PREFIXES.include?(@tester.prefix)
   end
 
   def test_male_name
     parts = @tester.male_name.split(' ')
     case parts.count
-    when 1 then assert Faker::NameMX::MALE_FIRST_NAMES.include?(parts[0])
-    when 2 then assert Faker::NameMX::MALE_FIRST_NAMES.include?(parts[0]) &&
-      Faker::NameMX::MALE_FIRST_NAMES.include?(parts[1])
+    when 1 then assert FFaker::NameMX::MALE_FIRST_NAMES.include?(parts[0])
+    when 2 then assert FFaker::NameMX::MALE_FIRST_NAMES.include?(parts[0]) &&
+      FFaker::NameMX::MALE_FIRST_NAMES.include?(parts[1])
     end
   end
 
   def test_female_name
     parts = @tester.female_name.split(' ')
     case parts.count
-    when 1 then assert Faker::NameMX::FEMALE_FIRST_NAMES.include?(parts[0])
-    when 2 then assert Faker::NameMX::FEMALE_FIRST_NAMES.include?(parts[0]) &&
-      Faker::NameMX::FEMALE_FIRST_NAMES.include?(parts[1])
+    when 1 then assert FFaker::NameMX::FEMALE_FIRST_NAMES.include?(parts[0])
+    when 2 then assert FFaker::NameMX::FEMALE_FIRST_NAMES.include?(parts[0]) &&
+      FFaker::NameMX::FEMALE_FIRST_NAMES.include?(parts[1])
     end
   end
 
@@ -60,23 +60,23 @@ class TestFakerNameMX < Test::Unit::TestCase
     parts = @tester.full_name(:male).split(' ')
     case parts.count
     when 5
-      assert Faker::NameMX::MALE_PREFIXES.include?(parts[0])
-      assert Faker::NameMX::MALE_FIRST_NAMES.include?(parts[1])
+      assert FFaker::NameMX::MALE_PREFIXES.include?(parts[0])
+      assert FFaker::NameMX::MALE_FIRST_NAMES.include?(parts[1])
       # Middle name
-      assert Faker::NameMX::MALE_FIRST_NAMES.include?(parts[2])
-      assert Faker::NameMX::LAST_NAMES.include?(parts[3])
-      assert Faker::NameMX::LAST_NAMES.include?(parts[4])
+      assert FFaker::NameMX::MALE_FIRST_NAMES.include?(parts[2])
+      assert FFaker::NameMX::LAST_NAMES.include?(parts[3])
+      assert FFaker::NameMX::LAST_NAMES.include?(parts[4])
     when 4
-      prefix_or_first_name = Faker::NameMX::MALE_PREFIXES.include?(parts[0]) ||
-        Faker::NameMX::MALE_FIRST_NAMES.include?(parts[0])
+      prefix_or_first_name = FFaker::NameMX::MALE_PREFIXES.include?(parts[0]) ||
+        FFaker::NameMX::MALE_FIRST_NAMES.include?(parts[0])
       assert prefix_or_first_name
-      assert Faker::NameMX::MALE_FIRST_NAMES.include?(parts[1])
-      assert Faker::NameMX::LAST_NAMES.include?(parts[2])
-      assert Faker::NameMX::LAST_NAMES.include?(parts[3])
+      assert FFaker::NameMX::MALE_FIRST_NAMES.include?(parts[1])
+      assert FFaker::NameMX::LAST_NAMES.include?(parts[2])
+      assert FFaker::NameMX::LAST_NAMES.include?(parts[3])
     when 3
-      assert Faker::NameMX::MALE_FIRST_NAMES.include?(parts[0])
-      assert Faker::NameMX::LAST_NAMES.include?(parts[1])
-      assert Faker::NameMX::LAST_NAMES.include?(parts[2])
+      assert FFaker::NameMX::MALE_FIRST_NAMES.include?(parts[0])
+      assert FFaker::NameMX::LAST_NAMES.include?(parts[1])
+      assert FFaker::NameMX::LAST_NAMES.include?(parts[2])
     else
       flunk "Invalid Male Name"
     end
@@ -86,23 +86,23 @@ class TestFakerNameMX < Test::Unit::TestCase
     parts = @tester.full_name(:female).split(' ')
     case parts.count
     when 5
-      assert Faker::NameMX::FEMALE_PREFIXES.include?(parts[0])
-      assert Faker::NameMX::FEMALE_FIRST_NAMES.include?(parts[1])
+      assert FFaker::NameMX::FEMALE_PREFIXES.include?(parts[0])
+      assert FFaker::NameMX::FEMALE_FIRST_NAMES.include?(parts[1])
       # Middle name
-      assert Faker::NameMX::FEMALE_FIRST_NAMES.include?(parts[2])
-      assert Faker::NameMX::LAST_NAMES.include?(parts[3])
-      assert Faker::NameMX::LAST_NAMES.include?(parts[4])
+      assert FFaker::NameMX::FEMALE_FIRST_NAMES.include?(parts[2])
+      assert FFaker::NameMX::LAST_NAMES.include?(parts[3])
+      assert FFaker::NameMX::LAST_NAMES.include?(parts[4])
     when 4
-      prefix_or_first_name = Faker::NameMX::FEMALE_PREFIXES.include?(parts[0]) ||
-        Faker::NameMX::FEMALE_FIRST_NAMES.include?(parts[0])
+      prefix_or_first_name = FFaker::NameMX::FEMALE_PREFIXES.include?(parts[0]) ||
+        FFaker::NameMX::FEMALE_FIRST_NAMES.include?(parts[0])
       assert prefix_or_first_name
-      assert Faker::NameMX::FEMALE_FIRST_NAMES.include?(parts[1])
-      assert Faker::NameMX::LAST_NAMES.include?(parts[2])
-      assert Faker::NameMX::LAST_NAMES.include?(parts[3])
+      assert FFaker::NameMX::FEMALE_FIRST_NAMES.include?(parts[1])
+      assert FFaker::NameMX::LAST_NAMES.include?(parts[2])
+      assert FFaker::NameMX::LAST_NAMES.include?(parts[3])
     when 3
-      assert Faker::NameMX::FEMALE_FIRST_NAMES.include?(parts[0])
-      assert Faker::NameMX::LAST_NAMES.include?(parts[1])
-      assert Faker::NameMX::LAST_NAMES.include?(parts[2])
+      assert FFaker::NameMX::FEMALE_FIRST_NAMES.include?(parts[0])
+      assert FFaker::NameMX::LAST_NAMES.include?(parts[1])
+      assert FFaker::NameMX::LAST_NAMES.include?(parts[2])
     else
       flunk "Invalid Female Name"
     end
@@ -112,23 +112,23 @@ class TestFakerNameMX < Test::Unit::TestCase
     parts = @tester.full_name.split(' ')
     case parts.count
     when 5
-      assert Faker::NameMX::PREFIXES.include?(parts[0])
+      assert FFaker::NameMX::PREFIXES.include?(parts[0])
       assert @all_names.include?(parts[1])
       # Middle name
       assert @all_names.include?(parts[2])
-      assert Faker::NameMX::LAST_NAMES.include?(parts[3])
-      assert Faker::NameMX::LAST_NAMES.include?(parts[4])
+      assert FFaker::NameMX::LAST_NAMES.include?(parts[3])
+      assert FFaker::NameMX::LAST_NAMES.include?(parts[4])
     when 4
-      prefix_or_first_name = Faker::NameMX::PREFIXES.include?(parts[0]) ||
+      prefix_or_first_name = FFaker::NameMX::PREFIXES.include?(parts[0]) ||
         @all_names.include?(parts[0])
       assert prefix_or_first_name
       assert @all_names.include?(parts[1])
-      assert Faker::NameMX::LAST_NAMES.include?(parts[2])
-      assert Faker::NameMX::LAST_NAMES.include?(parts[3])
+      assert FFaker::NameMX::LAST_NAMES.include?(parts[2])
+      assert FFaker::NameMX::LAST_NAMES.include?(parts[3])
     when 3
       assert @all_names.include?(parts[0])
-      assert Faker::NameMX::LAST_NAMES.include?(parts[1])
-      assert Faker::NameMX::LAST_NAMES.include?(parts[2])
+      assert FFaker::NameMX::LAST_NAMES.include?(parts[1])
+      assert FFaker::NameMX::LAST_NAMES.include?(parts[2])
     else
       flunk "Invalid Name"
     end
@@ -140,12 +140,12 @@ class TestFakerNameMX < Test::Unit::TestCase
     when 4
       assert @all_names.include?(parts[0])
       assert @all_names.include?(parts[1])
-      assert Faker::NameMX::LAST_NAMES.include?(parts[2])
-      assert Faker::NameMX::LAST_NAMES.include?(parts[3])
+      assert FFaker::NameMX::LAST_NAMES.include?(parts[2])
+      assert FFaker::NameMX::LAST_NAMES.include?(parts[3])
     when 3
       assert @all_names.include?(parts[0])
-      assert Faker::NameMX::LAST_NAMES.include?(parts[1])
-      assert Faker::NameMX::LAST_NAMES.include?(parts[2])
+      assert FFaker::NameMX::LAST_NAMES.include?(parts[1])
+      assert FFaker::NameMX::LAST_NAMES.include?(parts[2])
     else
       flunk "Invalid Name"
     end
@@ -155,23 +155,23 @@ class TestFakerNameMX < Test::Unit::TestCase
     parts = @tester.full_name_prefix.split(' ')
     case parts.count
     when 5
-      assert Faker::NameMX::PREFIXES.include?(parts[0])
+      assert FFaker::NameMX::PREFIXES.include?(parts[0])
       assert @all_names.include?(parts[1])
       # Middle name
       assert @all_names.include?(parts[2])
-      assert Faker::NameMX::LAST_NAMES.include?(parts[3])
-      assert Faker::NameMX::LAST_NAMES.include?(parts[4])
+      assert FFaker::NameMX::LAST_NAMES.include?(parts[3])
+      assert FFaker::NameMX::LAST_NAMES.include?(parts[4])
     when 4
-      prefix_or_first_name = Faker::NameMX::PREFIXES.include?(parts[0]) ||
+      prefix_or_first_name = FFaker::NameMX::PREFIXES.include?(parts[0]) ||
         @all_names.include?(parts[0])
       assert prefix_or_first_name
       assert @all_names.include?(parts[1])
-      assert Faker::NameMX::LAST_NAMES.include?(parts[2])
-      assert Faker::NameMX::LAST_NAMES.include?(parts[3])
+      assert FFaker::NameMX::LAST_NAMES.include?(parts[2])
+      assert FFaker::NameMX::LAST_NAMES.include?(parts[3])
     when 3
       assert @all_names.include?(parts[0])
-      assert Faker::NameMX::LAST_NAMES.include?(parts[1])
-      assert Faker::NameMX::LAST_NAMES.include?(parts[2])
+      assert FFaker::NameMX::LAST_NAMES.include?(parts[1])
+      assert FFaker::NameMX::LAST_NAMES.include?(parts[2])
     else
       flunk "Invalid Name"
     end