aquarium 0.3.0 → 0.3.1

data/spec/aquarium/extensions/hash_spec.rb

@@ -1,5 +1,5 @@
 require File.dirname(__FILE__) + '/../spec_helper'
-require File.dirname(__FILE__) + '/../spec_example_classes'
+require File.dirname(__FILE__) + '/../spec_example_types'
 require 'aquarium/extensions/hash'
 require 'aquarium/utils/array_utils'
 require 'aquarium/utils/hash_utils'

data/spec/aquarium/extensions/set_spec.rb

@@ -1,5 +1,5 @@
 require File.dirname(__FILE__) + '/../spec_helper'
-require File.dirname(__FILE__) + '/../spec_example_classes'
+require File.dirname(__FILE__) + '/../spec_example_types'
 require 'aquarium/extensions/set'
 
 class Foo

data/spec/aquarium/finders/finder_result_spec.rb

@@ -1,5 +1,5 @@
 require File.dirname(__FILE__) + '/../spec_helper'
-require File.dirname(__FILE__) + '/../spec_example_classes'
+require File.dirname(__FILE__) + '/../spec_example_types'
 
 require 'aquarium/finders/finder_result'
 require 'aquarium/extensions/set'

data/spec/aquarium/finders/method_finder_spec.rb

@@ -1,5 +1,5 @@
 require File.dirname(__FILE__) + '/../spec_helper'
-require File.dirname(__FILE__) + '/../spec_example_classes'
+require File.dirname(__FILE__) + '/../spec_example_types'
 require 'aquarium/finders/method_finder'
 
 # :stopdoc:

data/spec/aquarium/finders/type_finder_with_descendents_and_ancestors_spec.rb

@@ -2,220 +2,138 @@ require File.dirname(__FILE__) + '/../spec_helper'
 require File.dirname(__FILE__) + '/../utils/type_utils_sample_classes'
 require 'aquarium/finders/type_finder'
 
-# TODO Mock out type_utils to speed it up!
+include Aquarium::Utils
   
 def purge_actuals actuals
   # Remove extra stuff inserted by RSpec, Aquarium, and "pretty printer" (rake?), possibly in other specs! (TODO undo those when finished...)
   actuals.matched_keys.reject do |t2| 
-    t2.name.include?("Spec::") or t2.name =~ /Aquarium::(Utils|Extras|Examples|Aspects)/  or t2.name =~ /^PP/
+    t2.name.include?("Spec::") or t2.name =~ /Aquarium::(Utils|Extras|Examples|Aspects)/ or t2.name =~ /^PP/
   end
 end
 
-variant = ''
-describe "#find with types, including descendents", :shared => true do
+describe "#find types and their descendents, using :types_and_descendents" do
   it "should find the matching types and their descendent subclasses, even in different nested modules." do
-    option = "#{variant}_and_descendents".intern
-    Aquarium::Utils::TypeUtils.sample_types.each do |t|
-      actual = Aquarium::Finders::TypeFinder.new.find option => (t.name)
+    TypeUtils.sample_types.each do |t|
+      actual = Aquarium::Finders::TypeFinder.new.find :types_and_descendents => (t.name)
       actual_keys = purge_actuals actual
-      actual_keys.sort{|x,y| x.name <=> y.name}.should == Aquarium::Utils::TypeUtils.sample_types_descendents[t].sort{|x,y| x.name <=> y.name}
+      actual_keys.sort{|x,y| x.name <=> y.name}.should == TypeUtils.sample_types_descendents[t].sort{|x,y| x.name <=> y.name}
       actual.not_matched_keys.should == []
     end
   end
-end
 
-%w[type types name names].each do |n|
-  instance_eval <<-EOF
-    describe Aquarium::Finders::TypeFinder, "#find with :#{n}_and_descendents used to specify one or more names" do
-      variant = "#{n}"
-      it_should_behave_like "#find with types, including descendents"
+  Aquarium::Finders::TypeFinder::TYPES_SYNONYMS.reject{|t| t == :types}.each do |n|
+    it "should accept :#{n}_and_descendents as a synonym for :types_and_descendents" do
+      lambda {Aquarium::Finders::TypeFinder.new.find "#{n}_and_descendents".intern => TypeUtils.sample_types, :noop => true}.should_not raise_error(InvalidOptions)
     end
