cascading_classes 0.6.1 → 0.6.2

data/spec/basics/block_spec.rb

@@ -23,19 +23,19 @@ describe "block given" do
   end
 
   it "takes two params: value of self, parent classes" do
-    A.score{|my_score, parents| my_score}.must_equal A.score
+    A.score{|my_score, parents| my_score}.should == A.score
     
     B.score = 28.2
-    B.score{|my_score, parents| my_score}.must_equal B.score
+    B.score{|my_score, parents| my_score}.should == B.score
 
-    A.new.score{|my_score| my_score}.must_equal A.new.score
-    B.new.score{|my_score| my_score}.must_equal B.new.score
+    A.new.score{|my_score| my_score}.should == A.new.score
+    B.new.score{|my_score| my_score}.should == B.new.score
 
-    A.score{|my_score, parents| parents}.must_equal []
-    B.score{|my_score, parents| parents}.must_equal [A]
+    A.score{|my_score, parents| parents}.should == []
+    B.score{|my_score, parents| parents}.should == [A]
 
-    A.new.score{|my_score, parents| parents}.must_equal [A]
-    B.new.score{|my_score, parents| parents}.must_equal [B, A]
+    A.new.score{|my_score, parents| parents}.should == [A]
+    B.new.score{|my_score, parents| parents}.should == [B, A]
 
 =begin
     what_score, which_parents = nil, nil
@@ -45,8 +45,8 @@ describe "block given" do
       which_parents = parents
     }
     
-    what_score.must_equal(B.score)
-    which_parents.must_equal([A])
+    what_score.should ==(B.score)
+    which_parents.should ==([A])
 =end
   end
 end

data/spec/basics/container_spec.rb

@@ -23,16 +23,16 @@ describe "container types: typical" do
   end
 
   it "does not inherit by default" do
-    @props[:urls][:inherit].must_equal false
-    @props[:name][:inherit].must_equal false
+    @props[:urls][:inherit].should == false
+    @props[:name][:inherit].should == false
 
-    A.urls.must_equal ["www.google.com"]
-    B.urls.must_equal Array.new
-    C.urls.must_equal Array.new
+    A.urls.should == ["www.google.com"]
+    B.urls.should == Array.new
+    C.urls.should == Array.new
 
-    A.name.must_equal({:first => 'jon', :last => 'smith'})
-    B.name.must_equal Hash.new
-    C.name.must_equal Hash.new
+    A.name.should ==({:first => 'jon', :last => 'smith'})
+    B.name.should == Hash.new
+    C.name.should == Hash.new
   end
 
   describe "descendents can update their own container properties" do
@@ -47,84 +47,84 @@ describe "container types: typical" do
     end
 
     it "works" do
-      B.urls.must_equal ["www.bing.com", "www.example.com"]
-      C.urls.must_equal ["c.homepage.org", "example.org"]
+      B.urls.should == ["www.bing.com", "www.example.com"]
+      C.urls.should == ["c.homepage.org", "example.org"]
 
-      B.name.must_equal({:first => 'charlie'})
-      C.name.must_equal({:first => 'tim', :last => 'emerson'})
+      B.name.should ==({:first => 'charlie'})
+      C.name.should ==({:first => 'tim', :last => 'emerson'})
     end
   end
 
   describe "manual override: allowing inheritance" do
     it "accepts ':inherit' syntax" do
-      B.urls(:inherit).must_equal ["www.google.com"]
-      C.urls(:inherit).must_equal ["www.google.com"]
+      B.urls(:inherit).should == ["www.google.com"]
+      C.urls(:inherit).should == ["www.google.com"]
 
-      B.name(:inherit).must_equal({:first => 'jon', :last => 'smith'})
-      C.name(:inherit).must_equal({:first => 'jon', :last => 'smith'})
+      B.name(:inherit).should ==({:first => 'jon', :last => 'smith'})
+      C.name(:inherit).should ==({:first => 'jon', :last => 'smith'})
     end
 
     it "accepts ':inherit => <val>' syntax" do
