File: instance_snapshot_test.rb

package info (click to toggle)
ruby-introspection 0.0.2-2
  • links: PTS, VCS
  • area: main
  • in suites: wheezy
  • size: 200 kB
  • sloc: ruby: 685; makefile: 2
file content (122 lines) | stat: -rw-r--r-- 3,858 bytes parent folder | download | duplicates (2)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
require "test/test_helper"

class InstanceSnapshotTest < Test::Unit::TestCase

  def test_detect_instance_method_on_singleton_class
    for_all_method_visibilities do |visibility|
      instance = Class.new.new
      instance.__metaclass__.send(:define_method, :foo) {}
      instance.__metaclass__.send(visibility, :foo)
      assert_method_exists(instance, instance.__metaclass__, :foo, visibility)
    end
  end

  def test_detect_instance_method_on_module_included_into_singleton_class
    for_all_method_visibilities do |visibility|
      mod = Module.new
      mod.send(:define_method, :foo) {}
      mod.send(visibility, :foo)
      instance = Class.new.new
      instance.extend(mod)
      assert_method_exists(instance, mod, :foo, visibility)
    end
  end

  def test_detect_instance_method_on_module_included_module_included_into_singleton_class
    for_all_method_visibilities do |visibility|
      supermod = Module.new
      supermod.send(:define_method, :foo) {}
      supermod.send(visibility, :foo)
      mod = Module.new
      mod.send(:include, supermod)
      instance = Class.new.new
      instance.extend(mod)
      assert_method_exists(instance, supermod, :foo, visibility)
    end
  end

  def test_detect_instance_method_on_class
    for_all_method_visibilities do |visibility|
      klass = Class.new
      klass.send(:define_method, :foo) {}
      klass.send(visibility, :foo)
      instance = klass.new
      assert_method_exists(instance, klass, :foo, visibility)
    end
  end

  def test_detect_instance_method_on_superclass
    for_all_method_visibilities do |visibility|
      superklass = Class.new
      superklass.send(:define_method, :foo) {}
      superklass.send(visibility, :foo)
      instance = Class.new(superklass).new
      assert_method_exists(instance, superklass, :foo, visibility)
    end
  end

  def test_detect_instance_method_on_superclass_of_superclass
    for_all_method_visibilities do |visibility|
      superduperklass = Class.new
      superduperklass.send(:define_method, :foo) {}
      superduperklass.send(visibility, :foo)
      instance = Class.new(Class.new(superduperklass)).new
      assert_method_exists(instance, superduperklass, :foo, visibility)
    end
  end

  def test_detect_instance_method_on_module_included_into_class
    for_all_method_visibilities do |visibility|
      mod = Module.new
      mod.send(:define_method, :foo) {}
      mod.send(visibility, :foo)
      instance = Class.new do
        include mod
      end.new
      assert_method_exists(instance, mod, :foo, visibility)
    end
  end

  def test_detect_instance_method_on_module_included_into_superclass
    for_all_method_visibilities do |visibility|
      mod = Module.new
      mod.send(:define_method, :foo) {}
      mod.send(visibility, :foo)
      superklass = Class.new do
        include mod
      end
      instance = Class.new(superklass).new
      assert_method_exists(instance, mod, :foo, visibility)
    end
  end

  def test_detect_instance_method_on_module_included_into_superclass_of_superclass
    for_all_method_visibilities do |visibility|
      mod = Module.new
      mod.send(:define_method, :foo) {}
      mod.send(visibility, :foo)
      superduperklass = Class.new do
        include mod
      end
      instance = Class.new(Class.new(superduperklass)).new
      assert_method_exists(instance, mod, :foo, visibility)
    end
  end

  def test_detect_instance_method_on_module_included_into_module_included_into_class
    for_all_method_visibilities do |visibility|
      mod = Module.new
      mod.send(:define_method, :foo) {}
      mod.send(visibility, :foo)
      supermod = Module.new do
        include mod
      end
      klass = Class.new do
        include supermod
      end
      instance = klass.new
      assert_method_exists(instance, mod, :foo, visibility)
    end
  end

end