michel-randexp 0.1.4

data/spec/unit/randexp/reducer_spec.rb

@@ -0,0 +1,273 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe Randexp::Reducer do
+  describe ".reduce" do
+    it "should expect a sexp, and return a string" do
+      Randexp::Reducer.reduce([:literal, 'a']).should be_instance_of(String)
+    end
+
+    it "should be an alias for :[]" do
+      Randexp::Reducer[[:literal, 'a']].should == Randexp::Reducer.reduce([:literal, 'a'])
+    end
+  end
+
+  describe ".quantify" do
+    it "should call reduce with the sexp and quantity arguments as the :quantify sexp's head and tail" do
+      Randexp::Reducer.should_receive(:reduce).with([:literal, 'a'], :*)
+      Randexp::Reducer.quantify([[:literal, 'a'], :*], :'?')  # :'?' is ignored
+    end
+  end
+
+  describe ".random" do
+    it "should call :char with the quantity argument if the sexp's value is :w" do
+      Randexp::Reducer.should_receive(:char).with(:*)
+      Randexp::Reducer.random([:w], :*)
+    end
+
+    it "should call :digit with the quantity argument if the sexp's value is :d" do
+      Randexp::Reducer.should_receive(:digit).with(:*)
+      Randexp::Reducer.random([:d], :*)
+    end
+
+    it "should call :whitespace with the quantity argument if the sexp's value is :w" do
+      Randexp::Reducer.should_receive(:whitespace).with(:*)
+      Randexp::Reducer.random([:s], :*)
+    end
+    
+    
+    it "should call :any with the quantity argument if the sexp's value is :\".\"" do
+      Randexp::Reducer.should_receive(:any).with(:".")
+      Randexp::Reducer.random([:"."], :".")
+    end
+
+    it "should call :randgen with the quantity argument if the sexp's value for all other cases" do
+      Randexp::Reducer.should_receive(:randgen).with(:alpha_numeric, :*)
+      Randexp::Reducer.random([:alpha_numeric], :*)
+    end
+  end
+
+  describe ".literal" do
+    it "should raise an exception if the quantity argument is :+ or :'+?'" do
+      lambda { Randexp::Reducer.literal(['a'], :+) }.should raise_error("Sorry, \"a+\" is too vague, try setting a range: \"a{1,3}\"")
+      lambda { Randexp::Reducer.literal(['b'], :'+?') }.should raise_error("Sorry, \"b+\" is too vague, try setting a range: \"b{1,3}\"")
+    end
+
+    it "should raise an exception if the quantity argument is :* or :'*?'" do
+      lambda { Randexp::Reducer.literal(['a'], :*) }.should raise_error("Sorry, \"a*\" is too vague, try setting a range: \"a{0,3}\"")
+      lambda { Randexp::Reducer.literal(['b'], :'*?') }.should raise_error("Sorry, \"b*\" is too vague, try setting a range: \"b{0,3}\"")
+    end
+  end
+
+  describe ".intersection" do
+    it "should raise an exception if the quantity arguement is :+ or :'+?'" do
+      lambda { Randexp::Reducer.intersection([[:literal, 'a'], [:literal, 'b']], :+) }.should raise_error("Sorry, \"((...)|(...))+\" is too vague, try setting a range: \"((...)|(...)){1, 3}\"")
+      lambda { Randexp::Reducer.intersection([[:literal, 'b'], [:literal, 'a']], :'+?') }.should raise_error("Sorry, \"((...)|(...))+\" is too vague, try setting a range: \"((...)|(...)){1, 3}\"")
+    end
+
+    it "should raise an exception if the quantity argument is :* or :'*?'" do
+      lambda { Randexp::Reducer.intersection([[:literal, 'a'], [:literal, 'b']], :*) }.should raise_error("Sorry, \"((...)|(...))*\" is too vague, try setting a range: \"((...)|(...)){0, 3}\"")
+      lambda { Randexp::Reducer.intersection([[:literal, 'b'], [:literal, 'a']], :'*?') }.should raise_error("Sorry, \"((...)|(...))*\" is too vague, try setting a range: \"((...)|(...)){0, 3}\"")
+    end
+  end
+
+  describe ".union" do
+    it "should raise an exception if the quantity arguement is :+ or :'+?'" do
+      lambda { Randexp::Reducer.union([[:literal, 'a'], [:literal, 'b']], :+) }.should raise_error("Sorry, \"(...)+\" is too vague, try setting a range: \"(...){1, 3}\"")
+      lambda { Randexp::Reducer.union([[:literal, 'b'], [:literal, 'a']], :'+?') }.should raise_error("Sorry, \"(...)+\" is too vague, try setting a range: \"(...){1, 3}\"")
+    end
+
+    it "should raise an exception if the quantity argument is :* or :'*?'" do
+      lambda { Randexp::Reducer.union([[:literal, 'a'], [:literal, 'b']], :*) }.should raise_error("Sorry, \"(...)*\" is too vague, try setting a range: \"(...){0, 3}\"")
+      lambda { Randexp::Reducer.union([[:literal, 'b'], [:literal, 'a']], :'*?') }.should raise_error("Sorry, \"(...)*\" is too vague, try setting a range: \"(...){0, 3}\"")
+    end
+  end
+
+  describe ".char" do
+    it "should call Randgen.char if the quantity argument is :'?'" do
+      Randgen.should_receive(:char)
+      Randexp::Reducer.char(:'?')
+    end
+
+    it "should call Randgen.char if the quantity argument is 1" do
+      Randgen.should_receive(:char)
+      Randexp::Reducer.char(1)
+    end
+
+    it "should call Randgen.char if the quantity argument is nil" do
+      Randgen.should_receive(:char)
+      Randexp::Reducer.char(nil)
+    end
+
+    it "should call Randgen.word if the quantity argument is :+" do
+      Randgen.should_receive(:word)
+      Randexp::Reducer.char(:+)
+    end
+
+    it "should call Randgen.word if the quantity argument is :'+?'" do
+      Randgen.should_receive(:word)
+      Randexp::Reducer.char(:'+?')
+    end
+
+    it "should call Randgen.word with the :length option if the quantity argument is an Integer" do
+      Randgen.should_receive(:word).with(:length => 5)
+      Randexp::Reducer.char(5)
+    end
+
+    it "should call Randgen.word with the :length option if the quantity argument is a Range" do
+      range = 1..10
+      range.should_receive(:pick).and_return 7
+      Randgen.should_receive(:word).with(:length => 7)
+      Randexp::Reducer.char(range)
+    end
+  end
+  
+  
+  describe ".any" do
+    it "should call Randgen.any if the quantity argument is :'?'" do
+      Randgen.should_receive(:any)
+      Randexp::Reducer.any(:'?')
+    end
+
+    it "should call Randgen.any if the quantity argument is 1" do
+      Randgen.should_receive(:any)
+      Randexp::Reducer.any(1)
+    end
+
+    it "should call Randgen.any if the quantity argument is nil" do
+      Randgen.should_receive(:any)
+      Randexp::Reducer.any(nil)
+    end
+
+    it "should call Randgen.any if the quantity argument is :+" do
+      Randgen.should_receive(:any)
+      Randexp::Reducer.any(:+)
+    end
+
+    it "should call Randgen.any if the quantity argument is :'+?'" do
+      Randgen.should_receive(:any)
+      Randexp::Reducer.any(:'+?')
+    end
+
+    it "should call Randgen.any with the :length option if the quantity argument is an Integer" do
+      Randgen.should_receive(:any).with(:length => 5)
+      Randexp::Reducer.any(5)
+    end
+
+    it "should call Randgen.any with the :length option if the quantity argument is a Range" do
+      range = 1..10
+      range.should_receive(:pick).and_return 7
+      Randgen.should_receive(:any).with(:length => 7)
+      Randexp::Reducer.any(range)
+    end
+  end
+  
+  
+  
+
+  describe ".whitespace" do
+    it "should call Randgen.whitespace if the quantity is :'?'" do
+      Randgen.should_receive(:whitespace)
+      Randexp::Reducer.whitespace(:'?')
+    end
+
+    it "should call Randgen.whitespace if the quantity is nil" do
+      Randgen.should_receive(:whitespace)
+      Randexp::Reducer.whitespace(nil)
+    end
+
+    it "should call Randgen.whitespace quantity times if the quantity is an Integer" do
+      Randgen.should_receive(:whitespace).exactly(5).times
+      Randexp::Reducer.whitespace(5)
+    end
+
+    it "should call Randgen.whitespace quantity times if the quantity is a Range" do
+      range = 1..10
+      range.should_receive(:pick).and_return 7
+      Randgen.should_receive(:whitespace).exactly(7).times
+      Randexp::Reducer.whitespace(range)
+    end
+
+    it "should raise an exception if the quantity arguement is :+ or :'+?'" do
+      lambda { Randexp::Reducer.whitespace(:+) }.should raise_error("Sorry, \"\\s+\" is too vague, try setting a range: \"\\s{1, 5}\"")
+      lambda { Randexp::Reducer.whitespace(:'+?') }.should raise_error("Sorry, \"\\s+\" is too vague, try setting a range: \"\\s{1, 5}\"")
+    end
+
+    it "should raise an exception if the quantity argument is :* or :'*?'" do
+      lambda { Randexp::Reducer.whitespace(:*) }.should raise_error("Sorry, \"\\s*\" is too vague, try setting a range: \"\\s{0, 5}\"")
+      lambda { Randexp::Reducer.whitespace(:'*?') }.should raise_error("Sorry, \"\\s*\" is too vague, try setting a range: \"\\s{0, 5}\"")
+    end
+  end
+
+  describe ".digit" do
+    it "should call Randgen.digit if the quantity is :'?'" do
+      Randgen.should_receive(:digit)
+      Randexp::Reducer.digit(:'?')
+    end
+
+    it "should call Randgen.digit if the quantity is nil" do
+      Randgen.should_receive(:digit)
+      Randexp::Reducer.digit(nil)
+    end
+
+    it "should call Randgen.digit quantity times if the quantity is an Integer" do
+      Randgen.should_receive(:digit).exactly(5).times
+      Randexp::Reducer.digit(5)
+    end
+
+    it "should call Randgen.digit quantity times if the quantity is a Range" do
+      range = 1..10
+      range.should_receive(:pick).and_return 7
+      Randgen.should_receive(:digit).exactly(7).times
+      Randexp::Reducer.digit(range)
+    end
+
+    it "should raise an exception if the quantity arguement is :+ or :'+?'" do
+      lambda { Randexp::Reducer.digit(:+) }.should raise_error("Sorry, \"\\d+\" is too vague, try setting a range: \"\\d{1, 5}\"")
+      lambda { Randexp::Reducer.digit(:'+?') }.should raise_error("Sorry, \"\\d+\" is too vague, try setting a range: \"\\d{1, 5}\"")
+    end
+
+    it "should raise an exception if the quantity argument is :* or :'*?'" do
+      lambda { Randexp::Reducer.digit(:*) }.should raise_error("Sorry, \"\\d*\" is too vague, try setting a range: \"\\d{0, 5}\"")
+      lambda { Randexp::Reducer.digit(:'*?') }.should raise_error("Sorry, \"\\d*\" is too vague, try setting a range: \"\\d{0, 5}\"")
+    end
+  end
+
+  describe ".randgen" do
+    it "should send Randgen the method name argument with a :length => 1 option if the quantity is :'?'" do
+      Randgen.should_receive(:send).with(:foo, :length => 1)
+      Randexp::Reducer.randgen([:foo], :'?')
+    end
+
+    it "should send Randgen the method name argument if the quantity is nil" do
+      Randgen.should_receive(:send).with(:bar)
+      Randexp::Reducer.randgen([:bar], nil)
+    end
+
+    it "should send Rangen the method name argument if the quantity is 1" do
+      Randgen.should_receive(:send).with(:baz)
+      Randexp::Reducer.randgen([:baz], 1)
+    end
+
+    it "should send Randgen the method name argument if the quantity is :+" do
+      Randgen.should_receive(:send).with(:foo)
+      Randexp::Reducer.randgen([:foo], :+)
+    end
+
+    it "should send Randgen the method name argument if the quantity is :*" do
+      Randgen.should_receive(:send).with(:bar)
+      Randexp::Reducer.randgen([:bar], :*)
+    end
+
+    it "should send Randgen the method name argument with a length option if the quantity is a Range" do
+      range = 1..10
+      range.should_receive(:pick).and_return 7
+      Randgen.should_receive(:send).with(:baz, :length => 7)
+      Randexp::Reducer.randgen([:baz], range)
+    end
+
+    it "should send Randgen the method name argument with a length option if the quantity is a Integer" do
+      Randgen.should_receive(:send).with(:baz, :length => 7)
+      Randexp::Reducer.randgen([:baz], 7)
+    end
+  end
+end

