← Back to branch summary

~nvalcarcel/ubuntu/lucid/puppet/fix-546677

« back to all changes in this revision

Viewing changes to lib/puppet/external/event-loop/better-definers.rb

  • Committer: Bazaar Package Importer
  • Author(s): Chuck Short
  • Date: 2009-12-23 00:48:10 UTC
  • mfrom: (1.1.10 upstream) (3.1.7 squeeze)
  • Revision ID: james.westby@ubuntu.com-20091223004810-3i4oryds922g5n59
Tags: 0.25.1-3ubuntu1
* Merge from debian testing.  Remaining changes:
  - debian/rules:
    + Don't start puppet when first installing puppet.
  - debian/puppet.conf, lib/puppet/defaults.rb:
    + Move templates to /etc/puppet
  - lib/puppet/defaults.rb:
    + Fix /var/lib/puppet/state ownership.
  - man/man8/puppet.conf.8: 
    + Fix broken URL in manpage.
  - debian/control:
    + Update maintainer accordint to spec.
    + Puppetmaster Recommends -> Suggests
    + Created puppet-testsuite as a seperate. Allow the users to run puppet's 
      testsuite.
  - tests/Rakefile: Fix rakefile so that the testsuite can acutally be ran.

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/puppet/external/event-loop/better-definers.rb
18
18
# Boston, MA 02110-1301, USA.
19
19
 
20
20
class Symbol
21
 
  def predicate?
22
 
    to_s.include? "?" end
23
 
  def imperative?
24
 
    to_s.include? "!" end
25
 
  def writer?
26
 
    to_s.include? "=" end
27
 
 
28
 
  def punctuated?
29
 
    predicate? or imperative? or writer? end
30
 
  def without_punctuation
31
 
    to_s.delete("?!=").to_sym end
32
 
 
33
 
  def predicate
34
 
    without_punctuation.to_s + "?" end
35
 
  def imperative
36
 
    without_punctuation.to_s + "!" end
37
 
  def writer
38
 
    without_punctuation.to_s + "=" end
 
21
    def predicate?
 
22
        to_s.include? "?" end
 
23
    def imperative?
 
24
        to_s.include? "!" end
 
25
    def writer?
 
26
        to_s.include? "=" end
 
27
 
 
28
    def punctuated?
 
29
        predicate? or imperative? or writer? end
 
30
    def without_punctuation
 
31
        to_s.delete("?!=").to_sym end
 
32
 
 
33
    def predicate
 
34
        without_punctuation.to_s + "?" end
 
35
    def imperative
 
36
        without_punctuation.to_s + "!" end
 
37
    def writer
 
38
        without_punctuation.to_s + "=" end
39
39
end
40
40
 
41
41
class Hash
42
 
  def collect! (&block)
43
 
    replace Hash[*collect(&block).flatten]
44
 
  end
 
42
    def collect! (&block)
 
43
        replace Hash[*collect(&block).flatten]
 
44
    end
45
45
 
46
 
  def flatten
47
 
    to_a.flatten
48
 
  end
 
46
    def flatten
 
47
        to_a.flatten
 
48
    end
49
49
end
50
50
 
51
51
module Kernel
52
 
  def returning (value)
53
 
    yield value ; value
54
 
  end
 
52
    def returning (value)
 
53
        yield value ; value
 
54
    end
55
55
end
56
56
 
57
57
class Module
58
 
  def define_hard_aliases (name_pairs)
59
 
    for new_aliases, existing_name in name_pairs do
60
 
      new_aliases.kind_of? Array or new_aliases = [new_aliases]
61
 
      for new_alias in new_aliases do
62
 
        alias_method(new_alias, existing_name)
63
 
      end
64
 
    end
65
 
  end
66
 
 
67
 
  def define_soft_aliases (name_pairs)
68
 
    for new_aliases, existing_name in name_pairs do
69
 
      new_aliases.kind_of? Array or new_aliases = [new_aliases]
70
 
      for new_alias in new_aliases do
