def test_nil_has_a_few_methods_defined_on_it
    # nil对应空字符串, 所以 "#{nil}" 才不会影响输出.
    assert_equal '', nil.to_s
    # 这个就很新鲜, 之前没有注意到啊.
    assert_equal 'nil', nil.inspect
end

def test_some_system_objects_always_have_the_same_id
    # false, true, nil 三者都有固定的 object_id, 为什么会取 0 2 4 这三个值呢? 请看下文.
    assert_equal 0, false.object_id
    assert_equal 2, true.object_id
    assert_equal 4, nil.object_id
end

def test_small_integers_have_fixed_ids
    # 整型的 object_id 等于 2n+1, 所以负数的 object_id 也是负的.
    # 从 0 开始闲置的 object_id 就只有 0 2 4 等等. 所以之前特殊的 object_id 由此得来.
    assert_equal 1, 0.object_id
    assert_equal 3, 1.object_id
    assert_equal 5, 2.object_id
    assert_equal 201, 100.object_id
end

# 其它对象的 object_id 是随机产生并且绝不重复的(包括 Float), object_id 也是判断对象是否为同一个对象的依据.

def test_slicing_arrays
    array = [:peanut, :butter, :and, :jelly]

    # 这种用法对应于 Array#slice(start, length)
    # 当 length 超过数组长度时忽略.
    assert_equal [:and, :jelly], array[2,20]
    # 当 length 为 0 时返回空数组
    assert_equal [], array[4,0]
    assert_equal [], array[4,100]
    # 当 start 超过数组长度时返回 nil.
    assert_equal nil, array[5,0]
end

def test_flexible_quotes_can_handle_multiple_lines
    long_string = %{# \n
It was the best of times,# \n
It was the worst of times.# \n
}
    assert_equal 54, long_string.size
end

def test_here_documents_can_also_handle_multiple_lines
    long_string = <<EOS
It was the best of times,# \n
It was the worst of times.# \n
EOS
    assert_equal 53, long_string.size
end

# += 操作不会改变原始字符串.
def test_plus_equals_also_will_leave_the_original_string_unmodified
    original_string = "Hello, "
    hi = original_string
    there = "World"
    hi += there
    assert_equal "Hello, ", original_string
end

# << 操作会修改源始字符串的.
def test_the_shovel_operator_modifies_the_original_string
    original_string = "Hello, "
    hi = original_string
    there = "World"
    hi << there
    assert_equal "Hello, World", original_string
end