-      B.urls(:inherit => 0).must_equal []
-      B.urls(:inherit => false).must_equal []
-      B.urls(:inherit => nil).must_equal []
-      B.urls(:inherit => 1).must_equal ["www.google.com"]
-      B.urls(:inherit => true).must_equal ["www.google.com"]
-      B.urls(:inherit => -1).must_equal ["www.google.com"]
-
-      C.urls(:inherit => 0).must_equal []
-      C.urls(:inherit => false).must_equal []
-      C.urls(:inherit => nil).must_equal []
-      C.urls(:inherit => 1).must_equal []
-      C.urls(:inherit => 2).must_equal ["www.google.com"]
-      C.urls(:inherit => -1).must_equal ["www.google.com"]
-      C.urls(:inherit => true).must_equal ["www.google.com"]
+      B.urls(:inherit => 0).should == []
+      B.urls(:inherit => false).should == []
+      B.urls(:inherit => nil).should == []
+      B.urls(:inherit => 1).should == ["www.google.com"]
+      B.urls(:inherit => true).should == ["www.google.com"]
+      B.urls(:inherit => -1).should == ["www.google.com"]
+
+      C.urls(:inherit => 0).should == []
+      C.urls(:inherit => false).should == []
+      C.urls(:inherit => nil).should == []
+      C.urls(:inherit => 1).should == []
+      C.urls(:inherit => 2).should == ["www.google.com"]
+      C.urls(:inherit => -1).should == ["www.google.com"]
+      C.urls(:inherit => true).should == ["www.google.com"]
     end
 
     it "accepts ':inherit, <val>' syntax" do
-      B.name(:inherit, 0).must_equal Hash.new
-      B.name(:inherit, false).must_equal Hash.new
-      B.name(:inherit, nil).must_equal Hash.new
-      B.name(:inherit, 1).must_equal({:first => 'jon', :last => 'smith'})
-      B.name(:inherit, true).must_equal({:first => 'jon', :last => 'smith'})
-      B.name(:inherit, -1).must_equal({:first => 'jon', :last => 'smith'})
-
-      C.name(:inherit, 0).must_equal Hash.new
-      C.name(:inherit, false).must_equal Hash.new
-      C.name(:inherit, nil).must_equal Hash.new
-      C.name(:inherit, 1).must_equal Hash.new
-      C.name(:inherit, 2).must_equal({:first => 'jon', :last => 'smith'})
-      C.name(:inherit, true).must_equal({:first => 'jon', :last => 'smith'})
-      C.name(:inherit, -1).must_equal({:first => 'jon', :last => 'smith'})
+      B.name(:inherit, 0).should == Hash.new
+      B.name(:inherit, false).should == Hash.new
+      B.name(:inherit, nil).should == Hash.new
+      B.name(:inherit, 1).should ==({:first => 'jon', :last => 'smith'})
+      B.name(:inherit, true).should ==({:first => 'jon', :last => 'smith'})
+      B.name(:inherit, -1).should ==({:first => 'jon', :last => 'smith'})
+
+      C.name(:inherit, 0).should == Hash.new
+      C.name(:inherit, false).should == Hash.new
+      C.name(:inherit, nil).should == Hash.new
+      C.name(:inherit, 1).should == Hash.new
+      C.name(:inherit, 2).should ==({:first => 'jon', :last => 'smith'})
+      C.name(:inherit, true).should ==({:first => 'jon', :last => 'smith'})
+      C.name(:inherit, -1).should ==({:first => 'jon', :last => 'smith'})
     end
 
     describe "manual override has no effect on non-blank container properties" do
       it "works" do
         C.urls << "www.yahoo.com"
 