data/spec/unit/randexp_spec.rb

@@ -0,0 +1,164 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Randexp do
+  describe "#initialize" do
+    it "should set the sexp attribute" do
+      Randexp.new("abcd").sexp.should_not be_nil
+    end
+  end
+
+  describe ".reduce" do
+    it "should not change the original sexp in any way" do
+      @randexp = Randexp.new("def")
+      @sexp = @randexp.sexp
+
+      @randexp.reduce
+
+      @sexp.should == @randexp.sexp
+    end
+  end
+end
+
+describe Randexp do
+ describe "#parse" do
+
+   describe '("\\w")' do
+     it "should be a random sexp" do
+       Randexp::Parser.parse("\\w").first.should == :random
+     end
+
+     it "should hold a word symbol" do
+       Randexp::Parser.parse("\\w").last.should == :w
+     end
+   end
+   
+   describe '("\\s")' do
+     it "should be a literal sexp" do
+       Randexp::Parser.parse("\\s").first.should == :random
+     end
+
+     it "should hold a whitespace symbol " do
+       Randexp::Parser.parse("\\s").last.should == :s
+     end
+   end
+
+   describe '("\\d")' do
+     it "should be a literal sexp" do
+       Randexp::Parser.parse("\\d").first.should == :random
+     end
+
+     it "should hold a digit character " do
+       Randexp::Parser.parse("\\d").last.should == :d
+     end
+   end
+
+   describe '("\\c")' do
+     it "should be a literal sexp" do
+       Randexp::Parser.parse("\\c").first.should == :random
+     end
+
+     it "should hold a digit character " do
+       Randexp::Parser.parse("\\c").last.should == :c
+     end
+   end
+
+   describe '("(\\w)")' do
+     it "should be a random sexp" do
+       Randexp::Parser.parse("(\\w)").first.should == :random
+       Randexp::Parser.parse("(\\w)").last.should == :w
+     end
+   end
+
+   describe '("(\\w)(\\d)")' do
+     it "should be a union between random sexp's" do
+       Randexp::Parser.parse("(\\w)(\\d)").first.should == :union
+       Randexp::Parser.parse("(\\w)(\\d)")[1].first.should == :random
+       Randexp::Parser.parse("(\\w)(\\d)")[2].first.should == :random
+     end
+   end
+
+   describe '("(\\w)(\\s)(\\d)")' do
+     xit "should be a union between 3 sexp's" do
+       Randexp::Parser.parse("(\\w)(\\s)(\\d)").first.should == :union
+       Randexp::Parser.parse("(\\w)(\\s)(\\d)").size.should == 4
+     end
+   end
+
+   describe '("\\w*")' do
+     it "should be a quantify sexp and hold a random sexp" do
+       Randexp::Parser.parse("\\w*").first.should == :quantify
+       Randexp::Parser.parse("\\w*")[1].first.should == :random
+       Randexp::Parser.parse("\\w*")[2].should == :*
+     end
+   end
+
+   it "should blah" do
+     Randexp::Parser.parse("(\\w)|(\\d)").should == [:intersection, [:random, :w], [:random, :d]]
+   end
+
+   describe '("[:sentence:]")' do
+     it "should be a random sexp" do
+       Randexp::Parser.parse("[:sentence:]").first.should == :random
+       Randexp::Parser.parse("[:sentence:]").last.should == :sentence
+     end
+   end
+   
+  describe '(.) any' do
+    it "should hold any character" do
+       Randexp::Parser.parse(".").last.should == :"."       
+    end
+  end
+ end
+
+ describe "#reduce" do
+   it "should return a character" do
+     Randexp.new("\\w").reduce.should =~ /\w/
+   end
+
+   it "should return a word" do
+     Randexp.new("\\w+").reduce.should =~ /\w+/
+   end
+
+   it "should return a word or an empty string" do
+     Randexp.new("\\w*").reduce.should =~ /\w*/
+   end
+
+   it "should return a word with 4 to 5 characters" do
+     Randexp.new("\\w{4,5}").reduce.should =~ /\w{4,5}/
+   end
+
+   it "should return a digit" do
+     Randexp.new("\\d").reduce.should =~ /\d/
+   end
+
+   it "should return a 2 to 10 digit number" do
+     Randexp.new("\\d{2,10}").reduce.should =~ /\d{2,10}/
+   end
+
+   it "should return a digit or empty string" do
+     Randexp.new("\\d?").reduce.should =~ /\d?/
+   end
+
+   it "should return a digit or a character" do
+     Randexp.new("\\d|\\w").reduce.should =~ /\w|\d/
+   end
+
+   xit "should return a word or a 3 digit number" do
+     Randexp.new("\\d{3}|\\w+").reduce.should =~ /\w+|d{3}/
+   end
+
+   it "should return a word or number" do
+     Randexp.new("\\w+|\\d{3}").reduce.should =~ /\w+|d{3}/
+   end
+
+   it "should return a sentence" do
+     Randexp.new("[:sentence:]").reduce.should =~ /(\w+\s)*\w+/
+   end
+
+   it "should handle a telephone number" do
+     100.times do
+       Randexp.new("(\\d{3}-)?\\d{3}-\\d{4}").reduce.should =~ /(\d{3}-)?\d{3}-\d{4}/
+     end
+   end
+ end
+end