71
 
        class_eval %{def #{new_alias}(*args, &block)
72
 
                       #{existing_name}(*args, &block) end}
73
 
      end
74
 
    end
75
 
  end
76
 
 
77
 
  define_soft_aliases \
78
 
    :define_hard_alias => :define_hard_aliases,
79
 
    :define_soft_alias => :define_soft_aliases
80
 
 
81
 
  # This method lets you define predicates like :foo?,
82
 
  # which will be defined to return the value of @foo.
83
 
  def define_readers (*names)
84
 
    for name in names.map { |x| x.to_sym } do
85
 
      if name.punctuated?
86
 
        # There's no way to define an efficient reader whose
87
 
        # name is different from the instance variable.
88
 
        class_eval %{def #{name} ; @#{name.without_punctuation} end}
89
 
      else
90
 
        # Use `attr_reader' to define an efficient method.
91
 
        attr_reader(name)
92
 
      end
93
 
    end
94
 
  end
95
 
 
96
 
  def writer_defined? (name)
97
 
    method_defined? name.to_sym.writer
98
 
  end
99
 
 
100
 
  # If you pass a predicate symbol :foo? to this method, it'll first
101
 
  # define a regular writer method :foo, without a question mark.
102
 
  # Then it'll define an imperative writer method :foo! as a shorthand
103
 
  # for setting the property to true.
104
 
  def define_writers (*names, &body)
105
 
    for name in names.map { |x| x.to_sym } do
106
 
      if block_given?
107
 
        define_method(name.writer, &body)
108
 
      else
109
 
        attr_writer(name.without_punctuation)
110
 
      end
111
 
      if name.predicate?
112
 
        class_eval %{def #{name.imperative}
113
 
                       self.#{name.writer} true end}
114
 
      end
115
 
    end
116
 
  end
117
 
 
118
 
  define_soft_aliases \
119
 
    :define_reader => :define_readers,
120
 
    :define_writer => :define_writers
121
 
 
122
 
  # We don't need a singular alias for `define_accessors',
123
 
  # because it always defines at least two methods.
124
 
 
125
 
  def define_accessors (*names)
126
 
    define_readers(*names)
127
 
    define_writers(*names)
128
 
  end
129
 
 
130
 
  def define_opposite_readers (name_pairs)
131
 
    name_pairs.collect! { |k, v| [k.to_sym, v.to_sym] }
132
 
    for opposite_name, name in name_pairs do
133
 
      define_reader(name) unless method_defined? name
134
 
      class_eval %{def #{opposite_name} ; not #{name} end}
135
 
    end
136
 
  end
137
 
 
138
 
  def define_opposite_writers (name_pairs)
139
 
    name_pairs.collect! { |k, v| [k.to_sym, v.to_sym] }
140
 
    for opposite_name, name in name_pairs do
141
 
      define_writer(name) unless writer_defined? name
142
 
      class_eval %{def #{opposite_name.writer} x
143
 
                     self.#{name.writer} !x end} 
144
 
      class_eval %{def #{opposite_name.imperative}
145
 
                     self.#{name.writer} false end}
146
 
    end
147
 
  end
148
 
 
149
 
  define_soft_aliases \
150
 
    :define_opposite_reader => :define_opposite_readers,
151
 
    :define_opposite_writer => :define_opposite_writers
152
 
 
153
 
  def define_opposite_accessors (name_pairs)
154
 
    define_opposite_readers name_pairs
155
 
    define_opposite_writers name_pairs
156
 
  end
157
 
 
158
 
  def define_reader_with_opposite (name_pair, &body)
159
 
    name, opposite_name = name_pair.flatten.collect { |x| x.to_sym }
160
 
    define_method(name, &body)
161
 
    define_opposite_reader(opposite_name => name)
162
 
  end
163
 
 
164
 
  def define_writer_with_opposite (name_pair, &body)
165
 
    name, opposite_name = name_pair.flatten.collect { |x| x.to_sym }
166
 
    define_writer(name, &body)
167
 
    define_opposite_writer(opposite_name => name)
168
 
  end
 
58
    def define_hard_aliases (name_pairs)
 
59
        for new_aliases, existing_name in name_pairs do
 
60
            new_aliases.kind_of? Array or new_aliases = [new_aliases]
 
61
            for new_alias in new_aliases do
 
62
                alias_method(new_alias, existing_name)
 
63
            end
 
64
        end
 
65
    end
 
66
 
 
67
    def define_soft_aliases (name_pairs)
 
68
        for new_aliases, existing_name in name_pairs do
 
69
            new_aliases.kind_of? Array or new_aliases = [new_aliases]
 
70
            for new_alias in new_aliases do
 
71
                class_eval %{def #{new_alias}(*args, &block)
 
72
                            #{existing_name}(*args, &block) end}
 
73
            end
 
74
        end
 
75
    end
 
76
 
 
77
    define_soft_aliases \
 
78
        :define_hard_alias => :define_hard_aliases,
 
79
        :define_soft_alias => :define_soft_aliases
 
80
 
 
81
    # This method lets you define predicates like :foo?,
 
82
    # which will be defined to return the value of @foo.
 
83
    def define_readers (*names)
 
84
        for name in names.map { |x| x.to_sym } do
 
85
            if name.punctuated?
 
86
                # There's no way to define an efficient reader whose
 
87
                # name is different from the instance variable.
 
88
                class_eval %{def #{name} ; @#{name.without_punctuation} end}
 
89
            else
 
90
                # Use `attr_reader' to define an efficient method.
 
91
                attr_reader(name)
 
92
            end
 
93
        end
 
94
    end
 
95
 
 
96
    def writer_defined? (name)
 
97
        method_defined? name.to_sym.writer
 
98
    end
 
99
 
 
100
    # If you pass a predicate symbol :foo? to this method, it'll first
 
101
    # define a regular writer method :foo, without a question mark.
 
102
    # Then it'll define an imperative writer method :foo! as a shorthand
 
103
    # for setting the property to true.
 
104
    def define_writers (*names, &body)
 
105
        for name in names.map { |x| x.to_sym } do
 
106
            if block_given?
 
107
                define_method(name.writer, &body)
 
108
            else
 
109
                attr_writer(name.without_punctuation)
 
110
            end
 
111
            if name.predicate?
 
112
                class_eval %{def #{name.imperative}
 
113
                           self.#{name.writer} true end}
 
114
            end
 
115
        end
 
116
    end
 
117
 
 
118
    define_soft_aliases \
 
119
        :define_reader => :define_readers,
 
120
        :define_writer => :define_writers
 
121
 
 
122
    # We don't need a singular alias for `define_accessors',
 
123
    # because it always defines at least two methods.
 
124
 
 
125
    def define_accessors (*names)
 
126
        define_readers(*names)
 
127
        define_writers(*names)
 
128
    end
 
129
 
 
130
    def define_opposite_readers (name_pairs)
 
131
        name_pairs.collect! { |k, v| [k.to_sym, v.to_sym] }
 
132
        for opposite_name, name in name_pairs do
 
133
            define_reader(name) unless method_defined? name
 
134
            class_eval %{def #{opposite_name} ; not #{name} end}
 
135
        end
 
136
    end
 
137
 
 
138
    def define_opposite_writers (name_pairs)
 
139
        name_pairs.collect! { |k, v| [k.to_sym, v.to_sym] }
 
140
        for opposite_name, name in name_pairs do
 
141
            define_writer(name) unless writer_defined? name
 
142
            class_eval %{def #{opposite_name.writer} x
 
143
                         self.#{name.writer} !x end}
 
144
            class_eval %{def #{opposite_name.imperative}
 
145
                         self.#{name.writer} false end}
 
146
        end
 
147
    end
 
148
 
 
149
    define_soft_aliases \
 
150
        :define_opposite_reader => :define_opposite_readers,
 
151
        :define_opposite_writer => :define_opposite_writers
 
152
 
 
153
    def define_opposite_accessors (name_pairs)
 
154
        define_opposite_readers name_pairs
 
155
        define_opposite_writers name_pairs
 
156
    end
 
157
 
 
158
    def define_reader_with_opposite (name_pair, &body)
 
159
        name, opposite_name = name_pair.flatten.collect { |x| x.to_sym }
 
160
        define_method(name, &body)
 
161
        define_opposite_reader(opposite_name => name)
 
162
    end
 
163
 
 
164
    def define_writer_with_opposite (name_pair, &body)
 
165
        name, opposite_name = name_pair.flatten.collect { |x| x.to_sym }
 
166
        define_writer(name, &body)
 
167
        define_opposite_writer(opposite_name => name)
 
168
    end
169
169
 
170
170
  public :define_method
171
171
 
172
 
  def define_methods (*names, &body)
173
 
    names.each { |name| define_method(name, &body) }
174
 
  end
175
 
  
176
 
  def define_private_methods (*names, &body)
177
 
    define_methods(*names, &body)
178
 
    names.each { |name| private name }
179
 
  end
180
 
 
181
 
  def define_protected_methods (*names, &body)
182
 
    define_methods(*names, &body)
183
 
    names.each { |name| protected name }
184
 
  end
185
 
 
186
 
  def define_private_method (name, &body)
187
 
    define_method(name, &body)
188
 
    private name
189
 
  end
190
 
 
191
 
  def define_protected_method (name, &body)
192
 
    define_method(name, &body)
193
 
    protected name
194
 
  end
 
172
    def define_methods (*names, &body)
 
173
        names.each { |name| define_method(name, &body) }
 
174
    end
 
175
 
 
176
    def define_private_methods (*names, &body)
 
177
        define_methods(*names, &body)
 
178
        names.each { |name| private name }
 
179
    end
 
180
 
 
181
    def define_protected_methods (*names, &body)
 
182
        define_methods(*names, &body)
 
183
        names.each { |name| protected name }
 
184
    end
 
185
 
 
186
    def define_private_method (name, &body)
 
187
        define_method(name, &body)
 
188
        private name
 
189
    end
 
190
 
 
191
    def define_protected_method (name, &body)
 
192
        define_method(name, &body)
 
193
        protected name
 
194
    end
195
195
end
196
196
 
197
197
class ImmutableAttributeError < StandardError
198
 
  def initialize (attribute=nil, message=nil)
199
 
    super message
200
 
    @attribute = attribute
201
 
  end
202
 
 
203
 
  define_accessors :attribute
204
 
 
205
 
  def to_s
206
 
    if @attribute and @message
207
 
      "cannot change the value of `#@attribute': #@message"
208
 
    elsif @attribute
209
 
      "cannot change the value of `#@attribute'"
210
 
    elsif @message
211
 
      "cannot change the value of attribute: #@message"
212
 
    else
213
 
      "cannot change the value of attribute"
 
198
    def initialize (attribute=nil, message=nil)
 
199
        super message
 
200
        @attribute = attribute
214
201
    end
215
 
  end
216
 
end
217
 
 
218
 
class Module
219
 
  # Guard each of the specified attributes by replacing the writer
220
 
  # method with a proxy that asks the supplied block before proceeding
221
 
  # with the change.
222
 
  #
223
 
  # If it's okay to change the attribute, the block should return
224
 
  # either nil or the symbol :mutable.  If it isn't okay, the block
225
 
  # should return a string saying why the attribute can't be changed.
226
 
  # If you don't want to provide a reason, you can have the block
227
 
  # return just the symbol :immutable.
228
 
  def guard_writers(*names, &predicate)
229
 
    for name in names.map { |x| x.to_sym } do
230
 
      define_hard_alias("__unguarded_#{name.writer}" => name.writer)
231
 
      define_method(name.writer) do |new_value|
232
 
        case result = predicate.call
233
 
        when :mutable, nil
234
 
          __send__("__unguarded_#{name.writer}", new_value)
235
 
        when :immutable
236
 
          raise ImmutableAttributeError.new(name)
 
202
 
 
203
    define_accessors :attribute
 
204
 
 
205
    def to_s
 
206
        if @attribute and @message
 
207
            "cannot change the value of `#@attribute': #@message"
 
208
        elsif @attribute
 
209
            "cannot change the value of `#@attribute'"
 
210
        elsif @message
 
211
            "cannot change the value of attribute: #@message"
237
212
        else
238
 
          raise ImmutableAttributeError.new(name, result)
239
 
        end
240
 
      end
241
 
    end
242
 
  end
243
 
 
244
 
  def define_guarded_writers (*names, &block)
245
 
    define_writers(*names)
246
 
    guard_writers(*names, &block)
247
 
  end
248
 
 
249
 
  define_soft_alias :guard_writer => :guard_writers
250
 
  define_soft_alias :define_guarded_writer => :define_guarded_writers
 
213
            "cannot change the value of attribute"
 
214
        end
 
215
    end
 
216
end
 
217
 
 
218
class Module
 
219
    # Guard each of the specified attributes by replacing the writer
 
220
    # method with a proxy that asks the supplied block before proceeding
 
221
    # with the change.
 
222
    #
 
223
    # If it's okay to change the attribute, the block should return
 
224
    # either nil or the symbol :mutable.  If it isn't okay, the block
 
225
    # should return a string saying why the attribute can't be changed.
 
226
    # If you don't want to provide a reason, you can have the block
 
227
    # return just the symbol :immutable.
 
228
    def guard_writers(*names, &predicate)
 
229
        for name in names.map { |x| x.to_sym } do
 
230
            define_hard_alias("__unguarded_#{name.writer}" => name.writer)
 
231
            define_method(name.writer) do |new_value|
 
232
                case result = predicate.call
 
233
                when :mutable, nil
 
234
                    __send__("__unguarded_#{name.writer}", new_value)
 
235
                when :immutable
 
236
                    raise ImmutableAttributeError.new(name)
 
237
                else
 
238
                    raise ImmutableAttributeError.new(name, result)
 
239
                end
 
240
            end
 
241
        end
 
242
    end
 
243
 
 
244
    def define_guarded_writers (*names, &block)
 
245
        define_writers(*names)
 
246
        guard_writers(*names, &block)
 
247
    end
 
248
 
 
249
    define_soft_alias :guard_writer => :guard_writers
 
250
    define_soft_alias :define_guarded_writer => :define_guarded_writers
251
251
end
252
252
 
253
253
if __FILE__ == $0
254
 
  require "test/unit"
255
 
 
256
 
  class DefineAccessorsTest < Test::Unit::TestCase
257
 
    def setup
258
 
      @X = Class.new
259
 
      @Y = Class.new @X
260
 
      @x = @X.new
261
 
      @y = @Y.new
262
 
    end
263
 
 
264
 
    def test_define_hard_aliases
265
 
      @X.define_method(:foo) { 123 }
266
 
      @X.define_method(:baz) { 321 }
267
 
      @X.define_hard_aliases :bar => :foo, :quux => :baz
268
 
      assert_equal @x.foo, 123
269
 
      assert_equal @x.bar, 123
270
 
      assert_equal @y.foo, 123
271
 
      assert_equal @y.bar, 123
272
 
      assert_equal @x.baz, 321
273
 
      assert_equal @x.quux, 321
274
 
      assert_equal @y.baz, 321
275
 
      assert_equal @y.quux, 321
276
 
      @Y.define_method(:foo) { 456 }
277
 
      assert_equal @y.foo, 456
278
 
      assert_equal @y.bar, 123
279
 
      @Y.define_method(:quux) { 654 }
280
 
      assert_equal @y.baz, 321
281
 
      assert_equal @y.quux, 654
282
 
    end
283
 
    
284
 
    def test_define_soft_aliases
285
 
      @X.define_method(:foo) { 123 }
286
 
      @X.define_method(:baz) { 321 }
287
 
      @X.define_soft_aliases :bar => :foo, :quux => :baz
288
 
      assert_equal @x.foo, 123
289
 
      assert_equal @x.bar, 123
290
 
      assert_equal @y.foo, 123
291
 
      assert_equal @y.bar, 123
292
 
      assert_equal @x.baz, 321
293
 
      assert_equal @x.quux, 321
294
 
      assert_equal @y.baz, 321
295
 
      assert_equal @y.quux, 321
296
 
      @Y.define_method(:foo) { 456 }
297
 
      assert_equal @y.foo, @y.bar, 456
298
 
      @Y.define_method(:quux) { 654 }
299
 
      assert_equal @y.baz, 321
300
 
      assert_equal @y.quux, 654
301
 
    end
302
 
 
303
 
    def test_define_readers
304
 
      @X.define_readers :foo, :bar
305
 
      assert !@x.respond_to?(:foo=)
306
 
      assert !@x.respond_to?(:bar=)
307
 
      @x.instance_eval { @foo = 123 ; @bar = 456 }
308
 
      assert_equal @x.foo, 123
309
 
      assert_equal @x.bar, 456
310
 
      @X.define_readers :baz?, :quux?
311
 
      assert !@x.respond_to?(:baz=)
312
 
      assert !@x.respond_to?(:quux=)
313
 
      @x.instance_eval { @baz = false ; @quux = true }
314
 
      assert !@x.baz?
315
 
      assert @x.quux?
316
 
    end
317
 
 
318
 
    def test_define_writers
319
 
      assert !@X.writer_defined?(:foo)
320
 
      assert !@X.writer_defined?(:bar)
321
 
      @X.define_writers :foo, :bar
322
 
      assert @X.writer_defined?(:foo)
323
 
      assert @X.writer_defined?(:bar)
324
 
      assert @X.writer_defined?(:foo=)
325
 
      assert @X.writer_defined?(:bar=)
326
 
      assert @X.writer_defined?(:foo?)
327
 
      assert @X.writer_defined?(:bar?)
328
 
      assert !@x.respond_to?(:foo)
329
 
      assert !@x.respond_to?(:bar)
330
 
      @x.foo = 123
331
 
      @x.bar = 456
332
 
      assert_equal @x.instance_eval { @foo }, 123
333
 
      assert_equal @x.instance_eval { @bar }, 456
334
 
      @X.define_writers :baz?, :quux?
335
 
      assert !@x.respond_to?(:baz?)
336
 
      assert !@x.respond_to?(:quux?)
337
 
      @x.baz = true
338
 
      @x.quux = false
339
 
      assert_equal @x.instance_eval { @baz }, true
340
 
      assert_equal @x.instance_eval { @quux }, false
341
 
    end
342
 
 
343
 
    def test_define_accessors
344
 
      @X.define_accessors :foo, :bar
345
 
      @x.foo = 123 ; @x.bar = 456
346
 
      assert_equal @x.foo, 123
347
 
      assert_equal @x.bar, 456
348
 
    end
349
 
 
350
 
    def test_define_opposite_readers
351
 
      @X.define_opposite_readers :foo? => :bar?, :baz? => :quux?
352
 
      assert !@x.respond_to?(:foo=)
353
 
      assert !@x.respond_to?(:bar=)
354
 
      assert !@x.respond_to?(:baz=)
355
 
      assert !@x.respond_to?(:quux=)
356
 
      @x.instance_eval { @bar = true ; @quux = false }
357
 
      assert !@x.foo?
358
 
      assert @x.bar?
359
 
      assert @x.baz?
360
 
      assert !@x.quux?
361
 
    end
362
 
 
363
 
    def test_define_opposite_writers
364
 
      @X.define_opposite_writers :foo? => :bar?, :baz => :quux
365
 
    end
366
 
  end
 
254
    require "test/unit"
 
255
 
 
256
    class DefineAccessorsTest < Test::Unit::TestCase
 
257
        def setup
 
258
            @X = Class.new
 
259
            @Y = Class.new @X
 
260
            @x = @X.new
 
261
            @y = @Y.new
 
262
        end
 
263
 
 
264
        def test_define_hard_aliases
 
265
            @X.define_method(:foo) { 123 }
 
266
            @X.define_method(:baz) { 321 }
 
267
            @X.define_hard_aliases :bar => :foo, :quux => :baz
 
268
            assert_equal @x.foo, 123
 
269
            assert_equal @x.bar, 123
 
270
            assert_equal @y.foo, 123
 
271
            assert_equal @y.bar, 123
 
272
            assert_equal @x.baz, 321
 
273
            assert_equal @x.quux, 321
 
274
            assert_equal @y.baz, 321
 
275
            assert_equal @y.quux, 321
 
276
            @Y.define_method(:foo) { 456 }
 
277
            assert_equal @y.foo, 456
 
278
            assert_equal @y.bar, 123
 
279
            @Y.define_method(:quux) { 654 }
 
280
            assert_equal @y.baz, 321
 
281
            assert_equal @y.quux, 654
 
282
        end
 
283
 
 
284
        def test_define_soft_aliases
 
285
            @X.define_method(:foo) { 123 }
 
286
            @X.define_method(:baz) { 321 }
 
287
            @X.define_soft_aliases :bar => :foo, :quux => :baz
 
288
            assert_equal @x.foo, 123
 
289
            assert_equal @x.bar, 123
 
290
            assert_equal @y.foo, 123
 
291
            assert_equal @y.bar, 123
 
292
            assert_equal @x.baz, 321
 
293
            assert_equal @x.quux, 321
 
294
            assert_equal @y.baz, 321
 
295
            assert_equal @y.quux, 321
 
296
            @Y.define_method(:foo) { 456 }
 
297
            assert_equal @y.foo, @y.bar, 456
 
298
            @Y.define_method(:quux) { 654 }
 
299
            assert_equal @y.baz, 321
 
300
            assert_equal @y.quux, 654
 
301
        end
 
302
 
 
303
        def test_define_readers
 
304
            @X.define_readers :foo, :bar
 
305
            assert !@x.respond_to?(:foo=)
 
306
            assert !@x.respond_to?(:bar=)
 
307
            @x.instance_eval { @foo = 123 ; @bar = 456 }
 
308
            assert_equal @x.foo, 123
 
309
            assert_equal @x.bar, 456
 
310
            @X.define_readers :baz?, :quux?
 
311
            assert !@x.respond_to?(:baz=)
 
312
            assert !@x.respond_to?(:quux=)
 
313
            @x.instance_eval { @baz = false ; @quux = true }
 
314
            assert !@x.baz?
 
315
            assert @x.quux?
 
316
        end
 
317
 
 
318
        def test_define_writers
 
319
            assert !@X.writer_defined?(:foo)
 
320
            assert !@X.writer_defined?(:bar)
 
321
            @X.define_writers :foo, :bar
 
322
            assert @X.writer_defined?(:foo)
 
323
            assert @X.writer_defined?(:bar)
 
324
            assert @X.writer_defined?(:foo=)
 
325
            assert @X.writer_defined?(:bar=)
 
326
            assert @X.writer_defined?(:foo?)
 
327
            assert @X.writer_defined?(:bar?)
 
328
            assert !@x.respond_to?(:foo)
 
329
            assert !@x.respond_to?(:bar)
 
330
            @x.foo = 123
 
331
            @x.bar = 456
 
332
            assert_equal @x.instance_eval { @foo }, 123
 
333
            assert_equal @x.instance_eval { @bar }, 456
 
334
            @X.define_writers :baz?, :quux?
 
335
            assert !@x.respond_to?(:baz?)
 
336
            assert !@x.respond_to?(:quux?)
 
337
            @x.baz = true
 
338
            @x.quux = false
 
339
            assert_equal @x.instance_eval { @baz }, true
 
340
            assert_equal @x.instance_eval { @quux }, false
 
341
        end
 
342
 
 
343
        def test_define_accessors
 
344
            @X.define_accessors :foo, :bar
 
345
            @x.foo = 123 ; @x.bar = 456
 
346
            assert_equal @x.foo, 123
 
347
            assert_equal @x.bar, 456
 
348
        end
 
349
 
 
350
        def test_define_opposite_readers
 
351
            @X.define_opposite_readers :foo? => :bar?, :baz? => :quux?
 
352
            assert !@x.respond_to?(:foo=)
 
353
            assert !@x.respond_to?(:bar=)
 
354
            assert !@x.respond_to?(:baz=)
 
355
            assert !@x.respond_to?(:quux=)
 
356
            @x.instance_eval { @bar = true ; @quux = false }
 
357
            assert !@x.foo?
 
358
            assert @x.bar?
 
359
            assert @x.baz?
 
360
            assert !@x.quux?
 
361
        end
 
362
 
 
363
        def test_define_opposite_writers
 
364
            @X.define_opposite_writers :foo? => :bar?, :baz => :quux
 
365
        end
 
366
    end
367
367
end