-  EOF
+  end
 end
 
-describe "#find with excluded types, including descendents", :shared => true do
+describe "#find types subtracting out excluded types and descendents, using :exclude_types_and_descendents" do
   it "should find the matching types and their descendent subclasses, minus the excluded type hierarchies." do
-    option = "#{variant}_and_descendents".intern
-    exclude_option = "exclude_#{variant}_and_descendents".intern
-    actual = Aquarium::Finders::TypeFinder.new.find option => ModuleForDescendents, exclude_option => D1ForDescendents
+    actual = Aquarium::Finders::TypeFinder.new.find :types_and_descendents => ModuleForDescendents, :exclude_types_and_descendents => D1ForDescendents
     actual_keys = purge_actuals actual
-    expected = Aquarium::Utils::TypeUtils.sample_types_descendents[ModuleForDescendents].reject do |c|
-      Aquarium::Utils::TypeUtils.sample_types_descendents[D1ForDescendents].include? c
+    expected = TypeUtils.sample_types_descendents[ModuleForDescendents].reject do |c|
+      TypeUtils.sample_types_descendents[D1ForDescendents].include? c
     end
+    actual_keys.sort{|x,y| x.name <=> y.name}.should == expected.sort{|x,y| x.name <=> y.name}
     actual.not_matched_keys.should == []
   end
-end
 
-%w[type types name names].each do |n|
-  instance_eval <<-EOF
-    describe Aquarium::Finders::TypeFinder, "#find with :exclude_#{n}_and_descendents used to specify one or more names" do
-      variant = "#{n}"
-      it_should_behave_like "#find with excluded types, including descendents"
+  Aquarium::Finders::TypeFinder::TYPES_SYNONYMS.reject{|t| t == :types}.each do |n|
+    it "should accept :exclude_#{n}_and_descendents as a synonym for :exclude_types_and_descendents" do
+      lambda {Aquarium::Finders::TypeFinder.new.find :types_and_descendents => ModuleForDescendents, "exclude_#{n}_and_descendents".intern => D1ForDescendents, :noop => true}.should_not raise_error(InvalidOptions)
     end
-  EOF
+  end
 end
 
 
-describe "#find with types, including ancestors", :shared => true do
+describe "#find types and their ancestors, using :types_and_ancestors" do
   it "should find the matching types and their ancestors, even in different nested modules." do
-    option = "#{variant}_and_ancestors".intern
-    Aquarium::Utils::TypeUtils.sample_types.each do |t|
-      actual = Aquarium::Finders::TypeFinder.new.find option => (t.name)
+    TypeUtils.sample_types.each do |t|
+      actual = Aquarium::Finders::TypeFinder.new.find :types_and_ancestors => (t.name)
       actual_keys = purge_actuals actual
-      actual_keys.sort{|x,y| x.name <=> y.name}.should == Aquarium::Utils::TypeUtils.sample_types_ancestors[t].sort{|x,y| x.name <=> y.name}
+      actual_keys.sort{|x,y| x.name <=> y.name}.should == TypeUtils.sample_types_ancestors[t].sort{|x,y| x.name <=> y.name}
       actual.not_matched_keys.should == []
     end
   end
-end
 
-%w[type types name names].each do |n|
-  instance_eval <<-EOF
-    describe Aquarium::Finders::TypeFinder, "#find with :#{n}_and_ancestors used to specify one or more names" do
-      variant = "#{n}"
-      it_should_behave_like "#find with types, including ancestors"
+  Aquarium::Finders::TypeFinder::TYPES_SYNONYMS.reject{|t| t == :types}.each do |n|
+    it "should accept :#{n}_and_ancestors as a synonym for :types_and_ancestors" do
+      lambda {Aquarium::Finders::TypeFinder.new.find "#{n}_and_ancestors".intern => TypeUtils.sample_types, :noop => true}.should_not raise_error(InvalidOptions)
     end
-  EOF
+  end
 end
 
 
-describe "#find with excluded types, including ancestors", :shared => true do
+describe "#find types subtracting out excluded types and ancestors, using :exclude_types_and_ancestors" do
   it "should find the matching types and their ancestors, minus the excluded types and ancestors." do