-        A.urls_is_blank?.must_equal false
-        B.urls_is_blank?.must_equal true
-        C.urls_is_blank?.must_equal false
-
-        A.urls.must_equal ["www.google.com"]
-        A.urls(:inherit).must_equal ["www.google.com"]
-        A.urls(:inherit => false).must_equal ["www.google.com"]
-        A.urls(:inherit => nil).must_equal ["www.google.com"]
-        A.urls(:inherit => 0).must_equal ["www.google.com"]
-        A.urls(:inherit => 1).must_equal ["www.google.com"]
-        A.urls(:inherit => 2).must_equal ["www.google.com"]
-        A.urls(:inherit => -1).must_equal ["www.google.com"]
-        A.urls(:inherit => true).must_equal ["www.google.com"]
-
-        C.urls.must_equal ["www.yahoo.com"]
-        C.urls(:inherit).must_equal ["www.yahoo.com"]
-        C.urls(:inherit, false).must_equal ["www.yahoo.com"]
-        C.urls(:inherit, nil).must_equal ["www.yahoo.com"]
-        C.urls(:inherit, 0).must_equal ["www.yahoo.com"]
-        C.urls(:inherit, 1).must_equal ["www.yahoo.com"]
-        C.urls(:inherit, 2).must_equal ["www.yahoo.com"]
-        C.urls(:inherit, -1).must_equal ["www.yahoo.com"]
-        C.urls(:inherit, true).must_equal ["www.yahoo.com"]
+        A.urls_is_blank?.should == false
+        B.urls_is_blank?.should == true
+        C.urls_is_blank?.should == false
+
+        A.urls.should == ["www.google.com"]
+        A.urls(:inherit).should == ["www.google.com"]
+        A.urls(:inherit => false).should == ["www.google.com"]
+        A.urls(:inherit => nil).should == ["www.google.com"]
+        A.urls(:inherit => 0).should == ["www.google.com"]
+        A.urls(:inherit => 1).should == ["www.google.com"]
+        A.urls(:inherit => 2).should == ["www.google.com"]
+        A.urls(:inherit => -1).should == ["www.google.com"]
+        A.urls(:inherit => true).should == ["www.google.com"]
+
+        C.urls.should == ["www.yahoo.com"]
+        C.urls(:inherit).should == ["www.yahoo.com"]
+        C.urls(:inherit, false).should == ["www.yahoo.com"]
+        C.urls(:inherit, nil).should == ["www.yahoo.com"]
+        C.urls(:inherit, 0).should == ["www.yahoo.com"]
+        C.urls(:inherit, 1).should == ["www.yahoo.com"]
+        C.urls(:inherit, 2).should == ["www.yahoo.com"]
+        C.urls(:inherit, -1).should == ["www.yahoo.com"]
+        C.urls(:inherit, true).should == ["www.yahoo.com"]
       end
     end
   end
@@ -149,14 +149,14 @@ describe "container types: property-wide inheritance" do
   end
 
   it "inherits by default" do
-    @props[:urls][:inherit].must_equal true
-    @props[:name][:inherit].must_equal true
+    @props[:urls][:inherit].should == true
+    @props[:name][:inherit].should == true
 
-    B.urls.must_equal ["www.google.com"]
-    C.urls.must_equal ["www.google.com"]
+    B.urls.should == ["www.google.com"]
+    C.urls.should == ["www.google.com"]
 
-    B.name.must_equal({:first => 'jon', :last => 'smith'})
-    C.name.must_equal({:first => 'jon', :last => 'smith'})
+    B.name.should ==({:first => 'jon', :last => 'smith'})
+    C.name.should ==({:first => 'jon', :last => 'smith'})
   end
 
   describe "a descendent updates a container property" do
@@ -165,37 +165,37 @@ describe "container types: property-wide inheritance" do
     end
 
     it "cascades down its descendents" do
-      C.urls.must_equal ["www.bing.com"]
+      C.urls.should == ["www.bing.com"]
     end
   end
 
   describe "overriding the inheritance effect" do
     it "accepts ':inherit => <val>' syntax" do
-      B.urls.must_equal ["www.google.com"]
-      C.urls.must_equal ["www.google.com"]
+      B.urls.should == ["www.google.com"]
+      C.urls.should == ["www.google.com"]
 
-      B.urls(:inherit => false).must_equal []
-      C.urls(:inherit => false).must_equal []
+      B.urls(:inherit => false).should == []
+      C.urls(:inherit => false).should == []
 
-      B.urls(:inherit => 0).must_equal []
-      C.urls(:inherit => 0).must_equal []
+      B.urls(:inherit => 0).should == []
+      C.urls(:inherit => 0).should == []
 
-      B.urls(:inherit => 1).must_equal ["www.google.com"]
-      C.urls(:inherit => 1).must_equal []
+      B.urls(:inherit => 1).should == ["www.google.com"]
+      C.urls(:inherit => 1).should == []
     end
 
     it "accepts ':inherit, <val>' syntax" do      
-      B.urls.must_equal ["www.google.com"]
-      C.urls.must_equal ["www.google.com"]
+      B.urls.should == ["www.google.com"]
+      C.urls.should == ["www.google.com"]
 