# 单引号字符串里也会发生转义.
def test_single_quotes_sometimes_interpret_escape_characters
    string = '\\\''
    assert_equal 2, string.size
    assert_equal %{\\'}, string
end

def test_you_can_get_a_substring_from_a_string
    string = "Bacon, lettuce and tomato"
    # 可以像数组那样截取字符串分片
    assert_equal 'let', string[7,3]
    assert_equal 'let', string[7..9]
    # 但是如果只取一个字符的话, 返回的是字符的 ASCII 码.
    assert_equal 97, string[1]
end

def test_strings_can_be_split
    string = "Sausage Egg Cheese"
    words = string.split
    # 字符串分割的默认参数是 $;
    assert_equal ["Sausage", "Egg", "Cheese"], words
end

def test_strings_are_not_unique_objects
    a = "a string"
    b = "a string"
    # 值相等.
    assert_equal true, a           == b
    # 但却不是同一个对象.
    assert_equal false, a.object_id == b.object_id
end

def test_identical_symbols_are_a_single_internal_object
    symbol1 = :a_symbol
    symbol2 = :a_symbol
    # 符号是独一无二的.
    assert_equal true, symbol1           == symbol2
    assert_equal true, symbol1.object_id == symbol2.object_id
end

# all_symbols 方法可以返回所有符号, 这基中就包括方法名.
def test_method_names_become_symbols
    symbols_as_strings = Symbol.all_symbols.map { |x| x.to_s }
    assert_equal true, symbols_as_strings.include?("test_method_names_become_symbols")
end

# 在 MRI 版本里, 常量也是符号.
in_ruby_version("mri") do
    RubyConstant = "What is the sound of one hand clapping?"
    def test_constants_become_symbols
        all_symbols = Symbol.all_symbols
        
        assert_equal true, all_symbols.include?(:RubyConstant)
    end
end

# 符号可以长的不太一样.
def test_symbols_with_spaces_can_be_built
    symbol = :"cats and dogs"

    assert_equal symbol, symbol.to_sym
end

# 符号也可以在内部插入值.
def test_symbols_with_interpolation_can_be_built
    value = "and"
    symbol = :"cats #{value} dogs"

    assert_equal symbol, "cats and dogs".to_sym
end

# 符号不是"不可变的"字符串, 它没有字符串的方法.
def test_symbols_do_not_have_string_methods
    symbol = :not_a_string
    assert_equal false, symbol.respond_to?(:each_char)
    assert_equal false, symbol.respond_to?(:reverse)
end

# 连最基本的连接操作都不允许.
def test_symbols_cannot_be_concatenated
    assert_raise(NoMethodError) { :cats + :dogs }
end

# 符号可以动态创建, 但是不推荐这样做.
def test_symbols_can_be_dynamically_created
    assert_equal :catsdogs, ("cats" + "dogs").to_sym
end

# 字符串可以像这样查找内容.
def test_a_regexp_can_search_a_string_for_matching_content
    assert_equal "match", "some matching content"[/match/]
end

# 找不到会返回 nil, 这种方式更像是条件判断.
def test_a_failed_match_returns_nil
    assert_equal nil, "some matching content"[/missing/]
end

# 带星号的正则表达的十分贪婪.
def test_asterisk_means_zero_or_more
    assert_equal "", "abbcccddddeeeee"[/z*/]
end

# 这会儿又表现的十分容易满足, 这简直就是陷阱.
def test_the_left_most_match_wins
    assert_equal "a", "abbccc az"[/az*/]
end

# \w 里的连字符是下划线, 不包括减号.
def test_slash_w_is_a_shortcut_for_a_word_character_class
    assert_equal "variable_1", "variable_1 = 42"[/[a-zA-Z0-9_]+/]
    assert_equal "variable_1", "variable_1 = 42"[/\w+/]
end

# 不但能匹配, 还能选择返回第几个匹配结果.
def test_parentheses_also_capture_matched_content_by_number
    assert_equal "Gray", "Gray, James"[/(\w+), (\w+)/, 1]
    assert_equal "James", "Gray, James"[/(\w+), (\w+)/, 2]
end

# 每次匹配, 结果都会被记入全局变量中.
def test_variables_can_also_be_used_to_access_captures
    assert_equal "Gray, James", "Name:  Gray, James"[/(\w+), (\w+)/]
    assert_equal "Gray", $1
    assert_equal "James", $2
end

class Animal
    LEGS = 4
end

class MyAnimals
    LEGS = 2

    class Bird < Animal
        def legs_in_bird
            LEGS
        end
    end
end

# 嵌套常量赢过继承常量.
def test_who_wins_with_both_nested_and_inherited_constants
    assert_equal 2, MyAnimals::Bird.new.legs_in_bird
end

class MyAnimals::Oyster < Animal
    def legs_in_oyster
      LEGS
    end
end

# 如果定义成这样, 继承变量就赢了.
def test_who_wins_with_explicit_scoping_on_class_definition
    assert_equal 4, MyAnimals::Oyster.new.legs_in_oyster
end

class MySpecialError < RuntimeError
end

# 自定义异常完整的继承树.
def test_exceptions_inherit_from_Exception
    assert_equal RuntimeError, MySpecialError.ancestors[1]
    assert_equal StandardError, MySpecialError.ancestors[2]
    assert_equal Exception, MySpecialError.ancestors[3]
    assert_equal Object, MySpecialError.ancestors[4]
end

# 块中的代码甚至会给局部变量带来副作用.
def test_block_can_affect_variables_in_the_code_where_they_are_created
    value = :initial_value
    method_with_block { value = :modified_in_a_block }
    assert_equal :modified_in_a_block, value
end

def test_blocks_can_be_assigned_to_variables_and_called_explicitly
    add_one = lambda { |n| n + 1 }
    # 有两种方法调用 lambda 表达式.
    assert_equal 11, add_one.call(10)
    assert_equal 11, add_one[10]
end

class AboutScope
    class String
    end
    
    # 当前范围中的类名拥有更高的优先级.
    def test_bare_bones_class_names_assume_the_current_scope
        assert_equal true, AboutScope::String == String
    end
    
    # 当前范围中的类名如果与 Ruby 库中的类名重复, 会造成很多不必要的麻烦.
    def test_nested_string_is_not_the_same_as_the_system_string
        assert_equal false, String == "HI".class
    end
    
    def test_use_the_prefix_scope_operator_to_force_the_global_scope
        assert_equal true, ::String == "HI".class
    end
    
    MyString = ::String
    
    # 类名其实只是常量而已.
    def test_class_names_are_just_constants
        assert_equal true, MyString == ::String
        assert_equal true, MyString == "HI".class
    end
    
    def test_constants_can_be_looked_up_explicitly
        assert_equal true, MyString == AboutScope.const_get("MyString")
    end
end

class Dog
end

# 实例也可以定义方法
def test_you_can_define_methods_on_individual_objects
    fido = Dog.new
    def fido.wag
        :fidos_wag
    end
    assert_equal :fidos_wag, fido.wag
end

# 这个方法只属于这个实例, 不影响类的其它实例.
def test_other_objects_are_not_affected_by_these_singleton_methods
    fido = Dog.new
    rover = Dog.new
    def fido.wag
        :fidos_wag
    end

    assert_raise(NoMethodError) do
        rover.wag
    end
end

LastExpressionInClassStatement = class Dog; 21; end

# 你总能拿到最后一个表达式的结果.
def test_class_statements_return_the_value_of_their_last_expression
    assert_equal 21, LastExpressionInClassStatement
end

SelfInsideOfClassStatement = class Dog; self; end

# 甚至是 self.
def test_self_while_inside_class_is_class_object_not_instance
    assert_equal true, Dog == SelfInsideOfClassStatement
end

class CanBeTreatedAsString
    def to_s
        "string-like"
    end

    def to_str
        to_s
    end
end

# to_str 有更进一步的作用.
def test_to_str_allows_objects_to_be_treated_as_strings
    assert_equal false, File.exist?(CanBeTreatedAsString.new)
end

def suppress_warning &block
    old_v = $-v
    $-v = nil
    yield
ensure
    $-v = old_v
end