data/spec/unit/randgen_spec.rb

@@ -0,0 +1,216 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Randgen do
+  describe ".bool" do
+    it "should return 'true' or 'false'" do
+      100.times do
+        ['true', 'false'].should include(Randgen.bool)
+      end
+    end
+  end
+
+  describe ".lchar" do
+    it "should return 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', or 'z'" do
+      100.times do
+        ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'].should include(Randgen.lchar)
+      end
+    end
+  end
+
+  describe ".uchar" do
+    it "should return 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', or 'Z'" do
+      100.times do
+        ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'].should include(Randgen.uchar)
+      end
+    end
+  end
+
+  describe ".char" do
+    it "should return 'A', 'a', 'B', 'b', 'C', 'c', 'D', 'd', 'E', 'e', 'F', 'f', 'G', 'g', 'H', 'h', 'I', 'i', 'J', 'j', 'K', 'k', 'L', 'l', 'M', 'm', 'N', 'n', 'O', 'o', 'P', 'p', 'Q', 'q', 'R', 'r', 'S', 's', 'T', 't', 'U', 'u', 'V', 'v', 'W', 'w', 'X', 'x', 'Y', 'y', 'Z', or 'z'" do
+      100.times do
+        ['A', 'a', 'B', 'b', 'C', 'c', 'D', 'd', 'E', 'e', 'F', 'f', 'G', 'g', 'H', 'h', 'I', 'i', 'J', 'j', 'K', 'k', 'L', 'l', 'M', 'm', 'N', 'n', 'O', 'o', 'P', 'p', 'Q', 'q', 'R', 'r', 'S', 's', 'T', 't', 'U', 'u', 'V', 'v', 'W', 'w', 'X', 'x', 'Y', 'y', 'Z', 'z'].should include(Randgen.char)
+      end
+    end
+  end
+
+  describe ".whitespace" do
+    it "should return '\\t', '\\n', '\\r', or '\\f'" do
+      100.times do
+        ["\t", "\n", "\r", "\f"].should include(Randgen.whitespace)
+      end
+    end
+  end
+
+  describe ".digit" do
+    it "should return '0', '1', '2', '3', '4', '5', '6', '7', '8', or '9'" do
+      100.times do
+        ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'].should include(Randgen.digit)
+      end
+    end
+  end
+
+  describe ".alpha_numeric" do
+    it "should return 'A', 'a', 'B', 'b', 'C', 'c', 'D', 'd', 'E', 'e', 'F', 'f', 'G', 'g', 'H', 'h', 'I', 'i', 'J', 'j', 'K', 'k', 'L', 'l', 'M', 'm', 'N', 'n', 'O', 'o', 'P', 'p', 'Q', 'q', 'R', 'r', 'S', 's', 'T', 't', 'U', 'u', 'V', 'v', 'W', 'w', 'X', 'x', 'Y', 'y', 'Z', 'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', or '9'" do
+      100.times do
+        ['A', 'a', 'B', 'b', 'C', 'c', 'D', 'd', 'E', 'e', 'F', 'f', 'G', 'g', 'H', 'h', 'I', 'i', 'J', 'j', 'K', 'k', 'L', 'l', 'M', 'm', 'N', 'n', 'O', 'o', 'P', 'p', 'Q', 'q', 'R', 'r', 'S', 's', 'T', 't', 'U', 'u', 'V', 'v', 'W', 'w', 'X', 'x', 'Y', 'y', 'Z', 'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9'].should include(Randgen.alpha_numeric)
+      end
+    end
+  end
+
+  describe ".word" do
+    it "should handle generating long strings" do
+      Randgen.word(:length => 64).length.should == 64
+    end
+    it "should pick an entry from Dictionary" do
+      10.times do
+        Randexp::Dictionary.words.should include(Randgen.word)
+      end
+    end
+
+    it "should pick a word with a length if the length option is supplied" do
+      10.times do
+        length = (3..10).pick
+        Randgen.word(:length => length).length.should == length
+      end
+    end
+
+    it "should not return a string that is not a word" do
+      strings = %w[foo's bars]
+      Randexp::Dictionary.should_receive(:words).at_least(1).and_return strings
+
+      100.times do
+        Randgen.word.should_not == "foo's"
+      end
+    end
+  end
+
+  describe ".first_name" do
+    it "should pick a word from the female names list if the gender option is female" do
+      100.times do
+        female_name = Randgen.first_name(:gender => :female)
+        RealName.female_first_names.should include(female_name)
+      end
+    end
+
+    it "should pick a word from the male names list if the gender option is male" do
+      100.times do
+        male_name = Randgen.first_name(:gender => :male)
+        RealName.male_first_names.should include(male_name)
+      end
+    end
+
+    it "should pick a word from the male names list with the same length in the options" do
+      100.times do
+        length = (3..10).pick
+        male_name = Randgen.first_name(:length => length)
+        (RealName.female_first_names + RealName.male_first_names).should include(male_name)
+      end
+    end
+  end
+
+  describe ".last_name" do
+    it "should pick a word from the last names list with the same length in the options" do
+      100.times do
+        length = (3..10).pick
+        last_name = Randgen.last_name(:length => length)
+        RealName.surnames.should include(last_name)
+      end
+    end
+  end
+
+  describe ".name" do
+    it "should be two words long" do
+      100.times do
+        Randgen.name.should =~ /\w+ \w+/
+      end
+    end
+  end
+
+  describe ".sentence" do
+    it "should be capitalized" do
+      10.times do
+        Randgen.sentence.should =~ /^[A-Z]/
+      end
+    end
+  end
+
+  describe ".paragraph" do
+    it "should end in a period" do
+      10.times do
+        Randgen.paragraph.should =~ /\.$/
+      end
+    end
+  end
+
+  describe ".phone_number" do
+    it "should match /(\\d{3}-)?\\d{3}-\\d{4}/ when no length is given" do
+      100.times do
+        Randgen.phone_number =~ /(\d{3}-)?\d{3}-\d{4}/
+      end
+    end
+
+    it "should match /\\d{3}-\\d{4}/ when the length is 7" do
+      100.times do
+        Randgen.phone_number(:length => 7) =~ /\d{3}-\d{4}/
+      end
+    end
+
+    it "should match /\\d{3}-\\d{3}-\\d{4}/ when the length is 10" do
+      100.times do
+        Randgen.phone_number(:length => 10) =~ /\d{3}-\d{3}-\d{4}/
+      end
+    end
+  end
+
+  it "should generate a first name" do
+    100.times do
+      Randgen.first_name.should =~ /\w/
+    end
+  end
+  
+  it "should generate a male first name" do
+    male_list = RealName.male_first_names
+    100.times do
+      Randgen.first_name(:gender => :male).should =~ /\w/
+      male_list.include?(Randgen.first_name(:gender => :male)).should be_true
+    end
+  end
+  
+  it "should generate a female first name" do
+    female_list = RealName.female_first_names
+    100.times do
+      Randgen.first_name(:gender => :female).should =~ /\w/
+      female_list.include?(Randgen.first_name(:gender => :female)).should be_true
+    end
+  end
+  
+  it "should generate a last name" do
+    100.times do
+      Randgen.last_name.should =~ /\w/
+    end
+  end
+  
+  it "should generate a real name" do
+    100.times do
+      Randgen.name.should =~ /\w{2}/
+    end
+  end
+  
+  it "should generate a real male name" do
+    male_list = RealName.male_first_names
+    100.times do
+      name = Randgen.name(:gender => :male)
+      name.should =~ /\w{2}/
+      male_list.include?(name.split(' ').first).should be_true
+    end
+  end
+  
+  it "should generate a real female name" do
+    female_list = RealName.female_first_names
+    100.times do
+      name = Randgen.name(:gender => :female)
+      name.should =~ /\w{2}/
+      female_list.include?(name.split(' ').first).should be_true
+    end
+  end
+end