-    option = "#{variant}_and_ancestors".intern
-    exclude_option = "exclude_#{variant}_and_ancestors".intern
-    actual = Aquarium::Finders::TypeFinder.new.find option => D1ForDescendents, exclude_option => ModuleForDescendents
+    actual = Aquarium::Finders::TypeFinder.new.find :types_and_ancestors => D1ForDescendents, :exclude_types_and_ancestors => ModuleForDescendents
     actual_keys = purge_actuals actual
-    expected = Aquarium::Utils::TypeUtils.sample_types_ancestors[D1ForDescendents].reject do |c|
-      Aquarium::Utils::TypeUtils.sample_types_ancestors[ModuleForDescendents].include? c
+    expected = TypeUtils.sample_types_ancestors[D1ForDescendents].reject do |c|
+      TypeUtils.sample_types_ancestors[ModuleForDescendents].include? c
     end
+    actual_keys.sort{|x,y| x.name <=> y.name}.should == expected.sort{|x,y| x.name <=> y.name}
     actual.not_matched_keys.should == []
   end
-end
 
-%w[type types name names].each do |n|
-  instance_eval <<-EOF
-    describe Aquarium::Finders::TypeFinder, "#find with :exclude_#{n}_and_ancestors used to specify one or more names" do
-      variant = "#{n}"
-      it_should_behave_like "#find with excluded types, including ancestors"
+  Aquarium::Finders::TypeFinder::TYPES_SYNONYMS.reject{|t| t == :types}.each do |n|
+    it "should accept :exclude_#{n}_and_ancestors as a synonym for :exclude_types_and_ancestors" do
+      lambda {Aquarium::Finders::TypeFinder.new.find :types_and_ancestors => D1ForDescendents, "exclude_#{n}_and_ancestors".intern => ModuleForDescendents, :noop => true}.should_not raise_error(InvalidOptions)
     end
-  EOF
+  end
 end
 
 
-describe "#find with types, including descendents and ancestors", :shared => true do
-  it "should find the matching types, including their descendents and ancestors, even in different nested modules." do
-    doption = "#{variant}_and_descendents".intern
-    aoption = "#{variant}_and_ancestors".intern
-    Aquarium::Utils::TypeUtils.sample_types.each do |t|
-      actual = Aquarium::Finders::TypeFinder.new.find aoption => (t.name), doption => (t.name)
+describe "#find types and their descendents and ancestors" do
+  it "should find the matching types and their descendents and ancestors, even in different nested modules." do
+    TypeUtils.sample_types.each do |t|
+      actual = Aquarium::Finders::TypeFinder.new.find :types_and_ancestors => (t.name), :types_and_descendents => (t.name)
       actual_keys = purge_actuals actual
-      expected = Aquarium::Utils::TypeUtils.sample_types_ancestors[t] + Aquarium::Utils::TypeUtils.sample_types_descendents[t]
+      expected = TypeUtils.sample_types_ancestors[t] + TypeUtils.sample_types_descendents[t]
       actual_keys.sort{|x,y| x.name <=> y.name}.should == expected.sort{|x,y| x.name <=> y.name}.uniq
       actual.not_matched_keys.should == []
     end
   end
 end
 