-      B.urls(:inherit, false).must_equal []
-      C.urls(:inherit, false).must_equal []
+      B.urls(:inherit, false).should == []
+      C.urls(:inherit, false).should == []
 
-      B.urls(:inherit, 0).must_equal []
-      C.urls(:inherit, 0).must_equal []
+      B.urls(:inherit, 0).should == []
+      C.urls(:inherit, 0).should == []
 
-      B.urls(:inherit, 1).must_equal ["www.google.com"]
-      C.urls(:inherit, 1).must_equal []
+      B.urls(:inherit, 1).should == ["www.google.com"]
+      C.urls(:inherit, 1).should == []
     end
   end
 end

data/spec/basics/inherit_spec.rb

@@ -37,56 +37,56 @@ describe "inherit" do
 
     describe "descendents" do
       it "inherits symbols strings, fixnums, floats, and bools (by default)" do
-        @props[:location][:inherit].must_equal true
-        @props[:weather][:inherit].must_equal true
-        @props[:num][:inherit].must_equal true
-        @props[:score][:inherit].must_equal true
-        @props[:available][:inherit].must_equal true
+        @props[:location][:inherit].should == true
+        @props[:weather][:inherit].should == true
+        @props[:num][:inherit].should == true
+        @props[:score][:inherit].should == true
+        @props[:available][:inherit].should == true
 
-        B.location.must_equal "south side"
-        C.location.must_equal "south side"
+        B.location.should == "south side"
+        C.location.should == "south side"
 
-        B.weather.must_equal :sunny
-        C.weather.must_equal :sunny
+        B.weather.should == :sunny
+        C.weather.should == :sunny
 
-        B.num.must_equal 12
-        C.num.must_equal 12
+        B.num.should == 12
+        C.num.should == 12
 
-        B.score.must_equal 32.18
-        C.score.must_equal 32.18
+        B.score.should == 32.18
+        C.score.should == 32.18
 
-        B.available.must_equal false
-        C.available.must_equal false
+        B.available.should == false
+        C.available.should == false
       end
 
       it "doesn't inherit containers like hashes, arrays, and sets (by default)" do
-        @props[:name][:inherit].must_equal false
-        @props[:groceries][:inherit].must_equal false
+        @props[:name][:inherit].should == false
+        @props[:groceries][:inherit].should == false
 
-        B.name.must_equal Hash.new
-        C.name.must_equal Hash.new
+        B.name.should == Hash.new
+        C.name.should == Hash.new
 
-        B.groceries.must_equal Array.new
-        C.groceries.must_equal Array.new
+        B.groceries.should == Array.new
+        C.groceries.should == Array.new
 
-        B.ingredients.must_equal Set.new
-        C.ingredients.must_equal Set.new
+        B.ingredients.should == Set.new
+        C.ingredients.should == Set.new
       end
 
       it "inherits properties of type ':Proc'" do
-        @props[:mood][:inherit].must_equal true
+        @props[:mood][:inherit].should == true
 
         A.weather = :sunny
         B.weather = :rainy
 
-        C.weather.must_equal :rainy  
+        C.weather.should == :rainy  
 
-        A.mood.must_equal "content"
-        B.mood.must_equal "depressed"
-        C.mood.must_equal "depressed"
+        A.mood.should == "content"
+        B.mood.should == "depressed"
+        C.mood.should == "depressed"
 
         C.weather = :sunny
-        C.mood.must_equal "content"
+        C.mood.should == "content"
       end
     end
   end
@@ -112,124 +112,124 @@ describe "inherit" do
         end
 
         it "allows 'false', 'nil' and '0' to force no inheritance" do
-          B.location(false).must_equal ""
-          C.location(false).must_equal ""
+          B.location(false).should == ""
+          C.location(false).should == ""
 
-          B.score(nil).must_equal nil
-          C.score(nil).must_equal nil
+          B.score(nil).should == nil
+          C.score(nil).should == nil
 
-          B.weather(0).must_equal nil
-          C.weather(0).must_equal nil
+          B.weather(0).should == nil
+          C.weather(0).should == nil
         end
 
         it "allows 'true', '-1' to force full, inifinte max inheritance" do
-          B.num(true).must_equal 12
-          C.num(true).must_equal 12
+          B.num(true).should == 12
+          C.num(true).should == 12
 
