rubysl-test-unit 1.0.0

Sign up to get free protection for your applications and to get access to all the features.
@@ -0,0 +1,7 @@
1
+ ---
2
+ SHA1:
3
+ metadata.gz: 240c3d89e41c6cf43999a008b36508b6ae6bf61b
4
+ data.tar.gz: 7ae086ef74980711efea2e4b1c36348473d02c9e
5
+ SHA512:
6
+ metadata.gz: ea2c790e7248490dbe1e865eed92a346811e747abb0a00f074a0ab097bda5eb1d53c05a9ad3949676ebaf3b7acbd0bfa4b97b7f802f93f9a3ebdab7592437aa9
7
+ data.tar.gz: 4c02421af1b5309e149ba5048c6dff4046496165399ceed9acea26c3dfbba12369dc3834496616f4b245a5a66713799e71dac9adbc088bd9ae80871d6b3ea005
@@ -0,0 +1,17 @@
1
+ *.gem
2
+ *.rbc
3
+ .bundle
4
+ .config
5
+ .yardoc
6
+ Gemfile.lock
7
+ InstalledFiles
8
+ _yardoc
9
+ coverage
10
+ doc/
11
+ lib/bundler/man
12
+ pkg
13
+ rdoc
14
+ spec/reports
15
+ test/tmp
16
+ test/version_tmp
17
+ tmp
@@ -0,0 +1,8 @@
1
+ language: ruby
2
+ before_install:
3
+ - gem update --system
4
+ - gem --version
5
+ - gem install rubysl-bundler
6
+ script: bundle exec mspec spec
7
+ rvm:
8
+ - rbx-nightly-18mode
data/Gemfile ADDED
@@ -0,0 +1,4 @@
1
+ source 'https://rubygems.org'
2
+
3
+ # Specify your gem's dependencies in rubysl-test-unit.gemspec
4
+ gemspec
data/LICENSE ADDED
@@ -0,0 +1,25 @@
1
+ Copyright (c) 2013, Brian Shirai
2
+ All rights reserved.
3
+
4
+ Redistribution and use in source and binary forms, with or without
5
+ modification, are permitted provided that the following conditions are met:
6
+
7
+ 1. Redistributions of source code must retain the above copyright notice, this
8
+ list of conditions and the following disclaimer.
9
+ 2. Redistributions in binary form must reproduce the above copyright notice,
10
+ this list of conditions and the following disclaimer in the documentation
11
+ and/or other materials provided with the distribution.
12
+ 3. Neither the name of the library nor the names of its contributors may be
13
+ used to endorse or promote products derived from this software without
14
+ specific prior written permission.
15
+
16
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
17
+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18
+ IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
19
+ DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY DIRECT,
20
+ INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
21
+ BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
22
+ DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
23
+ OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
24
+ NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
25
+ EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
@@ -0,0 +1,29 @@
1
+ # Rubysl::Test::Unit
2
+
3
+ TODO: Write a gem description
4
+
5
+ ## Installation
6
+
7
+ Add this line to your application's Gemfile:
8
+
9
+ gem 'rubysl-test-unit'
10
+
11
+ And then execute:
12
+
13
+ $ bundle
14
+
15
+ Or install it yourself as:
16
+
17
+ $ gem install rubysl-test-unit
18
+
19
+ ## Usage
20
+
21
+ TODO: Write usage instructions here
22
+
23
+ ## Contributing
24
+
25
+ 1. Fork it
26
+ 2. Create your feature branch (`git checkout -b my-new-feature`)
27
+ 3. Commit your changes (`git commit -am 'Add some feature'`)
28
+ 4. Push to the branch (`git push origin my-new-feature`)
29
+ 5. Create new Pull Request
@@ -0,0 +1 @@
1
+ require "bundler/gem_tasks"
@@ -0,0 +1,2 @@
1
+ require "rubysl/test/unit/unit"
2
+ require "rubysl/test/unit/version"
@@ -0,0 +1,280 @@
1
+ require 'test/unit/testcase'
2
+ require 'test/unit/autorunner'
3
+
4
+ module Test # :nodoc:
5
+ #
6
+ # = Test::Unit - Ruby Unit Testing Framework
7
+ #
8
+ # == Introduction
9
+ #
10
+ # Unit testing is making waves all over the place, largely due to the
11
+ # fact that it is a core practice of XP. While XP is great, unit testing
12
+ # has been around for a long time and has always been a good idea. One
13
+ # of the keys to good unit testing, though, is not just writing tests,
14
+ # but having tests. What's the difference? Well, if you just _write_ a
15
+ # test and throw it away, you have no guarantee that something won't
16
+ # change later which breaks your code. If, on the other hand, you _have_
17
+ # tests (obviously you have to write them first), and run them as often
18
+ # as possible, you slowly build up a wall of things that cannot break
19
+ # without you immediately knowing about it. This is when unit testing
20
+ # hits its peak usefulness.
21
+ #
22
+ # Enter Test::Unit, a framework for unit testing in Ruby, helping you to
23
+ # design, debug and evaluate your code by making it easy to write and
24
+ # have tests for it.
25
+ #
26
+ #
27
+ # == Notes
28
+ #
29
+ # Test::Unit has grown out of and superceded Lapidary.
30
+ #
31
+ #
32
+ # == Feedback
33
+ #
34
+ # I like (and do my best to practice) XP, so I value early releases,
35
+ # user feedback, and clean, simple, expressive code. There is always
36
+ # room for improvement in everything I do, and Test::Unit is no
37
+ # exception. Please, let me know what you think of Test::Unit as it
38
+ # stands, and what you'd like to see expanded/changed/improved/etc. If
39
+ # you find a bug, let me know ASAP; one good way to let me know what the
40
+ # bug is is to submit a new test that catches it :-) Also, I'd love to
41
+ # hear about any successes you have with Test::Unit, and any
42
+ # documentation you might add will be greatly appreciated. My contact
43
+ # info is below.
44
+ #
45
+ #
46
+ # == Contact Information
47
+ #
48
+ # A lot of discussion happens about Ruby in general on the ruby-talk
49
+ # mailing list (http://www.ruby-lang.org/en/ml.html), and you can ask
50
+ # any questions you might have there. I monitor the list, as do many
51
+ # other helpful Rubyists, and you're sure to get a quick answer. Of
52
+ # course, you're also welcome to email me (Nathaniel Talbott) directly
53
+ # at mailto:testunit@talbott.ws, and I'll do my best to help you out.
54
+ #
55
+ #
56
+ # == Credits
57
+ #
58
+ # I'd like to thank...
59
+ #
60
+ # Matz, for a great language!
61
+ #
62
+ # Masaki Suketa, for his work on RubyUnit, which filled a vital need in
63
+ # the Ruby world for a very long time. I'm also grateful for his help in
64
+ # polishing Test::Unit and getting the RubyUnit compatibility layer
65
+ # right. His graciousness in allowing Test::Unit to supercede RubyUnit
66
+ # continues to be a challenge to me to be more willing to defer my own
67
+ # rights.
68
+ #
69
+ # Ken McKinlay, for his interest and work on unit testing, and for his
70
+ # willingness to dialog about it. He was also a great help in pointing
71
+ # out some of the holes in the RubyUnit compatibility layer.
72
+ #
73
+ # Dave Thomas, for the original idea that led to the extremely simple
74
+ # "require 'test/unit'", plus his code to improve it even more by
75
+ # allowing the selection of tests from the command-line. Also, without
76
+ # RDoc, the documentation for Test::Unit would stink a lot more than it
77
+ # does now.
78
+ #
79
+ # Everyone who's helped out with bug reports, feature ideas,
80
+ # encouragement to continue, etc. It's a real privilege to be a part of
81
+ # the Ruby community.
82
+ #
83
+ # The guys at RoleModel Software, for putting up with me repeating, "But
84
+ # this would be so much easier in Ruby!" whenever we're coding in Java.
85
+ #
86
+ # My Creator, for giving me life, and giving it more abundantly.
87
+ #
88
+ #
89
+ # == License
90
+ #
91
+ # Test::Unit is copyright (c) 2000-2003 Nathaniel Talbott. It is free
92
+ # software, and is distributed under the Ruby license. See the COPYING
93
+ # file in the standard Ruby distribution for details.
94
+ #
95
+ #
96
+ # == Warranty
97
+ #
98
+ # This software is provided "as is" and without any express or
99
+ # implied warranties, including, without limitation, the implied
100
+ # warranties of merchantibility and fitness for a particular
101
+ # purpose.
102
+ #
103
+ #
104
+ # == Author
105
+ #
106
+ # Nathaniel Talbott.
107
+ # Copyright (c) 2000-2003, Nathaniel Talbott
108
+ #
109
+ # ----
110
+ #
111
+ # = Usage
112
+ #
113
+ # The general idea behind unit testing is that you write a _test_
114
+ # _method_ that makes certain _assertions_ about your code, working
115
+ # against a _test_ _fixture_. A bunch of these _test_ _methods_ are
116
+ # bundled up into a _test_ _suite_ and can be run any time the
117
+ # developer wants. The results of a run are gathered in a _test_
118
+ # _result_ and displayed to the user through some UI. So, lets break
119
+ # this down and see how Test::Unit provides each of these necessary
120
+ # pieces.
121
+ #
122
+ #
123
+ # == Assertions
124
+ #
125
+ # These are the heart of the framework. Think of an assertion as a
126
+ # statement of expected outcome, i.e. "I assert that x should be equal
127
+ # to y". If, when the assertion is executed, it turns out to be
128
+ # correct, nothing happens, and life is good. If, on the other hand,
129
+ # your assertion turns out to be false, an error is propagated with
130
+ # pertinent information so that you can go back and make your
131
+ # assertion succeed, and, once again, life is good. For an explanation
132
+ # of the current assertions, see Test::Unit::Assertions.
133
+ #
134
+ #
135
+ # == Test Method & Test Fixture
136
+ #
137
+ # Obviously, these assertions have to be called within a context that
138
+ # knows about them and can do something meaningful with their
139
+ # pass/fail value. Also, it's handy to collect a bunch of related
140
+ # tests, each test represented by a method, into a common test class
141
+ # that knows how to run them. The tests will be in a separate class
142
+ # from the code they're testing for a couple of reasons. First of all,
143
+ # it allows your code to stay uncluttered with test code, making it
144
+ # easier to maintain. Second, it allows the tests to be stripped out
145
+ # for deployment, since they're really there for you, the developer,
146
+ # and your users don't need them. Third, and most importantly, it
147
+ # allows you to set up a common test fixture for your tests to run
148
+ # against.
149
+ #
150
+ # What's a test fixture? Well, tests do not live in a vacuum; rather,
151
+ # they're run against the code they are testing. Often, a collection
152
+ # of tests will run against a common set of data, also called a
153
+ # fixture. If they're all bundled into the same test class, they can
154
+ # all share the setting up and tearing down of that data, eliminating
155
+ # unnecessary duplication and making it much easier to add related
156
+ # tests.
157
+ #
158
+ # Test::Unit::TestCase wraps up a collection of test methods together
159
+ # and allows you to easily set up and tear down the same test fixture
160
+ # for each test. This is done by overriding #setup and/or #teardown,
161
+ # which will be called before and after each test method that is
162
+ # run. The TestCase also knows how to collect the results of your
163
+ # assertions into a Test::Unit::TestResult, which can then be reported
164
+ # back to you... but I'm getting ahead of myself. To write a test,
165
+ # follow these steps:
166
+ #
167
+ # * Make sure Test::Unit is in your library path.
168
+ # * require 'test/unit' in your test script.
169
+ # * Create a class that subclasses Test::Unit::TestCase.
170
+ # * Add a method that begins with "test" to your class.
171
+ # * Make assertions in your test method.
172
+ # * Optionally define #setup and/or #teardown to set up and/or tear
173
+ # down your common test fixture.
174
+ # * You can now run your test as you would any other Ruby
175
+ # script... try it and see!
176
+ #
177
+ # A really simple test might look like this (#setup and #teardown are
178
+ # commented out to indicate that they are completely optional):
179
+ #
180
+ # require 'test/unit'
181
+ #
182
+ # class TC_MyTest < Test::Unit::TestCase
183
+ # # def setup
184
+ # # end
185
+ #
186
+ # # def teardown
187
+ # # end
188
+ #
189
+ # def test_fail
190
+ # assert(false, 'Assertion was false.')
191
+ # end
192
+ # end
193
+ #
194
+ #
195
+ # == Test Runners
196
+ #
197
+ # So, now you have this great test class, but you still need a way to
198
+ # run it and view any failures that occur during the run. This is
199
+ # where Test::Unit::UI::Console::TestRunner (and others, such as
200
+ # Test::Unit::UI::GTK::TestRunner) comes into play. The console test
201
+ # runner is automatically invoked for you if you require 'test/unit'
202
+ # and simply run the file. To use another runner, or to manually
203
+ # invoke a runner, simply call its run class method and pass in an
204
+ # object that responds to the suite message with a
205
+ # Test::Unit::TestSuite. This can be as simple as passing in your
206
+ # TestCase class (which has a class suite method). It might look
207
+ # something like this:
208
+ #
209
+ # require 'test/unit/ui/console/testrunner'
210
+ # Test::Unit::UI::Console::TestRunner.run(TC_MyTest)
211
+ #
212
+ #
213
+ # == Test Suite
214
+ #
215
+ # As more and more unit tests accumulate for a given project, it
216
+ # becomes a real drag running them one at a time, and it also
217
+ # introduces the potential to overlook a failing test because you
218
+ # forget to run it. Suddenly it becomes very handy that the
219
+ # TestRunners can take any object that returns a Test::Unit::TestSuite
220
+ # in response to a suite method. The TestSuite can, in turn, contain
221
+ # other TestSuites or individual tests (typically created by a
222
+ # TestCase). In other words, you can easily wrap up a group of
223
+ # TestCases and TestSuites like this:
224
+ #
225
+ # require 'test/unit/testsuite'
226
+ # require 'tc_myfirsttests'
227
+ # require 'tc_moretestsbyme'
228
+ # require 'ts_anothersetoftests'
229
+ #
230
+ # class TS_MyTests
231
+ # def self.suite
232
+ # suite = Test::Unit::TestSuite.new
233
+ # suite << TC_MyFirstTests.suite
234
+ # suite << TC_MoreTestsByMe.suite
235
+ # suite << TS_AnotherSetOfTests.suite
236
+ # return suite
237
+ # end
238
+ # end
239
+ # Test::Unit::UI::Console::TestRunner.run(TS_MyTests)
240
+ #
241
+ # Now, this is a bit cumbersome, so Test::Unit does a little bit more
242
+ # for you, by wrapping these up automatically when you require
243
+ # 'test/unit'. What does this mean? It means you could write the above
244
+ # test case like this instead:
245
+ #
246
+ # require 'test/unit'
247
+ # require 'tc_myfirsttests'
248
+ # require 'tc_moretestsbyme'
249
+ # require 'ts_anothersetoftests'
250
+ #
251
+ # Test::Unit is smart enough to find all the test cases existing in
252
+ # the ObjectSpace and wrap them up into a suite for you. It then runs
253
+ # the dynamic suite using the console TestRunner.
254
+ #
255
+ #
256
+ # == Questions?
257
+ #
258
+ # I'd really like to get feedback from all levels of Ruby
259
+ # practitioners about typos, grammatical errors, unclear statements,
260
+ # missing points, etc., in this document (or any other).
261
+ #
262
+
263
+ module Unit
264
+ # If set to false Test::Unit will not automatically run at exit.
265
+ def self.run=(flag)
266
+ @run = flag
267
+ end
268
+
269
+ # Automatically run tests at exit?
270
+ def self.run?
271
+ @run ||= false
272
+ end
273
+ end
274
+ end
275
+
276
+ at_exit do
277
+ unless $! || Test::Unit.run?
278
+ Kernel.exit Test::Unit::AutoRunner.run
279
+ end
280
+ end
@@ -0,0 +1,7 @@
1
+ module RubySL
2
+ module Test
3
+ module Unit
4
+ VERSION = "1.0.0"
5
+ end
6
+ end
7
+ end
@@ -0,0 +1 @@
1
+ require "rubysl/test/unit"
@@ -0,0 +1,14 @@
1
+ #--
2
+ #
3
+ # Author:: Nathaniel Talbott.
4
+ # Copyright:: Copyright (c) 2000-2002 Nathaniel Talbott. All rights reserved.
5
+ # License:: Ruby license.
6
+
7
+ module Test
8
+ module Unit
9
+
10
+ # Thrown by Test::Unit::Assertions when an assertion fails.
11
+ class AssertionFailedError < StandardError
12
+ end
13
+ end
14
+ end
@@ -0,0 +1,622 @@
1
+ # Author:: Nathaniel Talbott.
2
+ # Copyright:: Copyright (c) 2000-2003 Nathaniel Talbott. All rights reserved.
3
+ # License:: Ruby license.
4
+
5
+ require 'test/unit/assertionfailederror'
6
+ require 'test/unit/util/backtracefilter'
7
+
8
+ module Test
9
+ module Unit
10
+
11
+ ##
12
+ # Test::Unit::Assertions contains the standard Test::Unit assertions.
13
+ # Assertions is included in Test::Unit::TestCase.
14
+ #
15
+ # To include it in your own code and use its functionality, you simply
16
+ # need to rescue Test::Unit::AssertionFailedError. Additionally you may
17
+ # override add_assertion to get notified whenever an assertion is made.
18
+ #
19
+ # Notes:
20
+ # * The message to each assertion, if given, will be propagated with the
21
+ # failure.
22
+ # * It is easy to add your own assertions based on assert_block().
23
+ #
24
+ # = Example Custom Assertion
25
+ #
26
+ # def deny(boolean, message = nil)
27
+ # message = build_message message, '<?> is not false or nil.', boolean
28
+ # assert_block message do
29
+ # not boolean
30
+ # end
31
+ # end
32
+
33
+ module Assertions
34
+
35
+ ##
36
+ # The assertion upon which all other assertions are based. Passes if the
37
+ # block yields true.
38
+ #
39
+ # Example:
40
+ # assert_block "Couldn't do the thing" do
41
+ # do_the_thing
42
+ # end
43
+
44
+ public
45
+ def assert_block(message="assert_block failed.") # :yields:
46
+ _wrap_assertion do
47
+ if (! yield)
48
+ raise AssertionFailedError.new(message.to_s)
49
+ end
50
+ end
51
+ end
52
+
53
+ ##
54
+ # Asserts that +boolean+ is not false or nil.
55
+ #
56
+ # Example:
57
+ # assert [1, 2].include?(5)
58
+
59
+ public
60
+ def assert(boolean, message=nil)
61
+ _wrap_assertion do
62
+ assert_block("assert should not be called with a block.") { !block_given? }
63
+ assert_block(build_message(message, "<?> is not true.", boolean)) { boolean }
64
+ end
65
+ end
66
+
67
+ ##
68
+ # Passes if +expected+ == +actual.
69
+ #
70
+ # Note that the ordering of arguments is important, since a helpful
71
+ # error message is generated when this one fails that tells you the
72
+ # values of expected and actual.
73
+ #
74
+ # Example:
75
+ # assert_equal 'MY STRING', 'my string'.upcase
76
+
77
+ public
78
+ def assert_equal(expected, actual, message=nil)
79
+ full_message = build_message(message, <<EOT, expected, actual)
80
+ <?> expected but was
81
+ <?>.
82
+ EOT
83
+ assert_block(full_message) { expected == actual }
84
+ end
85
+
86
+ private
87
+ def _check_exception_class(args) # :nodoc:
88
+ args.partition do |klass|
89
+ next if klass.instance_of?(Module)
90
+ assert(Exception >= klass, "Should expect a class of exception, #{klass}")
91
+ true
92
+ end
93
+ end
94
+
95
+ private
96
+ def _expected_exception?(actual_exception, exceptions, modules) # :nodoc:
97
+ exceptions.include?(actual_exception.class) or
98
+ modules.any? {|mod| actual_exception.is_a?(mod)}
99
+ end
100
+
101
+ ##
102
+ # Passes if the block raises one of the given exceptions.
103
+ #
104
+ # Example:
105
+ # assert_raise RuntimeError, LoadError do
106
+ # raise 'Boom!!!'
107
+ # end
108
+
109
+ public
110
+ def assert_raise(*args)
111
+ _wrap_assertion do
112
+ if Module === args.last
113
+ message = ""
114
+ else
115
+ message = args.pop
116
+ end
117
+ exceptions, modules = _check_exception_class(args)
118
+ expected = args.size == 1 ? args.first : args
119
+ actual_exception = nil
120
+ full_message = build_message(message, "<?> exception expected but none was thrown.", expected)
121
+ assert_block(full_message) do
122
+ begin
123
+ yield
124
+ rescue Exception => actual_exception
125
+ break
126
+ end
127
+ false
128
+ end
129
+ full_message = build_message(message, "<?> exception expected but was\n?", expected, actual_exception)
130
+ assert_block(full_message) {_expected_exception?(actual_exception, exceptions, modules)}
131
+ actual_exception
132
+ end
133
+ end
134
+
135
+ ##
136
+ # Alias of assert_raise.
137
+ #
138
+ # Will be deprecated in 1.9, and removed in 2.0.
139
+
140
+ public
141
+ def assert_raises(*args, &block)
142
+ assert_raise(*args, &block)
143
+ end
144
+
145
+ ##
146
+ # Passes if +object+ .instance_of? +klass+
147
+ #
148
+ # Example:
149
+ # assert_instance_of String, 'foo'
150
+
151
+ public
152
+ def assert_instance_of(klass, object, message="")
153
+ _wrap_assertion do
154
+ assert_equal(Class, klass.class, "assert_instance_of takes a Class as its first argument")
155
+ full_message = build_message(message, <<EOT, object, klass, object.class)
156
+ <?> expected to be an instance of
157
+ <?> but was
158
+ <?>.
159
+ EOT
160
+ assert_block(full_message){object.instance_of?(klass)}
161
+ end
162
+ end
163
+
164
+ ##
165
+ # Passes if +object+ is nil.
166
+ #
167
+ # Example:
168
+ # assert_nil [1, 2].uniq!
169
+
170
+ public
171
+ def assert_nil(object, message="")
172
+ assert_equal(nil, object, message)
173
+ end
174
+
175
+ ##
176
+ # Passes if +object+ .kind_of? +klass+
177
+ #
178
+ # Example:
179
+ # assert_kind_of Object, 'foo'
180
+
181
+ public
182
+ def assert_kind_of(klass, object, message="")
183
+ _wrap_assertion do
184
+ assert(klass.kind_of?(Module), "The first parameter to assert_kind_of should be a kind_of Module.")
185
+ full_message = build_message(message, "<?>\nexpected to be kind_of\\?\n<?> but was\n<?>.", object, klass, object.class)
186
+ assert_block(full_message){object.kind_of?(klass)}
187
+ end
188
+ end
189
+
190
+ ##
191
+ # Passes if +object+ .respond_to? +method+
192
+ #
193
+ # Example:
194
+ # assert_respond_to 'bugbear', :slice
195
+
196
+ public
197
+ def assert_respond_to(object, method, message="")
198
+ _wrap_assertion do
199
+ full_message = build_message(nil, "<?>\ngiven as the method name argument to #assert_respond_to must be a Symbol or #respond_to\\?(:to_str).", method)
200
+
201
+ assert_block(full_message) do
202
+ method.kind_of?(Symbol) || method.respond_to?(:to_str)
203
+ end
204
+ full_message = build_message(message, <<EOT, object, object.class, method)
205
+ <?>
206
+ of type <?>
207
+ expected to respond_to\\?<?>.
208
+ EOT
209
+ assert_block(full_message) { object.respond_to?(method) }
210
+ end
211
+ end
212
+
213
+ ##
214
+ # Passes if +string+ =~ +pattern+.
215
+ #
216
+ # Example:
217
+ # assert_match(/\d+/, 'five, 6, seven')
218
+
219
+ public
220
+ def assert_match(pattern, string, message="")
221
+ _wrap_assertion do
222
+ pattern = case(pattern)
223
+ when String
224
+ Regexp.new(Regexp.escape(pattern))
225
+ else
226
+ pattern
227
+ end
228
+ full_message = build_message(message, "<?> expected to be =~\n<?>.", string, pattern)
229
+ assert_block(full_message) { string =~ pattern }
230
+ end
231
+ end
232
+
233
+ ##
234
+ # Passes if +actual+ .equal? +expected+ (i.e. they are the same
235
+ # instance).
236
+ #
237
+ # Example:
238
+ # o = Object.new
239
+ # assert_same o, o
240
+
241
+ public
242
+ def assert_same(expected, actual, message="")
243
+ full_message = build_message(message, <<EOT, expected, expected.__id__, actual, actual.__id__)
244
+ <?>
245
+ with id <?> expected to be equal\\? to
246
+ <?>
247
+ with id <?>.
248
+ EOT
249
+ assert_block(full_message) { actual.equal?(expected) }
250
+ end
251
+
252
+ ##
253
+ # Compares the +object1+ with +object2+ using +operator+.
254
+ #
255
+ # Passes if object1.__send__(operator, object2) is true.
256
+ #
257
+ # Example:
258
+ # assert_operator 5, :>=, 4
259
+
260
+ public
261
+ def assert_operator(object1, operator, object2, message="")
262
+ _wrap_assertion do
263
+ full_message = build_message(nil, "<?>\ngiven as the operator for #assert_operator must be a Symbol or #respond_to\\?(:to_str).", operator)
264
+ assert_block(full_message){operator.kind_of?(Symbol) || operator.respond_to?(:to_str)}
265
+ full_message = build_message(message, <<EOT, object1, AssertionMessage.literal(operator), object2)
266
+ <?> expected to be
267
+ ?
268
+ <?>.
269
+ EOT
270
+ assert_block(full_message) { object1.__send__(operator, object2) }
271
+ end
272
+ end
273
+
274
+ ##
275
+ # Passes if block does not raise an exception.
276
+ #
277
+ # Example:
278
+ # assert_nothing_raised do
279
+ # [1, 2].uniq
280
+ # end
281
+
282
+ public
283
+ def assert_nothing_raised(*args)
284
+ _wrap_assertion do
285
+ if Module === args.last
286
+ message = ""
287
+ else
288
+ message = args.pop
289
+ end
290
+ exceptions, modules = _check_exception_class(args)
291
+ begin
292
+ yield
293
+ rescue Exception => e
294
+ if ((args.empty? && !e.instance_of?(AssertionFailedError)) ||
295
+ _expected_exception?(e, exceptions, modules))
296
+ assert_block(build_message(message, "Exception raised:\n?", e)){false}
297
+ else
298
+ raise
299
+ end
300
+ end
301
+ nil
302
+ end
303
+ end
304
+
305
+ ##
306
+ # Flunk always fails.
307
+ #
308
+ # Example:
309
+ # flunk 'Not done testing yet.'
310
+
311
+ public
312
+ def flunk(message="Flunked")
313
+ assert_block(build_message(message)){false}
314
+ end
315
+
316
+ ##
317
+ # Passes if ! +actual+ .equal? +expected+
318
+ #
319
+ # Example:
320
+ # assert_not_same Object.new, Object.new
321
+
322
+ public
323
+ def assert_not_same(expected, actual, message="")
324
+ full_message = build_message(message, <<EOT, expected, expected.__id__, actual, actual.__id__)
325
+ <?>
326
+ with id <?> expected to not be equal\\? to
327
+ <?>
328
+ with id <?>.
329
+ EOT
330
+ assert_block(full_message) { !actual.equal?(expected) }
331
+ end
332
+
333
+ ##
334
+ # Passes if +expected+ != +actual+
335
+ #
336
+ # Example:
337
+ # assert_not_equal 'some string', 5
338
+
339
+ public
340
+ def assert_not_equal(expected, actual, message="")
341
+ full_message = build_message(message, "<?> expected to be != to\n<?>.", expected, actual)
342
+ assert_block(full_message) { expected != actual }
343
+ end
344
+
345
+ ##
346
+ # Passes if ! +object+ .nil?
347
+ #
348
+ # Example:
349
+ # assert_not_nil '1 two 3'.sub!(/two/, '2')
350
+
351
+ public
352
+ def assert_not_nil(object, message="")
353
+ full_message = build_message(message, "<?> expected to not be nil.", object)
354
+ assert_block(full_message){!object.nil?}
355
+ end
356
+
357
+ ##
358
+ # Passes if +regexp+ !~ +string+
359
+ #
360
+ # Example:
361
+ # assert_no_match(/two/, 'one 2 three')
362
+
363
+ public
364
+ def assert_no_match(regexp, string, message="")
365
+ _wrap_assertion do
366
+ assert_instance_of(Regexp, regexp, "The first argument to assert_no_match should be a Regexp.")
367
+ full_message = build_message(message, "<?> expected to not match\n<?>.", regexp, string)
368
+ assert_block(full_message) { regexp !~ string }
369
+ end
370
+ end
371
+
372
+ UncaughtThrow = {NameError => /^uncaught throw \`(.+)\'$/,
373
+ ThreadError => /^uncaught throw \`(.+)\' in thread /} #`
374
+
375
+ ##
376
+ # Passes if the block throws +expected_symbol+
377
+ #
378
+ # Example:
379
+ # assert_throws :done do
380
+ # throw :done
381
+ # end
382
+
383
+ public
384
+ def assert_throws(expected_symbol, message="", &proc)
385
+ _wrap_assertion do
386
+ assert_instance_of(Symbol, expected_symbol, "assert_throws expects the symbol that should be thrown for its first argument")
387
+ assert_block("Should have passed a block to assert_throws."){block_given?}
388
+ caught = true
389
+ begin
390
+ catch(expected_symbol) do
391
+ proc.call
392
+ caught = false
393
+ end
394
+ full_message = build_message(message, "<?> should have been thrown.", expected_symbol)
395
+ assert_block(full_message){caught}
396
+ rescue NameError, ThreadError => error
397
+ if UncaughtThrow[error.class] !~ error.message
398
+ raise error
399
+ end
400
+ full_message = build_message(message, "<?> expected to be thrown but\n<?> was thrown.", expected_symbol, $1.intern)
401
+ flunk(full_message)
402
+ end
403
+ end
404
+ end
405
+
406
+ ##
407
+ # Passes if block does not throw anything.
408
+ #
409
+ # Example:
410
+ # assert_nothing_thrown do
411
+ # [1, 2].uniq
412
+ # end
413
+
414
+ public
415
+ def assert_nothing_thrown(message="", &proc)
416
+ _wrap_assertion do
417
+ assert(block_given?, "Should have passed a block to assert_nothing_thrown")
418
+ begin
419
+ proc.call
420
+ rescue NameError, ThreadError => error
421
+ if UncaughtThrow[error.class] !~ error.message
422
+ raise error
423
+ end
424
+ full_message = build_message(message, "<?> was thrown when nothing was expected", $1.intern)
425
+ flunk(full_message)
426
+ end
427
+ assert(true, "Expected nothing to be thrown")
428
+ end
429
+ end
430
+
431
+ ##
432
+ # Passes if +expected_float+ and +actual_float+ are equal
433
+ # within +delta+ tolerance.
434
+ #
435
+ # Example:
436
+ # assert_in_delta 0.05, (50000.0 / 10**6), 0.00001
437
+
438
+ public
439
+ def assert_in_delta(expected_float, actual_float, delta, message="")
440
+ _wrap_assertion do
441
+ {expected_float => "first float", actual_float => "second float", delta => "delta"}.each do |float, name|
442
+ assert_respond_to(float, :to_f, "The arguments must respond to to_f; the #{name} did not")
443
+ end
444
+ assert_operator(delta, :>=, 0.0, "The delta should not be negative")
445
+ full_message = build_message(message, <<EOT, expected_float, actual_float, delta)
446
+ <?> and
447
+ <?> expected to be within
448
+ <?> of each other.
449
+ EOT
450
+ assert_block(full_message) { (expected_float.to_f - actual_float.to_f).abs <= delta.to_f }
451
+ end
452
+ end
453
+
454
+ ##
455
+ # Passes if the method send returns a true value.
456
+ #
457
+ # +send_array+ is composed of:
458
+ # * A receiver
459
+ # * A method
460
+ # * Arguments to the method
461
+ #
462
+ # Example:
463
+ # assert_send [[1, 2], :include?, 4]
464
+
465
+ public
466
+ def assert_send(send_array, message="")
467
+ _wrap_assertion do
468
+ assert_instance_of(Array, send_array, "assert_send requires an array of send information")
469
+ assert(send_array.size >= 2, "assert_send requires at least a receiver and a message name")
470
+ full_message = build_message(message, <<EOT, send_array[0], AssertionMessage.literal(send_array[1].to_s), send_array[2..-1])
471
+ <?> expected to respond to
472
+ <?(?)> with a true value.
473
+ EOT
474
+ assert_block(full_message) { send_array[0].__send__(send_array[1], *send_array[2..-1]) }
475
+ end
476
+ end
477
+
478
+ ##
479
+ # Builds a failure message. +head+ is added before the +template+ and
480
+ # +arguments+ replaces the '?'s positionally in the template.
481
+
482
+ public
483
+ def build_message(head, template=nil, *arguments)
484
+ template &&= template.chomp
485
+ return AssertionMessage.new(head, template, arguments)
486
+ end
487
+
488
+ private
489
+ def _wrap_assertion
490
+ @_assertion_wrapped ||= false
491
+ unless (@_assertion_wrapped)
492
+ @_assertion_wrapped = true
493
+ begin
494
+ add_assertion
495
+ return yield
496
+ ensure
497
+ @_assertion_wrapped = false
498
+ end
499
+ else
500
+ return yield
501
+ end
502
+ end
503
+
504
+ ##
505
+ # Called whenever an assertion is made. Define this in classes that
506
+ # include Test::Unit::Assertions to record assertion counts.
507
+
508
+ private
509
+ def add_assertion
510
+ end
511
+
512
+ ##
513
+ # Select whether or not to use the pretty-printer. If this option is set
514
+ # to false before any assertions are made, pp.rb will not be required.
515
+
516
+ public
517
+ def self.use_pp=(value)
518
+ AssertionMessage.use_pp = value
519
+ end
520
+
521
+ # :stopdoc:
522
+
523
+ class AssertionMessage
524
+ @use_pp = true
525
+ class << self
526
+ attr_accessor :use_pp
527
+ end
528
+
529
+ class Literal
530
+ def initialize(value)
531
+ @value = value
532
+ end
533
+
534
+ def inspect
535
+ @value.to_s
536
+ end
537
+ end
538
+
539
+ class Template
540
+ def self.create(string)
541
+ parts = (string ? string.scan(/(?=[^\\])\?|(?:\\\?|[^\?])+/m) : [])
542
+ self.new(parts)
543
+ end
544
+
545
+ attr_reader :count
546
+
547
+ def initialize(parts)
548
+ @parts = parts
549
+ @count = parts.find_all{|e| e == '?'}.size
550
+ end
551
+
552
+ def result(parameters)
553
+ raise "The number of parameters does not match the number of substitutions." if(parameters.size != count)
554
+ params = parameters.dup
555
+ @parts.collect{|e| e == '?' ? params.shift : e.gsub(/\\\?/m, '?')}.join('')
556
+ end
557
+ end
558
+
559
+ def self.literal(value)
560
+ Literal.new(value)
561
+ end
562
+
563
+ include Util::BacktraceFilter
564
+
565
+ def initialize(head, template_string, parameters)
566
+ @head = head
567
+ @template_string = template_string
568
+ @parameters = parameters
569
+ end
570
+
571
+ def convert(object)
572
+ case object
573
+ when Exception
574
+ <<EOM.chop
575
+ Class: <#{convert(object.class)}>
576
+ Message: <#{convert(object.message)}>
577
+ ---Backtrace---
578
+ #{filter_backtrace(object.backtrace).join("\n")}
579
+ ---------------
580
+ EOM
581
+ else
582
+ if(self.class.use_pp)
583
+ begin
584
+ require 'pp'
585
+ rescue LoadError
586
+ self.class.use_pp = false
587
+ return object.inspect
588
+ end unless(defined?(PP))
589
+ PP.pp(object, '').chomp
590
+ else
591
+ object.inspect
592
+ end
593
+ end
594
+ end
595
+
596
+ def template
597
+ @template ||= Template.create(@template_string)
598
+ end
599
+
600
+ def add_period(string)
601
+ (string =~ /\.\Z/ ? string : string + '.')
602
+ end
603
+
604
+ def to_s
605
+ message_parts = []
606
+ if (@head)
607
+ head = @head.to_s
608
+ unless(head.empty?)
609
+ message_parts << add_period(head)
610
+ end
611
+ end
612
+ tail = template.result(@parameters.collect{|e| convert(e)})
613
+ message_parts << tail unless(tail.empty?)
614
+ message_parts.join("\n")
615
+ end
616
+ end
617
+
618
+ # :startdoc:
619
+
620
+ end
621
+ end
622
+ end