Fixes  def test_creating_hashes.

* I learned that for an empty hash:

class = Hash  

size = 0


[#65851842]
Fixes  def test_hash_literals and  def test_accessing_hashes.

I learned:

*when a hash has to values, its size reflects that:

hash = { :one => "uno", :two => "dos" }
hash.size = 2
 
* to access a hash variable, you use the assignment given:    

hash[:one] = "uno"
hash[:two] = "dos"

* if you call an assignment that doesn't exist, you get nil


[#65851842]
Fixes def test_accessing_hashes_with_fetch 

I learned:

* Fetching a hash symbol that doesn't exist gives you KeyError.

* If you replace a value for a particular hash symbol, 
calling the hash will reveal the new value.
Changes lines 39 & 40, but commented out the second line of code 
in order to proceed with tests:

expected = { :one => "eins", :two => "dos" }
#assert_equal {:one=>"eins", :two=>"dos"}, hash

[#65851838]
Fixes def test_hash_is_unordered.

* I learned that when 2 hashes have the same contents in a different order,
they are still considered equal.

*  hash1 = { :one => "uno", :two => "dos" }
    hash2 = { :two => "dos", :one => "uno" }
    hash 1 == hash 2

[#65851842]
Fixes def test_hash_keys and def test_hash_values

* I learned that hash keys and values can be tested in similar fashions. Ex:

hash = { :one => "uno", :two => "dos" }

hash.keys.size = 2
hash.values.size = 2

hash.keys.include?(:one)
hash.values.include?(:"uno")

* If you return the class of either keys or values, you get an array, so both have a class of Array.

[#65851842]
Fixes def test_combining_hashes

* Learned that when combining hashes, the results of .merge only apply to
the new hash. The new hash is not equal to the original hash.

[#65851842]
Committing changes in order to rebase about_arrays_master.

 [#65851842]
Fixes def test_default_value.

* I learned that when you create a new hash with a default value, keys that aren't
assigned values receive the default value.

* Ex:  hash2 = Hash.new("dos")
   	    hash2[:one] = 1
	    hash2[:one] == 1
	    hash2[:two] == "dos"

[#65851842]
Fixes def test_default_value_is_the_same_object. I learned:

* The syntax Hash.new([]) means "For any unknown key, return this array".

* When we assign << "uno" into that array, it still applies to any unknown key:

* Ex: hash = Hash.new([])
	   hash[:one] << "uno"
   	   hash[:two] << "dos"
	   hash[:one] == ["uno", "dos"]
	   hash[:two] == ["uno", "dos"]

* I also learned that both keys have the same object id:

* Ex: hash[:one].object_id == hash[:two].object_id

[#65851842]
Fixes def test_default_value_with_block.

* I learned that using a block to assign values separates the key/value pairs:

* Ex: hash = Hash.new {|hash, key| hash[key] = [] }

hash[:one] << "uno"
hash[:two] << "dos"

hash[:one] == ["uno"]
hash[:two] == ["dos"]
hash[:three] == []

[#65851842]
Fixes lines 39 and 40 in about_hashes.rb.

* expected = { :one => "eins", :two => "dos" }
 assert_equal expected, hash

[#65851838]