-          B.groceries(-1).must_equal [:ice, :lemons, :splenda]
-          C.groceries(-1).must_equal [:ice, :lemons, :splenda]
+          B.groceries(-1).should == [:ice, :lemons, :splenda]
+          C.groceries(-1).should == [:ice, :lemons, :splenda]
         end
 
         it "allows '<fixnum>' value to indicate max inheritance age" do
-          B.score(0).must_equal nil
-          B.score(1).must_equal 32.18
-          B.score(2).must_equal 32.18
-          C.score(1).must_equal nil
-          C.score(2).must_equal 32.18
-
-          B.name(0).must_equal Hash.new
-          B.name(1).must_equal({:first => 'jon', :last => 'smith'})
-          C.name(0).must_equal Hash.new
-          C.name(1).must_equal Hash.new
-          C.name(2).must_equal({:first => 'jon', :last => 'smith'})
+          B.score(0).should == nil
+          B.score(1).should == 32.18
+          B.score(2).should == 32.18
+          C.score(1).should == nil
+          C.score(2).should == 32.18
+
+          B.name(0).should == Hash.new
+          B.name(1).should ==({:first => 'jon', :last => 'smith'})
+          C.name(0).should == Hash.new
+          C.name(1).should == Hash.new
+          C.name(2).should ==({:first => 'jon', :last => 'smith'})
         end
 
         it "allows ':inherit => false' and ':inherit => nil' syntax" do
-          B.location(:inherit => false).must_equal ""
+          B.location(:inherit => false).should == ""
           c_location = C.location :inherit => false
-          c_location.must_equal ""
+          c_location.should == ""
 
-          B.weather(:inherit => nil).must_equal nil
+          B.weather(:inherit => nil).should == nil
           c_weather = C.weather :inherit => nil
-          c_weather.must_equal nil
+          c_weather.should == nil
         end
 
         it "allows ':inhert, false' and ':inherit, nil' syntax" do
-          B.num(:inherit, false).must_equal nil
+          B.num(:inherit, false).should == nil
           c_num = C.num :inherit, false
-          c_num.must_equal nil
+          c_num.should == nil
 
-          B.score(:inherit, nil).must_equal nil
+          B.score(:inherit, nil).should == nil
           c_score = C.score :inherit, nil
-          c_score.must_equal nil
+          c_score.should == nil
         end
 
         it "allows ':inherit => true' and ':inherit => -1' syntax" do
-          B.name(:inherit => true).must_equal({:first => 'jon', :last => 'smith'})
+          B.name(:inherit => true).should ==({:first => 'jon', :last => 'smith'})
           c_name = C.name :inherit => true
-          c_name.must_equal({:first => 'jon', :last => 'smith'})
+          c_name.should ==({:first => 'jon', :last => 'smith'})
 
-          B.groceries(:inherit => -1).must_equal [:ice, :lemons, :splenda]
+          B.groceries(:inherit => -1).should == [:ice, :lemons, :splenda]
           c_groceries = C.groceries :inherit => -1
-          c_groceries.must_equal [:ice, :lemons, :splenda]
+          c_groceries.should == [:ice, :lemons, :splenda]
         end
 
         it "allows ':inherit, true' and ':inherit, -1' syntax" do
-          B.ingredients(:inherit, true).must_equal Set.new([:sugar, :butter, :flour, :eggs])
+          B.ingredients(:inherit, true).should == Set.new([:sugar, :butter, :flour, :eggs])
           c_ingredients = C.ingredients :inherit, true
-          c_ingredients.must_equal Set.new([:sugar, :butter, :flour, :eggs])
+          c_ingredients.should == Set.new([:sugar, :butter, :flour, :eggs])
 
-          B.name(:inherit, -1).must_equal({:first => 'jon', :last => 'smith'})
+          B.name(:inherit, -1).should ==({:first => 'jon', :last => 'smith'})
           c_name = C.name :inherit, -1
-          c_name.must_equal({:first => 'jon', :last => 'smith'})
+          c_name.should ==({:first => 'jon', :last => 'smith'})
         end
 
         it "allows ':inherit => <n>' (n: fixnum) syntax" do
-          B.location(:inherit => 0).must_equal ''
-          B.location(:inherit => 1).must_equal "south side"
+          B.location(:inherit => 0).should == ''
+          B.location(:inherit => 1).should == "south side"
 
           c_loc_0 = C.location :inherit => 0
           c_loc_1 = C.location :inherit => 1
           c_loc_2 = C.location :inherit => 2
 