-%w[type types name names].each do |n|
-  instance_eval <<-EOF
-    describe Aquarium::Finders::TypeFinder, "#find with :#{n}_and_ancestors and :#{n}_and_descendents used to specify one or more names" do
-      variant = "#{n}"
-      it_should_behave_like "#find with types, including descendents and ancestors"
-    end
-  EOF
-end
-
-describe "#find with excluded types, including descendents and ancestors", :shared => true do
-  it "should find the matching types, their descendents and ancestors, minus the excluded types, descendents and ancestors." do
-    doption = "#{variant}_and_descendents".intern
-    aoption = "#{variant}_and_ancestors".intern
-    exclude_doption = "exclude_#{variant}_and_descendents".intern
-    exclude_aoption = "exclude_#{variant}_and_ancestors".intern
-    actual = Aquarium::Finders::TypeFinder.new.find aoption => Aquarium::ForDescendents::NestedD1ForDescendents, 
-      doption => Aquarium::ForDescendents::NestedD1ForDescendents, 
-      exclude_aoption => Aquarium::ForDescendents::NestedD2ForDescendents, 
-      exclude_doption => Aquarium::ForDescendents::NestedD2ForDescendents
+describe "#find types subtracting out excluded types and their descendents and ancestors" do
+  it "should find the matching types and their descendents and ancestors, minus the excluded types and their descendents and ancestors." do
+    actual = Aquarium::Finders::TypeFinder.new.find \
+      :types_and_ancestors => Aquarium::ForDescendents::NestedD1ForDescendents, 
+      :types_and_descendents => Aquarium::ForDescendents::NestedD1ForDescendents, 
+      :exclude_types_and_ancestors => Aquarium::ForDescendents::NestedD2ForDescendents, 
+      :exclude_types_and_descendents => Aquarium::ForDescendents::NestedD2ForDescendents
     actual_keys = purge_actuals actual
-    expected = Aquarium::Utils::TypeUtils.sample_types_ancestors[D1ForDescendents].reject do |c|
-      Aquarium::Utils::TypeUtils.sample_types_ancestors[ModuleForDescendents].include? c
-    end
+    expected = [Aquarium::ForDescendents::NestedD1ForDescendents, Aquarium::ForDescendents::NestedD11ForDescendents, Aquarium::ForDescendents::NestedModuleForDescendents]
+    actual_keys.sort{|x,y| x.name <=> y.name}.should == expected.sort{|x,y| x.name <=> y.name}.uniq
     actual.not_matched_keys.should == []
   end
 end
 
-%w[type types name names].each do |n|
-  instance_eval <<-EOF
-    describe Aquarium::Finders::TypeFinder, "#find with :exclude_#{n}_and_ancestors and :exclude_#{n}_and_descendents used to specify one or more names" do
-      variant = "#{n}"
-      it_should_behave_like "#find with excluded types, including descendents and ancestors"
-    end
-  EOF
-end
-
-describe "#find with regular expressions, including descendents and ancestors" do
-  it "should find the matching types, including their descendents and ancestors, even in different nested modules." do
-    doption = "types_and_descendents".intern
-    aoption = "types_and_ancestors".intern
+describe "#find types and their descendents and ancestors, specified with regular expressions" do
+  it "should find the matching types and their descendents and ancestors, even in different nested modules." do
     regexs = [/ForDescendents$/, /Aquarium::ForDescendents::.*ForDescendents/]
-    actual = Aquarium::Finders::TypeFinder.new.find aoption => regexs, doption => regexs
+    actual = Aquarium::Finders::TypeFinder.new.find :types_and_ancestors => regexs, :types_and_descendents => regexs
     actual_keys = purge_actuals actual
-    expected = Aquarium::Utils::TypeUtils.sample_types_descendents_and_ancestors.keys + [Kernel, Object]
+    expected = TypeUtils.sample_types_descendents_and_ancestors.keys + [Kernel, Object]
     actual_keys.size.should == expected.size
     expected.each do |t|
       actual_keys.should include(t)
     end
+    actual_keys.sort{|x,y| x.name <=> y.name}.should == expected.sort{|x,y| x.name <=> y.name}
     actual.not_matched_keys.should == []
   end
 end
 
-describe "#find with regular expressions, including descendents and ancestors", :shared => true do
-  it "should find the matching types, including their descendents and ancestors, even in different nested modules." do
-    doption = "#{variant}_and_descendents".intern
-    aoption = "#{variant}_and_ancestors".intern
-    regexs = [/ForDescendents$/, /Aquarium::ForDescendents::.*ForDescendents/]
-    actual = Aquarium::Finders::TypeFinder.new.find aoption => regexs, doption => regexs
+describe "#find types and their descendents and ancestors, subtracting out excluded types and their descendents and ancestors, specified using regular expressions" do
+  it "should find the matching types and their descendents and ancestors, minus the excluded types and their descendents and ancestors." do
+    actual = Aquarium::Finders::TypeFinder.new.find :types_and_ancestors => /Aquarium::ForDescendents::.*D1ForDescendents/, 
+      :types_and_descendents => /Aquarium::ForDescendents::.*D1ForDescendents/, 
+      :exclude_types_and_ancestors => /Aquarium::ForDescendents::.*D2ForDescendents/, 
+      :exclude_types_and_descendents => /Aquarium::ForDescendents::.*D2ForDescendents/
     actual_keys = purge_actuals actual
