File: instantiator_test.rb

package info (click to toggle)
ruby-instantiator 0.0.6%2Bgit9cbbe70-2
  • links: PTS, VCS
  • area: main
  • in suites: jessie, jessie-kfreebsd, stretch, wheezy
  • size: 152 kB
  • ctags: 101
  • sloc: ruby: 269; makefile: 2
file content (205 lines) | stat: -rw-r--r-- 5,960 bytes parent folder | download | duplicates (3)
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
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
require "test/test_helper"
require "instantiator"

class InstantiatorTest < Test::Unit::TestCase
  def test_should_instantiate_class_with_no_explicit_initialize
    klass = Class.new
    instance = klass.instantiate
    assert_equal klass, instance.class
  end

  def test_should_instantiate_class_with_initialize_with_no_parameters
    klass = Class.new do
      def initialize; end
    end
    instance = klass.instantiate
    assert_equal klass, instance.class
  end

  def test_should_instantiate_class_with_initialize_with_one_parameter
    klass = Class.new do
      def initialize(parameter_one); end
    end
    instance = klass.instantiate
    assert_equal klass, instance.class
  end

  def test_should_instantiate_class_with_initialize_with_multiple_parameters
    klass = Class.new do
      def initialize(parameter_one, parameter_two, parameter_three, parameter_four); end
    end
    instance = klass.instantiate
    assert_equal klass, instance.class
  end

  def test_should_instantiate_class_with_initialize_with_only_optional_parameters
    klass = Class.new do
      def initialize(*optional_parameters); end
    end
    instance = klass.instantiate
    assert_equal klass, instance.class
  end

  def test_should_instantiate_class_with_initialize_with_some_required_parameters_and_some_optional_parameters
    klass = Class.new do
      def initialize(parameter_one, parameter_two, *optional_parameters); end
    end
    instance = klass.instantiate
    assert_equal klass, instance.class
  end

  def test_should_instantiate_class_which_calls_method_on_parameter
    klass = Class.new do
      def initialize(parameter_one)
        parameter_one.foo
      end
    end
    instance = klass.instantiate
    assert_equal klass, instance.class
  end

  def test_should_instantiate_class_which_calls_method_on_multiple_parameters
    klass = Class.new do
      def initialize(parameter_one, parameter_two, parameter_three, parameter_four)
        parameter_one.foo
        parameter_two.foo
        parameter_three.foo
        parameter_four.foo
      end
    end
    instance = klass.instantiate
    assert_equal klass, instance.class
  end

  def test_should_instantiate_class_which_calls_method_on_result_of_calling_method_on_parameter
    klass = Class.new do
      def initialize(parameter_one)
        parameter_one.foo.bar
      end
    end
    instance = klass.instantiate
    assert_equal klass, instance.class
  end

  def test_should_instantiate_class_which_defines_its_own_new_method_with_no_parameters
    klass = Class.new do
      class << self
        alias_method :__new__, :new
        def new
          __new__("parameter_one")
        end
      end
      def initialize(parameter_one); end
    end
    instance = klass.instantiate
    assert_equal klass, instance.class
  end

  def test_should_instantiate_class_which_defines_its_own_new_method_with_one_parameter
    klass = Class.new do
      class << self
        alias_method :__new__, :new
        def new(parameter_one)
          __new__
        end
      end
    end
    instance = klass.instantiate
    assert_equal klass, instance.class
  end

  def test_should_instantiate_class_which_defines_its_own_new_method_with_multiple_parameters
    klass = Class.new do
      class << self
        alias_method :__new__, :new
        def new(parameter_one, parameter_two, parameter_three, parameter_four)
          __new__
        end
      end
    end
    instance = klass.instantiate
    assert_equal klass, instance.class
  end

  def test_should_instantiate_class_which_defines_its_own_new_method_with_only_optional_parameters
    klass = Class.new do
      class << self
        alias_method :__new__, :new
        def new(*optional_parameters)
          __new__
        end
      end
    end
    instance = klass.instantiate
    assert_equal klass, instance.class
  end

  def test_should_instantiate_class_which_defines_its_own_new_method_with_some_required_parameters_and_some_optional_parameters
    klass = Class.new do
      class << self
        alias_method :__new__, :new
        def new(parameter_one, parameter_two, *optional_parameters)
          __new__
        end
      end
    end
    instance = klass.instantiate
    assert_equal klass, instance.class
  end

  def test_should_instantiate_class_which_defines_its_own_new_method_which_calls_method_on_parameter
    klass = Class.new do
      class << self
        alias_method :__new__, :new
        def new(parameter_one)
          parameter_one.foo
          __new__
        end
      end
    end
    instance = klass.instantiate
    assert_equal klass, instance.class
  end

  def test_should_instantiate_class_which_defines_its_own_new_method_which_calls_method_on_multiple_parameters
    klass = Class.new do
      class << self
        alias_method :__new__, :new
        def new(parameter_one, parameter_two, parameter_three, parameter_four)
          parameter_one.foo
          parameter_two.foo
          parameter_three.foo
          parameter_four.foo
          __new__
        end
      end
    end
    instance = klass.instantiate
    assert_equal klass, instance.class
  end

  def test_should_instantiate_class_which_defines_its_own_new_method_which_calls_method_on_result_of_calling_method_on_parameter
    klass = Class.new do
      class << self
        alias_method :__new__, :new
        def new(parameter_one)
          parameter_one.foo.bar
          __new__
        end
      end
    end
    instance = klass.instantiate
    assert_equal klass, instance.class
  end

  def test_should_instantiate_class_which_defines_its_own_native_new_method_with_some_required_parameters_and_some_optional
    require "strscan"
    instance = StringScanner.instantiate
  end

  def test_should_raise_exception_if_instantiating_class_is_unsupported
    e = assert_raises(Instantiator::Error) { Proc.instantiate }
    assert_equal "Proc.instantiate is not yet supported", e.message
  end

end