-          c_loc_0.must_equal ''
-          c_loc_1.must_equal ''
-          c_loc_2.must_equal "south side"
+          c_loc_0.should == ''
+          c_loc_1.should == ''
+          c_loc_2.should == "south side"
 
-          B.groceries(:inherit => 0).must_equal []
-          B.groceries(:inherit => 1).must_equal [:ice, :lemons, :splenda]
+          B.groceries(:inherit => 0).should == []
+          B.groceries(:inherit => 1).should == [:ice, :lemons, :splenda]
 
           c_groc_0 = C.groceries :inherit => 0
           c_groc_1 = C.groceries :inherit => 1
           c_groc_2 = C.groceries :inherit => 2
 
-          c_groc_0.must_equal []
-          c_groc_1.must_equal []
-          c_groc_2.must_equal [:ice, :lemons, :splenda]
+          c_groc_0.should == []
+          c_groc_1.should == []
+          c_groc_2.should == [:ice, :lemons, :splenda]
         end
 
         it "allows ':inherit, <n>' (n: fixnum) syntax" do
-          B.score(:inherit, 0).must_equal nil
-          B.score(:inherit, 1).must_equal 32.18
+          B.score(:inherit, 0).should == nil
+          B.score(:inherit, 1).should == 32.18
 
           c_score_0 = C.score :inherit, 0
           c_score_1 = C.score :inherit, 1
           c_score_2 = C.score :inherit, 2
 
-          c_score_0.must_equal nil
-          c_score_1.must_equal nil
-          c_score_2.must_equal 32.18
+          c_score_0.should == nil
+          c_score_1.should == nil
+          c_score_2.should == 32.18
 
-          B.ingredients(:inherit, 0).must_equal Set.new([])
-          B.ingredients(:inherit, 1).must_equal Set.new([:sugar, :butter, :flour, :eggs])
+          B.ingredients(:inherit, 0).should == Set.new([])
+          B.ingredients(:inherit, 1).should == Set.new([:sugar, :butter, :flour, :eggs])
 
           c_ingr_0 = C.ingredients :inherit, 0
           c_ingr_1 = C.ingredients :inherit, 1
           c_ingr_2 = C.ingredients :inherit, 2
 
-          c_ingr_0.must_equal Set.new([])
-          c_ingr_1.must_equal Set.new([])
-          c_ingr_2.must_equal Set.new([:sugar, :butter, :flour, :eggs])
+          c_ingr_0.should == Set.new([])
+          c_ingr_1.should == Set.new([])
+          c_ingr_2.should == Set.new([:sugar, :butter, :flour, :eggs])
         end
       end
 
@@ -252,85 +252,85 @@ describe "inherit" do
         end
 
         it "all should not inherit" do