-    expected = Aquarium::Utils::TypeUtils.sample_types_descendents_and_ancestors.keys + [Kernel, Object]
-    actual_keys.size.should == expected.size
-    expected.each do |t|
-      actual_keys.should include(t)
-    end
-    actual.not_matched_keys.should == []
-  end
-end
-
-%w[type types name names].each do |n|
-  instance_eval <<-EOF
-    describe Aquarium::Finders::TypeFinder, "#find regexps with :#{n}_and_ancestors and :#{n}_and_descendents used to specify one or more names" do
-      variant = "#{n}"
-      it_should_behave_like "#find with regular expressions, including descendents and ancestors"
-    end
-  EOF
-end
-
-
-describe "#find with excluded regular expressions, including descendents and ancestors", :shared => true do
-  it "should find the matching types, their descendents and ancestors, minus the excluded types, descendents and ancestors." do
-    doption = "#{variant}_and_descendents".intern
-    aoption = "#{variant}_and_ancestors".intern
-    exclude_doption = "exclude_#{variant}_and_descendents".intern
-    exclude_aoption = "exclude_#{variant}_and_ancestors".intern
-    actual = Aquarium::Finders::TypeFinder.new.find aoption => /Aquarium::ForDescendents::.*D1ForDescendents/, 
-      doption => /Aquarium::ForDescendents::.*D1ForDescendents/, 
-      exclude_aoption => /Aquarium::ForDescendents::.*D2ForDescendents/, 
-      exclude_doption => /Aquarium::ForDescendents::.*D2ForDescendents/
-    actual_keys = purge_actuals actual
-    expected = Aquarium::Utils::TypeUtils.sample_types_ancestors[D1ForDescendents].reject do |c|
-      Aquarium::Utils::TypeUtils.sample_types_ancestors[ModuleForDescendents].include? c
-    end
+    expected = [Aquarium::ForDescendents::NestedD1ForDescendents, Aquarium::ForDescendents::NestedD11ForDescendents, Aquarium::ForDescendents::NestedModuleForDescendents]
+    actual_keys.sort{|x,y| x.name <=> y.name}.should == expected.sort{|x,y| x.name <=> y.name}
     actual.not_matched_keys.should == []
   end
 end
-
-%w[type types name names].each do |n|
-  instance_eval <<-EOF
-    describe Aquarium::Finders::TypeFinder, "#find regexps with :exclude_#{n}_and_ancestors and :exclude_#{n}_and_descendents used to specify one or more names" do
-      variant = "#{n}"
-      it_should_behave_like "#find with excluded regular expressions, including descendents and ancestors"
-    end
-  EOF
-end

data/spec/aquarium/{spec_example_classes.rb → spec_example_types.rb}

@@ -198,4 +198,39 @@ end
 class TestableClassIncludingTestableModule1
   include TestableModule1
   def instance_method1; end