-          @props[:location][:inherit].must_equal false
-          @props[:score][:inherit].must_equal false
-          @props[:num][:inherit].must_equal false
-          @props[:weather][:inherit].must_equal false
-          @props[:available][:inherit].must_equal false
-          @props[:mood][:inherit].must_equal false
-          @props[:color][:inherit].must_equal false
-          @props[:groceries][:inherit].must_equal false
-          @props[:ingredients][:inherit].must_equal false
-
-          A.location.must_equal "south side"
-          B.location.must_equal ''
-          C.location.must_equal ''
-
-          A.score.must_equal 32.18
-          B.score.must_equal nil
-          C.score.must_equal nil
-
-          A.num.must_equal 12
-          B.num.must_equal nil
-          C.num.must_equal nil
-
-          A.weather.must_equal :sunny
-          B.weather.must_equal nil
-          C.weather.must_equal nil
-
-          A.available.must_equal false
-          B.available.must_equal nil
-          C.available.must_equal nil
-
-          A.mood.must_equal "content"
-          B.mood.must_equal "depressed"
-          C.mood.must_equal "depressed"
-
-          A.color.must_equal "rosy"
-          B.color.must_equal "B: blue"
-          C.color.must_equal "blue"
-
-          A.name.must_equal({:first => 'jon', :last => 'smith'})
-          B.name.must_equal Hash.new
-          C.name.must_equal Hash.new
-
-          A.groceries.must_equal [:ice, :lemons, :splenda]
-          B.groceries.must_equal Array.new
-          C.groceries.must_equal Array.new
-
-          A.ingredients.must_equal Set.new([:sugar, :butter, :flour, :eggs])
-          B.ingredients.must_equal Set.new
-          C.ingredients.must_equal Set.new
+          @props[:location][:inherit].should == false
+          @props[:score][:inherit].should == false
+          @props[:num][:inherit].should == false
+          @props[:weather][:inherit].should == false
+          @props[:available][:inherit].should == false
+          @props[:mood][:inherit].should == false
+          @props[:color][:inherit].should == false
+          @props[:groceries][:inherit].should == false
+          @props[:ingredients][:inherit].should == false
+
+          A.location.should == "south side"
+          B.location.should == ''
+          C.location.should == ''
+
+          A.score.should == 32.18
+          B.score.should == nil
+          C.score.should == nil
+
+          A.num.should == 12
+          B.num.should == nil
+          C.num.should == nil
+
+          A.weather.should == :sunny
+          B.weather.should == nil
+          C.weather.should == nil
+
+          A.available.should == false
+          B.available.should == nil
+          C.available.should == nil
+
+          A.mood.should == "content"
+          B.mood.should == "depressed"
+          C.mood.should == "depressed"
+
+          A.color.should == "rosy"
+          B.color.should == "B: blue"
+          C.color.should == "blue"
+
+          A.name.should ==({:first => 'jon', :last => 'smith'})
+          B.name.should == Hash.new
+          C.name.should == Hash.new
+
+          A.groceries.should == [:ice, :lemons, :splenda]
+          B.groceries.should == Array.new
+          C.groceries.should == Array.new
+
+          A.ingredients.should == Set.new([:sugar, :butter, :flour, :eggs])
+          B.ingredients.should == Set.new
+          C.ingredients.should == Set.new
         end
 
         describe "manual inheritance age override" do
           it "allows 'true' and '-1' syntax" do
-            B.location(true).must_equal "south side"
-            C.location(true).must_equal "south side"
+            B.location(true).should == "south side"
+            C.location(true).should == "south side"
 
-            B.score(-1).must_equal 32.18
-            C.score(-1).must_equal 32.18
+            B.score(-1).should == 32.18
+            C.score(-1).should == 32.18
 
-            B.ingredients(true).must_equal Set.new([:sugar, :butter, :flour, :eggs])
-            C.ingredients(true).must_equal Set.new([:sugar, :butter, :flour, :eggs])
+            B.ingredients(true).should == Set.new([:sugar, :butter, :flour, :eggs])
+            C.ingredients(true).should == Set.new([:sugar, :butter, :flour, :eggs])
           end
 
           it "allows <fixnum> (n > 0) syntax to indicate max inheritance age" do
-            B.weather(0).must_equal nil
-            B.weather(1).must_equal :sunny
-            B.weather(2).must_equal :sunny
-            C.weather(0).must_equal nil
-            C.weather(1).must_equal nil
-            C.weather(2).must_equal :sunny
-            C.weather(3).must_equal :sunny
-
-            B.groceries(0).must_equal Array.new
-            B.groceries(1).must_equal [:ice, :lemons, :splenda]
-            B.groceries(2).must_equal [:ice, :lemons, :splenda]
-            C.groceries(0).must_equal Array.new
-            C.groceries(1).must_equal Array.new
-            C.groceries(2).must_equal Array.new [:ice, :lemons, :splenda]
-            C.groceries(3).must_equal Array.new [:ice, :lemons, :splenda]
+            B.weather(0).should == nil
+            B.weather(1).should == :sunny
+            B.weather(2).should == :sunny
+            C.weather(0).should == nil
+            C.weather(1).should == nil
+            C.weather(2).should == :sunny
+            C.weather(3).should == :sunny
+
+            B.groceries(0).should == Array.new
+            B.groceries(1).should == [:ice, :lemons, :splenda]
+            B.groceries(2).should == [:ice, :lemons, :splenda]
+            C.groceries(0).should == Array.new
+            C.groceries(1).should == Array.new
+            C.groceries(2).should == Array.new [:ice, :lemons, :splenda]
+            C.groceries(3).should == Array.new [:ice, :lemons, :splenda]
           end
         end
       end