+end
+
+# Used to mock the expensive computation of descendents in some examples.
+module Aquarium
+  module SpecExampleTypes
+    def descendents
+      {Watchful => [Watchful, WatchfulChild],
+       TestableModule2 => [TestableModule2, TestableModule1],
+       ExampleParentClass => [ExampleParentClass, ClassWithAttribs,
+                             ClassWithPublicInstanceMethod, ClassWithPublicInstanceMethod2, ClassWithProtectedInstanceMethod, 
+                             ClassWithPrivateInstanceMethod, ClassWithPublicClassMethod, ClassWithPrivateClassMethod],
+       ModuleWithPublicInstanceMethod => [ModuleWithPublicInstanceMethod, ModuleIncludingModuleWithPublicInstanceMethod,
+                             ClassIncludingModuleWithPublicInstanceMethod, ClassDerivedFromClassIncludingModuleWithPublicInstanceMethod],
+       ModuleWithProtectedInstanceMethod => [ModuleWithProtectedInstanceMethod, ClassIncludingModuleWithProtectedInstanceMethod],
+       ModuleWithPrivateInstanceMethod => [ModuleWithPrivateInstanceMethod, ClassIncludingModuleWithPrivateInstanceMethod],
+       ModuleWithPublicClassMethod => [ModuleWithPublicClassMethod, ClassIncludingModuleWithPublicClassMethod],
+       ModuleWithPrivateClassMethod => [ModuleWithPrivateClassMethod, ClassIncludingModuleWithPrivateClassMethod],
+       ClassIncludingModuleWithPublicInstanceMethod => [ClassIncludingModuleWithPublicInstanceMethod, ClassDerivedFromClassIncludingModuleWithPublicInstanceMethod],
+       ModuleIncludingModuleWithPublicInstanceMethod => [ModuleIncludingModuleWithPublicInstanceMethod, ClassDerivedFromClassIncludingModuleWithPublicInstanceMethod]
+      }
+    end
+  end
+
+  module TypeUtilsStub
+    include SpecExampleTypes
+    
+    def stub_type_utils_descendents
+  	  @stubbed_type_utils_descendents = Aspect.new :around, :calls_to => :descendents, :on_type => Aquarium::Utils::TypeUtils, :restricting_methods_to => :class_methods do |jp, object, *args|
+        descendents[args[0]]
+      end
+    end
+    def unstub_type_utils_descendents
+      @stubbed_type_utils_descendents.unadvise
+    end
+  end
 end

data/spec/aquarium/utils/default_logger_spec.rb

@@ -0,0 +1,28 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require 'aquarium/utils/default_logger'
+require 'logger'
+
+include Aquarium::Utils
+
+describe DefaultLogger, ".logger=" do
+  before :each do
+    @saved_logger = DefaultLogger.logger
+  end
+  after :each do
+    DefaultLogger.logger= @saved_logger   # restore the original!
+  end
+  
+  it "should set the global logger." do
+    test_logger = Logger.new STDOUT
+    DefaultLogger.logger = test_logger
+    DefaultLogger.logger.should be_eql(test_logger)
+  end
+end
+
+describe DefaultLogger, ".logger" do
+  it "should get the global logger." do
+    test_logger = Logger.new STDOUT
+    DefaultLogger.logger = test_logger
+    DefaultLogger.logger.should be_eql(test_logger)
+  end
+end

data/spec/aquarium/utils/hash_utils_spec.rb

@@ -1,5 +1,5 @@
 require File.dirname(__FILE__) + '/../spec_helper'
-require File.dirname(__FILE__) + '/../spec_example_classes'
+require File.dirname(__FILE__) + '/../spec_example_types'
 require 'aquarium/utils/hash_utils'
 
 describe Aquarium::Utils::HashUtils, "#make_hash" do

data/spec/aquarium/utils/logic_error_spec.rb

@@ -1,5 +1,5 @@
 require File.dirname(__FILE__) + '/../spec_helper'
-require File.dirname(__FILE__) + '/../spec_example_classes'
+require File.dirname(__FILE__) + '/../spec_example_types'
 require 'aquarium/utils/logic_error'
 
 # This doesn't do much..., except make rcov happy, since this exception is essentially for catching bugs.

data/spec/aquarium/utils/name_utils_spec.rb

@@ -1,5 +1,5 @@
 require File.dirname(__FILE__) + '/../spec_helper'
-require File.dirname(__FILE__) + '/../spec_example_classes'
+require File.dirname(__FILE__) + '/../spec_example_types'
 require 'aquarium/utils/name_utils'
 
 describe Aquarium::Utils::NameUtils, ".make_valid_attr_name_from_method_name" do

data/spec/aquarium/utils/nil_object_spec.rb

@@ -1,5 +1,5 @@
 require File.dirname(__FILE__) + '/../spec_helper'
-require File.dirname(__FILE__) + '/../spec_example_classes'
+require File.dirname(__FILE__) + '/../spec_example_types'
 require 'aquarium/utils/nil_object'
 
 describe Aquarium::Utils::NilObject, " (when a message is sent to it)" do

data/spec/aquarium/utils/options_utils_spec.rb

@@ -0,0 +1,122 @@
+
+require File.dirname(__FILE__) + '/../spec_helper'
+require 'aquarium/utils'
+
+include Aquarium::Utils
+
+module Aquarium
+  class OptionsUtilsUser
+    include OptionsUtils
+    def initialize hash = {}
+      init_specification hash, {}
+    end
+    def all_allowed_option_symbols
+      []
+    end
+  end
+end
+  
+describe OptionsUtils, "with no 'universal' options specified" do
+  it "should use the default logger." do
+    object = Aquarium::OptionsUtilsUser.new
+    object.logger.should == DefaultLogger.logger
+  end
+
+  it "should set noop to false." do
+    object = Aquarium::OptionsUtilsUser.new
+    object.noop.should be_false
+  end
+end
+
+describe OptionsUtils, ":logger option" do
+  it "should set the object's logger to the specified logger." do
+    logger = Logger.new STDOUT
+    object = Aquarium::OptionsUtilsUser.new :logger => logger
+    object.logger.should == logger    
+  end
+end
+
+describe OptionsUtils, ":severity option" do
+  it "should set the level on the object's logger to the :severity value." do
+    logger = Logger.new STDOUT
+    object = Aquarium::OptionsUtilsUser.new :logger => logger, :severity => Logger::Severity::WARN
+    object.logger.level.should == Logger::Severity::WARN    
+  end
+  
+  it "should cause the creation of a unique logger if one was not specified." do
+    object = Aquarium::OptionsUtilsUser.new :severity => Logger::Severity::WARN
+    object.logger.should_not eql(DefaultLogger.logger)
+  end
+end
+
+describe OptionsUtils, ":logger_stream option" do
+  it "should set the output stream on the object's logger to the :logger_stream value." do
+    stringio = StringIO.new
+    object = Aquarium::OptionsUtilsUser.new :logger_stream => stringio
+    object.logger << "message"
+    stringio.string.should eql("message")
+  end
+  
+  it "should cause the creation of a unique logger if one was not specified." do
+    stringio = StringIO.new
+    object = Aquarium::OptionsUtilsUser.new :logger_stream => stringio
+    object.logger.should_not eql(DefaultLogger.logger)
+  end
+end
+
+describe OptionsUtils, ":logger_stream option" do
+  it "should set the output stream on the object's logger to the :logger_stream value." do
+    logger = Logger.new STDOUT
+    object = Aquarium::OptionsUtilsUser.new :logger => logger, :severity => Logger::Severity::WARN
+    object.logger.level.should == Logger::Severity::WARN    
+  end
+  
+  it "should cause the creation of a unique logger if one was not specified." do
+    object = Aquarium::OptionsUtilsUser.new :severity => Logger::Severity::WARN
+    object.logger.should_not eql(DefaultLogger.logger)
+  end
+end
+
+describe OptionsUtils, "#logger" do
+  it "should return the logger specified with the :logger => ... option." do
+    logger = Logger.new STDOUT
+    object = Aquarium::OptionsUtilsUser.new :logger => logger
+    object.logger.should == logger    
+  end
+
+  it "should return the default logger if no :logger => ... option was specified." do
+    logger = Logger.new STDOUT
+    object = Aquarium::OptionsUtilsUser.new 
+    object.logger.should == DefaultLogger.logger
+  end
+end
+
+describe OptionsUtils, "#logger=" do
+  it "should set a new logger." do
+    logger1 = Logger.new STDOUT
+    logger2 = Logger.new STDERR
+    object = Aquarium::OptionsUtilsUser.new :logger => logger1
+    object.logger = logger2
+    object.logger.should == logger2    
+  end
+end
+
+describe OptionsUtils, "#noop" do
+  it "should return false if :noop was not specified." do
+    object = Aquarium::OptionsUtilsUser.new 
+    object.noop.should be_false
+  end
+
+  it "should return the value specified with :noop." do
+    object = Aquarium::OptionsUtilsUser.new :noop => true
+    object.noop.should be_true
+  end
+end
+
+describe OptionsUtils, "#noop=" do
+  it "should set the noop value." do
+    object = Aquarium::OptionsUtilsUser.new :noop => true
+    object.noop = false
+    object.noop.should be_false
+  end
+end