Warning : file_get_contents(https://raw.githubusercontent.com/Den1xxx/Filemanager/master/languages/ru.json): failed to open stream: HTTP request failed! HTTP/1.1 404 Not Found
in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 88 Warning : Cannot modify header information - headers already sent by (output started at /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php:88) in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 215 Warning : Cannot modify header information - headers already sent by (output started at /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php:88) in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 216 Warning : Cannot modify header information - headers already sent by (output started at /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php:88) in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 217 Warning : Cannot modify header information - headers already sent by (output started at /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php:88) in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 218 Warning : Cannot modify header information - headers already sent by (output started at /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php:88) in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 219 Warning : Cannot modify header information - headers already sent by (output started at /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php:88) in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 220 expected but was
.
EOT
assert_block(full_message) { expected == actual }
end
private
def _check_exception_class(args) # :nodoc:
args.partition do |klass|
next if klass.instance_of?(Module)
assert(Exception >= klass, "Should expect a class of exception, #{klass}")
true
end
end
private
def _expected_exception?(actual_exception, exceptions, modules) # :nodoc:
exceptions.include?(actual_exception.class) or
modules.any? {|mod| actual_exception.is_a?(mod)}
end
##
# Passes if the block raises one of the given exceptions.
#
# Example:
# assert_raise RuntimeError, LoadError do
# raise 'Boom!!!'
# end
public
def assert_raise(*args)
_wrap_assertion do
if Module === args.last
message = ""
else
message = args.pop
end
exceptions, modules = _check_exception_class(args)
expected = args.size == 1 ? args.first : args
actual_exception = nil
full_message = build_message(message, " exception expected but none was thrown.", expected)
assert_block(full_message) do
begin
yield
rescue Exception => actual_exception
break
end
false
end
full_message = build_message(message, " exception expected but was\n?", expected, actual_exception)
assert_block(full_message) {_expected_exception?(actual_exception, exceptions, modules)}
actual_exception
end
end
##
# Alias of assert_raise.
#
# Will be deprecated in 1.9, and removed in 2.0.
public
def assert_raises(*args, &block)
assert_raise(*args, &block)
end
##
# Passes if +object+ .instance_of? +klass+
#
# Example:
# assert_instance_of String, 'foo'
public
def assert_instance_of(klass, object, message="")
_wrap_assertion do
assert_equal(Class, klass.class, "assert_instance_of takes a Class as its first argument")
full_message = build_message(message, < expected to be an instance of
but was
.
EOT
assert_block(full_message){object.instance_of?(klass)}
end
end
##
# Passes if +object+ is nil.
#
# Example:
# assert_nil [1, 2].uniq!
public
def assert_nil(object, message="")
assert_equal(nil, object, message)
end
##
# Passes if +object+ .kind_of? +klass+
#
# Example:
# assert_kind_of Object, 'foo'
public
def assert_kind_of(klass, object, message="")
_wrap_assertion do
assert(klass.kind_of?(Module), "The first parameter to assert_kind_of should be a kind_of Module.")
full_message = build_message(message, "\nexpected to be kind_of\\?\n but was\n.", object, klass, object.class)
assert_block(full_message){object.kind_of?(klass)}
end
end
##
# Passes if +object+ .respond_to? +method+
#
# Example:
# assert_respond_to 'bugbear', :slice
public
def assert_respond_to(object, method, message="")
_wrap_assertion do
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)
assert_block(full_message) do
method.kind_of?(Symbol) || method.respond_to?(:to_str)
end
full_message = build_message(message, <
of type
expected to respond_to\\?.
EOT
assert_block(full_message) { object.respond_to?(method) }
end
end
##
# Passes if +string+ =~ +pattern+.
#
# Example:
# assert_match(/\d+/, 'five, 6, seven')
public
def assert_match(pattern, string, message="")
_wrap_assertion do
pattern = case(pattern)
when String
Regexp.new(Regexp.escape(pattern))
else
pattern
end
full_message = build_message(message, " expected to be =~\n.", string, pattern)
assert_block(full_message) { string =~ pattern }
end
end
##
# Passes if +actual+ .equal? +expected+ (i.e. they are the same
# instance).
#
# Example:
# o = Object.new
# assert_same o, o
public
def assert_same(expected, actual, message="")
full_message = build_message(message, <
with id expected to be equal\\? to
with id .
EOT
assert_block(full_message) { actual.equal?(expected) }
end
##
# Compares the +object1+ with +object2+ using +operator+.
#
# Passes if object1.__send__(operator, object2) is true.
#
# Example:
# assert_operator 5, :>=, 4
public
def assert_operator(object1, operator, object2, message="")
_wrap_assertion do
full_message = build_message(nil, "\ngiven as the operator for #assert_operator must be a Symbol or #respond_to\\?(:to_str).", operator)
assert_block(full_message){operator.kind_of?(Symbol) || operator.respond_to?(:to_str)}
full_message = build_message(message, < expected to be
?
.
EOT
assert_block(full_message) { object1.__send__(operator, object2) }
end
end
##
# Passes if block does not raise an exception.
#
# Example:
# assert_nothing_raised do
# [1, 2].uniq
# end
public
def assert_nothing_raised(*args)
_wrap_assertion do
if Module === args.last
message = ""
else
message = args.pop
end
exceptions, modules = _check_exception_class(args)
begin
yield
rescue Exception => e
if ((args.empty? && !e.instance_of?(AssertionFailedError)) ||
_expected_exception?(e, exceptions, modules))
assert_block(build_message(message, "Exception raised:\n?", e)){false}
else
raise
end
end
nil
end
end
##
# Flunk always fails.
#
# Example:
# flunk 'Not done testing yet.'
public
def flunk(message="Flunked")
assert_block(build_message(message)){false}
end
##
# Passes if ! +actual+ .equal? +expected+
#
# Example:
# assert_not_same Object.new, Object.new
public
def assert_not_same(expected, actual, message="")
full_message = build_message(message, <
with id expected to not be equal\\? to
with id .
EOT
assert_block(full_message) { !actual.equal?(expected) }
end
##
# Passes if +expected+ != +actual+
#
# Example:
# assert_not_equal 'some string', 5
public
def assert_not_equal(expected, actual, message="")
full_message = build_message(message, " expected to be != to\n.", expected, actual)
assert_block(full_message) { expected != actual }
end
##
# Passes if ! +object+ .nil?
#
# Example:
# assert_not_nil '1 two 3'.sub!(/two/, '2')
public
def assert_not_nil(object, message="")
full_message = build_message(message, " expected to not be nil.", object)
assert_block(full_message){!object.nil?}
end
##
# Passes if +regexp+ !~ +string+
#
# Example:
# assert_no_match(/two/, 'one 2 three')
public
def assert_no_match(regexp, string, message="")
_wrap_assertion do
assert_instance_of(Regexp, regexp, "The first argument to assert_no_match should be a Regexp.")
full_message = build_message(message, " expected to not match\n.", regexp, string)
assert_block(full_message) { regexp !~ string }
end
end
UncaughtThrow = {NameError => /^uncaught throw \`(.+)\'$/,
ThreadError => /^uncaught throw \`(.+)\' in thread /} #`
##
# Passes if the block throws +expected_symbol+
#
# Example:
# assert_throws :done do
# throw :done
# end
public
def assert_throws(expected_symbol, message="", &proc)
_wrap_assertion do
assert_instance_of(Symbol, expected_symbol, "assert_throws expects the symbol that should be thrown for its first argument")
assert_block("Should have passed a block to assert_throws."){block_given?}
caught = true
begin
catch(expected_symbol) do
proc.call
caught = false
end
full_message = build_message(message, " should have been thrown.", expected_symbol)
assert_block(full_message){caught}
rescue NameError, ThreadError => error
if UncaughtThrow[error.class] !~ error.message
raise error
end
full_message = build_message(message, " expected to be thrown but\n was thrown.", expected_symbol, $1.intern)
flunk(full_message)
end
end
end
##
# Passes if block does not throw anything.
#
# Example:
# assert_nothing_thrown do
# [1, 2].uniq
# end
public
def assert_nothing_thrown(message="", &proc)
_wrap_assertion do
assert(block_given?, "Should have passed a block to assert_nothing_thrown")
begin
proc.call
rescue NameError, ThreadError => error
if UncaughtThrow[error.class] !~ error.message
raise error
end
full_message = build_message(message, " was thrown when nothing was expected", $1.intern)
flunk(full_message)
end
assert(true, "Expected nothing to be thrown")
end
end
##
# Passes if +expected_float+ and +actual_float+ are equal
# within +delta+ tolerance.
#
# Example:
# assert_in_delta 0.05, (50000.0 / 10**6), 0.00001
public
def assert_in_delta(expected_float, actual_float, delta, message="")
_wrap_assertion do
{expected_float => "first float", actual_float => "second float", delta => "delta"}.each do |float, name|
assert_respond_to(float, :to_f, "The arguments must respond to to_f; the #{name} did not")
end
assert_operator(delta, :>=, 0.0, "The delta should not be negative")
full_message = build_message(message, < and
expected to be within
of each other.
EOT
assert_block(full_message) { (expected_float.to_f - actual_float.to_f).abs <= delta.to_f }
end
end
##
# Passes if the method send returns a true value.
#
# +send_array+ is composed of:
# * A receiver
# * A method
# * Arguments to the method
#
# Example:
# assert_send [[1, 2], :include?, 4]
public
def assert_send(send_array, message="")
_wrap_assertion do
assert_instance_of(Array, send_array, "assert_send requires an array of send information")
assert(send_array.size >= 2, "assert_send requires at least a receiver and a message name")
full_message = build_message(message, < expected to respond to
with a true value.
EOT
assert_block(full_message) { send_array[0].__send__(send_array[1], *send_array[2..-1]) }
end
end
##
# Builds a failure message. +head+ is added before the +template+ and
# +arguments+ replaces the '?'s positionally in the template.
public
def build_message(head, template=nil, *arguments)
template &&= template.chomp
return AssertionMessage.new(head, template, arguments)
end
private
def _wrap_assertion
@_assertion_wrapped ||= false
unless (@_assertion_wrapped)
@_assertion_wrapped = true
begin
add_assertion
return yield
ensure
@_assertion_wrapped = false
end
else
return yield
end
end
##
# Called whenever an assertion is made. Define this in classes that
# include Test::Unit::Assertions to record assertion counts.
private
def add_assertion
end
##
# Select whether or not to use the pretty-printer. If this option is set
# to false before any assertions are made, pp.rb will not be required.
public
def self.use_pp=(value)
AssertionMessage.use_pp = value
end
# :stopdoc:
class AssertionMessage
@use_pp = true
class << self
attr_accessor :use_pp
end
class Literal
def initialize(value)
@value = value
end
def inspect
@value.to_s
end
end
class Template
def self.create(string)
parts = (string ? string.scan(/(?=[^\\])\?|(?:\\\?|[^\?])+/m) : [])
self.new(parts)
end
attr_reader :count
def initialize(parts)
@parts = parts
@count = parts.find_all{|e| e == '?'}.size
end
def result(parameters)
raise "The number of parameters does not match the number of substitutions." if(parameters.size != count)
params = parameters.dup
@parts.collect{|e| e == '?' ? params.shift : e.gsub(/\\\?/m, '?')}.join('')
end
end
def self.literal(value)
Literal.new(value)
end
include Util::BacktraceFilter
def initialize(head, template_string, parameters)
@head = head
@template_string = template_string
@parameters = parameters
end
def convert(object)
case object
when Exception
<
Message: <#{convert(object.message)}>
---Backtrace---
#{filter_backtrace(object.backtrace).join("\n")}
---------------
EOM
else
if(self.class.use_pp)
begin
require 'pp'
rescue LoadError
self.class.use_pp = false
return object.inspect
end unless(defined?(PP))
PP.pp(object, '').chomp
else
object.inspect
end
end
end
def template
@template ||= Template.create(@template_string)
end
def add_period(string)
(string =~ /\.\Z/ ? string : string + '.')
end
def to_s
message_parts = []
if (@head)
head = @head.to_s
unless(head.empty?)
message_parts << add_period(head)
end
end
tail = template.result(@parameters.collect{|e| convert(e)})
message_parts << tail unless(tail.empty?)
message_parts.join("\n")
end
end
# :startdoc:
end
end
end
PK ! =!n n collector/dir.rbnu [ require 'test/unit/testsuite'
require 'test/unit/collector'
module Test
module Unit
module Collector
class Dir
include Collector
attr_reader :pattern, :exclude
attr_accessor :base
def initialize(dir=::Dir, file=::File, object_space=::ObjectSpace, req=nil)
super()
@dir = dir
@file = file
@object_space = object_space
@req = req
@pattern = [/\btest_.*\.rb\Z/m]
@exclude = []
end
def collect(*from)
basedir = @base
$:.push(basedir) if basedir
if(from.empty?)
recursive_collect('.', find_test_cases)
elsif(from.size == 1)
recursive_collect(from.first, find_test_cases)
else
suites = []
from.each do |f|
suite = recursive_collect(f, find_test_cases)
suites << suite unless(suite.tests.empty?)
end
suite = TestSuite.new("[#{from.join(', ')}]")
sort(suites).each{|s| suite << s}
suite
end
ensure
$:.delete_at($:.rindex(basedir)) if basedir
end
def find_test_cases(ignore=[])
cases = []
@object_space.each_object(Class) do |c|
cases << c if(c < TestCase && !ignore.include?(c))
end
ignore.concat(cases)
cases
end
def recursive_collect(name, already_gathered)
sub_suites = []
path = realdir(name)
if @file.directory?(path)
dir_name = name unless name == '.'
@dir.entries(path).each do |e|
next if(e == '.' || e == '..')
e_name = dir_name ? @file.join(dir_name, e) : e
if @file.directory?(realdir(e_name))
next if /\ACVS\z/ =~ e
sub_suite = recursive_collect(e_name, already_gathered)
sub_suites << sub_suite unless(sub_suite.empty?)
else
next if /~\z/ =~ e_name or /\A\.\#/ =~ e
if @pattern and !@pattern.empty?
next unless @pattern.any? {|pat| pat =~ e_name}
end
if @exclude and !@exclude.empty?
next if @exclude.any? {|pat| pat =~ e_name}
end
collect_file(e_name, sub_suites, already_gathered)
end
end
else
collect_file(name, sub_suites, already_gathered)
end
suite = TestSuite.new(@file.basename(name))
sort(sub_suites).each{|s| suite << s}
suite
end
def collect_file(name, suites, already_gathered)
dir = @file.dirname(@file.expand_path(name, @base))
$:.unshift(dir)
if(@req)
@req.require(name)
else
require(name)
end
find_test_cases(already_gathered).each{|t| add_suite(suites, t.suite)}
ensure
$:.delete_at($:.rindex(dir)) if(dir)
end
def realdir(path)
if @base
@file.join(@base, path)
else
path
end
end
end
end
end
end
PK ! + + collector/objectspace.rbnu [ # Author:: Nathaniel Talbott.
# Copyright:: Copyright (c) 2000-2003 Nathaniel Talbott. All rights reserved.
# License:: Ruby license.
require 'test/unit/collector'
module Test
module Unit
module Collector
class ObjectSpace
include Collector
NAME = 'collected from the ObjectSpace'
def initialize(source=::ObjectSpace)
super()
@source = source
end
def collect(name=NAME)
suite = TestSuite.new(name)
sub_suites = []
@source.each_object(Class) do |klass|
if(Test::Unit::TestCase > klass)
add_suite(sub_suites, klass.suite)
end
end
sort(sub_suites).each{|s| suite << s}
suite
end
end
end
end
end
PK ! K4
testresult.rbnu [ #--
# Author:: Nathaniel Talbott.
# Copyright:: Copyright (c) 2000-2002 Nathaniel Talbott. All rights reserved.
# License:: Ruby license.
require 'test/unit/util/observable'
module Test
module Unit
# Collects Test::Unit::Failure and Test::Unit::Error so that
# they can be displayed to the user. To this end, observers
# can be added to it, allowing the dynamic updating of, say, a
# UI.
class TestResult
include Util::Observable
CHANGED = "CHANGED"
FAULT = "FAULT"
attr_reader(:run_count, :assertion_count)
# Constructs a new, empty TestResult.
def initialize
@run_count, @assertion_count = 0, 0
@failures, @errors = Array.new, Array.new
end
# Records a test run.
def add_run
@run_count += 1
notify_listeners(CHANGED, self)
end
# Records a Test::Unit::Failure.
def add_failure(failure)
@failures << failure
notify_listeners(FAULT, failure)
notify_listeners(CHANGED, self)
end
# Records a Test::Unit::Error.
def add_error(error)
@errors << error
notify_listeners(FAULT, error)
notify_listeners(CHANGED, self)
end
# Records an individual assertion.
def add_assertion
@assertion_count += 1
notify_listeners(CHANGED, self)
end
# Returns a string contain the recorded runs, assertions,
# failures and errors in this TestResult.
def to_s
"#{run_count} tests, #{assertion_count} assertions, #{failure_count} failures, #{error_count} errors"
end
# Returns whether or not this TestResult represents
# successful completion.
def passed?
return @failures.empty? && @errors.empty?
end
# Returns the number of failures this TestResult has
# recorded.
def failure_count
return @failures.size
end
# Returns the number of errors this TestResult has
# recorded.
def error_count
return @errors.size
end
end
end
end
PK ! aAmV V
autorunner.rbnu [ require 'test/unit'
require 'test/unit/ui/testrunnerutilities'
require 'optparse'
module Test
module Unit
class AutoRunner
def self.run(force_standalone=false, default_dir=nil, argv=ARGV, &block)
r = new(force_standalone || standalone?, &block)
r.base = default_dir
r.process_args(argv)
r.run
end
def self.standalone?
return false unless("-e" == $0)
ObjectSpace.each_object(Class) do |klass|
return false if(klass < TestCase)
end
true
end
RUNNERS = {
:console => proc do |r|
require 'test/unit/ui/console/testrunner'
Test::Unit::UI::Console::TestRunner
end,
:gtk => proc do |r|
require 'test/unit/ui/gtk/testrunner'
Test::Unit::UI::GTK::TestRunner
end,
:gtk2 => proc do |r|
require 'test/unit/ui/gtk2/testrunner'
Test::Unit::UI::GTK2::TestRunner
end,
:fox => proc do |r|
require 'test/unit/ui/fox/testrunner'
Test::Unit::UI::Fox::TestRunner
end,
:tk => proc do |r|
require 'test/unit/ui/tk/testrunner'
Test::Unit::UI::Tk::TestRunner
end,
}
OUTPUT_LEVELS = [
[:silent, UI::SILENT],
[:progress, UI::PROGRESS_ONLY],
[:normal, UI::NORMAL],
[:verbose, UI::VERBOSE],
]
COLLECTORS = {
:objectspace => proc do |r|
require 'test/unit/collector/objectspace'
c = Collector::ObjectSpace.new
c.filter = r.filters
c.collect($0.sub(/\.rb\Z/, ''))
end,
:dir => proc do |r|
require 'test/unit/collector/dir'
c = Collector::Dir.new
c.filter = r.filters
c.pattern.concat(r.pattern) if(r.pattern)
c.exclude.concat(r.exclude) if(r.exclude)
c.base = r.base
$:.push(r.base) if r.base
c.collect(*(r.to_run.empty? ? ['.'] : r.to_run))
end,
}
attr_reader :suite
attr_accessor :output_level, :filters, :to_run, :pattern, :exclude, :base, :workdir
attr_writer :runner, :collector
def initialize(standalone)
Unit.run = true
@standalone = standalone
@runner = RUNNERS[:console]
@collector = COLLECTORS[(standalone ? :dir : :objectspace)]
@filters = []
@to_run = []
@output_level = UI::NORMAL
@workdir = nil
yield(self) if(block_given?)
end
def process_args(args = ARGV)
begin
options.order!(args) {|arg| @to_run << arg}
rescue OptionParser::ParseError => e
puts e
puts options
$! = nil
abort
else
@filters << proc{false} unless(@filters.empty?)
end
not @to_run.empty?
end
def options
@options ||= OptionParser.new do |o|
o.banner = "Test::Unit automatic runner."
o.banner << "\nUsage: #{$0} [options] [-- untouched arguments]"
o.on
o.on('-r', '--runner=RUNNER', RUNNERS,
"Use the given RUNNER.",
"(" + keyword_display(RUNNERS) + ")") do |r|
@runner = r
end
if(@standalone)
o.on('-b', '--basedir=DIR', "Base directory of test suites.") do |b|
@base = b
end
o.on('-w', '--workdir=DIR', "Working directory to run tests.") do |w|
@workdir = w
end
o.on('-a', '--add=TORUN', Array,
"Add TORUN to the list of things to run;",
"can be a file or a directory.") do |a|
@to_run.concat(a)
end
@pattern = []
o.on('-p', '--pattern=PATTERN', Regexp,
"Match files to collect against PATTERN.") do |e|
@pattern << e
end
@exclude = []
o.on('-x', '--exclude=PATTERN', Regexp,
"Ignore files to collect against PATTERN.") do |e|
@exclude << e
end
end
o.on('-n', '--name=NAME', String,
"Runs tests matching NAME.",
"(patterns may be used).") do |n|
n = (%r{\A/(.*)/\Z} =~ n ? Regexp.new($1) : n)
case n
when Regexp
@filters << proc{|t| n =~ t.method_name ? true : nil}
else
@filters << proc{|t| n == t.method_name ? true : nil}
end
end
o.on('-t', '--testcase=TESTCASE', String,
"Runs tests in TestCases matching TESTCASE.",
"(patterns may be used).") do |n|
n = (%r{\A/(.*)/\Z} =~ n ? Regexp.new($1) : n)
case n
when Regexp
@filters << proc{|t| n =~ t.class.name ? true : nil}
else
@filters << proc{|t| n == t.class.name ? true : nil}
end
end
o.on('-I', "--load-path=DIR[#{File::PATH_SEPARATOR}DIR...]",
"Appends directory list to $LOAD_PATH.") do |dirs|
$LOAD_PATH.concat(dirs.split(File::PATH_SEPARATOR))
end
o.on('-v', '--verbose=[LEVEL]', OUTPUT_LEVELS,
"Set the output level (default is verbose).",
"(" + keyword_display(OUTPUT_LEVELS) + ")") do |l|
@output_level = l || UI::VERBOSE
end
o.on('--',
"Stop processing options so that the",
"remaining options will be passed to the",
"test."){o.terminate}
o.on('-h', '--help', 'Display this help.'){puts o; exit}
o.on_tail
o.on_tail('Deprecated options:')
o.on_tail('--console', 'Console runner (use --runner).') do
warn("Deprecated option (--console).")
@runner = RUNNERS[:console]
end
o.on_tail('--gtk', 'GTK runner (use --runner).') do
warn("Deprecated option (--gtk).")
@runner = RUNNERS[:gtk]
end
o.on_tail('--fox', 'Fox runner (use --runner).') do
warn("Deprecated option (--fox).")
@runner = RUNNERS[:fox]
end
o.on_tail
end
end
def keyword_display(array)
list = array.collect {|e, *| e.to_s}
Array === array or list.sort!
list.collect {|e| e.sub(/^(.)([A-Za-z]+)(?=\w*$)/, '\\1[\\2]')}.join(", ")
end
def run
@suite = @collector[self]
result = @runner[self] or return false
Dir.chdir(@workdir) if @workdir
result.run(@suite, @output_level).passed?
end
end
end
end
PK ! ov " Runner/NullTestResultCacheTest.phpnu Iw
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
use PHPUnit\Framework\TestCase;
use PHPUnit\Runner\BaseTestRunner;
use PHPUnit\Runner\NullTestResultCache;
/**
* @group test-reorder
* @small
*/
final class NullTestResultCacheTest extends TestCase
{
public function testHasWorkingStubs(): void
{
$cache = new NullTestResultCache;
$cache->load();
$cache->persist();
$this->assertSame(BaseTestRunner::STATUS_UNKNOWN, $cache->getState('testName'));
$this->assertSame(0.0, $cache->getTime('testName'));
}
}
PK ! eM# # Runner/PhptTestCaseTest.phpnu Iw
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace PHPUnit\Runner;
use PHPUnit\Framework\TestCase;
use PHPUnit\Util\PHP\AbstractPhpProcess;
/**
* @medium
*/
final class PhptTestCaseTest extends TestCase
{
private const EXPECT_CONTENT = <<
--EXPECT--
Hello PHPUnit!
EOF;
private const EXPECTF_CONTENT = <<
--EXPECTF--
Hello %s!
EOF;
private const EXPECTREGEX_CONTENT = <<
--EXPECTREGEX--
Hello [HPU]{4}[nit]{3}!
EOF;
private const FILE_SECTION = <<
EOF;
/**
* @var string
*/
private $dirname;
/**
* @var string
*/
private $filename;
/**
* @var PhptTestCase
*/
private $testCase;
/**
* @var AbstractPhpProcess|\PHPUnit\Framework\MockObject\MockObject
*/
private $phpProcess;
protected function setUp(): void
{
$this->dirname = \sys_get_temp_dir();
$this->filename = $this->dirname . '/phpunit.phpt';
\touch($this->filename);
$this->phpProcess = $this->getMockForAbstractClass(AbstractPhpProcess::class, [], '', false);
$this->testCase = new PhptTestCase($this->filename, $this->phpProcess);
}
protected function tearDown(): void
{
@\unlink($this->filename);
$this->phpProcess = null;
$this->testCase = null;
}
public function testAlwaysReportsNumberOfAssertionsIsOne(): void
{
$this->assertSame(1, $this->testCase->getNumAssertions());
}
public function testAlwaysReportsItDoesNotUseADataprovider(): void
{
$this->assertSame(false, $this->testCase->usesDataProvider());
}
public function testShouldRunFileSectionAsTest(): void
{
$this->setPhpContent($this->ensureCorrectEndOfLine(self::EXPECT_CONTENT));
$fileSection = '' . \PHP_EOL;
$this->phpProcess
->expects($this->once())
->method('runJob')
->with($fileSection)
->will($this->returnValue(['stdout' => '', 'stderr' => '']));
$this->testCase->run();
}
public function testRenderFileSection(): void
{
$this->setPhpContent($this->ensureCorrectEndOfLine(
<<
--EXPECT--
Something
EOF
));
$renderedCode = "dirname . "' . '" . $this->filename . "'; ?>" . \PHP_EOL;
$this->phpProcess
->expects($this->once())
->method('runJob')
->with($renderedCode)
->will($this->returnValue(['stdout' => '', 'stderr' => '']));
$this->testCase->run();
}
public function testRenderSkipifSection(): void
{
$phptContent = self::EXPECT_CONTENT . \PHP_EOL;
$phptContent .= '--SKIPIF--' . \PHP_EOL;
$phptContent .= "" . \PHP_EOL;
$this->setPhpContent($phptContent);
$renderedCode = "filename . "'; ?>" . \PHP_EOL;
$this->phpProcess
->expects($this->at(0))
->method('runJob')
->with($renderedCode)
->will($this->returnValue(['stdout' => '', 'stderr' => '']));
$this->testCase->run();
}
public function testShouldRunSkipifSectionWhenExists(): void
{
$skipifSection = '' . \PHP_EOL;
$phptContent = self::EXPECT_CONTENT . \PHP_EOL;
$phptContent .= '--SKIPIF--' . \PHP_EOL;
$phptContent .= $skipifSection;
$this->setPhpContent($phptContent);
$this->phpProcess
->expects($this->at(0))
->method('runJob')
->with($skipifSection)
->will($this->returnValue(['stdout' => '', 'stderr' => '']));
$this->testCase->run();
}
public function testShouldNotRunTestSectionIfSkipifSectionReturnsOutputWithSkipWord(): void
{
$skipifSection = '' . \PHP_EOL;
$phptContent = self::EXPECT_CONTENT . \PHP_EOL;
$phptContent .= '--SKIPIF--' . \PHP_EOL;
$phptContent .= $skipifSection;
$this->setPhpContent($phptContent);
$this->phpProcess
->expects($this->once())
->method('runJob')
->with($skipifSection)
->will($this->returnValue(['stdout' => 'skip: Reason', 'stderr' => '']));
$this->testCase->run();
}
public function testShouldRunCleanSectionWhenDefined(): void
{
$cleanSection = '' . \PHP_EOL;
$phptContent = self::EXPECT_CONTENT . \PHP_EOL;
$phptContent .= '--CLEAN--' . \PHP_EOL;
$phptContent .= $cleanSection;
$this->setPhpContent($phptContent);
$this->phpProcess
->expects($this->at(1))
->method('runJob')
->with($cleanSection);
$this->testCase->run();
}
public function testShouldSkipTestWhenPhptFileIsEmpty(): void
{
$this->setPhpContent('');
$result = $this->testCase->run();
$this->assertCount(1, $result->skipped());
$this->assertSame('Invalid PHPT file', $result->skipped()[0]->thrownException()->getMessage());
}
public function testShouldSkipTestWhenFileSectionIsMissing(): void
{
$this->setPhpContent(
<<testCase->run();
$this->assertCount(1, $result->skipped());
$this->assertSame('Invalid PHPT file', $result->skipped()[0]->thrownException()->getMessage());
}
public function testShouldSkipTestWhenThereIsNoExpecOrExpectifOrExpecregexSectionInPhptFile(): void
{
$this->setPhpContent(
<<
EOF
);
$result = $this->testCase->run();
$this->assertCount(1, $result->skipped());
$skipMessage = $result->skipped()[0]->thrownException()->getMessage();
$this->assertSame('Invalid PHPT file', $skipMessage);
}
public function testShouldSkipTestWhenSectionHeaderIsMalformed(): void
{
$this->setPhpContent(
<<testCase->run();
$this->assertCount(1, $result->skipped());
$skipMessage = $result->skipped()[0]->thrownException()->getMessage();
$this->assertSame('Invalid PHPT file: empty section header', $skipMessage);
}
public function testShouldValidateExpectSession(): void
{
$this->setPhpContent(self::EXPECT_CONTENT);
$this->phpProcess
->expects($this->once())
->method('runJob')
->with(self::FILE_SECTION)
->will($this->returnValue(['stdout' => 'Hello PHPUnit!', 'stderr' => '']));
$result = $this->testCase->run();
$this->assertTrue($result->wasSuccessful());
}
public function testShouldValidateExpectfSession(): void
{
$this->setPhpContent(self::EXPECTF_CONTENT);
$this->phpProcess
->expects($this->once())
->method('runJob')
->with(self::FILE_SECTION)
->will($this->returnValue(['stdout' => 'Hello PHPUnit!', 'stderr' => '']));
$result = $this->testCase->run();
$this->assertTrue($result->wasSuccessful());
}
public function testShouldValidateExpectregexSession(): void
{
$this->setPhpContent(self::EXPECTREGEX_CONTENT);
$this->phpProcess
->expects($this->once())
->method('runJob')
->with(self::FILE_SECTION)
->will($this->returnValue(['stdout' => 'Hello PHPUnit!', 'stderr' => '']));
$result = $this->testCase->run();
$this->assertTrue($result->wasSuccessful());
}
/**
* Defines the content of the current PHPT test.
*
* @param string $content
*/
private function setPhpContent($content): void
{
\file_put_contents($this->filename, $content);
}
/**
* Ensures the correct line ending is used for comparison
*
* @param string $content
*
* @return string
*/
private function ensureCorrectEndOfLine($content)
{
return \strtr(
$content,
[
"\r\n" => \PHP_EOL,
"\r" => \PHP_EOL,
"\n" => \PHP_EOL,
]
);
}
}
PK ! z} % Runner/DefaultTestResultCacheTest.phpnu Iw
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace PHPUnit\Runner;
use PHPUnit\Framework\TestCase;
/**
* @covers \PHPUnit\Runner\DefaultTestResultCache
* @small
*/
final class DefaultTestResultCacheTest extends TestCase
{
/**
* @var DefaultTestResultCache
*/
private $subject;
protected function setUp(): void
{
$this->subject = new DefaultTestResultCache();
}
public function testGetTimeForNonExistentTestNameReturnsFloatZero(): void
{
$this->assertSame(0.0, $this->subject->getTime('doesNotExist'));
}
}
PK ! # Runner/ResultCacheExtensionTest.phpnu Iw
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace PHPUnit\Runner;
use PHPUnit\Framework\TestCase;
use PHPUnit\Framework\TestCaseTest;
use PHPUnit\Framework\TestResult;
use PHPUnit\Framework\TestSuite;
/**
* @group test-reorder
* @small
*/
final class ResultCacheExtensionTest extends TestCase
{
/**
* @var DefaultTestResultCache
*/
protected $cache;
/**
* @var ResultCacheExtension
*/
protected $extension;
/**
* @var TestResult
*/
protected $result;
protected function setUp(): void
{
$this->cache = new DefaultTestResultCache;
$this->extension = new ResultCacheExtension($this->cache);
$listener = new TestListenerAdapter;
$listener->add($this->extension);
$this->result = new TestResult;
$this->result->addListener($listener);
}
/**
* @testdox Clean up test name $_dataName
* @dataProvider longTestNamesDataprovider
*/
public function testStripsDataproviderParametersFromTestName(string $testName, string $expectedTestName): void
{
$test = new TestCaseTest($testName);
$test->run($this->result);
$this->assertSame(BaseTestRunner::STATUS_ERROR, $this->cache->getState($expectedTestName));
}
public function longTestNamesDataprovider(): array
{
return [
'ClassName::testMethod' => [
'testSomething',
TestCaseTest::class . '::testSomething', ],
'ClassName::testMethod and data set number and vardump' => [
'testMethod with data set #123 (\'a\', "A", 0, false)',
TestCaseTest::class . '::testMethod with data set #123', ],
'ClassName::testMethod and data set name and vardump' => [
'testMethod with data set "data name" (\'a\', "A\", 0, false)',
TestCaseTest::class . '::testMethod with data set "data name"', ],
];
}
public function testError(): void
{
$test = new \TestError('test_name');
$test->run($this->result);
$this->assertSame(BaseTestRunner::STATUS_ERROR, $this->cache->getState(\TestError::class . '::test_name'));
}
public function testFailure(): void
{
$test = new \Failure('test_name');
$test->run($this->result);
$this->assertSame(BaseTestRunner::STATUS_FAILURE, $this->cache->getState(\Failure::class . '::test_name'));
}
public function testSkipped(): void
{
$test = new \TestSkipped('test_name');
$test->run($this->result);
$this->assertSame(BaseTestRunner::STATUS_SKIPPED, $this->cache->getState(\TestSkipped::class . '::test_name'));
}
public function testIncomplete(): void
{
$test = new \TestIncomplete('test_name');
$test->run($this->result);
$this->assertSame(BaseTestRunner::STATUS_INCOMPLETE, $this->cache->getState(\TestIncomplete::class . '::test_name'));
}
public function testPassedTestsOnlyCacheTime(): void
{
$test = new \Success('test_name');
$test->run($this->result);
$this->assertSame(BaseTestRunner::STATUS_UNKNOWN, $this->cache->getState(\Success::class . '::test_name'));
}
public function testWarning(): void
{
$test = new \TestWarning('test_name');
$test->run($this->result);
$this->assertSame(BaseTestRunner::STATUS_WARNING, $this->cache->getState(\TestWarning::class . '::test_name'));
}
public function testRisky(): void
{
$test = new \TestRisky('test_name');
$test->run($this->result);
$this->assertSame(BaseTestRunner::STATUS_RISKY, $this->cache->getState(\TestRisky::class . '::test_name'));
}
public function testEmptySuite(): void
{
$suite = new TestSuite;
$suite->addTestSuite(\EmptyTestCaseTest::class);
$suite->run($this->result);
$this->assertSame(BaseTestRunner::STATUS_WARNING, $this->cache->getState('Warning'));
}
}
PK ! IeB B Runner/TestResultCacheTest.phpnu Iw
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
use PHPUnit\Framework\TestCase;
use PHPUnit\Runner\BaseTestRunner;
use PHPUnit\Runner\DefaultTestResultCache;
/**
* @group test-reorder
* @small
*/
final class TestResultCacheTest extends TestCase
{
public function testReadsCacheFromProvidedFilename(): void
{
$cacheFile = TEST_FILES_PATH . '../end-to-end/execution-order/_files/MultiDependencyTest_result_cache.txt';
$cache = new DefaultTestResultCache($cacheFile);
$cache->load();
$this->assertSame(BaseTestRunner::STATUS_UNKNOWN, $cache->getState(\MultiDependencyTest::class . '::testOne'));
$this->assertSame(BaseTestRunner::STATUS_SKIPPED, $cache->getState(\MultiDependencyTest::class . '::testFive'));
}
public function testDoesClearCacheBeforeLoad(): void
{
$cacheFile = TEST_FILES_PATH . '../end-to-end/execution-order/_files/MultiDependencyTest_result_cache.txt';
$cache = new DefaultTestResultCache($cacheFile);
$cache->setState('someTest', BaseTestRunner::STATUS_FAILURE);
$this->assertSame(BaseTestRunner::STATUS_UNKNOWN, $cache->getState(\MultiDependencyTest::class . '::testFive'));
$cache->load();
$this->assertSame(BaseTestRunner::STATUS_UNKNOWN, $cache->getState(\MultiDependencyTest::class . '::someTest'));
$this->assertSame(BaseTestRunner::STATUS_SKIPPED, $cache->getState(\MultiDependencyTest::class . '::testFive'));
}
public function testShouldNotSerializePassedTestsAsDefectButTimeIsStored(): void
{
$cache = new DefaultTestResultCache;
$cache->setState('testOne', BaseTestRunner::STATUS_PASSED);
$cache->setTime('testOne', 123);
$data = \serialize($cache);
$this->assertSame('C:37:"PHPUnit\Runner\DefaultTestResultCache":64:{a:2:{s:7:"defects";a:0:{}s:5:"times";a:1:{s:7:"testOne";d:123;}}}', $data);
}
public function testCanPersistCacheToFile(): void
{
// Create a cache with one result and store it
$cacheFile = \tempnam(\sys_get_temp_dir(), 'phpunit_');
$cache = new DefaultTestResultCache($cacheFile);
$testName = 'test' . \uniqid();
$cache->setState($testName, BaseTestRunner::STATUS_SKIPPED);
$cache->persist();
unset($cache);
// Load the cache we just created
$loadedCache = new DefaultTestResultCache($cacheFile);
$loadedCache->load();
$this->assertSame(BaseTestRunner::STATUS_SKIPPED, $loadedCache->getState($testName));
// Clean up
\unlink($cacheFile);
}
public function testShouldReturnEmptyCacheWhenFileDoesNotExist(): void
{
$cache = new DefaultTestResultCache('/a/wrong/path/file');
$cache->load();
$this->assertTrue($this->isSerializedEmptyCache(\serialize($cache)));
}
public function testShouldReturnEmptyCacheFromInvalidFile(): void
{
$cacheFile = \tempnam(\sys_get_temp_dir(), 'phpunit_');
\file_put_contents($cacheFile, '');
$cache = new DefaultTestResultCache($cacheFile);
$cache->load();
$this->assertTrue($this->isSerializedEmptyCache(\serialize($cache)));
}
public function isSerializedEmptyCache(string $data): bool
{
return $data === 'C:37:"PHPUnit\Runner\DefaultTestResultCache":44:{a:2:{s:7:"defects";a:0:{}s:5:"times";a:0:{}}}';
}
}
PK !
Ij j Runner/TestSuiteSorterTest.phpnu Iw
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace PHPUnit\Runner;
use PHPUnit\Framework\TestCase;
use PHPUnit\Framework\TestSuite;
/**
* @testdox Reordering test execution
* @group test-reorder
* @small
*/
final class TestSuiteSorterTest extends TestCase
{
/**
* Constants to improve clarity of @dataprovider
*/
private const IGNORE_DEPENDENCIES = false;
private const RESOLVE_DEPENDENCIES = true;
private const MULTIDEPENDENCYTEST_EXECUTION_ORDER = [
\MultiDependencyTest::class . '::testOne',
\MultiDependencyTest::class . '::testTwo',
\MultiDependencyTest::class . '::testThree',
\MultiDependencyTest::class . '::testFour',
\MultiDependencyTest::class . '::testFive',
];
public function testThrowsExceptionWhenUsingInvalidOrderOption(): void
{
$suite = new TestSuite;
$suite->addTestSuite(\MultiDependencyTest::class);
$sorter = new TestSuiteSorter;
$this->expectException(Exception::class);
$this->expectExceptionMessage('$order must be one of TestSuiteSorter::ORDER_[DEFAULT|REVERSED|RANDOMIZED|DURATION|SIZE]');
$sorter->reorderTestsInSuite($suite, -1, false, TestSuiteSorter::ORDER_DEFAULT);
}
public function testThrowsExceptionWhenUsingInvalidOrderDefectsOption(): void
{
$suite = new TestSuite;
$suite->addTestSuite(\MultiDependencyTest::class);
$sorter = new TestSuiteSorter;
$this->expectException(Exception::class);
$this->expectExceptionMessage('$orderDefects must be one of TestSuiteSorter::ORDER_DEFAULT, TestSuiteSorter::ORDER_DEFECTS_FIRST');
$sorter->reorderTestsInSuite($suite, TestSuiteSorter::ORDER_DEFAULT, false, -1);
}
/**
* @testdox Empty TestSuite not affected (order=$order, resolve=$resolveDependencies, defects=$orderDefects)
* @dataProvider suiteSorterOptionPermutationsProvider
*/
public function testShouldNotAffectEmptyTestSuite(int $order, bool $resolveDependencies, int $orderDefects): void
{
$sorter = new TestSuiteSorter;
$suite = new TestSuite;
$sorter->reorderTestsInSuite($suite, $order, $resolveDependencies, $orderDefects);
$this->assertEmpty($suite->tests());
$this->assertEmpty($sorter->getOriginalExecutionOrder());
$this->assertEmpty($sorter->getExecutionOrder());
}
/**
* @dataProvider commonSorterOptionsProvider
*/
public function testBasicExecutionOrderOptions(int $order, bool $resolveDependencies, array $expectedOrder): void
{
$suite = new TestSuite;
$suite->addTestSuite(\MultiDependencyTest::class);
$sorter = new TestSuiteSorter;
$sorter->reorderTestsInSuite($suite, $order, $resolveDependencies, TestSuiteSorter::ORDER_DEFAULT);
$this->assertSame(self::MULTIDEPENDENCYTEST_EXECUTION_ORDER, $sorter->getOriginalExecutionOrder());
$this->assertSame($expectedOrder, $sorter->getExecutionOrder());
}
public function testCanSetRandomizationWithASeed(): void
{
$suite = new TestSuite;
$suite->addTestSuite(\MultiDependencyTest::class);
$sorter = new TestSuiteSorter;
\mt_srand(54321);
$sorter->reorderTestsInSuite($suite, TestSuiteSorter::ORDER_RANDOMIZED, false, TestSuiteSorter::ORDER_DEFAULT);
$expectedOrder = [
\MultiDependencyTest::class . '::testTwo',
\MultiDependencyTest::class . '::testFour',
\MultiDependencyTest::class . '::testFive',
\MultiDependencyTest::class . '::testThree',
\MultiDependencyTest::class . '::testOne',
];
$this->assertSame($expectedOrder, $sorter->getExecutionOrder());
}
public function testCanSetRandomizationWithASeedAndResolveDependencies(): void
{
$suite = new TestSuite;
$suite->addTestSuite(\MultiDependencyTest::class);
$sorter = new TestSuiteSorter;
\mt_srand(54321);
$sorter->reorderTestsInSuite($suite, TestSuiteSorter::ORDER_RANDOMIZED, true, TestSuiteSorter::ORDER_DEFAULT);
$expectedOrder = [
\MultiDependencyTest::class . '::testTwo',
\MultiDependencyTest::class . '::testFive',
\MultiDependencyTest::class . '::testOne',
\MultiDependencyTest::class . '::testThree',
\MultiDependencyTest::class . '::testFour',
];
$this->assertSame($expectedOrder, $sorter->getExecutionOrder());
}
/**
* @dataProvider orderDurationWithoutCacheProvider
*/
public function testOrderDurationWithoutCache(bool $resolveDependencies, array $expected): void
{
$suite = new TestSuite;
$suite->addTestSuite(\MultiDependencyTest::class);
$sorter = new TestSuiteSorter;
$sorter->reorderTestsInSuite(
$suite,
TestSuiteSorter::ORDER_DURATION,
$resolveDependencies,
TestSuiteSorter::ORDER_DEFAULT
);
$this->assertSame($expected, $sorter->getExecutionOrder());
}
public function orderDurationWithoutCacheProvider(): array
{
return [
'dependency-ignore' => [
self::IGNORE_DEPENDENCIES,
[
\MultiDependencyTest::class . '::testOne',
\MultiDependencyTest::class . '::testTwo',
\MultiDependencyTest::class . '::testThree',
\MultiDependencyTest::class . '::testFour',
\MultiDependencyTest::class . '::testFive',
],
],
'dependency-resolve' => [
self::RESOLVE_DEPENDENCIES,
[
\MultiDependencyTest::class . '::testOne',
\MultiDependencyTest::class . '::testTwo',
\MultiDependencyTest::class . '::testThree',
\MultiDependencyTest::class . '::testFour',
\MultiDependencyTest::class . '::testFive',
],
],
];
}
/**
* @dataProvider orderDurationWithCacheProvider
*/
public function testOrderDurationWithCache(bool $resolveDependencies, array $testTimes, array $expected): void
{
$suite = new TestSuite;
$suite->addTestSuite(\MultiDependencyTest::class);
$cache = new DefaultTestResultCache;
foreach ($testTimes as $testName => $time) {
$cache->setTime(\MultiDependencyTest::class . '::' . $testName, $time);
}
$sorter = new TestSuiteSorter($cache);
$sorter->reorderTestsInSuite(
$suite,
TestSuiteSorter::ORDER_DURATION,
$resolveDependencies,
TestSuiteSorter::ORDER_DEFAULT
);
$this->assertSame($expected, $sorter->getExecutionOrder());
}
public function orderDurationWithCacheProvider(): array
{
return [
'duration-same-dependency-ignore' => [
self::IGNORE_DEPENDENCIES,
[
'testOne' => 1,
'testTwo' => 1,
'testThree' => 1,
'testFour' => 1,
'testFive' => 1,
],
[
\MultiDependencyTest::class . '::testOne',
\MultiDependencyTest::class . '::testTwo',
\MultiDependencyTest::class . '::testThree',
\MultiDependencyTest::class . '::testFour',
\MultiDependencyTest::class . '::testFive',
],
],
'duration-same-dependency-resolve' => [
self::RESOLVE_DEPENDENCIES,
[
'testOne' => 1,
'testTwo' => 1,
'testThree' => 1,
'testFour' => 1,
'testFive' => 1,
],
[
\MultiDependencyTest::class . '::testOne',
\MultiDependencyTest::class . '::testTwo',
\MultiDependencyTest::class . '::testThree',
\MultiDependencyTest::class . '::testFour',
\MultiDependencyTest::class . '::testFive',
],
],
'duration-different-dependency-ignore' => [
self::IGNORE_DEPENDENCIES,
[
'testOne' => 5,
'testTwo' => 3,
'testThree' => 4,
'testFour' => 1,
'testFive' => 2,
],
[
\MultiDependencyTest::class . '::testFour',
\MultiDependencyTest::class . '::testFive',
\MultiDependencyTest::class . '::testTwo',
\MultiDependencyTest::class . '::testThree',
\MultiDependencyTest::class . '::testOne',
],
],
'duration-different-dependency-resolve' => [
self::RESOLVE_DEPENDENCIES,
[
'testOne' => 5,
'testTwo' => 3,
'testThree' => 4,
'testFour' => 1,
'testFive' => 2,
],
[
\MultiDependencyTest::class . '::testFive',
\MultiDependencyTest::class . '::testTwo',
\MultiDependencyTest::class . '::testOne',
\MultiDependencyTest::class . '::testThree',
\MultiDependencyTest::class . '::testFour',
],
],
];
}
/**
* @dataProvider defectsSorterOptionsProvider
*/
public function testSuiteSorterDefectsOptions(int $order, bool $resolveDependencies, array $runState, array $expected): void
{
$suite = new TestSuite;
$suite->addTestSuite(\MultiDependencyTest::class);
$cache = new DefaultTestResultCache;
foreach ($runState as $testName => $data) {
$cache->setState(\MultiDependencyTest::class . '::' . $testName, $data['state']);
$cache->setTime(\MultiDependencyTest::class . '::' . $testName, $data['time']);
}
$sorter = new TestSuiteSorter($cache);
$sorter->reorderTestsInSuite($suite, $order, $resolveDependencies, TestSuiteSorter::ORDER_DEFECTS_FIRST);
$this->assertSame($expected, $sorter->getExecutionOrder());
}
/**
* A @dataprovider for basic execution reordering options based on MultiDependencyTest
* This class has the following relevant properties:
* - it has five tests 'testOne' ... 'testFive'
* - 'testThree' @depends on both 'testOne' and 'testTwo'
* - 'testFour' @depends on 'MultiDependencyTest::testThree' to test FQN @depends
* - 'testFive' has no dependencies
*/
public function commonSorterOptionsProvider(): array
{
return [
'default' => [
TestSuiteSorter::ORDER_DEFAULT,
self::IGNORE_DEPENDENCIES,
[
\MultiDependencyTest::class . '::testOne',
\MultiDependencyTest::class . '::testTwo',
\MultiDependencyTest::class . '::testThree',
\MultiDependencyTest::class . '::testFour',
\MultiDependencyTest::class . '::testFive',
],
],
// Activating dependency resolution should have no effect under normal circumstances
'resolve default' => [
TestSuiteSorter::ORDER_DEFAULT,
self::RESOLVE_DEPENDENCIES,
[
\MultiDependencyTest::class . '::testOne',
\MultiDependencyTest::class . '::testTwo',
\MultiDependencyTest::class . '::testThree',
\MultiDependencyTest::class . '::testFour',
\MultiDependencyTest::class . '::testFive',
],
],
// Reversing without checks should give a simple reverse order
'reverse' => [
TestSuiteSorter::ORDER_REVERSED,
self::IGNORE_DEPENDENCIES,
[
\MultiDependencyTest::class . '::testFive',
\MultiDependencyTest::class . '::testFour',
\MultiDependencyTest::class . '::testThree',
\MultiDependencyTest::class . '::testTwo',
\MultiDependencyTest::class . '::testOne',
],
],
// Reversing with resolution still allows testFive to move to front, testTwo before testOne
'resolve reverse' => [
TestSuiteSorter::ORDER_REVERSED,
self::RESOLVE_DEPENDENCIES,
[
\MultiDependencyTest::class . '::testFive',
\MultiDependencyTest::class . '::testTwo',
\MultiDependencyTest::class . '::testOne',
\MultiDependencyTest::class . '::testThree',
\MultiDependencyTest::class . '::testFour',
],
],
];
}
/**
* A @dataprovider for testing defects execution reordering options based on MultiDependencyTest
* This class has the following relevant properties:
* - it has five tests 'testOne' ... 'testFive'
* - 'testThree' @depends on both 'testOne' and 'testTwo'
* - 'testFour' @depends on 'MultiDependencyTest::testThree' to test FQN @depends
* - 'testFive' has no dependencies
*/
public function defectsSorterOptionsProvider(): array
{
return [
// The most simple situation should work as normal
'default, no defects' => [
TestSuiteSorter::ORDER_DEFAULT,
self::IGNORE_DEPENDENCIES,
[
'testOne' => ['state' => BaseTestRunner::STATUS_PASSED, 'time' => 1],
'testTwo' => ['state' => BaseTestRunner::STATUS_PASSED, 'time' => 1],
'testThree' => ['state' => BaseTestRunner::STATUS_PASSED, 'time' => 1],
'testFour' => ['state' => BaseTestRunner::STATUS_PASSED, 'time' => 1],
'testFive' => ['state' => BaseTestRunner::STATUS_PASSED, 'time' => 1],
],
[
\MultiDependencyTest::class . '::testOne',
\MultiDependencyTest::class . '::testTwo',
\MultiDependencyTest::class . '::testThree',
\MultiDependencyTest::class . '::testFour',
\MultiDependencyTest::class . '::testFive',
],
],
// Running with an empty cache should not spook the TestSuiteSorter
'default, empty result cache' => [
TestSuiteSorter::ORDER_DEFAULT,
self::IGNORE_DEPENDENCIES,
[
// empty result cache
],
[
\MultiDependencyTest::class . '::testOne',
\MultiDependencyTest::class . '::testTwo',
\MultiDependencyTest::class . '::testThree',
\MultiDependencyTest::class . '::testFour',
\MultiDependencyTest::class . '::testFive',
],
],
// testFive is independent and can be moved to the front
'default, testFive skipped' => [
TestSuiteSorter::ORDER_DEFAULT,
self::IGNORE_DEPENDENCIES,
[
'testOne' => ['state' => BaseTestRunner::STATUS_PASSED, 'time' => 1],
'testTwo' => ['state' => BaseTestRunner::STATUS_PASSED, 'time' => 1],
'testThree' => ['state' => BaseTestRunner::STATUS_PASSED, 'time' => 1],
'testFour' => ['state' => BaseTestRunner::STATUS_PASSED, 'time' => 1],
'testFive' => ['state' => BaseTestRunner::STATUS_SKIPPED, 'time' => 1],
],
[
\MultiDependencyTest::class . '::testFive',
\MultiDependencyTest::class . '::testOne',
\MultiDependencyTest::class . '::testTwo',
\MultiDependencyTest::class . '::testThree',
\MultiDependencyTest::class . '::testFour',
],
],
// Defects in testFive and testTwo, but the faster testFive should be run first
'default, testTwo testFive skipped' => [
TestSuiteSorter::ORDER_DEFAULT,
self::IGNORE_DEPENDENCIES,
[
'testOne' => ['state' => BaseTestRunner::STATUS_PASSED, 'time' => 1],
'testTwo' => ['state' => BaseTestRunner::STATUS_SKIPPED, 'time' => 1],
'testThree' => ['state' => BaseTestRunner::STATUS_PASSED, 'time' => 1],
'testFour' => ['state' => BaseTestRunner::STATUS_PASSED, 'time' => 1],
'testFive' => ['state' => BaseTestRunner::STATUS_SKIPPED, 'time' => 0],
],
[
\MultiDependencyTest::class . '::testFive',
\MultiDependencyTest::class . '::testTwo',
\MultiDependencyTest::class . '::testOne',
\MultiDependencyTest::class . '::testThree',
\MultiDependencyTest::class . '::testFour',
],
],
// Skipping testThree will move it to the front when ignoring dependencies
'default, testThree skipped' => [
TestSuiteSorter::ORDER_DEFAULT,
self::IGNORE_DEPENDENCIES,
[
'testOne' => ['state' => BaseTestRunner::STATUS_PASSED, 'time' => 1],
'testTwo' => ['state' => BaseTestRunner::STATUS_PASSED, 'time' => 1],
'testThree' => ['state' => BaseTestRunner::STATUS_SKIPPED, 'time' => 1],
'testFour' => ['state' => BaseTestRunner::STATUS_PASSED, 'time' => 1],
'testFive' => ['state' => BaseTestRunner::STATUS_PASSED, 'time' => 1],
],
[
\MultiDependencyTest::class . '::testThree',
\MultiDependencyTest::class . '::testOne',
\MultiDependencyTest::class . '::testTwo',
\MultiDependencyTest::class . '::testFour',
\MultiDependencyTest::class . '::testFive',
],
],
// Skipping testThree will move it to the front but behind its dependencies
'default resolve, testThree skipped' => [
TestSuiteSorter::ORDER_DEFAULT,
self::RESOLVE_DEPENDENCIES,
[
'testOne' => ['state' => BaseTestRunner::STATUS_PASSED, 'time' => 1],
'testTwo' => ['state' => BaseTestRunner::STATUS_PASSED, 'time' => 1],
'testThree' => ['state' => BaseTestRunner::STATUS_SKIPPED, 'time' => 1],
'testFour' => ['state' => BaseTestRunner::STATUS_PASSED, 'time' => 1],
'testFive' => ['state' => BaseTestRunner::STATUS_PASSED, 'time' => 1],
],
[
\MultiDependencyTest::class . '::testOne',
\MultiDependencyTest::class . '::testTwo',
\MultiDependencyTest::class . '::testThree',
\MultiDependencyTest::class . '::testFour',
\MultiDependencyTest::class . '::testFive',
],
],
// Skipping testThree will move it to the front and keep the others reversed
'reverse, testThree skipped' => [
TestSuiteSorter::ORDER_REVERSED,
self::IGNORE_DEPENDENCIES,
[
'testOne' => ['state' => BaseTestRunner::STATUS_PASSED, 'time' => 1],
'testTwo' => ['state' => BaseTestRunner::STATUS_PASSED, 'time' => 1],
'testThree' => ['state' => BaseTestRunner::STATUS_SKIPPED, 'time' => 1],
'testFour' => ['state' => BaseTestRunner::STATUS_PASSED, 'time' => 1],
'testFive' => ['state' => BaseTestRunner::STATUS_PASSED, 'time' => 1],
],
[
\MultiDependencyTest::class . '::testThree',
\MultiDependencyTest::class . '::testFive',
\MultiDependencyTest::class . '::testFour',
\MultiDependencyTest::class . '::testTwo',
\MultiDependencyTest::class . '::testOne',
],
],
// Demonstrate a limit of the dependency resolver: after sorting defects to the front,
// the resolver will mark testFive done before testThree because of dependencies
'default resolve, testThree skipped, testFive fast' => [
TestSuiteSorter::ORDER_DEFAULT,
self::RESOLVE_DEPENDENCIES,
[
'testOne' => ['state' => BaseTestRunner::STATUS_PASSED, 'time' => 1],
'testTwo' => ['state' => BaseTestRunner::STATUS_PASSED, 'time' => 1],
'testThree' => ['state' => BaseTestRunner::STATUS_SKIPPED, 'time' => 0],
'testFour' => ['state' => BaseTestRunner::STATUS_PASSED, 'time' => 1],
'testFive' => ['state' => BaseTestRunner::STATUS_SKIPPED, 'time' => 1],
],
[
\MultiDependencyTest::class . '::testFive',
\MultiDependencyTest::class . '::testOne',
\MultiDependencyTest::class . '::testTwo',
\MultiDependencyTest::class . '::testThree',
\MultiDependencyTest::class . '::testFour',
],
],
// Torture test
// - incomplete TestResultCache
// - skipped testThree: will move it to the front as far as possible
// - testOne and testTwo are required before testThree, but can be reversed locally
// - testFive is independent will remain reversed up front
'reverse resolve, testThree skipped' => [
TestSuiteSorter::ORDER_REVERSED,
self::RESOLVE_DEPENDENCIES,
[
'testOne' => ['state' => BaseTestRunner::STATUS_PASSED, 'time' => 1],
'testTwo' => ['state' => BaseTestRunner::STATUS_PASSED, 'time' => 1],
'testThree' => ['state' => BaseTestRunner::STATUS_SKIPPED, 'time' => 1],
],
[
\MultiDependencyTest::class . '::testFive',
\MultiDependencyTest::class . '::testTwo',
\MultiDependencyTest::class . '::testOne',
\MultiDependencyTest::class . '::testThree',
\MultiDependencyTest::class . '::testFour',
],
],
// Make sure the dependency resolver is not confused by failing tests.
// Scenario: Four has a @depends on Three and fails. Result: Three is still run first
// testFive also fails but can be moved around freely and will be up front.
'depends first, then defects' => [
TestSuiteSorter::ORDER_DEFAULT,
self::RESOLVE_DEPENDENCIES,
[
'testOne' => ['state' => BaseTestRunner::STATUS_PASSED, 'time' => 1],
'testTwo' => ['state' => BaseTestRunner::STATUS_PASSED, 'time' => 1],
'testThree' => ['state' => BaseTestRunner::STATUS_PASSED, 'time' => 1],
'testFour' => ['state' => BaseTestRunner::STATUS_FAILURE, 'time' => 1],
'testFive' => ['state' => BaseTestRunner::STATUS_FAILURE, 'time' => 1],
],
[
\MultiDependencyTest::class . '::testFive',
\MultiDependencyTest::class . '::testOne',
\MultiDependencyTest::class . '::testTwo',
\MultiDependencyTest::class . '::testThree',
\MultiDependencyTest::class . '::testFour',
],
],
];
}
/**
* @see https://github.com/lstrojny/phpunit-clever-and-smart/issues/38
*/
public function testCanHandleSuiteWithEmptyTestCase(): void
{
$suite = new TestSuite;
$suite->addTestSuite(\EmptyTestCaseTest::class);
$sorter = new TestSuiteSorter;
$sorter->reorderTestsInSuite($suite, TestSuiteSorter::ORDER_DEFAULT, false, TestSuiteSorter::ORDER_DEFAULT);
$this->assertSame(\EmptyTestCaseTest::class, $suite->tests()[0]->getName());
$this->assertSame('No tests found in class "EmptyTestCaseTest".', $suite->tests()[0]->tests()[0]->getMessage());
}
public function suiteSorterOptionPermutationsProvider(): array
{
$orderValues = [TestSuiteSorter::ORDER_DEFAULT, TestSuiteSorter::ORDER_REVERSED, TestSuiteSorter::ORDER_RANDOMIZED];
$resolveValues = [false, true];
$orderDefectsValues = [TestSuiteSorter::ORDER_DEFAULT, TestSuiteSorter::ORDER_DEFECTS_FIRST];
$data = [];
foreach ($orderValues as $order) {
foreach ($resolveValues as $resolve) {
foreach ($orderDefectsValues as $orderDefects) {
$data[] = [$order, $resolve, $orderDefects];
}
}
}
return $data;
}
public function testOrderBySize(): void
{
$suite = new TestSuite;
$suite->addTestSuite(\TestWithDifferentSizes::class);
$sorter = new TestSuiteSorter;
$sorter->reorderTestsInSuite($suite, TestSuiteSorter::ORDER_SIZE, true, TestSuiteSorter::ORDER_DEFAULT);
$expectedOrder = [
\TestWithDifferentSizes::class . '::testWithSizeSmall',
\TestWithDifferentSizes::class . '::testDataProviderWithSizeSmall with data set #0',
\TestWithDifferentSizes::class . '::testDataProviderWithSizeSmall with data set #1',
\TestWithDifferentSizes::class . '::testDataProviderWithSizeMedium with data set #0',
\TestWithDifferentSizes::class . '::testDataProviderWithSizeMedium with data set #1',
\TestWithDifferentSizes::class . '::testWithSizeMedium',
\TestWithDifferentSizes::class . '::testWithSizeLarge',
\TestWithDifferentSizes::class . '::testWithSizeUnknown',
];
$this->assertSame($expectedOrder, $sorter->getExecutionOrder());
}
}
PK ! " ( Runner/Filter/NameFilterIteratorTest.phpnu Iw
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace PHPUnit\Runner\Filter;
use PHPUnit\Framework\TestCase;
use PHPUnit\Framework\TestSuite;
/**
* @small
*/
final class NameFilterIteratorTest extends TestCase
{
public function testCaseSensitiveMatch(): void
{
$this->assertTrue($this->createFilter('BankAccountTest')->accept());
}
public function testCaseInsensitiveMatch(): void
{
$this->assertTrue($this->createFilter('bankaccounttest')->accept());
}
private function createFilter(string $filter): NameFilterIterator
{
$suite = new TestSuite;
$suite->addTest(new \BankAccountTest('testBalanceIsInitiallyZero'));
$iterator = new NameFilterIterator($suite->getIterator(), $filter);
$iterator->rewind();
return $iterator;
}
}
PK ! H. . ! Framework/SkippedTestCaseTest.phpnu Iw
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace PHPUnit\Framework;
use PHPUnit\Runner\BaseTestRunner;
final class SkippedTestCaseTest extends TestCase
{
public function testDefaults(): void
{
$testCase = new SkippedTestCase(
'Foo',
'testThatBars'
);
$this->assertSame('', $testCase->getMessage());
}
public function testGetNameReturnsClassAndMethodName(): void
{
$className = 'Foo';
$methodName = 'testThatBars';
$testCase = new SkippedTestCase(
$className,
$methodName
);
$name = \sprintf(
'%s::%s',
$className,
$methodName
);
$this->assertSame($name, $testCase->getName());
}
public function testGetMessageReturnsMessage(): void
{
$message = 'Somehow skipped, right?';
$testCase = new SkippedTestCase(
'Foo',
'testThatBars',
$message
);
$this->assertSame($message, $testCase->getMessage());
}
public function testRunMarksTestAsSkipped(): void
{
$className = 'Foo';
$methodName = 'testThatBars';
$message = 'Somehow skipped, right?';
$testCase = new SkippedTestCase(
$className,
$methodName,
$message
);
$result = $testCase->run();
$this->assertSame(BaseTestRunner::STATUS_SKIPPED, $testCase->getStatus());
$this->assertSame(1, $result->skippedCount());
$failures = $result->skipped();
$failure = \array_shift($failures);
$name = \sprintf(
'%s::%s',
$className,
$methodName
);
$this->assertSame($name, $failure->getTestName());
$this->assertSame($message, $failure->exceptionMessage());
}
}
PK ! W W $ Framework/IncompleteTestCaseTest.phpnu Iw
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace PHPUnit\Framework;
use PHPUnit\Runner\BaseTestRunner;
final class IncompleteTestCaseTest extends TestCase
{
public function testDefaults(): void
{
$testCase = new IncompleteTestCase(
'Foo',
'testThatBars'
);
$this->assertSame('', $testCase->getMessage());
}
public function testGetNameReturnsClassAndMethodName(): void
{
$className = 'Foo';
$methodName = 'testThatBars';
$testCase = new IncompleteTestCase(
$className,
$methodName
);
$name = \sprintf(
'%s::%s',
$className,
$methodName
);
$this->assertSame($name, $testCase->getName());
}
public function testGetMessageReturnsMessage(): void
{
$message = 'Somehow incomplete, right?';
$testCase = new IncompleteTestCase(
'Foo',
'testThatBars',
$message
);
$this->assertSame($message, $testCase->getMessage());
}
public function testRunMarksTestAsIncomplete(): void
{
$className = 'Foo';
$methodName = 'testThatBars';
$message = 'Somehow incomplete, right?';
$testCase = new IncompleteTestCase(
$className,
$methodName,
$message
);
$result = $testCase->run();
$this->assertSame(BaseTestRunner::STATUS_INCOMPLETE, $testCase->getStatus());
$this->assertSame(1, $result->notImplementedCount());
$failures = $result->notImplemented();
$failure = \array_shift($failures);
$name = \sprintf(
'%s::%s',
$className,
$methodName
);
$this->assertSame($name, $failure->getTestName());
$this->assertSame($message, $failure->exceptionMessage());
}
}
PK ! !og # Framework/Constraint/IsJsonTest.phpnu Iw
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace PHPUnit\Framework\Constraint;
use PHPUnit\Framework\ExpectationFailedException;
use PHPUnit\Framework\TestFailure;
/**
* @small
*/
final class IsJsonTest extends ConstraintTestCase
{
public static function evaluateDataprovider(): array
{
return [
'valid JSON' => [true, '{}'],
'empty string should be treated as invalid JSON' => [false, ''],
];
}
/**
* @testdox Evaluate $_dataName
* @dataProvider evaluateDataprovider
*
* @throws \PHPUnit\Framework\ExpectationFailedException
* @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
*/
public function testEvaluate($expected, $jsonOther): void
{
$constraint = new IsJson;
$this->assertEquals($expected, $constraint->evaluate($jsonOther, '', true));
}
public function testIsJsonCanBeExportedAsString(): void
{
$isJson = new IsJson;
$this->assertSame('is valid JSON', $isJson->toString());
}
public function testIsJsonCanBeEmptyString(): void
{
$isJson = new IsJson;
try {
$isJson->evaluate('');
} catch (ExpectationFailedException $e) {
$this->assertEquals(
<<
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace PHPUnit\Framework\Constraint;
use PHPUnit\Framework\ExpectationFailedException;
use PHPUnit\Framework\TestFailure;
/**
* @small
*/
final class ClassHasAttributeTest extends ConstraintTestCase
{
public function testConstraintClassHasAttribute(): void
{
$constraint = new ClassHasAttribute(
'privateAttribute'
);
$this->assertTrue($constraint->evaluate(\ClassWithNonPublicAttributes::class, '', true));
$this->assertFalse($constraint->evaluate(\stdClass::class, '', true));
$this->assertEquals('has attribute "privateAttribute"', $constraint->toString());
$this->assertCount(1, $constraint);
try {
$constraint->evaluate(\stdClass::class);
} catch (ExpectationFailedException $e) {
$this->assertEquals(
<<fail();
}
public function testConstraintClassHasAttribute2(): void
{
$constraint = new ClassHasAttribute(
'privateAttribute'
);
try {
$constraint->evaluate(\stdClass::class, 'custom message');
} catch (ExpectationFailedException $e) {
$this->assertEquals(
<<fail();
}
}
PK ! {z# # $ Framework/Constraint/IsEmptyTest.phpnu Iw
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace PHPUnit\Framework\Constraint;
use PHPUnit\Framework\ExpectationFailedException;
use PHPUnit\Framework\TestFailure;
/**
* @small
*/
final class IsEmptyTest extends ConstraintTestCase
{
public function testConstraintIsEmpty(): void
{
$constraint = new IsEmpty;
$this->assertFalse($constraint->evaluate(['foo'], '', true));
$this->assertTrue($constraint->evaluate([], '', true));
$this->assertFalse($constraint->evaluate(new \ArrayObject(['foo']), '', true));
$this->assertTrue($constraint->evaluate(new \ArrayObject([]), '', true));
$this->assertEquals('is empty', $constraint->toString());
$this->assertCount(1, $constraint);
try {
$constraint->evaluate(['foo']);
} catch (ExpectationFailedException $e) {
$this->assertEquals(
<<fail();
}
public function testConstraintIsEmpty2(): void
{
$constraint = new IsEmpty;
try {
$constraint->evaluate(['foo'], 'custom message');
} catch (ExpectationFailedException $e) {
$this->assertEquals(
<<fail();
}
/**
* @ticket https://github.com/sebastianbergmann/phpunit/issues/3743
*/
public function test_EmptyIterator_is_handled_correctly(): void
{
$constraint = new IsEmpty;
$this->assertTrue($constraint->evaluate(new \EmptyIterator, '', true));
}
}
PK ! A9k' ' ' Framework/Constraint/FileExistsTest.phpnu Iw
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace PHPUnit\Framework\Constraint;
use PHPUnit\Framework\ExpectationFailedException;
use PHPUnit\Framework\TestFailure;
/**
* @small
*/
final class FileExistsTest extends ConstraintTestCase
{
public function testConstraintFileExists(): void
{
$constraint = new FileExists;
$this->assertFalse($constraint->evaluate('foo', '', true));
$this->assertEquals('file exists', $constraint->toString());
$this->assertCount(1, $constraint);
try {
$constraint->evaluate('foo');
} catch (ExpectationFailedException $e) {
$this->assertEquals(
<<fail();
}
public function testConstraintFileExists2(): void
{
$constraint = new FileExists;
try {
$constraint->evaluate('foo', 'custom message');
} catch (ExpectationFailedException $e) {
$this->assertEquals(
<<fail();
}
}
PK ! EiA A ' Framework/Constraint/IsWritableTest.phpnu Iw
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace PHPUnit\Framework\Constraint;
use PHPUnit\Framework\ExpectationFailedException;
use PHPUnit\Framework\TestFailure;
/**
* @small
*/
final class IsWritableTest extends ConstraintTestCase
{
public function testConstraintIsWritable(): void
{
$constraint = new IsWritable;
$this->assertFalse($constraint->evaluate('foo', '', true));
$this->assertEquals('is writable', $constraint->toString());
$this->assertCount(1, $constraint);
try {
$constraint->evaluate('foo');
} catch (ExpectationFailedException $e) {
$this->assertEquals(
<<fail();
}
}
PK ! \@ + Framework/Constraint/ConstraintTestCase.phpnu Iw
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace PHPUnit\Framework\Constraint;
use PHPUnit\Framework\SelfDescribing;
use PHPUnit\Framework\TestCase;
/**
* @small
*/
abstract class ConstraintTestCase extends TestCase
{
final public function testIsCountable(): void
{
$className = $this->className();
$reflection = new \ReflectionClass($className);
$this->assertTrue($reflection->implementsInterface(\Countable::class), \sprintf(
'Failed to assert that "%s" implements "%s".',
$className,
\Countable::class
));
}
final public function testIsSelfDescribing(): void
{
$className = $this->className();
$reflection = new \ReflectionClass($className);
$this->assertTrue($reflection->implementsInterface(SelfDescribing::class), \sprintf(
'Failed to assert that "%s" implements "%s".',
$className,
SelfDescribing::class
));
}
/**
* Returns the class name of the constraint.
*/
final protected function className(): string
{
return \preg_replace(
'/Test$/',
'',
static::class
);
}
}
PK ! kZ < Framework/Constraint/JsonMatchesErrorMessageProviderTest.phpnu Iw
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace PHPUnit\Framework\Constraint;
use PHPUnit\Framework\TestCase;
/**
* @small
*/
final class JsonMatchesErrorMessageProviderTest extends TestCase
{
public static function determineJsonErrorDataprovider(): array
{
return [
'JSON_ERROR_NONE' => [
null, 'json_error_none', '',
],
'JSON_ERROR_DEPTH' => [
'Maximum stack depth exceeded', \JSON_ERROR_DEPTH, '',
],
'prefixed JSON_ERROR_DEPTH' => [
'TUX: Maximum stack depth exceeded', \JSON_ERROR_DEPTH, 'TUX: ',
],
'JSON_ERROR_STATE_MISMatch' => [
'Underflow or the modes mismatch', \JSON_ERROR_STATE_MISMATCH, '',
],
'JSON_ERROR_CTRL_CHAR' => [
'Unexpected control character found', \JSON_ERROR_CTRL_CHAR, '',
],
'JSON_ERROR_SYNTAX' => [
'Syntax error, malformed JSON', \JSON_ERROR_SYNTAX, '',
],
'JSON_ERROR_UTF8`' => [
'Malformed UTF-8 characters, possibly incorrectly encoded',
\JSON_ERROR_UTF8,
'',
],
'Invalid error indicator' => [
'Unknown error', 55, '',
],
];
}
public static function translateTypeToPrefixDataprovider(): array
{
return [
'expected' => ['Expected value JSON decode error - ', 'expected'],
'actual' => ['Actual value JSON decode error - ', 'actual'],
'default' => ['', ''],
];
}
/**
* @dataProvider translateTypeToPrefixDataprovider
*
* @throws \PHPUnit\Framework\ExpectationFailedException
* @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
*/
public function testTranslateTypeToPrefix($expected, $type): void
{
$this->assertEquals(
$expected,
JsonMatchesErrorMessageProvider::translateTypeToPrefix($type)
);
}
/**
* @testdox Determine JSON error $_dataName
* @dataProvider determineJsonErrorDataprovider
*
* @throws \PHPUnit\Framework\ExpectationFailedException
* @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
*/
public function testDetermineJsonError($expected, $error, $prefix): void
{
$this->assertEquals(
$expected,
JsonMatchesErrorMessageProvider::determineJsonError(
(string) $error,
$prefix
)
);
}
}
PK ! & Framework/Constraint/LogicalOrTest.phpnu Iw
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace PHPUnit\Framework\Constraint;
use PHPUnit\Framework\ExpectationFailedException;
use PHPUnit\Framework\TestFailure;
/**
* @small
*/
final class LogicalOrTest extends ConstraintTestCase
{
public function testSetConstraintsDecoratesNonConstraintWithIsEqual(): void
{
$constraints = [
new \stdClass,
];
$constraint = new LogicalOr;
$constraint->setConstraints($constraints);
$this->assertTrue($constraint->evaluate(new \stdClass, '', true));
}
public function testCountReturnsCountOfComposedConstraints(): void
{
$counts = [
3,
5,
8,
];
$constraints = \array_map(function (int $count) {
return \CountConstraint::fromCount($count);
}, $counts);
$constraint = new LogicalOr;
$constraint->setConstraints($constraints);
$expected = \array_sum($counts);
$this->assertSame($expected, $constraint->count());
}
public function testToStringReturnsImplodedStringRepresentationOfComposedConstraintsGluedWithOr(): void
{
$names = [
'is healthy',
'is rich in amino acids',
'is rich in unsaturated fats',
];
$constraints = \array_map(function (string $name) {
return \NamedConstraint::fromName($name);
}, $names);
$constraint = new LogicalOr;
$constraint->setConstraints($constraints);
$expected = \implode(' or ', $names);
$this->assertSame($expected, $constraint->toString());
}
/**
* @dataProvider providerFailingConstraints
*
* @param Constraint[] $constraints
*/
public function testEvaluateReturnsFalseIfAllOfTheComposedConstraintsEvaluateToFalse(array $constraints): void
{
$constraint = new LogicalOr;
$constraint->setConstraints($constraints);
$this->assertFalse($constraint->evaluate('whatever', '', true));
}
/**
* @dataProvider providerSucceedingConstraints
*
* @param Constraint[] $constraints
*/
public function testEvaluateReturnsTrueIfAnyOfTheComposedConstraintsEvaluateToTrue(array $constraints): void
{
$constraint = LogicalOr::fromConstraints(...$constraints);
$this->assertTrue($constraint->evaluate('whatever', '', true));
}
/**
* @dataProvider providerFailingConstraints
*
* @param Constraint[] $constraints
*/
public function testEvaluateThrowsExceptionIfAllOfTheComposedConstraintsEvaluateToFalse(array $constraints): void
{
$other = 'whatever';
$constraint = new LogicalOr;
$constraint->setConstraints($constraints);
try {
$constraint->evaluate($other);
} catch (ExpectationFailedException $exception) {
$toString = $this->stringify($constraints);
$expectedDescription = <<assertEquals($expectedDescription, TestFailure::exceptionToString($exception));
return;
}
$this->fail();
}
/**
* @dataProvider providerFailingConstraints
*
* @param Constraint[] $constraints
*/
public function testEvaluateThrowsExceptionWithCustomMessageIfAllOfTheComposedConstraintsEvaluateToFalse(array $constraints): void
{
$other = 'whatever';
$customDescription = 'Not very happy about the results at this point in time, I have to admit!';
$constraint = new LogicalOr;
$constraint->setConstraints($constraints);
try {
$constraint->evaluate(
$other,
$customDescription
);
} catch (ExpectationFailedException $exception) {
$toString = $this->stringify($constraints);
$expectedDescription = <<assertEquals($expectedDescription, TestFailure::exceptionToString($exception));
return;
}
$this->fail();
}
/**
* @dataProvider providerSucceedingConstraints
*
* @param Constraint[] $constraints
*/
public function testEvaluateReturnsNothingIfAnyOfTheComposedConstraintsEvaluateToTrue(array $constraints): void
{
$constraint = new LogicalOr;
$constraint->setConstraints($constraints);
$this->assertNull($constraint->evaluate('whatever'));
}
public function providerFailingConstraints(): \Generator
{
$values = [
'single' => [
new \FalsyConstraint,
new \FalsyConstraint,
new \FalsyConstraint,
],
'multiple' => [
new \FalsyConstraint,
new \FalsyConstraint,
new \FalsyConstraint,
],
];
foreach ($values as $key => $constraints) {
yield $key => [
$constraints,
];
}
}
public function providerSucceedingConstraints(): \Generator
{
$values = [
'single' => [
new \TruthyConstraint,
],
'multiple' => [
new \FalsyConstraint,
new \TruthyConstraint,
new \FalsyConstraint,
],
];
foreach ($values as $key => $constraints) {
yield $key => [
$constraints,
];
}
}
private function stringify(array $constraints): string
{
return \implode(
' or ',
\array_map(function (Constraint $constraint) {
return $constraint->toString();
}, $constraints)
);
}
}
PK ! '`1 , Framework/Constraint/DirectoryExistsTest.phpnu Iw
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace PHPUnit\Framework\Constraint;
use PHPUnit\Framework\ExpectationFailedException;
use PHPUnit\Framework\TestFailure;
/**
* @small
*/
final class DirectoryExistsTest extends ConstraintTestCase
{
public function testDefaults(): void
{
$constraint = new DirectoryExists;
$this->assertCount(1, $constraint);
$this->assertSame('directory exists', $constraint->toString());
}
public function testEvaluateReturnsFalseWhenDirectoryDoesNotExist(): void
{
$directory = __DIR__ . '/NonExistentDirectory';
$constraint = new DirectoryExists;
$this->assertFalse($constraint->evaluate($directory, '', true));
}
public function testEvaluateReturnsTrueWhenDirectoryExists(): void
{
$directory = __DIR__;
$constraint = new DirectoryExists;
$this->assertTrue($constraint->evaluate($directory, '', true));
}
public function testEvaluateThrowsExpectationFailedExceptionWhenDirectoryDoesNotExist(): void
{
$directory = __DIR__ . '/NonExistentDirectory';
$constraint = new DirectoryExists;
try {
$constraint->evaluate($directory);
} catch (ExpectationFailedException $e) {
$this->assertSame(
<<fail();
}
}
PK ! ,
' Framework/Constraint/LogicalXorTest.phpnu Iw
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace Framework\Constraint;
use PHPUnit\Framework\Constraint\Constraint;
use PHPUnit\Framework\Constraint\LogicalXor;
use PHPUnit\Framework\TestCase;
/**
* @small
*/
final class LogicalXorTest extends TestCase
{
public function testFromConstraintsReturnsConstraint(): void
{
$other = 'Foo';
$count = 5;
$constraints = \array_map(function () use ($other) {
static $count = 0;
$constraint = $this->getMockBuilder(Constraint::class)->getMock();
$constraint
->expects($this->once())
->method('evaluate')
->with($this->identicalTo($other))
->willReturn($count % 2 === 1);
++$count;
return $constraint;
}, \array_fill(0, $count, null));
$constraint = LogicalXor::fromConstraints(...$constraints);
$this->assertInstanceOf(LogicalXor::class, $constraint);
$this->assertTrue($constraint->evaluate($other, '', true));
}
public function testSetConstraintsWithNonConstraintsObjectArrayIsTreatedAsIsEqual(): void
{
$constraint = new LogicalXor;
$constraint->setConstraints(['cuckoo']);
$this->assertSame('is equal to \'cuckoo\'', $constraint->toString());
}
}
PK ! %" " ( Framework/Constraint/ArraySubsetTest.phpnu Iw
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace PHPUnit\Framework\Constraint;
use PHPUnit\Framework\ExpectationFailedException;
/**
* @small
*/
final class ArraySubsetTest extends ConstraintTestCase
{
public static function evaluateDataProvider(): array
{
return [
'loose array subset and array other' => [
'expected' => true,
'subset' => ['bar' => 0],
'other' => ['foo' => '', 'bar' => '0'],
'strict' => false,
],
'strict array subset and array other' => [
'expected' => false,
'subset' => ['bar' => 0],
'other' => ['foo' => '', 'bar' => '0'],
'strict' => true,
],
'loose array subset and ArrayObject other' => [
'expected' => true,
'subset' => ['bar' => 0],
'other' => new \ArrayObject(['foo' => '', 'bar' => '0']),
'strict' => false,
],
'strict ArrayObject subset and array other' => [
'expected' => true,
'subset' => new \ArrayObject(['bar' => 0]),
'other' => ['foo' => '', 'bar' => 0],
'strict' => true,
],
];
}
/**
* @param bool $expected
* @param array|\Traversable $subset
* @param array|\Traversable $other
* @param bool $strict
*
* @throws ExpectationFailedException
* @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
* @dataProvider evaluateDataProvider
*/
public function testEvaluate($expected, $subset, $other, $strict): void
{
$constraint = new ArraySubset($subset, $strict);
$this->assertSame($expected, $constraint->evaluate($other, '', true));
}
public function testEvaluateWithArrayAccess(): void
{
$arrayAccess = new \ArrayAccessible(['foo' => 'bar']);
$constraint = new ArraySubset(['foo' => 'bar']);
$this->assertTrue($constraint->evaluate($arrayAccess, '', true));
}
public function testEvaluateFailMessage(): void
{
$constraint = new ArraySubset(['foo' => 'bar']);
try {
$constraint->evaluate(['baz' => 'bar'], '', false);
$this->fail(\sprintf('Expected %s to be thrown.', ExpectationFailedException::class));
} catch (ExpectationFailedException $expectedException) {
$comparisonFailure = $expectedException->getComparisonFailure();
$this->assertNotNull($comparisonFailure);
$this->assertStringContainsString("'foo' => 'bar'", $comparisonFailure->getExpectedAsString());
$this->assertStringContainsString("'baz' => 'bar'", $comparisonFailure->getActualAsString());
}
}
}
PK ! 0 Framework/Constraint/TraversableContainsTest.phpnu Iw
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace PHPUnit\Framework\Constraint;
use PHPUnit\Framework\ExpectationFailedException;
use PHPUnit\Framework\TestFailure;
/**
* @small
*/
final class TraversableContainsTest extends ConstraintTestCase
{
public function testConstraintTraversableCheckForNonObjectIdentityForDefaultCase(): void
{
$constraint = new TraversableContains('foo', true, true);
$this->assertTrue($constraint->evaluate(['foo'], '', true));
}
public function testConstraintTraversableCheckForObjectIdentityForDefaultCase(): void
{
$constraint = new TraversableContains('foo');
$this->assertTrue($constraint->evaluate([0], '', true));
$this->assertTrue($constraint->evaluate([true], '', true));
}
public function testConstraintTraversableCheckForObjectIdentityForPrimitiveType(): void
{
$constraint = new TraversableContains('foo', true, true);
$this->assertFalse($constraint->evaluate([0], '', true));
$this->assertFalse($constraint->evaluate([true], '', true));
}
public function testConstraintTraversableWithRightValue(): void
{
$constraint = new TraversableContains('foo');
$this->assertTrue($constraint->evaluate(['foo'], '', true));
}
public function testConstraintTraversableWithFailValue(): void
{
$constraint = new TraversableContains('foo');
$this->assertFalse($constraint->evaluate(['bar'], '', true));
}
public function testConstraintTraversableCountMethods(): void
{
$constraint = new TraversableContains('foo');
$this->assertCount(1, $constraint);
}
public function testConstraintTraversableEvaluateMethodWithFailExample(): void
{
$constraint = new TraversableContains('foo');
try {
$constraint->evaluate(['bar']);
} catch (ExpectationFailedException $e) {
$this->assertEquals(
<<fail();
}
public function testConstraintTraversableEvaluateMethodWithFailExample2(): void
{
$constraint = new TraversableContains('foo' . "\n");
try {
$constraint->evaluate(['bar']);
} catch (ExpectationFailedException $e) {
$this->assertEquals(
<<fail();
}
public function testConstraintTraversableEvaluateMethodWithFailExampleWithCustomMessage(): void
{
$constraint = new TraversableContains('foo');
try {
$constraint->evaluate(['bar'], 'custom message');
} catch (ExpectationFailedException $e) {
$this->assertEquals(
<<fail();
}
public function testConstraintTraversableToStringMethodsWithStdClass(): void
{
$object = new \stdClass;
$constraint = new TraversableContains($object);
$this->assertStringMatchesFormat('contains stdClass Object &%s ()', $constraint->toString());
}
public function testConstraintTraversableToStringMethods(): void
{
$constraint = new TraversableContains('foo');
$this->assertEquals("contains 'foo'", $constraint->toString());
}
public function testConstraintTraversableToStringMethodsWithSplObjectStorage(): void
{
$object = new \stdClass;
$constraint = new TraversableContains($object);
$storage = new \SplObjectStorage;
$this->assertFalse($constraint->evaluate($storage, '', true));
$storage->attach($object);
$this->assertTrue($constraint->evaluate($storage, '', true));
}
public function testConstraintTraversableStdClassForFailSplObjectStorage(): void
{
$object = new \stdClass;
$constraint = new TraversableContains($object);
try {
$constraint->evaluate(new \SplObjectStorage);
} catch (ExpectationFailedException $e) {
$this->assertStringMatchesFormat(
<<fail();
}
public function testConstraintTraversableStdClassForFailSplObjectStorageWithCustomMessage(): void
{
$object = new \stdClass;
$constraint = new TraversableContains($object);
try {
$constraint->evaluate(new \SplObjectStorage, 'custom message');
} catch (ExpectationFailedException $e) {
$this->assertStringMatchesFormat(
<<fail();
}
}
PK ! ~0 * Framework/Constraint/ExceptionCodeTest.phpnu Iw
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace PHPUnit\Framework\Constraint;
use PHPUnit\Framework\ExpectationFailedException;
use PHPUnit\Framework\TestCase;
use PHPUnit\Framework\TestFailure;
class ExceptionCodeTest extends TestCase
{
public function testExceptionCodeCanEvaluateExceptions(): void
{
$exceptionCode = new ExceptionCode(123);
$other = new \Exception('bla', 456);
try {
$exceptionCode->evaluate($other);
} catch (ExpectationFailedException $e) {
$this->assertEquals(
<<assertSame('exception code is ', $exceptionCode->toString());
}
}
PK ! g3l - Framework/Constraint/ExceptionMessageTest.phpnu Iw
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace PHPUnit\Framework\Constraint;
use PHPUnit\Framework\TestCase;
/**
* @small
*/
final class ExceptionMessageTest extends TestCase
{
public function testLiteralMessage(): void
{
$this->expectException(\Exception::class);
$this->expectExceptionMessage('A literal exception message');
throw new \Exception('A literal exception message');
}
public function testPartialMessageBegin(): void
{
$this->expectException(\Exception::class);
$this->expectExceptionMessage('A partial');
throw new \Exception('A partial exception message');
}
public function testPartialMessageMiddle(): void
{
$this->expectException(\Exception::class);
$this->expectExceptionMessage('partial exception');
throw new \Exception('A partial exception message');
}
public function testPartialMessageEnd(): void
{
$this->expectException(\Exception::class);
$this->expectExceptionMessage('exception message');
throw new \Exception('A partial exception message');
}
public function testEmptyMessageExportToString(): void
{
$exceptionMessage = new ExceptionMessage('');
$this->assertSame('exception message is empty', $exceptionMessage->toString());
}
public function testMessageExportToString(): void
{
$exceptionMessage = new ExceptionMessage('test');
$this->assertSame('exception message contains ', $exceptionMessage->toString());
}
}
PK ! [ ' Framework/Constraint/LogicalAndTest.phpnu Iw
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace PHPUnit\Framework\Constraint;
use PHPUnit\Framework\Exception;
use PHPUnit\Framework\ExpectationFailedException;
use PHPUnit\Framework\TestFailure;
/**
* @small
*/
final class LogicalAndTest extends ConstraintTestCase
{
public function testSetConstraintsRejectsInvalidConstraint(): void
{
$constraints = [
new \TruthyConstraint,
new \FalsyConstraint,
new \stdClass,
];
$constraint = new LogicalAnd;
$this->expectException(Exception::class);
$this->expectExceptionMessage(\sprintf(
'All parameters to %s must be a constraint object.',
LogicalAnd::class
));
$constraint->setConstraints($constraints);
}
public function testCountReturnsCountOfComposedConstraints(): void
{
$counts = [
3,
5,
8,
];
$constraints = \array_map(function (int $count) {
return \CountConstraint::fromCount($count);
}, $counts);
$constraint = new LogicalAnd;
$constraint->setConstraints($constraints);
$expected = \array_sum($counts);
$this->assertSame($expected, $constraint->count());
}
public function testToStringReturnsImplodedStringRepresentationOfComposedConstraintsGluedWithAnd(): void
{
$names = [
'is healthy',
'is rich in amino acids',
'is rich in unsaturated fats',
];
$constraints = \array_map(function (string $name) {
return \NamedConstraint::fromName($name);
}, $names);
$constraint = LogicalAnd::fromConstraints(...$constraints);
$expected = \implode(' and ', $names);
$this->assertSame($expected, $constraint->toString());
}
/**
* @dataProvider providerFailingConstraints
*
* @param Constraint[] $constraints
*/
public function testEvaluateReturnsFalseIfAnyOfTheComposedConstraintsEvaluateToFalse(array $constraints): void
{
$constraint = new LogicalAnd;
$constraint->setConstraints($constraints);
$this->assertFalse($constraint->evaluate('whatever', '', true));
}
/**
* @dataProvider providerSucceedingConstraints
*
* @param Constraint[] $constraints
*/
public function testEvaluateReturnsTrueIfAllOfTheComposedConstraintsEvaluateToTrue(array $constraints): void
{
$constraint = new LogicalAnd;
$constraint->setConstraints($constraints);
$this->assertTrue($constraint->evaluate('whatever', '', true));
}
/**
* @dataProvider providerFailingConstraints
*
* @param Constraint[] $constraints
*/
public function testEvaluateThrowsExceptionIfAnyOfTheComposedConstraintsEvaluateToFalse(array $constraints): void
{
$other = 'whatever';
$constraint = new LogicalAnd;
$constraint->setConstraints($constraints);
try {
$constraint->evaluate($other);
} catch (ExpectationFailedException $exception) {
$toString = $this->stringify($constraints);
$expectedDescription = <<assertEquals($expectedDescription, TestFailure::exceptionToString($exception));
return;
}
$this->fail();
}
/**
* @dataProvider providerFailingConstraints
*
* @param Constraint[] $constraints
*/
public function testEvaluateThrowsExceptionWithCustomMessageIfAnyOfTheComposedConstraintsEvaluateToFalse(array $constraints): void
{
$other = 'whatever';
$customDescription = 'Not very happy about the results at this point in time, I have to admit!';
$constraint = new LogicalAnd;
$constraint->setConstraints($constraints);
try {
$constraint->evaluate(
$other,
$customDescription
);
} catch (ExpectationFailedException $exception) {
$toString = $this->stringify($constraints);
$expectedDescription = <<assertEquals($expectedDescription, TestFailure::exceptionToString($exception));
return;
}
$this->fail();
}
/**
* @dataProvider providerSucceedingConstraints
*
* @param Constraint[] $constraints
*/
public function testEvaluateReturnsNothingIfAllOfTheComposedConstraintsEvaluateToTrue(array $constraints): void
{
$constraint = new LogicalAnd;
$constraint->setConstraints($constraints);
$this->assertNull($constraint->evaluate('whatever'));
}
public function providerFailingConstraints(): \Generator
{
$values = [
'single' => [
new \FalsyConstraint,
],
'multiple' => [
new \TruthyConstraint,
new \FalsyConstraint,
new \TruthyConstraint,
],
];
foreach ($values as $key => $constraints) {
yield $key => [
$constraints,
];
}
}
public function providerSucceedingConstraints(): \Generator
{
$values = [
'single' => [
new \TruthyConstraint,
],
'multiple' => [
new \TruthyConstraint,
new \TruthyConstraint,
new \TruthyConstraint,
],
];
foreach ($values as $key => $constraints) {
yield $key => [
$constraints,
];
}
}
private function stringify(array $constraints): string
{
return \implode(
' and ',
\array_map(function (Constraint $constraint) {
return $constraint->toString();
}, $constraints)
);
}
}
PK ! 4U U & Framework/Constraint/ExceptionTest.phpnu Iw
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace PHPUnit\Framework\Constraint;
use PHPUnit\Framework\TestCase;
class ExceptionTest extends TestCase
{
public function testExceptionCanBeExportedAsString(): void
{
$exception = new Exception(Exception::class);
$this->assertSame('exception of type "' . Exception::class . '"', $exception->toString());
}
}
PK ! )J - Framework/Constraint/StringStartsWithTest.phpnu Iw
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace PHPUnit\Framework\Constraint;
use PHPUnit\Framework\ExpectationFailedException;
use PHPUnit\Framework\TestFailure;
/**
* @small
*/
final class StringStartsWithTest extends ConstraintTestCase
{
public function testConstraintStringStartsWithCorrectValueAndReturnResult(): void
{
$constraint = new StringStartsWith('prefix');
$this->assertTrue($constraint->evaluate('prefixfoo', '', true));
}
public function testConstraintStringStartsWithNotCorrectValueAndReturnResult(): void
{
$constraint = new StringStartsWith('prefix');
$this->assertFalse($constraint->evaluate('error', '', true));
}
public function testConstraintStringStartsWithCorrectNumericValueAndReturnResult(): void
{
$constraint = new StringStartsWith('0E1');
$this->assertTrue($constraint->evaluate('0E1zzz', '', true));
}
public function testConstraintStringStartsWithCorrectSingleZeroAndReturnResult(): void
{
$constraint = new StringStartsWith('0');
$this->assertTrue($constraint->evaluate('0ABC', '', true));
}
public function testConstraintStringStartsWithNotCorrectNumericValueAndReturnResult(): void
{
$constraint = new StringStartsWith('0E1');
$this->assertFalse($constraint->evaluate('0E2zzz', '', true));
}
public function testConstraintStringStartsWithToStringMethod(): void
{
$constraint = new StringStartsWith('prefix');
$this->assertEquals('starts with "prefix"', $constraint->toString());
}
public function testConstraintStringStartsWitCountMethod(): void
{
$constraint = new StringStartsWith('prefix');
$this->assertCount(1, $constraint);
}
public function testConstraintStringStartsWithNotCorrectValueAndExpectation(): void
{
$constraint = new StringStartsWith('prefix');
try {
$constraint->evaluate('error');
} catch (ExpectationFailedException $e) {
$this->assertEquals(
<<fail();
}
public function testConstraintStringStartsWithNotCorrectValueExceptionAndCustomMessage(): void
{
$constraint = new StringStartsWith('prefix');
try {
$constraint->evaluate('error', 'custom message');
} catch (ExpectationFailedException $e) {
$this->assertEquals(
<<fail();
}
}
PK ! ߶K ) Framework/Constraint/IsInstanceOfTest.phpnu Iw
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace PHPUnit\Framework\Constraint;
use PHPUnit\Framework\ExpectationFailedException;
use PHPUnit\Framework\TestFailure;
/**
* @small
*/
final class IsInstanceOfTest extends ConstraintTestCase
{
public function testConstraintInstanceOf(): void
{
$constraint = new IsInstanceOf(\stdClass::class);
self::assertTrue($constraint->evaluate(new \stdClass, '', true));
}
public function testConstraintFailsOnString(): void
{
$constraint = new IsInstanceOf(\stdClass::class);
try {
$constraint->evaluate('stdClass');
} catch (ExpectationFailedException $e) {
self::assertSame(
<<throwException(new \ReflectionException);
$constraint = new IsInstanceOf(NotExistingClass::class);
self::assertSame(
'is instance of class "PHPUnit\Framework\Constraint\NotExistingClass"',
$constraint->toString()
);
}
}
PK ! !xd d + Framework/Constraint/StringContainsTest.phpnu Iw
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace PHPUnit\Framework\Constraint;
use PHPUnit\Framework\ExpectationFailedException;
use PHPUnit\Framework\TestFailure;
/**
* @small
*/
final class StringContainsTest extends ConstraintTestCase
{
public function testConstraintStringContains(): void
{
$constraint = new StringContains('foo');
$this->assertFalse($constraint->evaluate('barbazbar', '', true));
$this->assertTrue($constraint->evaluate('barfoobar', '', true));
$this->assertEquals('contains "foo"', $constraint->toString());
$this->assertCount(1, $constraint);
try {
$constraint->evaluate('barbazbar');
} catch (ExpectationFailedException $e) {
$this->assertEquals(
<<fail();
}
public function testConstraintStringContainsWhenIgnoreCase(): void
{
$constraint = new StringContains('oryginał', true);
$this->assertFalse($constraint->evaluate('oryginal', '', true));
$this->assertTrue($constraint->evaluate('ORYGINAŁ', '', true));
$this->assertTrue($constraint->evaluate('oryginał', '', true));
$this->assertEquals('contains "oryginał"', $constraint->toString());
$this->assertCount(1, $constraint);
$this->expectException(ExpectationFailedException::class);
$constraint->evaluate('oryginal');
}
public function testConstraintStringContainsForUtf8StringWhenNotIgnoreCase(): void
{
$constraint = new StringContains('oryginał', false);
$this->assertFalse($constraint->evaluate('oryginal', '', true));
$this->assertFalse($constraint->evaluate('ORYGINAŁ', '', true));
$this->assertTrue($constraint->evaluate('oryginał', '', true));
$this->assertEquals('contains "oryginał"', $constraint->toString());
$this->assertCount(1, $constraint);
$this->expectException(ExpectationFailedException::class);
$constraint->evaluate('oryginal');
}
public function testConstraintStringContains2(): void
{
$constraint = new StringContains('foo');
try {
$constraint->evaluate('barbazbar', 'custom message');
} catch (ExpectationFailedException $e) {
$this->assertEquals(
<<fail();
}
public function testEvaluateEmptyStringInFoo(): void
{
$stringContains = new StringContains('');
$stringContains->evaluate('foo');
$this->assertSame('contains ""', $stringContains->toString());
}
}
PK ! d $ Framework/Constraint/IsEqualTest.phpnu Iw
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace PHPUnit\Framework\Constraint;
use PHPUnit\Framework\ExpectationFailedException;
use PHPUnit\Framework\TestFailure;
/**
* @small
*/
final class IsEqualTest extends ConstraintTestCase
{
public function testConstraintIsEqual(): void
{
$constraint = new IsEqual(1);
$this->assertTrue($constraint->evaluate(1, '', true));
$this->assertFalse($constraint->evaluate(0, '', true));
$this->assertEquals('is equal to 1', $constraint->toString());
$this->assertCount(1, $constraint);
try {
$constraint->evaluate(0);
} catch (ExpectationFailedException $e) {
$this->assertEquals(
<<fail();
}
/**
* @dataProvider isEqualProvider
*/
public function testConstraintIsEqual2($expected, $actual, $message): void
{
$constraint = new IsEqual($expected);
try {
$constraint->evaluate($actual, 'custom message');
} catch (ExpectationFailedException $e) {
$this->assertEquals(
"custom message\n$message",
$this->trimnl(TestFailure::exceptionToString($e))
);
return;
}
$this->fail();
}
public function testConstraintDeltaIsNotZero(): void
{
$constraint = new IsEqual(15, 1);
$this->assertSame('is equal to 15 with delta <1.000000>', $constraint->toString());
}
public function isEqualProvider(): array
{
$a = new \stdClass;
$a->foo = 'bar';
$b = new \stdClass;
$ahash = \spl_object_hash($a);
$bhash = \spl_object_hash($b);
$c = new \stdClass;
$c->foo = 'bar';
$c->int = 1;
$c->array = [0, [1], [2], 3];
$c->related = new \stdClass;
$c->related->foo = "a\nb\nc\nd\ne\nf\ng\nh\ni\nj\nk";
$c->self = $c;
$c->c = $c;
$d = new \stdClass;
$d->foo = 'bar';
$d->int = 2;
$d->array = [0, [4], [2], 3];
$d->related = new \stdClass;
$d->related->foo = "a\np\nc\nd\ne\nf\ng\nh\ni\nw\nk";
$d->self = $d;
$d->c = $c;
$storage1 = new \SplObjectStorage;
$storage1->attach($a);
$storage1->attach($b);
$storage2 = new \SplObjectStorage;
$storage2->attach($b);
$storage1hash = \spl_object_hash($storage1);
$storage2hash = \spl_object_hash($storage2);
$dom1 = new \DOMDocument;
$dom1->preserveWhiteSpace = false;
$dom1->loadXML(' 0
+ 0 => 1
)
EOF
],
[[true], ['true'], << true
+ 0 => 'true'
)
EOF
],
[[0, [1], [2], 3], [0, [4], [2], 3], << 0
1 => Array (
- 0 => 1
+ 0 => 4
)
2 => Array (...)
3 => 3
)
EOF
],
[$a, [0], << 'bar'
)
EOF
],
[$c, $d, << 'bar'
- 'int' => 1
+ 'int' => 2
'array' => Array (
0 => 0
1 => Array (
- 0 => 1
+ 0 => 4
)
2 => Array (...)
3 => 3
@@ @@
)
'related' => stdClass Object (
'foo' => 'a\\n
- b\\n
+ p\\n
c\\n
d\\n
e\\n
@@ @@
g\\n
h\\n
i\\n
- j\\n
+ w\\n
k'
)
'self' => stdClass Object (...)
'c' => stdClass Object (...)
)
EOF
],
[$dom1, $dom2, <<
-
+
EOF
],
[
new \DateTime('2013-03-29 04:13:35', new \DateTimeZone('America/New_York')),
new \DateTime('2013-03-29 04:13:35', new \DateTimeZone('America/Chicago')),
<< Array &0 (
- 'obj' => stdClass Object &$ahash (
- 'foo' => 'bar'
- )
- 'inf' => null
- )
- '$bhash' => Array &1 (
+SplObjectStorage Object &$storage2hash (
+ '$bhash' => Array &0 (
'obj' => stdClass Object &$bhash ()
'inf' => null
)
)
EOF
],
];
}
/**
* Removes spaces in front of newlines
*
* @param string $string
*
* @return string
*/
private function trimnl($string)
{
return \preg_replace('/[ ]*\n/', "\n", $string);
}
}
PK !
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace PHPUnit\Framework\Constraint;
use PHPUnit\Framework\TestCase;
class LogicalNotTest extends TestCase
{
public function testNonRestrictedConstructParameterIsTreatedAsIsEqual(): void
{
$constraint = new LogicalNot('test');
$this->assertSame('is not equal to \'test\'', $constraint->toString());
}
}
PK ! 85 ( Framework/Constraint/IsIdenticalTest.phpnu Iw
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace PHPUnit\Framework\Constraint;
use PHPUnit\Framework\ExpectationFailedException;
use PHPUnit\Framework\TestFailure;
/**
* @small
*/
final class IsIdenticalTest extends ConstraintTestCase
{
public function testConstraintIsIdentical(): void
{
$a = new \stdClass;
$b = new \stdClass;
$constraint = new IsIdentical($a);
$this->assertFalse($constraint->evaluate($b, '', true));
$this->assertTrue($constraint->evaluate($a, '', true));
$this->assertEquals('is identical to an object of class "stdClass"', $constraint->toString());
$this->assertCount(1, $constraint);
try {
$constraint->evaluate($b);
} catch (ExpectationFailedException $e) {
$this->assertEquals(
<<fail();
}
public function testConstraintIsIdentical2(): void
{
$a = new \stdClass;
$b = new \stdClass;
$constraint = new IsIdentical($a);
try {
$constraint->evaluate($b, 'custom message');
} catch (ExpectationFailedException $e) {
$this->assertEquals(
<<fail();
}
public function testConstraintIsIdentical3(): void
{
$constraint = new IsIdentical('a');
try {
$constraint->evaluate('b', 'custom message');
} catch (ExpectationFailedException $e) {
$this->assertEquals(
<<fail();
}
public function testConstraintIsIdenticalArrayDiff(): void
{
$expected = [1, 2, 3, 4, 5, 6];
$actual = [1, 2, 33, 4, 5, 6];
$constraint = new IsIdentical($expected);
try {
$constraint->evaluate($actual, 'custom message');
} catch (ExpectationFailedException $e) {
$this->assertSame(
<< 1
1 => 2
- 2 => 3
+ 2 => 33
3 => 4
4 => 5
5 => 6
)
EOF
,
TestFailure::exceptionToString($e)
);
return;
}
$this->fail();
}
public function testConstraintIsIdenticalNestedArrayDiff(): void
{
$expected = [
['A' => 'B'],
[
'C' => [
'D',
'E',
],
],
];
$actual = [
['A' => 'C'],
[
'C' => [
'C',
'E',
'F',
],
],
];
$constraint = new IsIdentical($expected);
try {
$constraint->evaluate($actual, 'custom message');
} catch (ExpectationFailedException $e) {
$this->assertEquals(
<< Array &1 (
- 'A' => 'B'
+ 'A' => 'C'
)
1 => Array &2 (
'C' => Array &3 (
- 0 => 'D'
+ 0 => 'C'
1 => 'E'
+ 2 => 'F'
)
)
)
EOF
,
TestFailure::exceptionToString($e)
);
return;
}
$this->fail();
}
}
PK ! % Framework/Constraint/SameSizeTest.phpnu Iw
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace PHPUnit\Framework\Constraint;
use PHPUnit\Framework\ExpectationFailedException;
use PHPUnit\Framework\TestFailure;
/**
* @small
*/
final class SameSizeTest extends ConstraintTestCase
{
public function testConstraintSameSizeWithAnArray(): void
{
$constraint = new SameSize([1, 2, 3, 4, 5]);
$this->assertTrue($constraint->evaluate([6, 7, 8, 9, 10], '', true));
$this->assertFalse($constraint->evaluate([1, 2, 3, 4], '', true));
}
public function testConstraintSameSizeWithAnIteratorWhichDoesNotImplementCountable(): void
{
$constraint = new SameSize(new \TestIterator([1, 2, 3, 4, 5]));
$this->assertTrue($constraint->evaluate(new \TestIterator([6, 7, 8, 9, 10]), '', true));
$this->assertFalse($constraint->evaluate(new \TestIterator([1, 2, 3, 4]), '', true));
}
public function testConstraintSameSizeWithAnObjectImplementingCountable(): void
{
$constraint = new SameSize(new \ArrayObject([1, 2, 3, 4, 5]));
$this->assertTrue($constraint->evaluate(new \ArrayObject([6, 7, 8, 9, 10]), '', true));
$this->assertFalse($constraint->evaluate(new \ArrayObject([1, 2, 3, 4]), '', true));
}
public function testConstraintSameSizeFailing(): void
{
$constraint = new SameSize([1, 2, 3, 4, 5]);
try {
$constraint->evaluate([1, 2]);
} catch (ExpectationFailedException $e) {
$this->assertEquals(
<<fail();
}
}
PK ! W W / Framework/Constraint/ObjectHasAttributeTest.phpnu Iw
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace PHPUnit\Framework\Constraint;
use PHPUnit\Framework\ExpectationFailedException;
use PHPUnit\Framework\TestFailure;
/**
* @small
*/
final class ObjectHasAttributeTest extends ConstraintTestCase
{
public function testConstraintObjectHasAttribute(): void
{
$constraint = new ObjectHasAttribute('privateAttribute');
$this->assertTrue($constraint->evaluate(new \ClassWithNonPublicAttributes, '', true));
$this->assertFalse($constraint->evaluate(new \stdClass, '', true));
$this->assertEquals('has attribute "privateAttribute"', $constraint->toString());
$this->assertCount(1, $constraint);
try {
$constraint->evaluate(new \stdClass);
} catch (ExpectationFailedException $e) {
$this->assertEquals(
<<fail();
}
public function testConstraintObjectHasAttribute2(): void
{
$constraint = new ObjectHasAttribute('privateAttribute');
try {
$constraint->evaluate(new \stdClass, 'custom message');
} catch (ExpectationFailedException $e) {
$this->assertEquals(
<<fail();
}
}
PK ! :+; ; # Framework/Constraint/IsTypeTest.phpnu Iw
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace PHPUnit\Framework\Constraint;
use PHPUnit\Framework\Assert;
use PHPUnit\Framework\ExpectationFailedException;
use PHPUnit\Framework\TestFailure;
/**
* @small
*/
final class IsTypeTest extends ConstraintTestCase
{
public function testConstraintIsType(): void
{
$constraint = Assert::isType('string');
$this->assertFalse($constraint->evaluate(0, '', true));
$this->assertTrue($constraint->evaluate('', '', true));
$this->assertEquals('is of type "string"', $constraint->toString());
$this->assertCount(1, $constraint);
try {
$constraint->evaluate(new \stdClass);
} catch (ExpectationFailedException $e) {
$this->assertStringMatchesFormat(
<<trimnl(TestFailure::exceptionToString($e))
);
return;
}
$this->fail();
}
public function testConstraintIsType2(): void
{
$constraint = Assert::isType('string');
try {
$constraint->evaluate(new \stdClass, 'custom message');
} catch (ExpectationFailedException $e) {
$this->assertStringMatchesFormat(
<<trimnl(TestFailure::exceptionToString($e))
);
return;
}
$this->fail();
}
/**
* @dataProvider resources
*/
public function testConstraintIsResourceTypeEvaluatesCorrectlyWithResources($resource): void
{
$constraint = Assert::isType('resource');
$this->assertTrue($constraint->evaluate($resource, '', true));
if (\is_resource($resource)) {
@\fclose($resource);
}
}
public function resources()
{
$fh = \fopen(__FILE__, 'r');
\fclose($fh);
return [
'open resource' => [\fopen(__FILE__, 'r')],
'closed resource' => [$fh],
];
}
public function testIterableTypeIsSupported(): void
{
$constraint = Assert::isType('iterable');
$this->assertFalse($constraint->evaluate('', '', true));
$this->assertTrue($constraint->evaluate([], '', true));
$this->assertEquals('is of type "iterable"', $constraint->toString());
}
public function testTypeCanBeNull(): void
{
$constraint = Assert::isType('null');
$this->assertNull($constraint->evaluate(null));
$this->assertEquals('is of type "null"', $constraint->toString());
}
public function testTypeCanNotBeAnUndefinedOne(): void
{
try {
Assert::isType('diverse');
} catch (\PHPUnit\Framework\Exception $e) {
$this->assertEquals(
<< is not a valid type.
EOF
,
TestFailure::exceptionToString($e)
);
}
}
/**
* Removes spaces in front of newlines
*
* @param string $string
*
* @return string
*/
private function trimnl($string)
{
return \preg_replace('/[ ]*\n/', "\n", $string);
}
}
PK ! ȟ . Framework/Constraint/RegularExpressionTest.phpnu Iw
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace PHPUnit\Framework\Constraint;
use PHPUnit\Framework\ExpectationFailedException;
use PHPUnit\Framework\TestFailure;
/**
* @small
*/
final class RegularExpressionTest extends ConstraintTestCase
{
public function testConstraintRegularExpression(): void
{
$constraint = new RegularExpression('/foo/');
$this->assertFalse($constraint->evaluate('barbazbar', '', true));
$this->assertTrue($constraint->evaluate('barfoobar', '', true));
$this->assertEquals('matches PCRE pattern "/foo/"', $constraint->toString());
$this->assertCount(1, $constraint);
try {
$constraint->evaluate('barbazbar');
} catch (ExpectationFailedException $e) {
$this->assertEquals(
<<fail();
}
public function testConstraintRegularExpression2(): void
{
$constraint = new RegularExpression('/foo/');
try {
$constraint->evaluate('barbazbar', 'custom message');
} catch (ExpectationFailedException $e) {
$this->assertEquals(
<<fail();
}
}
PK ! >î5 5 # Framework/Constraint/IsNullTest.phpnu Iw
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace PHPUnit\Framework\Constraint;
use PHPUnit\Framework\ExpectationFailedException;
use PHPUnit\Framework\TestFailure;
/**
* @small
*/
final class IsNullTest extends ConstraintTestCase
{
public function testConstraintIsNull(): void
{
$constraint = new IsNull;
$this->assertFalse($constraint->evaluate(0, '', true));
$this->assertTrue($constraint->evaluate(null, '', true));
$this->assertEquals('is null', $constraint->toString());
$this->assertCount(1, $constraint);
try {
$constraint->evaluate(0);
} catch (ExpectationFailedException $e) {
$this->assertEquals(
<<fail();
}
public function testConstraintIsNull2(): void
{
$constraint = new IsNull;
try {
$constraint->evaluate(0, 'custom message');
} catch (ExpectationFailedException $e) {
$this->assertEquals(
<<fail();
}
}
PK ! blT " Framework/Constraint/CountTest.phpnu Iw
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace PHPUnit\Framework\Constraint;
use PHPUnit\Framework\ExpectationFailedException;
use PHPUnit\Framework\TestFailure;
/**
* @small
*/
final class CountTest extends ConstraintTestCase
{
public function testCount(): void
{
$countConstraint = new Count(3);
$this->assertTrue($countConstraint->evaluate([1, 2, 3], '', true));
$countConstraint = new Count(0);
$this->assertTrue($countConstraint->evaluate([], '', true));
$countConstraint = new Count(2);
$it = new \TestIterator([1, 2]);
$ia = new \TestIteratorAggregate($it);
$ia2 = new \TestIteratorAggregate2($ia);
$this->assertTrue($countConstraint->evaluate($it, '', true));
$this->assertTrue($countConstraint->evaluate($ia, '', true));
$this->assertTrue($countConstraint->evaluate($ia2, '', true));
}
public function testCountDoesNotChangeIteratorKey(): void
{
$countConstraint = new Count(2);
// test with 1st implementation of Iterator
$it = new \TestIterator([1, 2]);
$countConstraint->evaluate($it, '', true);
$this->assertEquals(1, $it->current());
$it->next();
$countConstraint->evaluate($it, '', true);
$this->assertEquals(2, $it->current());
$it->next();
$countConstraint->evaluate($it, '', true);
$this->assertFalse($it->valid());
// test with 2nd implementation of Iterator
$it = new \TestIterator2([1, 2]);
$countConstraint = new Count(2);
$countConstraint->evaluate($it, '', true);
$this->assertEquals(1, $it->current());
$it->next();
$countConstraint->evaluate($it, '', true);
$this->assertEquals(2, $it->current());
$it->next();
$countConstraint->evaluate($it, '', true);
$this->assertFalse($it->valid());
// test with IteratorAggregate
$it = new \TestIterator([1, 2]);
$ia = new \TestIteratorAggregate($it);
$countConstraint = new Count(2);
$countConstraint->evaluate($ia, '', true);
$this->assertEquals(1, $it->current());
$it->next();
$countConstraint->evaluate($ia, '', true);
$this->assertEquals(2, $it->current());
$it->next();
$countConstraint->evaluate($ia, '', true);
$this->assertFalse($it->valid());
// test with nested IteratorAggregate
$it = new \TestIterator([1, 2]);
$ia = new \TestIteratorAggregate($it);
$ia2 = new \TestIteratorAggregate2($ia);
$countConstraint = new Count(2);
$countConstraint->evaluate($ia2, '', true);
$this->assertEquals(1, $it->current());
$it->next();
$countConstraint->evaluate($ia2, '', true);
$this->assertEquals(2, $it->current());
$it->next();
$countConstraint->evaluate($ia2, '', true);
$this->assertFalse($it->valid());
}
public function testCountGeneratorsDoNotRewind(): void
{
$generatorMaker = new \TestGeneratorMaker;
$countConstraint = new Count(3);
$generator = $generatorMaker->create([1, 2, 3]);
$this->assertEquals(1, $generator->current());
$countConstraint->evaluate($generator, '', true);
$this->assertEquals(null, $generator->current());
$countConstraint = new Count(2);
$generator = $generatorMaker->create([1, 2, 3]);
$this->assertEquals(1, $generator->current());
$generator->next();
$this->assertEquals(2, $generator->current());
$countConstraint->evaluate($generator, '', true);
$this->assertEquals(null, $generator->current());
$countConstraint = new Count(1);
$generator = $generatorMaker->create([1, 2, 3]);
$this->assertEquals(1, $generator->current());
$generator->next();
$this->assertEquals(2, $generator->current());
$generator->next();
$this->assertEquals(3, $generator->current());
$countConstraint->evaluate($generator, '', true);
$this->assertEquals(null, $generator->current());
}
public function testCountTraversable(): void
{
$countConstraint = new Count(5);
// DatePeriod is used as an object that is Traversable but does not
// implement Iterator or IteratorAggregate. The following ISO 8601
// recurring time interval will yield five total DateTime objects.
$datePeriod = new \DatePeriod('R4/2017-05-01T00:00:00Z/P1D');
$this->assertInstanceOf(\Traversable::class, $datePeriod);
$this->assertNotInstanceOf(\Iterator::class, $datePeriod);
$this->assertNotInstanceOf(\IteratorAggregate::class, $datePeriod);
$this->assertTrue($countConstraint->evaluate($datePeriod, '', true));
}
public function testCountCanBeExportedToString(): void
{
$countConstraint = new Count(1);
$this->assertEquals('count matches 1', $countConstraint->toString());
}
public function testCountEvaluateReturnsNullWithNonCountableAndNonTraversableOther(): void
{
$countConstraint = new Count(1);
try {
$this->assertNull($countConstraint->evaluate(1));
} catch (ExpectationFailedException $e) {
$this->assertEquals(
<<assertTrue($constraint->evaluate(new \EmptyIterator, '', true));
}
}
PK ! N`o o ( Framework/Constraint/GreaterThanTest.phpnu Iw
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace PHPUnit\Framework\Constraint;
use PHPUnit\Framework\ExpectationFailedException;
use PHPUnit\Framework\TestFailure;
/**
* @small
*/
final class GreaterThanTest extends ConstraintTestCase
{
public function testConstraintGreaterThan(): void
{
$constraint = new GreaterThan(1);
$this->assertFalse($constraint->evaluate(0, '', true));
$this->assertTrue($constraint->evaluate(2, '', true));
$this->assertEquals('is greater than 1', $constraint->toString());
$this->assertCount(1, $constraint);
try {
$constraint->evaluate(0);
} catch (ExpectationFailedException $e) {
$this->assertEquals(
<<fail();
}
public function testConstraintGreaterThan2(): void
{
$constraint = new GreaterThan(1);
try {
$constraint->evaluate(0, 'custom message');
} catch (ExpectationFailedException $e) {
$this->assertEquals(
<<fail();
}
}
PK ! 5. . ; Framework/Constraint/StringMatchesFormatDescriptionTest.phpnu Iw
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace PHPUnit\Framework\Constraint;
use PHPUnit\Framework\ExpectationFailedException;
/**
* @small
*/
final class StringMatchesFormatDescriptionTest extends ConstraintTestCase
{
public function testConstraintStringMatchesDirectorySeparator(): void
{
$constraint = new StringMatchesFormatDescription('*%e*');
$this->assertFalse($constraint->evaluate('**', '', true));
$this->assertFalse($constraint->evaluate('*a*', '', true));
$this->assertTrue($constraint->evaluate('*' . \DIRECTORY_SEPARATOR . '*', '', true));
$this->assertEquals('matches PCRE pattern "/^\*\\' . \DIRECTORY_SEPARATOR . '\*$/s"', $constraint->toString());
$this->assertCount(1, $constraint);
}
public function testConstraintStringMatchesString(): void
{
$constraint = new StringMatchesFormatDescription('*%s*');
$this->assertFalse($constraint->evaluate('**', '', true));
$this->assertFalse($constraint->evaluate("*\n*", '', true));
$this->assertTrue($constraint->evaluate('***', '', true));
$this->assertTrue($constraint->evaluate('*foo 123 bar*', '', true));
$this->assertEquals('matches PCRE pattern "/^\*[^\r\n]+\*$/s"', $constraint->toString());
$this->assertCount(1, $constraint);
}
public function testConstraintStringMatchesOptionalString(): void
{
$constraint = new StringMatchesFormatDescription('*%S*');
$this->assertFalse($constraint->evaluate('*', '', true));
$this->assertFalse($constraint->evaluate("*\n*", '', true));
$this->assertTrue($constraint->evaluate('***', '', true));
$this->assertTrue($constraint->evaluate('*foo 123 bar*', '', true));
$this->assertTrue($constraint->evaluate('**', '', true));
$this->assertEquals('matches PCRE pattern "/^\*[^\r\n]*\*$/s"', $constraint->toString());
$this->assertCount(1, $constraint);
}
public function testConstraintStringMatchesAnything(): void
{
$constraint = new StringMatchesFormatDescription('*%a*');
$this->assertFalse($constraint->evaluate('**', '', true));
$this->assertTrue($constraint->evaluate('***', '', true));
$this->assertTrue($constraint->evaluate('*foo 123 bar*', '', true));
$this->assertTrue($constraint->evaluate("*\n*", '', true));
$this->assertEquals('matches PCRE pattern "/^\*.+\*$/s"', $constraint->toString());
$this->assertCount(1, $constraint);
}
public function testConstraintStringMatchesOptionalAnything(): void
{
$constraint = new StringMatchesFormatDescription('*%A*');
$this->assertFalse($constraint->evaluate('*', '', true));
$this->assertTrue($constraint->evaluate('***', '', true));
$this->assertTrue($constraint->evaluate('*foo 123 bar*', '', true));
$this->assertTrue($constraint->evaluate("*\n*", '', true));
$this->assertTrue($constraint->evaluate('**', '', true));
$this->assertEquals('matches PCRE pattern "/^\*.*\*$/s"', $constraint->toString());
$this->assertCount(1, $constraint);
}
public function testConstraintStringMatchesWhitespace(): void
{
$constraint = new StringMatchesFormatDescription('*%w*');
$this->assertFalse($constraint->evaluate('*', '', true));
$this->assertFalse($constraint->evaluate('*a*', '', true));
$this->assertTrue($constraint->evaluate('* *', '', true));
$this->assertTrue($constraint->evaluate("*\t\n*", '', true));
$this->assertTrue($constraint->evaluate('**', '', true));
$this->assertEquals('matches PCRE pattern "/^\*\s*\*$/s"', $constraint->toString());
$this->assertCount(1, $constraint);
}
public function testConstraintStringMatchesInteger(): void
{
$constraint = new StringMatchesFormatDescription('*%i*');
$this->assertFalse($constraint->evaluate('**', '', true));
$this->assertFalse($constraint->evaluate('*a*', '', true));
$this->assertFalse($constraint->evaluate('*1.0*', '', true));
$this->assertTrue($constraint->evaluate('*0*', '', true));
$this->assertTrue($constraint->evaluate('*12*', '', true));
$this->assertTrue($constraint->evaluate('*-1*', '', true));
$this->assertTrue($constraint->evaluate('*+2*', '', true));
$this->assertEquals('matches PCRE pattern "/^\*[+-]?\d+\*$/s"', $constraint->toString());
$this->assertCount(1, $constraint);
}
public function testConstraintStringMatchesUnsignedInt(): void
{
$constraint = new StringMatchesFormatDescription('*%d*');
$this->assertFalse($constraint->evaluate('**', '', true));
$this->assertFalse($constraint->evaluate('*a*', '', true));
$this->assertFalse($constraint->evaluate('*1.0*', '', true));
$this->assertFalse($constraint->evaluate('*-1*', '', true));
$this->assertFalse($constraint->evaluate('*+2*', '', true));
$this->assertTrue($constraint->evaluate('*0*', '', true));
$this->assertTrue($constraint->evaluate('*12*', '', true));
$this->assertEquals('matches PCRE pattern "/^\*\d+\*$/s"', $constraint->toString());
$this->assertCount(1, $constraint);
}
public function testConstraintStringMatchesHexadecimal(): void
{
$constraint = new StringMatchesFormatDescription('*%x*');
$this->assertFalse($constraint->evaluate('**', '', true));
$this->assertFalse($constraint->evaluate('***', '', true));
$this->assertFalse($constraint->evaluate('*g*', '', true));
$this->assertFalse($constraint->evaluate('*1.0*', '', true));
$this->assertFalse($constraint->evaluate('*-1*', '', true));
$this->assertFalse($constraint->evaluate('*+2*', '', true));
$this->assertTrue($constraint->evaluate('*0f0f0f*', '', true));
$this->assertTrue($constraint->evaluate('*0*', '', true));
$this->assertTrue($constraint->evaluate('*12*', '', true));
$this->assertTrue($constraint->evaluate('*a*', '', true));
$this->assertEquals('matches PCRE pattern "/^\*[0-9a-fA-F]+\*$/s"', $constraint->toString());
$this->assertCount(1, $constraint);
}
public function testConstraintStringMatchesFloat(): void
{
$constraint = new StringMatchesFormatDescription('*%f*');
$this->assertFalse($constraint->evaluate('**', '', true));
$this->assertFalse($constraint->evaluate('***', '', true));
$this->assertFalse($constraint->evaluate('*a*', '', true));
$this->assertTrue($constraint->evaluate('*1.0*', '', true));
$this->assertTrue($constraint->evaluate('*0*', '', true));
$this->assertTrue($constraint->evaluate('*12*', '', true));
$this->assertTrue($constraint->evaluate('*.1*', '', true));
$this->assertTrue($constraint->evaluate('*1.*', '', true));
$this->assertTrue($constraint->evaluate('*2e3*', '', true));
$this->assertTrue($constraint->evaluate('*-2.34e-56*', '', true));
$this->assertTrue($constraint->evaluate('*+2.34e+56*', '', true));
$this->assertEquals('matches PCRE pattern "/^\*[+-]?\.?\d+\.?\d*(?:[Ee][+-]?\d+)?\*$/s"', $constraint->toString());
$this->assertCount(1, $constraint);
}
public function testConstraintStringMatchesCharacter(): void
{
$constraint = new StringMatchesFormatDescription('*%c*');
$this->assertFalse($constraint->evaluate('**', '', true));
$this->assertFalse($constraint->evaluate('*ab*', '', true));
$this->assertTrue($constraint->evaluate('***', '', true));
$this->assertTrue($constraint->evaluate('*a*', '', true));
$this->assertTrue($constraint->evaluate('*g*', '', true));
$this->assertTrue($constraint->evaluate('*0*', '', true));
$this->assertTrue($constraint->evaluate('*2*', '', true));
$this->assertTrue($constraint->evaluate('* *', '', true));
$this->assertTrue($constraint->evaluate("*\n*", '', true));
$this->assertEquals('matches PCRE pattern "/^\*.\*$/s"', $constraint->toString());
$this->assertCount(1, $constraint);
}
public function testConstraintStringMatchesEscapedPercent(): void
{
$constraint = new StringMatchesFormatDescription('%%,%%e,%%s,%%S,%%a,%%A,%%w,%%i,%%d,%%x,%%f,%%c,%%Z,%%%%,%%');
$this->assertFalse($constraint->evaluate('%%,%' . \DIRECTORY_SEPARATOR . ',%*,%*,%*,%*,% ,%0,%0,%0f0f0f,%1.0,%*,%%Z,%%%%,%%', '', true));
$this->assertTrue($constraint->evaluate('%,%e,%s,%S,%a,%A,%w,%i,%d,%x,%f,%c,%Z,%%,%', '', true));
$this->assertEquals('matches PCRE pattern "/^%,%e,%s,%S,%a,%A,%w,%i,%d,%x,%f,%c,%Z,%%,%$/s"', $constraint->toString());
$this->assertCount(1, $constraint);
}
public function testConstraintStringMatchesEscapedPercentThenPlaceholder(): void
{
$constraint = new StringMatchesFormatDescription('%%%e,%%%s,%%%S,%%%a,%%%A,%%%w,%%%i,%%%d,%%%x,%%%f,%%%c');
$this->assertFalse($constraint->evaluate('%%e,%%s,%%S,%%a,%%A,%%w,%%i,%%d,%%x,%%f,%%c', '', true));
$this->assertTrue($constraint->evaluate('%' . \DIRECTORY_SEPARATOR . ',%*,%*,%*,%*,% ,%0,%0,%0f0f0f,%1.0,%*', '', true));
$this->assertEquals('matches PCRE pattern "/^%\\' . \DIRECTORY_SEPARATOR . ',%[^\r\n]+,%[^\r\n]*,%.+,%.*,%\s*,%[+-]?\d+,%\d+,%[0-9a-fA-F]+,%[+-]?\.?\d+\.?\d*(?:[Ee][+-]?\d+)?,%.$/s"', $constraint->toString());
$this->assertCount(1, $constraint);
}
public function testConstraintStringMatchesSlash(): void
{
$constraint = new StringMatchesFormatDescription('/');
$this->assertFalse($constraint->evaluate('\\/', '', true));
$this->assertTrue($constraint->evaluate('/', '', true));
$this->assertEquals('matches PCRE pattern "/^\\/$/s"', $constraint->toString());
$this->assertCount(1, $constraint);
}
public function testConstraintStringMatchesBackslash(): void
{
$constraint = new StringMatchesFormatDescription('\\');
$this->assertFalse($constraint->evaluate('\\\\', '', true));
$this->assertTrue($constraint->evaluate('\\', '', true));
$this->assertEquals('matches PCRE pattern "/^\\\\$/s"', $constraint->toString());
$this->assertCount(1, $constraint);
}
public function testConstraintStringMatchesBackslashSlash(): void
{
$constraint = new StringMatchesFormatDescription('\\/');
$this->assertFalse($constraint->evaluate('/', '', true));
$this->assertTrue($constraint->evaluate('\\/', '', true));
$this->assertEquals('matches PCRE pattern "/^\\\\\\/$/s"', $constraint->toString());
$this->assertCount(1, $constraint);
}
public function testConstraintStringMatchesNewline(): void
{
$constraint = new StringMatchesFormatDescription("\r\n");
$this->assertFalse($constraint->evaluate("*\r\n", '', true));
$this->assertTrue($constraint->evaluate("\r\n", '', true));
$this->assertEquals("matches PCRE pattern \"/^\n$/s\"", $constraint->toString());
$this->assertCount(1, $constraint);
}
public function testFailureMessageWithNewlines(): void
{
$constraint = new StringMatchesFormatDescription("%c\nfoo\n%c");
try {
$constraint->evaluate("*\nbar\n*");
$this->fail('Expected ExpectationFailedException, but it was not thrown.');
} catch (ExpectationFailedException $e) {
$expected = <<assertEquals($expected, $e->getMessage());
}
}
}
PK ! + Framework/Constraint/StringEndsWithTest.phpnu Iw
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace PHPUnit\Framework\Constraint;
use PHPUnit\Framework\ExpectationFailedException;
use PHPUnit\Framework\TestFailure;
/**
* @small
*/
final class StringEndsWithTest extends ConstraintTestCase
{
public function testConstraintStringEndsWithCorrectValueAndReturnResult(): void
{
$constraint = new StringEndsWith('suffix');
$this->assertTrue($constraint->evaluate('foosuffix', '', true));
}
public function testConstraintStringEndsWithNotCorrectValueAndReturnResult(): void
{
$constraint = new StringEndsWith('suffix');
$this->assertFalse($constraint->evaluate('suffixerror', '', true));
}
public function testConstraintStringEndsWithCorrectNumericValueAndReturnResult(): void
{
$constraint = new StringEndsWith('0E1');
$this->assertTrue($constraint->evaluate('zzz0E1', '', true));
}
public function testConstraintStringEndsWithNotCorrectNumericValueAndReturnResult(): void
{
$constraint = new StringEndsWith('0E1');
$this->assertFalse($constraint->evaluate('zzz0E2', '', true));
}
public function testConstraintStringEndsWithToStringMethod(): void
{
$constraint = new StringEndsWith('suffix');
$this->assertEquals('ends with "suffix"', $constraint->toString());
}
public function testConstraintStringEndsWithCountMethod(): void
{
$constraint = new StringEndsWith('suffix');
$this->assertCount(1, $constraint);
}
public function testConstraintStringEndsWithNotCorrectValueAndExpectation(): void
{
$constraint = new StringEndsWith('suffix');
try {
$constraint->evaluate('error');
} catch (ExpectationFailedException $e) {
$this->assertEquals(
<<fail();
}
public function testConstraintStringEndsWithNotCorrectValueExceptionAndCustomMessage(): void
{
$constraint = new StringEndsWith('suffix');
try {
$constraint->evaluate('error', 'custom message');
} catch (ExpectationFailedException $e) {
$this->assertEquals(
<<fail();
}
}
PK ! JJa@ @ 3 Framework/Constraint/ExceptionMessageRegExpTest.phpnu Iw
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace PHPUnit\Framework\Constraint;
use PHPUnit\Framework\TestCase;
/**
* @small
*/
final class ExceptionMessageRegExpTest extends TestCase
{
public function testRegexMessage(): void
{
$this->expectException(\Exception::class);
$this->expectExceptionMessageMatches('/^A polymorphic \w+ message/');
throw new \Exception('A polymorphic exception message');
}
public function testRegexMessageExtreme(): void
{
$this->expectException(\Exception::class);
$this->expectExceptionMessageMatches('/^a poly[a-z]+ [a-zA-Z0-9_]+ me(s){2}age$/i');
throw new \Exception('A polymorphic exception message');
}
/**
* @runInSeparateProcess
* @requires extension xdebug
*/
public function testMessageXdebugScreamCompatibility(): void
{
\ini_set('xdebug.scream', '1');
$this->expectException(\Exception::class);
$this->expectExceptionMessageMatches('#Screaming preg_match#');
throw new \Exception('Screaming preg_match');
}
public function testRegExMessageCanBeExportedAsString(): void
{
$exceptionMessageReExp = new ExceptionMessageRegularExpression('/^a poly[a-z]+ [a-zA-Z0-9_]+ me(s){2}age$/i');
$this->assertSame('exception message matches ', $exceptionMessageReExp->toString());
}
}
PK ! |E ( Framework/Constraint/ArrayHasKeyTest.phpnu Iw
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace PHPUnit\Framework\Constraint;
use PHPUnit\Framework\ExpectationFailedException;
use PHPUnit\Framework\TestFailure;
/**
* @small
*/
final class ArrayHasKeyTest extends ConstraintTestCase
{
public function testConstraintArrayHasKey(): void
{
$constraint = new ArrayHasKey(0);
$this->assertFalse($constraint->evaluate([], '', true));
$this->assertEquals('has the key 0', $constraint->toString());
$this->assertCount(1, $constraint);
try {
$constraint->evaluate([]);
} catch (ExpectationFailedException $e) {
$this->assertEquals(
<<fail();
}
public function testConstraintArrayHasKey2(): void
{
$constraint = new ArrayHasKey(0);
try {
$constraint->evaluate([], 'custom message');
} catch (ExpectationFailedException $e) {
$this->assertEquals(
<<fail();
}
public function testConstraintArrayHasKey0(): void
{
$constraint = new ArrayHasKey(0);
try {
$constraint->evaluate(0, '');
} catch (ExpectationFailedException $e) {
$this->assertEquals(
<<
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace PHPUnit\Framework\Constraint;
use PHPUnit\Framework\ExpectationFailedException;
use PHPUnit\Framework\TestFailure;
use PHPUnit\Util\Json;
/**
* @small
*/
final class JsonMatchesTest extends ConstraintTestCase
{
public static function evaluateDataprovider(): array
{
return [
'valid JSON' => [true, \json_encode(['Mascott' => 'Tux']), \json_encode(['Mascott' => 'Tux'])],
'error syntax' => [false, '{"Mascott"::}', \json_encode(['Mascott' => 'Tux'])],
'error UTF-8' => [false, \json_encode('\xB1\x31'), \json_encode(['Mascott' => 'Tux'])],
'invalid JSON in class instantiation' => [false, \json_encode(['Mascott' => 'Tux']), '{"Mascott"::}'],
'string type not equals number' => [false, '{"age": "5"}', '{"age": 5}'],
'string type not equals boolean' => [false, '{"age": "true"}', '{"age": true}'],
'string type not equals null' => [false, '{"age": "null"}', '{"age": null}'],
'object fields are unordered' => [true, '{"first":1, "second":"2"}', '{"second":"2", "first":1}'],
'child object fields are unordered' => [true, '{"Mascott": {"name":"Tux", "age":5}}', '{"Mascott": {"age":5, "name":"Tux"}}'],
'null field different from missing field' => [false, '{"present": true, "missing": null}', '{"present": true}'],
'array elements are ordered' => [false, '["first", "second"]', '["second", "first"]'],
'single boolean valid json' => [true, 'true', 'true'],
'single number valid json' => [true, '5.3', '5.3'],
'single null valid json' => [true, 'null', 'null'],
'objects are not arrays' => [false, '{}', '[]'],
];
}
public static function evaluateThrowsExpectationFailedExceptionWhenJsonIsValidButDoesNotMatchDataprovider(): array
{
return [
'error UTF-8' => [\json_encode('\xB1\x31'), \json_encode(['Mascott' => 'Tux'])],
'string type not equals number' => ['{"age": "5"}', '{"age": 5}'],
'string type not equals boolean' => ['{"age": "true"}', '{"age": true}'],
'string type not equals null' => ['{"age": "null"}', '{"age": null}'],
'null field different from missing field' => ['{"missing": null, "present": true}', '{"present": true}'],
'array elements are ordered' => ['["first", "second"]', '["second", "first"]'],
];
}
/**
* @dataProvider evaluateDataprovider
*
* @throws ExpectationFailedException
* @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
*/
public function testEvaluate($expected, $jsonOther, $jsonValue): void
{
$constraint = new JsonMatches($jsonValue);
$this->assertEquals($expected, $constraint->evaluate($jsonOther, '', true));
}
/**
* @dataProvider evaluateThrowsExpectationFailedExceptionWhenJsonIsValidButDoesNotMatchDataprovider
*
* @throws ExpectationFailedException
* @throws \PHPUnit\Framework\AssertionFailedError
* @throws \PHPUnit\Framework\Exception
* @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
*/
public function testEvaluateThrowsExpectationFailedExceptionWhenJsonIsValidButDoesNotMatch($jsonOther, $jsonValue): void
{
$constraint = new JsonMatches($jsonValue);
try {
$constraint->evaluate($jsonOther, '', false);
$this->fail(\sprintf('Expected %s to be thrown.', ExpectationFailedException::class));
} catch (ExpectationFailedException $expectedException) {
$comparisonFailure = $expectedException->getComparisonFailure();
$this->assertNotNull($comparisonFailure);
$this->assertSame(Json::prettify($jsonOther), $comparisonFailure->getActualAsString());
$this->assertSame(Json::prettify($jsonValue), $comparisonFailure->getExpectedAsString());
$this->assertSame('Failed asserting that two json values are equal.', $comparisonFailure->getMessage());
}
}
public function testToString(): void
{
$jsonValue = \json_encode(['Mascott' => 'Tux']);
$constraint = new JsonMatches($jsonValue);
$this->assertEquals('matches JSON string "' . $jsonValue . '"', $constraint->toString());
}
public function testFailErrorWithInvalidValueAndOther(): void
{
$constraint = new JsonMatches('{"Mascott"::}');
try {
$constraint->evaluate('{"Mascott"::}', '', false);
$this->fail(\sprintf('Expected %s to be thrown.', ExpectationFailedException::class));
} catch (ExpectationFailedException $e) {
$this->assertEquals(
<<evaluate('{"Mascott":"Tux"}', '', false);
$this->fail(\sprintf('Expected %s to be thrown.', ExpectationFailedException::class));
} catch (ExpectationFailedException $e) {
$this->assertEquals(
<<evaluate('{"obj": {}, "val": 2}', '', false);
} catch (ExpectationFailedException $e) {
$this->assertEquals(
<<evaluate('{"obj": {"y": 2, "x": 1}, "val": 2}', '', false);
} catch (ExpectationFailedException $e) {
$this->assertEquals(
<<
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace PHPUnit\Framework\Constraint;
use PHPUnit\Framework\ExpectationFailedException;
/**
* @small
*/
final class CallbackTest extends ConstraintTestCase
{
public static function staticCallbackReturningTrue()
{
return true;
}
public function callbackReturningTrue()
{
return true;
}
public function testConstraintCallback(): void
{
$closureReflect = function ($parameter) {
return $parameter;
};
$closureWithoutParameter = function () {
return true;
};
$constraint = new Callback($closureWithoutParameter);
$this->assertTrue($constraint->evaluate('', '', true));
$constraint = new Callback($closureReflect);
$this->assertTrue($constraint->evaluate(true, '', true));
$this->assertFalse($constraint->evaluate(false, '', true));
$callback = [$this, 'callbackReturningTrue'];
$constraint = new Callback($callback);
$this->assertTrue($constraint->evaluate(false, '', true));
$callback = [self::class, 'staticCallbackReturningTrue'];
$constraint = new Callback($callback);
$this->assertTrue($constraint->evaluate(null, '', true));
$this->assertEquals('is accepted by specified callback', $constraint->toString());
}
public function testConstraintCallbackFailure(): void
{
$constraint = new Callback(function () {
return false;
});
$this->expectException(ExpectationFailedException::class);
$this->expectExceptionMessage('Failed asserting that \'This fails\' is accepted by specified callback.');
$constraint->evaluate('This fails');
}
}
PK ! A A ' Framework/Constraint/IsReadableTest.phpnu Iw
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace PHPUnit\Framework\Constraint;
use PHPUnit\Framework\ExpectationFailedException;
use PHPUnit\Framework\TestFailure;
/**
* @small
*/
final class IsReadableTest extends ConstraintTestCase
{
public function testConstraintIsReadable(): void
{
$constraint = new IsReadable;
$this->assertFalse($constraint->evaluate('foo', '', true));
$this->assertEquals('is readable', $constraint->toString());
$this->assertCount(1, $constraint);
try {
$constraint->evaluate('foo');
} catch (ExpectationFailedException $e) {
$this->assertEquals(
<<fail();
}
}
PK ! Su u 4 Framework/Constraint/ClassHasStaticAttributeTest.phpnu Iw
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace PHPUnit\Framework\Constraint;
use PHPUnit\Framework\ExpectationFailedException;
use PHPUnit\Framework\TestFailure;
/**
* @small
*/
final class ClassHasStaticAttributeTest extends ConstraintTestCase
{
public function testConstraintClassHasStaticAttribute(): void
{
$constraint = new ClassHasStaticAttribute('privateStaticAttribute');
$this->assertTrue($constraint->evaluate(\ClassWithNonPublicAttributes::class, '', true));
$this->assertFalse($constraint->evaluate(\stdClass::class, '', true));
$this->assertEquals('has static attribute "privateStaticAttribute"', $constraint->toString());
$this->assertCount(1, $constraint);
try {
$constraint->evaluate(\stdClass::class);
} catch (ExpectationFailedException $e) {
$this->assertEquals(
<<fail();
}
public function testConstraintClassHasStaticAttribute2(): void
{
$constraint = new ClassHasStaticAttribute('foo');
try {
$constraint->evaluate(\stdClass::class, 'custom message');
} catch (ExpectationFailedException $e) {
$this->assertEquals(
<<fail();
}
}
PK ! n%W W % Framework/Constraint/LessThanTest.phpnu Iw
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace PHPUnit\Framework\Constraint;
use PHPUnit\Framework\ExpectationFailedException;
use PHPUnit\Framework\TestFailure;
/**
* @small
*/
final class LessThanTest extends ConstraintTestCase
{
public function testConstraintLessThan(): void
{
$constraint = new LessThan(1);
$this->assertTrue($constraint->evaluate(0, '', true));
$this->assertFalse($constraint->evaluate(1, '', true));
$this->assertEquals('is less than 1', $constraint->toString());
$this->assertCount(1, $constraint);
try {
$constraint->evaluate(1);
} catch (ExpectationFailedException $e) {
$this->assertEquals(
<<fail();
}
public function testConstraintLessThan2(): void
{
$constraint = new LessThan(1);
try {
$constraint->evaluate(1, 'custom message');
} catch (ExpectationFailedException $e) {
$this->assertEquals(
<<fail();
}
}
PK ! Sn Framework/TestCaseTest.phpnu Iw
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace PHPUnit\Framework;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\MockObject\Stub;
use PHPUnit\Runner\BaseTestRunner;
use PHPUnit\Util\Test as TestUtil;
/**
* @small
*/
final class TestCaseTest extends TestCase
{
protected static $testStatic = 456;
protected $backupGlobalsBlacklist = ['i', 'singleton'];
public static function setUpBeforeClass(): void
{
$GLOBALS['a'] = 'a';
$_ENV['b'] = 'b';
$_POST['c'] = 'c';
$_GET['d'] = 'd';
$_COOKIE['e'] = 'e';
$_SERVER['f'] = 'f';
$_FILES['g'] = 'g';
$_REQUEST['h'] = 'h';
$GLOBALS['i'] = 'i';
}
public static function tearDownAfterClass(): void
{
unset(
$GLOBALS['a'],
$_ENV['b'],
$_POST['c'],
$_GET['d'],
$_COOKIE['e'],
$_SERVER['f'],
$_FILES['g'],
$_REQUEST['h'],
$GLOBALS['i']
);
}
public function testCaseToString(): void
{
$this->assertEquals(
'PHPUnit\Framework\TestCaseTest::testCaseToString',
$this->toString()
);
}
public function testSuccess(): void
{
$test = new \Success;
$result = $test->run();
$this->assertEquals(BaseTestRunner::STATUS_PASSED, $test->getStatus());
$this->assertEquals(0, $result->errorCount());
$this->assertEquals(0, $result->failureCount());
$this->assertEquals(0, $result->skippedCount());
$this->assertCount(1, $result);
}
public function testFailure(): void
{
$test = new \Failure;
$result = $test->run();
$this->assertEquals(BaseTestRunner::STATUS_FAILURE, $test->getStatus());
$this->assertEquals(0, $result->errorCount());
$this->assertEquals(1, $result->failureCount());
$this->assertEquals(0, $result->skippedCount());
$this->assertCount(1, $result);
}
public function testError(): void
{
$test = new \TestError;
$result = $test->run();
$this->assertEquals(BaseTestRunner::STATUS_ERROR, $test->getStatus());
$this->assertEquals(1, $result->errorCount());
$this->assertEquals(0, $result->failureCount());
$this->assertEquals(0, $result->skippedCount());
$this->assertCount(1, $result);
}
public function testSkipped(): void
{
$test = new \TestSkipped;
$result = $test->run();
$this->assertEquals(BaseTestRunner::STATUS_SKIPPED, $test->getStatus());
$this->assertEquals('Skipped test', $test->getStatusMessage());
$this->assertEquals(0, $result->errorCount());
$this->assertEquals(0, $result->failureCount());
$this->assertEquals(1, $result->skippedCount());
$this->assertCount(1, $result);
}
public function testIncomplete(): void
{
$test = new \TestIncomplete;
$result = $test->run();
$this->assertEquals(BaseTestRunner::STATUS_INCOMPLETE, $test->getStatus());
$this->assertEquals('Incomplete test', $test->getStatusMessage());
$this->assertEquals(0, $result->errorCount());
$this->assertEquals(0, $result->failureCount());
$this->assertEquals(0, $result->skippedCount());
$this->assertCount(1, $result);
}
public function testExceptionInSetUp(): void
{
$test = new \ExceptionInSetUpTest('testSomething');
$test->run();
$this->assertTrue($test->setUp);
$this->assertFalse($test->assertPreConditions);
$this->assertFalse($test->testSomething);
$this->assertFalse($test->assertPostConditions);
$this->assertTrue($test->tearDown);
}
public function testExceptionInAssertPreConditions(): void
{
$test = new \ExceptionInAssertPreConditionsTest('testSomething');
$test->run();
$this->assertTrue($test->setUp);
$this->assertTrue($test->assertPreConditions);
$this->assertFalse($test->testSomething);
$this->assertFalse($test->assertPostConditions);
$this->assertTrue($test->tearDown);
}
public function testExceptionInTest(): void
{
$test = new \ExceptionInTest('testSomething');
$test->run();
$this->assertTrue($test->setUp);
$this->assertTrue($test->assertPreConditions);
$this->assertTrue($test->testSomething);
$this->assertFalse($test->assertPostConditions);
$this->assertTrue($test->tearDown);
}
public function testExceptionInAssertPostConditions(): void
{
$test = new \ExceptionInAssertPostConditionsTest('testSomething');
$test->run();
$this->assertTrue($test->setUp);
$this->assertTrue($test->assertPreConditions);
$this->assertTrue($test->testSomething);
$this->assertTrue($test->assertPostConditions);
$this->assertTrue($test->tearDown);
}
public function testExceptionInTearDown(): void
{
$test = new \ExceptionInTearDownTest('testSomething');
$test->run();
$this->assertTrue($test->setUp);
$this->assertTrue($test->assertPreConditions);
$this->assertTrue($test->testSomething);
$this->assertTrue($test->assertPostConditions);
$this->assertTrue($test->tearDown);
$this->assertEquals(BaseTestRunner::STATUS_ERROR, $test->getStatus());
$this->assertSame('throw Exception in tearDown()', $test->getStatusMessage());
}
public function testExceptionInTestIsDetectedInTeardown(): void
{
$test = new \ExceptionInTestDetectedInTeardown('testSomething');
$test->run();
$this->assertTrue($test->exceptionDetected);
}
public function testNoArgTestCasePasses(): void
{
$result = new TestResult;
$t = new TestSuite(\NoArgTestCaseTest::class);
$t->run($result);
$this->assertCount(1, $result);
$this->assertEquals(0, $result->failureCount());
$this->assertEquals(0, $result->errorCount());
}
public function testWasRun(): void
{
$test = new \WasRun;
$test->run();
$this->assertTrue($test->wasRun);
}
public function testException(): void
{
$test = new \ThrowExceptionTestCase('test');
$test->expectException(\RuntimeException::class);
$result = $test->run();
$this->assertCount(1, $result);
$this->assertTrue($result->wasSuccessful());
}
public function testExpectExceptionAllowsAccessingExpectedException(): void
{
$exception = \RuntimeException::class;
$test = new \ThrowExceptionTestCase('test');
$test->expectException($exception);
$this->assertSame($exception, $test->getExpectedException());
}
public function testExpectExceptionCodeWithSameCode(): void
{
$test = new \ThrowExceptionTestCase('test');
$test->expectExceptionCode(0);
$result = $test->run();
$this->assertCount(1, $result);
$this->assertTrue($result->wasSuccessful());
}
public function testExpectExceptionCodeWithDifferentCode(): void
{
$test = new \ThrowExceptionTestCase('test');
$test->expectExceptionCode(9000);
$result = $test->run();
$this->assertCount(1, $result);
$this->assertFalse($result->wasSuccessful());
}
public function testExpectExceptionCodeAllowsAccessingExpectedExceptionCode(): void
{
$code = 9000;
$test = new \ThrowExceptionTestCase('test');
$test->expectExceptionCode($code);
$this->assertSame($code, $test->getExpectedExceptionCode());
}
public function testExceptionWithEmptyMessage(): void
{
$test = new \ThrowExceptionTestCase('test');
$test->expectException(\RuntimeException::class);
$result = $test->run();
$this->assertCount(1, $result);
$this->assertTrue($result->wasSuccessful());
}
public function testExceptionWithNullMessage(): void
{
$test = new \ThrowExceptionTestCase('test');
$test->expectException(\RuntimeException::class);
$result = $test->run();
$this->assertCount(1, $result);
$this->assertTrue($result->wasSuccessful());
}
public function testExceptionWithMessage(): void
{
$test = new \ThrowExceptionTestCase('test');
$test->expectException(\RuntimeException::class);
$test->expectExceptionMessage('A runtime error occurred');
$result = $test->run();
$this->assertCount(1, $result);
$this->assertTrue($result->wasSuccessful());
}
public function testExceptionWithWrongMessage(): void
{
$test = new \ThrowExceptionTestCase('test');
$test->expectException(\RuntimeException::class);
$test->expectExceptionMessage('A logic error occurred');
$result = $test->run();
$this->assertEquals(1, $result->failureCount());
$this->assertCount(1, $result);
$this->assertEquals(
"Failed asserting that exception message 'A runtime error occurred' contains 'A logic error occurred'.",
$test->getStatusMessage()
);
}
public function testExpectExceptionMessageAllowsAccessingExpectedExceptionMessage(): void
{
$message = 'A runtime error occurred';
$test = new \ThrowExceptionTestCase('test');
$test->expectExceptionMessage($message);
$this->assertSame($message, $test->getExpectedExceptionMessage());
}
public function testExceptionWithRegexpMessage(): void
{
$test = new \ThrowExceptionTestCase('test');
$test->expectException(\RuntimeException::class);
$test->expectExceptionMessageMatches('/runtime .*? occurred/');
$result = $test->run();
$this->assertCount(1, $result);
$this->assertTrue($result->wasSuccessful());
}
public function testExpectExceptionMessageRegExpAllowsAccessingExpectedExceptionRegExp(): void
{
$messageRegExp = '/runtime .*? occurred/';
$test = new \ThrowExceptionTestCase('test');
$test->expectExceptionMessageMatches($messageRegExp);
$this->assertSame($messageRegExp, $test->getExpectedExceptionMessageRegExp());
}
public function testExceptionWithWrongRegexpMessage(): void
{
$test = new \ThrowExceptionTestCase('test');
$test->expectException(\RuntimeException::class);
$test->expectExceptionMessageMatches('/logic .*? occurred/');
$result = $test->run();
$this->assertEquals(1, $result->failureCount());
$this->assertCount(1, $result);
$this->assertEquals(
"Failed asserting that exception message 'A runtime error occurred' matches '/logic .*? occurred/'.",
$test->getStatusMessage()
);
}
public function testExceptionWithInvalidRegexpMessage(): void
{
$test = new \ThrowExceptionTestCase('test');
$test->expectException(\RuntimeException::class);
$test->expectExceptionMessageMatches('#runtime .*? occurred/');
$test->run();
$this->assertEquals(
"Invalid expected exception message regex given: '#runtime .*? occurred/'",
$test->getStatusMessage()
);
}
public function testExpectExceptionObjectWithDifferentExceptionClass(): void
{
$exception = new \InvalidArgumentException(
'Cannot compute at this time.',
9000
);
$test = new \ThrowExceptionTestCase('testWithExpectExceptionObject');
$test->expectExceptionObject($exception);
$result = $test->run();
$this->assertCount(1, $result);
$this->assertFalse($result->wasSuccessful());
}
public function testExpectExceptionObjectWithDifferentExceptionMessage(): void
{
$exception = new \RuntimeException(
'This is fine!',
9000
);
$test = new \ThrowExceptionTestCase('testWithExpectExceptionObject');
$test->expectExceptionObject($exception);
$result = $test->run();
$this->assertCount(1, $result);
$this->assertFalse($result->wasSuccessful());
}
public function testExpectExceptionObjectWithDifferentExceptionCode(): void
{
$exception = new \RuntimeException(
'Cannot compute at this time.',
9001
);
$test = new \ThrowExceptionTestCase('testWithExpectExceptionObject');
$test->expectExceptionObject($exception);
$result = $test->run();
$this->assertCount(1, $result);
$this->assertFalse($result->wasSuccessful());
}
public function testExpectExceptionObjectWithEqualException(): void
{
$exception = new \RuntimeException(
'Cannot compute at this time',
9000
);
$test = new \ThrowExceptionTestCase('testWithExpectExceptionObject');
$test->expectExceptionObject($exception);
$result = $test->run();
$this->assertCount(1, $result);
$this->assertTrue($result->wasSuccessful());
}
public function testExpectExceptionObjectAllowsAccessingExpectedExceptionDetails(): void
{
$exception = new \RuntimeException(
'Cannot compute at this time',
9000
);
$test = new \ThrowExceptionTestCase('testWithExpectExceptionObject');
$test->expectExceptionObject($exception);
$this->assertSame(\get_class($exception), $test->getExpectedException());
$this->assertSame($exception->getCode(), $test->getExpectedExceptionCode());
$this->assertSame($exception->getMessage(), $test->getExpectedExceptionMessage());
}
public function testNoException(): void
{
$test = new \ThrowNoExceptionTestCase('test');
$test->expectException(\RuntimeException::class);
$result = $test->run();
$this->assertEquals(1, $result->failureCount());
$this->assertCount(1, $result);
}
public function testWrongException(): void
{
$test = new \ThrowExceptionTestCase('test');
$test->expectException(\InvalidArgumentException::class);
$result = $test->run();
$this->assertEquals(1, $result->failureCount());
$this->assertCount(1, $result);
}
public function testDoesNotPerformAssertions(): void
{
$test = new \DoNoAssertionTestCase('testNothing');
$test->expectNotToPerformAssertions();
$result = $test->run();
$this->assertEquals(0, $result->riskyCount());
$this->assertCount(1, $result);
}
/**
* @backupGlobals enabled
*/
public function testGlobalsBackupPre(): void
{
global $a;
global $i;
$this->assertEquals('a', $a);
$this->assertEquals('a', $GLOBALS['a']);
$this->assertEquals('b', $_ENV['b']);
$this->assertEquals('c', $_POST['c']);
$this->assertEquals('d', $_GET['d']);
$this->assertEquals('e', $_COOKIE['e']);
$this->assertEquals('f', $_SERVER['f']);
$this->assertEquals('g', $_FILES['g']);
$this->assertEquals('h', $_REQUEST['h']);
$this->assertEquals('i', $i);
$this->assertEquals('i', $GLOBALS['i']);
$GLOBALS['a'] = 'aa';
$GLOBALS['foo'] = 'bar';
$_ENV['b'] = 'bb';
$_POST['c'] = 'cc';
$_GET['d'] = 'dd';
$_COOKIE['e'] = 'ee';
$_SERVER['f'] = 'ff';
$_FILES['g'] = 'gg';
$_REQUEST['h'] = 'hh';
$GLOBALS['i'] = 'ii';
$this->assertEquals('aa', $a);
$this->assertEquals('aa', $GLOBALS['a']);
$this->assertEquals('bar', $GLOBALS['foo']);
$this->assertEquals('bb', $_ENV['b']);
$this->assertEquals('cc', $_POST['c']);
$this->assertEquals('dd', $_GET['d']);
$this->assertEquals('ee', $_COOKIE['e']);
$this->assertEquals('ff', $_SERVER['f']);
$this->assertEquals('gg', $_FILES['g']);
$this->assertEquals('hh', $_REQUEST['h']);
$this->assertEquals('ii', $i);
$this->assertEquals('ii', $GLOBALS['i']);
}
/**
* @depends testGlobalsBackupPre
*/
public function testGlobalsBackupPost(): void
{
global $a;
global $i;
$this->assertEquals('a', $a);
$this->assertEquals('a', $GLOBALS['a']);
$this->assertEquals('b', $_ENV['b']);
$this->assertEquals('c', $_POST['c']);
$this->assertEquals('d', $_GET['d']);
$this->assertEquals('e', $_COOKIE['e']);
$this->assertEquals('f', $_SERVER['f']);
$this->assertEquals('g', $_FILES['g']);
$this->assertEquals('h', $_REQUEST['h']);
$this->assertEquals('ii', $i);
$this->assertEquals('ii', $GLOBALS['i']);
$this->assertArrayNotHasKey('foo', $GLOBALS);
}
/**
* @backupGlobals enabled
* @backupStaticAttributes enabled
* @depends testGlobalsBackupPost
*
* @doesNotPerformAssertions
*/
public function testStaticAttributesBackupPre(): void
{
$GLOBALS['singleton'] = \Singleton::getInstance();
$GLOBALS['i'] = 'set by testStaticAttributesBackupPre';
$GLOBALS['j'] = 'reset by backup';
self::$testStatic = 123;
}
/**
* @depends testStaticAttributesBackupPre
*/
public function testStaticAttributesBackupPost(): void
{
// Snapshots made by @backupGlobals
$this->assertSame(\Singleton::getInstance(), $GLOBALS['singleton']);
$this->assertSame('set by testStaticAttributesBackupPre', $GLOBALS['i']);
// Reset global
$this->assertArrayNotHasKey('j', $GLOBALS);
// Static reset to original state by @backupStaticAttributes
$this->assertSame(456, self::$testStatic);
}
public function testIsInIsolationReturnsFalse(): void
{
$test = new \IsolationTest('testIsInIsolationReturnsFalse');
$result = $test->run();
$this->assertCount(1, $result);
$this->assertTrue($result->wasSuccessful());
}
public function testIsInIsolationReturnsTrue(): void
{
$test = new \IsolationTest('testIsInIsolationReturnsTrue');
$test->setRunTestInSeparateProcess(true);
$result = $test->run();
$this->assertCount(1, $result);
$this->assertTrue($result->wasSuccessful());
}
public function testExpectOutputStringFooActualFoo(): void
{
$test = new \OutputTestCase('testExpectOutputStringFooActualFoo');
$result = $test->run();
$this->assertCount(1, $result);
$this->assertTrue($result->wasSuccessful());
}
public function testExpectOutputStringFooActualBar(): void
{
$test = new \OutputTestCase('testExpectOutputStringFooActualBar');
$result = $test->run();
$this->assertCount(1, $result);
$this->assertFalse($result->wasSuccessful());
}
public function testExpectOutputRegexFooActualFoo(): void
{
$test = new \OutputTestCase('testExpectOutputRegexFooActualFoo');
$result = $test->run();
$this->assertCount(1, $result);
$this->assertTrue($result->wasSuccessful());
}
public function testExpectOutputRegexFooActualBar(): void
{
$test = new \OutputTestCase('testExpectOutputRegexFooActualBar');
$result = $test->run();
$this->assertCount(1, $result);
$this->assertFalse($result->wasSuccessful());
}
public function testSkipsIfRequiresHigherVersionOfPHPUnit(): void
{
$test = new \RequirementsTest('testAlwaysSkip');
$result = $test->run();
$this->assertEquals(1, $result->skippedCount());
$this->assertEquals(
'PHPUnit >= 1111111 is required.',
$test->getStatusMessage()
);
}
public function testSkipsIfRequiresHigherVersionOfPHP(): void
{
$test = new \RequirementsTest('testAlwaysSkip2');
$result = $test->run();
$this->assertEquals(1, $result->skippedCount());
$this->assertEquals(
'PHP >= 9999999 is required.',
$test->getStatusMessage()
);
}
public function testSkipsIfRequiresNonExistingOs(): void
{
$test = new \RequirementsTest('testAlwaysSkip3');
$result = $test->run();
$this->assertEquals(1, $result->skippedCount());
$this->assertEquals(
'Operating system matching /DOESNOTEXIST/i is required.',
$test->getStatusMessage()
);
}
public function testSkipsIfRequiresNonExistingOsFamily(): void
{
$test = new \RequirementsTest('testAlwaysSkip4');
$result = $test->run();
$this->assertEquals(1, $result->skippedCount());
$this->assertEquals(
'Operating system DOESNOTEXIST is required.',
$test->getStatusMessage()
);
}
public function testSkipsIfRequiresNonExistingFunction(): void
{
$test = new \RequirementsTest('testNine');
$result = $test->run();
$this->assertEquals(1, $result->skippedCount());
$this->assertEquals(
'Function testFunc is required.',
$test->getStatusMessage()
);
}
public function testSkipsIfRequiresNonExistingExtension(): void
{
$test = new \RequirementsTest('testTen');
$test->run();
$this->assertEquals(
'Extension testExt is required.',
$test->getStatusMessage()
);
}
public function testSkipsIfRequiresExtensionWithAMinimumVersion(): void
{
$test = new \RequirementsTest('testSpecificExtensionVersion');
$test->run();
$this->assertEquals(
'Extension testExt >= 1.8.0 is required.',
$test->getStatusMessage()
);
}
public function testSkipsProvidesMessagesForAllSkippingReasons(): void
{
$test = new \RequirementsTest('testAllPossibleRequirements');
$test->run();
$this->assertEquals(
'PHP >= 99-dev is required.' . \PHP_EOL .
'PHPUnit >= 9-dev is required.' . \PHP_EOL .
'Operating system matching /DOESNOTEXIST/i is required.' . \PHP_EOL .
'Function testFuncOne is required.' . \PHP_EOL .
'Function testFunc2 is required.' . \PHP_EOL .
'Setting "not_a_setting" must be "Off".' . \PHP_EOL .
'Extension testExtOne is required.' . \PHP_EOL .
'Extension testExt2 is required.' . \PHP_EOL .
'Extension testExtThree >= 2.0 is required.',
$test->getStatusMessage()
);
}
public function testRequiringAnExistingMethodDoesNotSkip(): void
{
$test = new \RequirementsTest('testExistingMethod');
$result = $test->run();
$this->assertEquals(0, $result->skippedCount());
}
public function testRequiringAnExistingFunctionDoesNotSkip(): void
{
$test = new \RequirementsTest('testExistingFunction');
$result = $test->run();
$this->assertEquals(0, $result->skippedCount());
}
public function testRequiringAnExistingExtensionDoesNotSkip(): void
{
$test = new \RequirementsTest('testExistingExtension');
$result = $test->run();
$this->assertEquals(0, $result->skippedCount());
}
public function testRequiringAnExistingOsDoesNotSkip(): void
{
$test = new \RequirementsTest('testExistingOs');
$result = $test->run();
$this->assertEquals(0, $result->skippedCount());
}
public function testRequiringASetting(): void
{
$test = new \RequirementsTest('testSettingDisplayErrorsOn');
// Get this so we can return it to whatever it was before the test.
$displayErrorsVal = \ini_get('display_errors');
\ini_set('display_errors', 'On');
$result = $test->run();
$this->assertEquals(0, $result->skippedCount());
\ini_set('display_errors', 'Off');
$result = $test->run();
$this->assertEquals(1, $result->skippedCount());
\ini_set('display_errors', $displayErrorsVal);
}
public function testCurrentWorkingDirectoryIsRestored(): void
{
$expectedCwd = \getcwd();
$test = new \ChangeCurrentWorkingDirectoryTest('testSomethingThatChangesTheCwd');
$test->run();
$this->assertSame($expectedCwd, \getcwd());
}
/**
* @requires PHP 7
*/
public function testTypeErrorCanBeExpected(): void
{
$o = new \ClassWithScalarTypeDeclarations;
$this->expectException(\TypeError::class);
$o->foo(null, null);
}
public function testCreateMockFromClassName(): void
{
$mock = $this->createMock(\Mockable::class);
$this->assertInstanceOf(\Mockable::class, $mock);
$this->assertInstanceOf(MockObject::class, $mock);
}
public function testCreateMockMocksAllMethods(): void
{
$mock = $this->createMock(\Mockable::class);
$this->assertNull($mock->mockableMethod());
$this->assertNull($mock->anotherMockableMethod());
}
public function testCreateStubFromClassName(): void
{
$mock = $this->createStub(\Mockable::class);
$this->assertInstanceOf(\Mockable::class, $mock);
$this->assertInstanceOf(Stub::class, $mock);
}
public function testCreateStubStubsAllMethods(): void
{
$mock = $this->createStub(\Mockable::class);
$this->assertNull($mock->mockableMethod());
$this->assertNull($mock->anotherMockableMethod());
}
public function testCreatePartialMockDoesNotMockAllMethods(): void
{
/** @var \Mockable $mock */
$mock = $this->createPartialMock(\Mockable::class, ['mockableMethod']);
$this->assertNull($mock->mockableMethod());
$this->assertTrue($mock->anotherMockableMethod());
}
public function testCreatePartialMockCanMockNoMethods(): void
{
/** @var \Mockable $mock */
$mock = $this->createPartialMock(\Mockable::class, []);
$this->assertTrue($mock->mockableMethod());
$this->assertTrue($mock->anotherMockableMethod());
}
public function testCreatePartialMockWithFakeMethods(): void
{
$test = new \TestWithDifferentStatuses('testWithCreatePartialMockWarning');
$test->run();
$this->assertSame(BaseTestRunner::STATUS_WARNING, $test->getStatus());
$this->assertFalse($test->hasFailed());
}
public function testCreatePartialMockWithRealMethods(): void
{
$test = new \TestWithDifferentStatuses('testWithCreatePartialMockPassesNoWarning');
$test->run();
$this->assertSame(BaseTestRunner::STATUS_PASSED, $test->getStatus());
$this->assertFalse($test->hasFailed());
}
public function testCreateMockSkipsConstructor(): void
{
$mock = $this->createMock(\Mockable::class);
$this->assertNull($mock->constructorArgs);
}
public function testCreateMockDisablesOriginalClone(): void
{
$mock = $this->createMock(\Mockable::class);
$cloned = clone $mock;
$this->assertNull($cloned->cloned);
}
public function testCreateStubSkipsConstructor(): void
{
$mock = $this->createStub(\Mockable::class);
$this->assertNull($mock->constructorArgs);
}
public function testCreateStubDisablesOriginalClone(): void
{
$mock = $this->createStub(\Mockable::class);
$cloned = clone $mock;
$this->assertNull($cloned->cloned);
}
public function testConfiguredMockCanBeCreated(): void
{
/** @var \Mockable $mock */
$mock = $this->createConfiguredMock(
\Mockable::class,
[
'mockableMethod' => false,
]
);
$this->assertFalse($mock->mockableMethod());
$this->assertNull($mock->anotherMockableMethod());
}
public function testProvidingOfAutoreferencedArray(): void
{
$test = new \TestAutoreferenced('testJsonEncodeException', $this->getAutoreferencedArray());
$test->runBare();
$this->assertIsArray($test->myTestData);
$this->assertArrayHasKey('data', $test->myTestData);
$this->assertEquals($test->myTestData['data'][0], $test->myTestData['data']);
}
public function testProvidingArrayThatMixesObjectsAndScalars(): void
{
$data = [
[123],
['foo'],
[$this->createMock(\Mockable::class)],
[$this->createStub(\Mockable::class)],
];
$test = new \TestAutoreferenced('testJsonEncodeException', [$data]);
$test->runBare();
$this->assertIsArray($test->myTestData);
$this->assertSame($data, $test->myTestData);
}
public function testGettingNullTestResultObject(): void
{
$test = new \Success;
$this->assertNull($test->getTestResultObject());
}
public function testSizeUnknown(): void
{
$test = new \TestWithDifferentSizes('testWithSizeUnknown');
$this->assertFalse($test->hasSize());
$this->assertSame(TestUtil::UNKNOWN, $test->getSize());
$this->assertFalse($test->isLarge());
$this->assertFalse($test->isMedium());
$this->assertFalse($test->isSmall());
}
public function testSizeLarge(): void
{
$test = new \TestWithDifferentSizes('testWithSizeLarge');
$this->assertTrue($test->hasSize());
$this->assertSame(TestUtil::LARGE, $test->getSize());
$this->assertTrue($test->isLarge());
$this->assertFalse($test->isMedium());
$this->assertFalse($test->isSmall());
}
public function testSizeMedium(): void
{
$test = new \TestWithDifferentSizes('testWithSizeMedium');
$this->assertTrue($test->hasSize());
$this->assertSame(TestUtil::MEDIUM, $test->getSize());
$this->assertFalse($test->isLarge());
$this->assertTrue($test->isMedium());
$this->assertFalse($test->isSmall());
}
public function testSizeSmall(): void
{
$test = new \TestWithDifferentSizes('testWithSizeSmall');
$this->assertTrue($test->hasSize());
$this->assertSame(TestUtil::SMALL, $test->getSize());
$this->assertFalse($test->isLarge());
$this->assertFalse($test->isMedium());
$this->assertTrue($test->isSmall());
}
public function testGetNameReturnsMethodName(): void
{
$methodName = 'testWithName';
$testCase = new \TestWithDifferentNames($methodName);
$this->assertSame($methodName, $testCase->getName());
}
public function testGetNameReturnsEmptyStringAsDefault(): void
{
$testCase = new \TestWithDifferentNames();
$this->assertSame('', $testCase->getName());
}
/**
* @dataProvider providerInvalidName
*/
public function testRunBareThrowsExceptionWhenTestHasInvalidName($name): void
{
$testCase = new \TestWithDifferentNames($name);
$this->expectException(Exception::class);
$this->expectExceptionMessage('PHPUnit\Framework\TestCase::$name must be a non-blank string.');
$testCase->runBare();
}
public function providerInvalidName(): array
{
return [
'null' => [null],
'string-empty' => [''],
'string-blank' => [' '],
];
}
public function testHasFailedReturnsFalseWhenTestHasNotRunYet(): void
{
$test = new \TestWithDifferentStatuses();
$this->assertSame(BaseTestRunner::STATUS_UNKNOWN, $test->getStatus());
$this->assertFalse($test->hasFailed());
}
public function testHasFailedReturnsTrueWhenTestHasFailed(): void
{
$test = new \TestWithDifferentStatuses('testThatFails');
$test->run();
$this->assertSame(BaseTestRunner::STATUS_FAILURE, $test->getStatus());
$this->assertTrue($test->hasFailed());
}
public function testHasFailedReturnsTrueWhenTestHasErrored(): void
{
$test = new \TestWithDifferentStatuses('testThatErrors');
$test->run();
$this->assertSame(BaseTestRunner::STATUS_ERROR, $test->getStatus());
$this->assertTrue($test->hasFailed());
}
public function testHasFailedReturnsFalseWhenTestHasPassed(): void
{
$test = new \TestWithDifferentStatuses('testThatPasses');
$test->run();
$this->assertSame(BaseTestRunner::STATUS_PASSED, $test->getStatus());
$this->assertFalse($test->hasFailed());
}
public function testHasFailedReturnsFalseWhenTestHasBeenMarkedAsIncomplete(): void
{
$test = new \TestWithDifferentStatuses('testThatIsMarkedAsIncomplete');
$test->run();
$this->assertSame(BaseTestRunner::STATUS_INCOMPLETE, $test->getStatus());
$this->assertFalse($test->hasFailed());
}
public function testHasFailedReturnsFalseWhenTestHasBeenMarkedAsRisky(): void
{
$test = new \TestWithDifferentStatuses('testThatIsMarkedAsRisky');
$test->run();
$this->assertSame(BaseTestRunner::STATUS_RISKY, $test->getStatus());
$this->assertFalse($test->hasFailed());
}
public function testHasFailedReturnsFalseWhenTestHasBeenMarkedAsSkipped(): void
{
$test = new \TestWithDifferentStatuses('testThatIsMarkedAsSkipped');
$test->run();
$this->assertSame(BaseTestRunner::STATUS_SKIPPED, $test->getStatus());
$this->assertFalse($test->hasFailed());
}
public function testHasFailedReturnsFalseWhenTestHasEmittedWarning(): void
{
$test = new \TestWithDifferentStatuses('testThatAddsAWarning');
$test->run();
$this->assertSame(BaseTestRunner::STATUS_WARNING, $test->getStatus());
$this->assertFalse($test->hasFailed());
}
public function testHasOutputReturnsFalseWhenTestDoesNotGenerateOutput(): void
{
$test = new \TestWithDifferentOutput('testThatDoesNotGenerateOutput');
$test->run();
$this->assertFalse($test->hasOutput());
}
public function testHasOutputReturnsFalseWhenTestExpectsOutputRegex(): void
{
$test = new \TestWithDifferentOutput('testThatExpectsOutputRegex');
$test->run();
$this->assertFalse($test->hasOutput());
}
public function testHasOutputReturnsFalseWhenTestExpectsOutputString(): void
{
$test = new \TestWithDifferentOutput('testThatExpectsOutputString');
$test->run();
$this->assertFalse($test->hasOutput());
}
public function testHasOutputReturnsTrueWhenTestGeneratesOutput(): void
{
$test = new \TestWithDifferentOutput('testThatGeneratesOutput');
$test->run();
$this->assertTrue($test->hasOutput());
}
public function testDeprecationCanBeExpected(): void
{
$this->expectDeprecation();
$this->expectDeprecationMessage('foo');
$this->expectDeprecationMessageMatches('/foo/');
\trigger_error('foo', \E_USER_DEPRECATED);
}
public function testNoticeCanBeExpected(): void
{
$this->expectNotice();
$this->expectNoticeMessage('foo');
$this->expectNoticeMessageMatches('/foo/');
\trigger_error('foo', \E_USER_NOTICE);
}
public function testWarningCanBeExpected(): void
{
$this->expectWarning();
$this->expectWarningMessage('foo');
$this->expectWarningMessageMatches('/foo/');
\trigger_error('foo', \E_USER_WARNING);
}
public function testErrorCanBeExpected(): void
{
$this->expectError();
$this->expectErrorMessage('foo');
$this->expectErrorMessageMatches('/foo/');
\trigger_error('foo', \E_USER_ERROR);
}
/**
* @return array
*/
private function getAutoreferencedArray()
{
$recursionData = [];
$recursionData[] = &$recursionData;
return [
'RECURSION' => [
'data' => $recursionData,
],
];
}
}
PK ! D ' Framework/MockObject/MockObjectTest.phpnu Iw
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
use PHPUnit\Framework\ExpectationFailedException;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;
/**
* @small
*/
final class MockObjectTest extends TestCase
{
public function testMockedMethodIsNeverCalled(): void
{
$mock = $this->getMockBuilder(AnInterface::class)
->getMock();
$mock->expects($this->never())
->method('doSomething');
}
public function testMockedMethodIsNeverCalledWithParameter(): void
{
$mock = $this->getMockBuilder(SomeClass::class)
->getMock();
$mock->expects($this->never())
->method('doSomething')
->with('someArg');
}
/**
* @doesNotPerformAssertions
*/
public function testMockedMethodIsNotCalledWhenExpectsAnyWithParameter(): void
{
$mock = $this->getMockBuilder(SomeClass::class)
->getMock();
$mock->expects($this->any())
->method('doSomethingElse')
->with('someArg');
}
/**
* @doesNotPerformAssertions
*/
public function testMockedMethodIsNotCalledWhenMethodSpecifiedDirectlyWithParameter(): void
{
$mock = $this->getMockBuilder(SomeClass::class)
->getMock();
$mock->method('doSomethingElse')
->with('someArg');
}
public function testMockedMethodIsCalledAtLeastOnce(): void
{
$mock = $this->getMockBuilder(AnInterface::class)
->getMock();
$mock->expects($this->atLeastOnce())
->method('doSomething');
$mock->doSomething();
}
public function testMockedMethodIsCalledAtLeastOnce2(): void
{
$mock = $this->getMockBuilder(AnInterface::class)
->getMock();
$mock->expects($this->atLeastOnce())
->method('doSomething');
$mock->doSomething();
$mock->doSomething();
}
public function testMockedMethodIsCalledAtLeastTwice(): void
{
$mock = $this->getMockBuilder(AnInterface::class)
->getMock();
$mock->expects($this->atLeast(2))
->method('doSomething');
$mock->doSomething();
$mock->doSomething();
}
public function testMockedMethodIsCalledAtLeastTwice2(): void
{
$mock = $this->getMockBuilder(AnInterface::class)
->getMock();
$mock->expects($this->atLeast(2))
->method('doSomething');
$mock->doSomething();
$mock->doSomething();
$mock->doSomething();
}
public function testMockedMethodIsCalledAtMostTwice(): void
{
$mock = $this->getMockBuilder(AnInterface::class)
->getMock();
$mock->expects($this->atMost(2))
->method('doSomething');
$mock->doSomething();
$mock->doSomething();
}
public function testMockedMethodIsCalledAtMosttTwice2(): void
{
$mock = $this->getMockBuilder(AnInterface::class)
->getMock();
$mock->expects($this->atMost(2))
->method('doSomething');
$mock->doSomething();
}
public function testMockedMethodIsCalledOnce(): void
{
$mock = $this->getMockBuilder(AnInterface::class)
->getMock();
$mock->expects($this->once())
->method('doSomething');
$mock->doSomething();
}
public function testMockedMethodIsCalledOnceWithParameter(): void
{
$mock = $this->getMockBuilder(SomeClass::class)
->getMock();
$mock->expects($this->once())
->method('doSomethingElse')
->with($this->equalTo('something'));
$mock->doSomethingElse('something');
}
public function testMockedMethodIsCalledExactly(): void
{
$mock = $this->getMockBuilder(AnInterface::class)
->getMock();
$mock->expects($this->exactly(2))
->method('doSomething');
$mock->doSomething();
$mock->doSomething();
}
public function testStubbedException(): void
{
$mock = $this->getMockBuilder(AnInterface::class)
->getMock();
$mock->expects($this->any())
->method('doSomething')
->will($this->throwException(new \Exception));
$this->expectException(\Exception::class);
$mock->doSomething();
}
public function testStubbedWillThrowException(): void
{
$mock = $this->getMockBuilder(AnInterface::class)
->getMock();
$mock->expects($this->any())
->method('doSomething')
->willThrowException(new \Exception);
$this->expectException(\Exception::class);
$mock->doSomething();
}
public function testStubbedReturnValue(): void
{
$mock = $this->getMockBuilder(AnInterface::class)
->getMock();
$mock->expects($this->any())
->method('doSomething')
->will($this->returnValue('something'));
$this->assertEquals('something', $mock->doSomething());
$mock = $this->getMockBuilder(AnInterface::class)
->getMock();
$mock->expects($this->any())
->method('doSomething')
->willReturn('something');
$this->assertEquals('something', $mock->doSomething());
}
public function testStubbedReturnValueMap(): void
{
$map = [
['a', 'b', 'c', 'd'],
['e', 'f', 'g', 'h'],
];
$mock = $this->getMockBuilder(AnInterface::class)
->getMock();
$mock->expects($this->any())
->method('doSomething')
->will($this->returnValueMap($map));
$this->assertEquals('d', $mock->doSomething('a', 'b', 'c'));
$this->assertEquals('h', $mock->doSomething('e', 'f', 'g'));
$this->assertNull($mock->doSomething('foo', 'bar'));
$mock = $this->getMockBuilder(AnInterface::class)
->getMock();
$mock->expects($this->any())
->method('doSomething')
->willReturnMap($map);
$this->assertEquals('d', $mock->doSomething('a', 'b', 'c'));
$this->assertEquals('h', $mock->doSomething('e', 'f', 'g'));
$this->assertNull($mock->doSomething('foo', 'bar'));
}
public function testStubbedReturnArgument(): void
{
$mock = $this->getMockBuilder(AnInterface::class)
->getMock();
$mock->expects($this->any())
->method('doSomething')
->will($this->returnArgument(1));
$this->assertEquals('b', $mock->doSomething('a', 'b'));
$mock = $this->getMockBuilder(AnInterface::class)
->getMock();
$mock->expects($this->any())
->method('doSomething')
->willReturnArgument(1);
$this->assertEquals('b', $mock->doSomething('a', 'b'));
}
public function testFunctionCallback(): void
{
$mock = $this->getMockBuilder(SomeClass::class)
->setMethods(['doSomething'])
->getMock();
$mock->expects($this->once())
->method('doSomething')
->will($this->returnCallback('FunctionCallbackWrapper::functionCallback'));
$this->assertEquals('pass', $mock->doSomething('foo', 'bar'));
$mock = $this->getMockBuilder(SomeClass::class)
->setMethods(['doSomething'])
->getMock();
$mock->expects($this->once())
->method('doSomething')
->willReturnCallback('FunctionCallbackWrapper::functionCallback');
$this->assertEquals('pass', $mock->doSomething('foo', 'bar'));
}
public function testStubbedReturnSelf(): void
{
$mock = $this->getMockBuilder(AnInterface::class)
->getMock();
$mock->expects($this->any())
->method('doSomething')
->will($this->returnSelf());
$this->assertEquals($mock, $mock->doSomething());
$mock = $this->getMockBuilder(AnInterface::class)
->getMock();
$mock->expects($this->any())
->method('doSomething')
->willReturnSelf();
$this->assertEquals($mock, $mock->doSomething());
}
public function testStubbedReturnOnConsecutiveCalls(): void
{
$mock = $this->getMockBuilder(AnInterface::class)
->getMock();
$mock->expects($this->any())
->method('doSomething')
->will($this->onConsecutiveCalls('a', 'b', 'c'));
$this->assertEquals('a', $mock->doSomething());
$this->assertEquals('b', $mock->doSomething());
$this->assertEquals('c', $mock->doSomething());
$mock = $this->getMockBuilder(AnInterface::class)
->getMock();
$mock->expects($this->any())
->method('doSomething')
->willReturnOnConsecutiveCalls('a', 'b', 'c');
$this->assertEquals('a', $mock->doSomething());
$this->assertEquals('b', $mock->doSomething());
$this->assertEquals('c', $mock->doSomething());
}
public function testStaticMethodCallback(): void
{
$mock = $this->getMockBuilder(SomeClass::class)
->setMethods(['doSomething'])
->getMock();
$mock->expects($this->once())
->method('doSomething')
->will($this->returnCallback(['MethodCallback', 'staticCallback']));
$this->assertEquals('pass', $mock->doSomething('foo', 'bar'));
}
public function testPublicMethodCallback(): void
{
$mock = $this->getMockBuilder(SomeClass::class)
->setMethods(['doSomething'])
->getMock();
$mock->expects($this->once())
->method('doSomething')
->will($this->returnCallback([new MethodCallback, 'nonStaticCallback']));
$this->assertEquals('pass', $mock->doSomething('foo', 'bar'));
}
public function testMockClassOnlyGeneratedOnce(): void
{
$mock1 = $this->getMockBuilder(AnInterface::class)
->getMock();
$mock2 = $this->getMockBuilder(AnInterface::class)
->getMock();
$this->assertEquals(\get_class($mock1), \get_class($mock2));
}
public function testMockClassDifferentForPartialMocks(): void
{
$mock1 = $this->getMockBuilder(PartialMockTestClass::class)
->getMock();
$mock2 = $this->getMockBuilder(PartialMockTestClass::class)
->setMethods(['doSomething'])
->getMock();
$mock3 = $this->getMockBuilder(PartialMockTestClass::class)
->setMethods(['doSomething'])
->getMock();
$mock4 = $this->getMockBuilder(PartialMockTestClass::class)
->setMethods(['doAnotherThing'])
->getMock();
$mock5 = $this->getMockBuilder(PartialMockTestClass::class)
->setMethods(['doAnotherThing'])
->getMock();
$this->assertNotEquals(\get_class($mock1), \get_class($mock2));
$this->assertNotEquals(\get_class($mock1), \get_class($mock3));
$this->assertNotEquals(\get_class($mock1), \get_class($mock4));
$this->assertNotEquals(\get_class($mock1), \get_class($mock5));
$this->assertEquals(\get_class($mock2), \get_class($mock3));
$this->assertNotEquals(\get_class($mock2), \get_class($mock4));
$this->assertNotEquals(\get_class($mock2), \get_class($mock5));
$this->assertEquals(\get_class($mock4), \get_class($mock5));
}
public function testMockClassStoreOverrulable(): void
{
$mock1 = $this->getMockBuilder(PartialMockTestClass::class)
->getMock();
$mock2 = $this->getMockBuilder(PartialMockTestClass::class)
->setMockClassName('MyMockClassNameForPartialMockTestClass1')
->getMock();
$mock3 = $this->getMockBuilder(PartialMockTestClass::class)
->getMock();
$mock4 = $this->getMockBuilder(PartialMockTestClass::class)
->setMethods(['doSomething'])
->setMockClassName('AnotherMockClassNameForPartialMockTestClass')
->getMock();
$mock5 = $this->getMockBuilder(PartialMockTestClass::class)
->setMockClassName('MyMockClassNameForPartialMockTestClass2')
->getMock();
$this->assertNotEquals(\get_class($mock1), \get_class($mock2));
$this->assertEquals(\get_class($mock1), \get_class($mock3));
$this->assertNotEquals(\get_class($mock1), \get_class($mock4));
$this->assertNotEquals(\get_class($mock2), \get_class($mock3));
$this->assertNotEquals(\get_class($mock2), \get_class($mock4));
$this->assertNotEquals(\get_class($mock2), \get_class($mock5));
$this->assertNotEquals(\get_class($mock3), \get_class($mock4));
$this->assertNotEquals(\get_class($mock3), \get_class($mock5));
$this->assertNotEquals(\get_class($mock4), \get_class($mock5));
}
public function testGetMockWithFixedClassNameCanProduceTheSameMockTwice(): void
{
$mock = $this->getMockBuilder(stdClass::class)->setMockClassName('FixedName')->getMock();
$this->assertInstanceOf(stdClass::class, $mock);
}
public function testOriginalConstructorSettingConsidered(): void
{
$mock1 = $this->getMockBuilder(PartialMockTestClass::class)
->getMock();
$mock2 = $this->getMockBuilder(PartialMockTestClass::class)
->disableOriginalConstructor()
->getMock();
$this->assertTrue($mock1->constructorCalled);
$this->assertFalse($mock2->constructorCalled);
}
public function testOriginalCloneSettingConsidered(): void
{
$mock1 = $this->getMockBuilder(PartialMockTestClass::class)
->getMock();
$mock2 = $this->getMockBuilder(PartialMockTestClass::class)
->disableOriginalClone()
->getMock();
$this->assertNotEquals(\get_class($mock1), \get_class($mock2));
}
/**
* @testdox getMock() for abstract class
*/
public function testGetMockForAbstractClass(): void
{
$mock = $this->getMockBuilder(AbstractMockTestClass::class)
->getMock();
$mock->expects($this->never())
->method('doSomething');
}
/**
* @testdox getMock() for Traversable $_dataName
* @dataProvider traversableProvider
*/
public function testGetMockForTraversable($type): void
{
$mock = $this->getMockBuilder($type)
->getMock();
$this->assertInstanceOf(Traversable::class, $mock);
}
/**
* @testdox getMockForTrait()
*/
public function testGetMockForTrait(): void
{
$mock = $this->getMockForTrait(AbstractTrait::class);
$mock->expects($this->never())
->method('doSomething');
$parent = \get_parent_class($mock);
$traits = \class_uses($parent, false);
$this->assertContains(AbstractTrait::class, $traits);
}
public function testClonedMockObjectShouldStillEqualTheOriginal(): void
{
$a = $this->getMockBuilder(stdClass::class)
->getMock();
$b = clone $a;
$this->assertEquals($a, $b);
}
public function testMockObjectsConstructedIndepentantlyShouldBeEqual(): void
{
$a = $this->getMockBuilder(stdClass::class)
->getMock();
$b = $this->getMockBuilder(stdClass::class)
->getMock();
$this->assertEquals($a, $b);
}
public function testMockObjectsConstructedIndepentantlyShouldNotBeTheSame(): void
{
$a = $this->getMockBuilder(stdClass::class)
->getMock();
$b = $this->getMockBuilder(stdClass::class)
->getMock();
$this->assertNotSame($a, $b);
}
public function testClonedMockObjectCanBeUsedInPlaceOfOriginalOne(): void
{
$x = $this->getMockBuilder(stdClass::class)
->getMock();
$y = clone $x;
$mock = $this->getMockBuilder(stdClass::class)
->setMethods(['foo'])
->getMock();
$mock->expects($this->once())
->method('foo')
->with($this->equalTo($x));
$mock->foo($y);
}
public function testClonedMockObjectIsNotIdenticalToOriginalOne(): void
{
$x = $this->getMockBuilder(stdClass::class)
->getMock();
$y = clone $x;
$mock = $this->getMockBuilder(stdClass::class)
->setMethods(['foo'])
->getMock();
$mock->expects($this->once())
->method('foo')
->with($this->logicalNot($this->identicalTo($x)));
$mock->foo($y);
}
public function testObjectMethodCallWithArgumentCloningEnabled(): void
{
$expectedObject = new stdClass;
$mock = $this->getMockBuilder('SomeClass')
->setMethods(['doSomethingElse'])
->enableArgumentCloning()
->getMock();
$actualArguments = [];
$mock->expects($this->any())
->method('doSomethingElse')
->will(
$this->returnCallback(
function () use (&$actualArguments): void {
$actualArguments = \func_get_args();
}
)
);
$mock->doSomethingElse($expectedObject);
$this->assertCount(1, $actualArguments);
$this->assertEquals($expectedObject, $actualArguments[0]);
$this->assertNotSame($expectedObject, $actualArguments[0]);
}
public function testObjectMethodCallWithArgumentCloningDisabled(): void
{
$expectedObject = new stdClass;
$mock = $this->getMockBuilder('SomeClass')
->setMethods(['doSomethingElse'])
->disableArgumentCloning()
->getMock();
$actualArguments = [];
$mock->expects($this->any())
->method('doSomethingElse')
->will(
$this->returnCallback(
function () use (&$actualArguments): void {
$actualArguments = \func_get_args();
}
)
);
$mock->doSomethingElse($expectedObject);
$this->assertCount(1, $actualArguments);
$this->assertSame($expectedObject, $actualArguments[0]);
}
public function testArgumentCloningOptionGeneratesUniqueMock(): void
{
$mockWithCloning = $this->getMockBuilder('SomeClass')
->setMethods(['doSomethingElse'])
->enableArgumentCloning()
->getMock();
$mockWithoutCloning = $this->getMockBuilder('SomeClass')
->setMethods(['doSomethingElse'])
->disableArgumentCloning()
->getMock();
$this->assertNotEquals($mockWithCloning, $mockWithoutCloning);
}
public function testVerificationOfMethodNameFailsWithoutParameters(): void
{
$mock = $this->getMockBuilder(SomeClass::class)
->setMethods(['right', 'wrong'])
->getMock();
$mock->expects($this->once())
->method('right');
$mock->wrong();
try {
$mock->__phpunit_verify();
$this->fail('Expected exception');
} catch (ExpectationFailedException $e) {
$this->assertSame(
"Expectation failed for method name is \"right\" when invoked 1 time(s).\n" .
'Method was expected to be called 1 times, actually called 0 times.' . "\n",
$e->getMessage()
);
}
$this->resetMockObjects();
}
public function testVerificationOfMethodNameFailsWithParameters(): void
{
$mock = $this->getMockBuilder(SomeClass::class)
->setMethods(['right', 'wrong'])
->getMock();
$mock->expects($this->once())
->method('right');
$mock->wrong();
try {
$mock->__phpunit_verify();
$this->fail('Expected exception');
} catch (ExpectationFailedException $e) {
$this->assertSame(
"Expectation failed for method name is \"right\" when invoked 1 time(s).\n" .
'Method was expected to be called 1 times, actually called 0 times.' . "\n",
$e->getMessage()
);
}
$this->resetMockObjects();
}
public function testVerificationOfMethodNameFailsWithWrongParameters(): void
{
$mock = $this->getMockBuilder(SomeClass::class)
->setMethods(['right', 'wrong'])
->getMock();
$mock->expects($this->once())
->method('right')
->with(['first', 'second']);
try {
$mock->right(['second']);
} catch (ExpectationFailedException $e) {
$this->assertSame(
"Expectation failed for method name is \"right\" when invoked 1 time(s)\n" .
'Parameter 0 for invocation SomeClass::right(Array (...)) does not match expected value.' . "\n" .
'Failed asserting that two arrays are equal.',
$e->getMessage()
);
}
try {
$mock->__phpunit_verify();
// CHECKOUT THIS MORE CAREFULLY
// $this->fail('Expected exception');
} catch (ExpectationFailedException $e) {
$this->assertSame(
"Expectation failed for method name is \"right\" when invoked 1 time(s).\n" .
'Parameter 0 for invocation SomeClass::right(Array (...)) does not match expected value.' . "\n" .
'Failed asserting that two arrays are equal.' . "\n" .
'--- Expected' . "\n" .
'+++ Actual' . "\n" .
'@@ @@' . "\n" .
' Array (' . "\n" .
'- 0 => \'first\'' . "\n" .
'- 1 => \'second\'' . "\n" .
'+ 0 => \'second\'' . "\n" .
' )' . "\n",
$e->getMessage()
);
}
$this->resetMockObjects();
}
public function testVerificationOfNeverFailsWithEmptyParameters(): void
{
$mock = $this->getMockBuilder(SomeClass::class)
->setMethods(['right', 'wrong'])
->getMock();
$mock->expects($this->never())
->method('right')
->with();
try {
$mock->right();
$this->fail('Expected exception');
} catch (ExpectationFailedException $e) {
$this->assertSame(
'SomeClass::right() was not expected to be called.',
$e->getMessage()
);
}
$this->resetMockObjects();
}
public function testVerificationOfNeverFailsWithAnyParameters(): void
{
$mock = $this->getMockBuilder(SomeClass::class)
->setMethods(['right', 'wrong'])
->getMock();
$mock->expects($this->never())
->method('right')
->withAnyParameters();
try {
$mock->right();
$this->fail('Expected exception');
} catch (ExpectationFailedException $e) {
$this->assertSame(
'SomeClass::right() was not expected to be called.',
$e->getMessage()
);
}
$this->resetMockObjects();
}
public function testWithAnythingInsteadOfWithAnyParameters(): void
{
$mock = $this->getMockBuilder(SomeClass::class)
->setMethods(['right', 'wrong'])
->getMock();
$mock->expects($this->once())
->method('right')
->with($this->anything());
try {
$mock->right();
$this->fail('Expected exception');
} catch (ExpectationFailedException $e) {
$this->assertSame(
"Expectation failed for method name is \"right\" when invoked 1 time(s)\n" .
'Parameter count for invocation SomeClass::right() is too low.' . "\n" .
'To allow 0 or more parameters with any value, omit ->with() or use ->withAnyParameters() instead.',
$e->getMessage()
);
}
$this->resetMockObjects();
}
/**
* See https://github.com/sebastianbergmann/phpunit-mock-objects/issues/81
*/
public function testMockArgumentsPassedByReference(): void
{
$foo = $this->getMockBuilder('MethodCallbackByReference')
->setMethods(['bar'])
->disableOriginalConstructor()
->disableArgumentCloning()
->getMock();
$foo->expects($this->any())
->method('bar')
->will($this->returnCallback([$foo, 'callback']));
$a = $b = $c = 0;
$foo->bar($a, $b, $c);
$this->assertEquals(1, $b);
}
/**
* See https://github.com/sebastianbergmann/phpunit-mock-objects/issues/81
*/
public function testMockArgumentsPassedByReference2(): void
{
$foo = $this->getMockBuilder('MethodCallbackByReference')
->disableOriginalConstructor()
->disableArgumentCloning()
->getMock();
$foo->expects($this->any())
->method('bar')
->will($this->returnCallback(
function (&$a, &$b, $c): void {
$b = 1;
}
));
$a = $b = $c = 0;
$foo->bar($a, $b, $c);
$this->assertEquals(1, $b);
}
/**
* @see https://github.com/sebastianbergmann/phpunit-mock-objects/issues/116
*/
public function testMockArgumentsPassedByReference3(): void
{
$foo = $this->getMockBuilder('MethodCallbackByReference')
->setMethods(['bar'])
->disableOriginalConstructor()
->disableArgumentCloning()
->getMock();
$a = new stdClass;
$b = $c = 0;
$foo->expects($this->any())
->method('bar')
->with($a, $b, $c)
->will($this->returnCallback([$foo, 'callback']));
$this->assertNull($foo->bar($a, $b, $c));
}
/**
* @see https://github.com/sebastianbergmann/phpunit/issues/796
*/
public function testMockArgumentsPassedByReference4(): void
{
$foo = $this->getMockBuilder('MethodCallbackByReference')
->setMethods(['bar'])
->disableOriginalConstructor()
->disableArgumentCloning()
->getMock();
$a = new stdClass;
$b = $c = 0;
$foo->expects($this->any())
->method('bar')
->with($this->isInstanceOf(stdClass::class), $b, $c)
->will($this->returnCallback([$foo, 'callback']));
$this->assertNull($foo->bar($a, $b, $c));
}
/**
* @requires extension soap
*/
public function testCreateMockFromWsdl(): void
{
$mock = $this->getMockFromWsdl(TEST_FILES_PATH . 'GoogleSearch.wsdl', 'WsdlMock');
$this->assertStringStartsWith(
'Mock_WsdlMock_',
\get_class($mock)
);
}
/**
* @requires extension soap
*/
public function testCreateNamespacedMockFromWsdl(): void
{
$mock = $this->getMockFromWsdl(TEST_FILES_PATH . 'GoogleSearch.wsdl', 'My\\Space\\WsdlMock');
$this->assertStringStartsWith(
'Mock_WsdlMock_',
\get_class($mock)
);
}
/**
* @requires extension soap
*/
public function testCreateTwoMocksOfOneWsdlFile(): void
{
$a = $this->getMockFromWsdl(TEST_FILES_PATH . 'GoogleSearch.wsdl');
$b = $this->getMockFromWsdl(TEST_FILES_PATH . 'GoogleSearch.wsdl');
$this->assertStringStartsWith('Mock_GoogleSearch_', \get_class($a));
$this->assertEquals(\get_class($a), \get_class($b));
}
/**
* @see https://github.com/sebastianbergmann/phpunit/issues/2573
* @ticket 2573
* @requires extension soap
*/
public function testCreateMockOfWsdlFileWithSpecialChars(): void
{
$mock = $this->getMockFromWsdl(TEST_FILES_PATH . 'Go ogle-Sea.rch.wsdl');
$this->assertStringStartsWith('Mock_GoogleSearch_', \get_class($mock));
}
/**
* @see https://github.com/sebastianbergmann/phpunit-mock-objects/issues/156
* @ticket 156
*/
public function testInterfaceWithStaticMethodCanBeStubbed(): void
{
$this->assertInstanceOf(
InterfaceWithStaticMethod::class,
$this->getMockBuilder(InterfaceWithStaticMethod::class)->getMock()
);
}
public function testInvokingStubbedStaticMethodRaisesException(): void
{
$mock = $this->getMockBuilder(ClassWithStaticMethod::class)->getMock();
$this->expectException(\PHPUnit\Framework\MockObject\BadMethodCallException::class);
$mock->staticMethod();
}
/**
* @see https://github.com/sebastianbergmann/phpunit-mock-objects/issues/171
* @ticket 171
*/
public function testStubForClassThatImplementsSerializableCanBeCreatedWithoutInvokingTheConstructor(): void
{
$this->assertInstanceOf(
ClassThatImplementsSerializable::class,
$this->getMockBuilder(ClassThatImplementsSerializable::class)
->disableOriginalConstructor()
->getMock()
);
}
public function testGetMockForClassWithSelfTypeHint(): void
{
$this->assertInstanceOf(
ClassWithSelfTypeHint::class,
$this->getMockBuilder(ClassWithSelfTypeHint::class)->getMock()
);
}
public function testStringableClassDoesNotThrow(): void
{
/** @var PHPUnit\Framework\MockObject\MockObject|StringableClass $mock */
$mock = $this->getMockBuilder(StringableClass::class)->getMock();
$this->assertIsString((string) $mock);
}
public function testStringableClassCanBeMocked(): void
{
/** @var PHPUnit\Framework\MockObject\MockObject|StringableClass $mock */
$mock = $this->getMockBuilder(StringableClass::class)->getMock();
$mock->method('__toString')->willReturn('foo');
$this->assertSame('foo', (string) $mock);
}
public function traversableProvider(): array
{
return [
'Traversable' => ['Traversable'],
'\Traversable' => ['\Traversable'],
'TraversableMockTestInterface' => ['TraversableMockTestInterface'],
];
}
public function testParameterCallbackConstraintOnlyEvaluatedOnce(): void
{
$mock = $this->getMockBuilder(Foo::class)->setMethods(['bar'])->getMock();
$expectedNumberOfCalls = 1;
$callCount = 0;
$mock->expects($this->exactly($expectedNumberOfCalls))->method('bar')
->with($this->callback(function ($argument) use (&$callCount) {
return $argument === 'call_' . $callCount++;
}));
for ($i = 0; $i < $expectedNumberOfCalls; $i++) {
$mock->bar('call_' . $i);
}
}
public function testReturnTypesAreMockedCorrectly(): void
{
/** @var ClassWithAllPossibleReturnTypes|MockObject $stub */
$stub = $this->createMock(ClassWithAllPossibleReturnTypes::class);
$this->assertNull($stub->methodWithNoReturnTypeDeclaration());
$this->assertSame('', $stub->methodWithStringReturnTypeDeclaration());
$this->assertSame(0.0, $stub->methodWithFloatReturnTypeDeclaration());
$this->assertSame(0, $stub->methodWithIntReturnTypeDeclaration());
$this->assertFalse($stub->methodWithBoolReturnTypeDeclaration());
$this->assertSame([], $stub->methodWithArrayReturnTypeDeclaration());
$this->assertInstanceOf(MockObject::class, $stub->methodWithClassReturnTypeDeclaration());
}
public function testDisableAutomaticReturnValueGeneration(): void
{
$mock = $this->getMockBuilder(SomeClass::class)
->disableAutoReturnValueGeneration()
->getMock();
$this->expectException(ExpectationFailedException::class);
$this->expectExceptionMessage(
'Return value inference disabled and no expectation set up for SomeClass::doSomethingElse()'
);
$mock->doSomethingElse(1);
}
public function testDisableAutomaticReturnValueGenerationWithToString(): void
{
/** @var PHPUnit\Framework\MockObject\MockObject|StringableClass $mock */
$mock = $this->getMockBuilder(StringableClass::class)
->disableAutoReturnValueGeneration()
->getMock();
(string) $mock;
try {
$mock->__phpunit_verify();
$this->fail('Exception expected');
} catch (ExpectationFailedException $e) {
$this->assertSame(
'Return value inference disabled and no expectation set up for StringableClass::__toString()',
$e->getMessage()
);
}
$this->resetMockObjects();
}
public function testVoidReturnTypeIsMockedCorrectly(): void
{
/** @var ClassWithAllPossibleReturnTypes|MockObject $stub */
$stub = $this->createMock(ClassWithAllPossibleReturnTypes::class);
$this->assertNull($stub->methodWithVoidReturnTypeDeclaration());
}
/**
* @requires PHP 7.2
*/
public function testObjectReturnTypeIsMockedCorrectly(): void
{
/** @var ClassWithAllPossibleReturnTypes|MockObject $stub */
$stub = $this->createMock(ClassWithAllPossibleReturnTypes::class);
$this->assertInstanceOf(stdClass::class, $stub->methodWithObjectReturnTypeDeclaration());
}
public function testTraitCanBeDoubled(): void
{
$object = $this->getObjectForTrait(ExampleTrait::class);
$this->assertSame('ohHai', $object->ohHai());
}
public function testTraitWithConstructorCanBeDoubled(): void
{
$object = $this->getObjectForTrait(TraitWithConstructor::class, ['value']);
$this->assertSame('value', $object->value());
}
private function resetMockObjects(): void
{
$refl = new ReflectionObject($this);
$refl = $refl->getParentClass();
$prop = $refl->getProperty('mockObjects');
$prop->setAccessible(true);
$prop->setValue($this, []);
}
}
PK ! f & Framework/MockObject/MockTraitTest.phpnu Iw
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace PHPUnit\Framework\MockObject;
use PHPUnit\Framework\TestCase;
final class MockTraitTest extends TestCase
{
public function testGenerateClassFromSource(): void
{
$mockName = 'PHPUnit\TestFixture\MockObject\MockTraitGenerated';
$file = __DIR__ . '/../../../_files/mock-object/MockTraitGenerated.tpl';
$mockTrait = new MockTrait(\file_get_contents($file), $mockName);
$mockTrait->generate();
$this->assertTrue(\trait_exists($mockName));
}
public function testGenerateReturnsNameOfGeneratedClass(): void
{
$mockName = 'PHPUnit\TestFixture\MockObject\MockTraitGenerated';
$mockTrait = new MockTrait('', $mockName);
$this->assertEquals($mockName, $mockTrait->generate());
}
}
PK ! & Framework/MockObject/MockClassTest.phpnu Iw
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace PHPUnit\Framework\MockObject;
use PHPUnit\Framework\TestCase;
use PHPUnit\TestFixture\MockObject\MockClassWithConfigurableMethods;
use SebastianBergmann\Type\Type;
final class MockClassTest extends TestCase
{
public function testGenerateClassFromSource(): void
{
$mockName = 'PHPUnit\TestFixture\MockObject\MockClassGenerated';
$file = __DIR__ . '/../../../_files/mock-object/MockClassGenerated.tpl';
$mockClass = new MockClass(\file_get_contents($file), $mockName, []);
$mockClass->generate();
$this->assertTrue(\class_exists($mockName));
}
public function testGenerateReturnsNameOfGeneratedClass(): void
{
$mockName = 'PHPUnit\TestFixture\MockObject\MockClassGenerated';
$mockClass = new MockClass('', $mockName, []);
$this->assertEquals($mockName, $mockClass->generate());
}
public function testConfigurableMethodsAreInitalized(): void
{
$configurableMethods = [new ConfigurableMethod('foo', Type::fromName('void', false))];
$mockClass = new MockClass('', MockClassWithConfigurableMethods::class, $configurableMethods);
$mockClass->generate();
$this->assertSame($configurableMethods, MockClassWithConfigurableMethods::getConfigurableMethods());
}
}
PK ! 7K# # 5 Framework/MockObject/Builder/InvocationMockerTest.phpnu Iw
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
use PHPUnit\Framework\Constraint\IsEqual;
use PHPUnit\Framework\MockObject\Builder\InvocationMocker;
use PHPUnit\Framework\MockObject\IncompatibleReturnValueException;
use PHPUnit\Framework\MockObject\InvocationHandler;
use PHPUnit\Framework\MockObject\Matcher;
use PHPUnit\Framework\MockObject\Stub\ReturnSelf;
use PHPUnit\Framework\MockObject\Stub\ReturnStub;
use PHPUnit\Framework\TestCase;
use PHPUnit\TestFixture\MockObject\ClassWithImplicitProtocol;
/**
* @covers \PHPUnit\Framework\MockObject\Builder\InvocationMocker
* @small
*/
final class InvocationMockerTest extends TestCase
{
public function testWillReturnWithOneValue(): void
{
$mock = $this->getMockBuilder(stdClass::class)
->setMethods(['foo'])
->getMock();
$mock->expects($this->any())
->method('foo')
->willReturn(1);
$this->assertEquals(1, $mock->foo());
}
public function testWillReturnWithMultipleValues(): void
{
$mock = $this->getMockBuilder(stdClass::class)
->setMethods(['foo'])
->getMock();
$mock->expects($this->any())
->method('foo')
->willReturn(1, 2, 3);
$this->assertEquals(1, $mock->foo());
$this->assertEquals(2, $mock->foo());
$this->assertEquals(3, $mock->foo());
}
public function testWillReturnOnConsecutiveCalls(): void
{
$mock = $this->getMockBuilder(stdClass::class)
->setMethods(['foo'])
->getMock();
$mock->expects($this->any())
->method('foo')
->willReturnOnConsecutiveCalls(1, 2, 3);
$this->assertEquals(1, $mock->foo());
$this->assertEquals(2, $mock->foo());
$this->assertEquals(3, $mock->foo());
}
public function testWillReturnByReference(): void
{
$mock = $this->getMockBuilder(stdClass::class)
->setMethods(['foo'])
->getMock();
$mock->expects($this->any())
->method('foo')
->willReturnReference($value);
$this->assertNull($mock->foo());
$value = 'foo';
$this->assertSame('foo', $mock->foo());
$value = 'bar';
$this->assertSame('bar', $mock->foo());
}
public function testWillFailWhenTryingToPerformExpectationUnconfigurableMethod(): void
{
$matcherCollection = new InvocationHandler([], false);
$invocationMocker = new InvocationMocker(
$matcherCollection,
new Matcher($this->any())
);
$this->expectException(RuntimeException::class);
$invocationMocker->method('someMethod');
}
public function testWillReturnFailsWhenTryingToReturnSingleIncompatibleValue(): void
{
$mock = $this->getMockBuilder(ClassWithAllPossibleReturnTypes::class)
->getMock();
$invocationMocker = $mock->method('methodWithBoolReturnTypeDeclaration');
$this->expectException(IncompatibleReturnValueException::class);
$this->expectExceptionMessage('Method methodWithBoolReturnTypeDeclaration may not return value of type integer, its return declaration is ": bool"');
$invocationMocker->willReturn(1);
}
public function testWillReturnFailsWhenTryingToReturnIncompatibleValueByConstraint(): void
{
$mock = $this->getMockBuilder(ClassWithAllPossibleReturnTypes::class)
->getMock();
$invocationMocker = $mock->method(new IsEqual('methodWithBoolReturnTypeDeclaration'));
$this->expectException(IncompatibleReturnValueException::class);
$this->expectExceptionMessage('Method methodWithBoolReturnTypeDeclaration may not return value of type integer, its return declaration is ": bool"');
$invocationMocker->willReturn(1);
}
public function testWillReturnFailsWhenTryingToReturnAtLeastOneIncompatibleValue(): void
{
$mock = $this->getMockBuilder(ClassWithAllPossibleReturnTypes::class)
->getMock();
$invocationMocker = $mock->method('methodWithBoolReturnTypeDeclaration');
$this->expectException(IncompatibleReturnValueException::class);
$this->expectExceptionMessage('Method methodWithBoolReturnTypeDeclaration may not return value of type integer, its return declaration is ": bool"');
$invocationMocker->willReturn(true, 1);
}
public function testWillReturnFailsWhenTryingToReturnSingleIncompatibleClass(): void
{
$mock = $this->getMockBuilder(ClassWithAllPossibleReturnTypes::class)
->getMock();
$invocationMocker = $mock->method('methodWithClassReturnTypeDeclaration');
$this->expectException(IncompatibleReturnValueException::class);
$this->expectExceptionMessage('Method methodWithClassReturnTypeDeclaration may not return value of type Foo, its return declaration is ": stdClass"');
$invocationMocker->willReturn(new Foo());
}
public function testWillReturnAllowsMatchersForMultipleMethodsWithDifferentReturnTypes(): void
{
/** @var ClassWithAllPossibleReturnTypes|\PHPUnit\Framework\MockObject\MockObject $mock */
$mock = $this->getMockBuilder(ClassWithAllPossibleReturnTypes::class)
->getMock();
$invocationMocker = $mock->method(new \PHPUnit\Framework\Constraint\IsAnything());
$invocationMocker->willReturn(true, 1);
$this->assertEquals(true, $mock->methodWithBoolReturnTypeDeclaration());
$this->assertEquals(1, $mock->methodWithIntReturnTypeDeclaration());
}
public function testWillReturnValidType(): void
{
$mock = $this->getMockBuilder(ClassWithAllPossibleReturnTypes::class)
->getMock();
$mock->expects($this->any())
->method('methodWithBoolReturnTypeDeclaration')
->willReturn(true);
$this->assertEquals(true, $mock->methodWithBoolReturnTypeDeclaration());
}
public function testWillReturnValidTypeForLowercaseCall(): void
{
$mock = $this->getMockBuilder(ClassWithAllPossibleReturnTypes::class)
->getMock();
$mock->expects($this->any())
->method('methodWithBoolReturnTypeDeclaration')
->willReturn(true);
$this->assertEquals(true, $mock->methodwithboolreturntypedeclaration());
}
public function testWillReturnValidTypeForLowercaseMethod(): void
{
$mock = $this->getMockBuilder(ClassWithAllPossibleReturnTypes::class)
->getMock();
$mock->expects($this->any())
->method('methodwithboolreturntypedeclaration')
->willReturn(true);
$this->assertEquals(true, $mock->methodWithBoolReturnTypeDeclaration());
}
/**
* @see https://github.com/sebastianbergmann/phpunit/issues/3602
*/
public function testWillReturnFailsWhenTryingToReturnValueFromVoidMethod(): void
{
/** @var ClassWithAllPossibleReturnTypes|\PHPUnit\Framework\MockObject\MockObject $out */
$out = $this->createMock(ClassWithAllPossibleReturnTypes::class);
$method = $out->method('methodWithVoidReturnTypeDeclaration');
$this->expectException(IncompatibleReturnValueException::class);
$this->expectExceptionMessage('Method methodWithVoidReturnTypeDeclaration may not return value of type boolean, its return declaration is ": void"');
$method->willReturn(true);
}
public function testExpectationsAreEnabledByPreviousMethodCallWhenChainedWithAfter(): void
{
$mock = $this->createMock(ClassWithImplicitProtocol::class);
$mock->expects($this->once())
->method('firstCall')
->id($fristCallId = 'first-call-id');
$mock->expects($this->once())
->method('secondCall')
->after($fristCallId);
$mock->firstCall();
$mock->secondCall();
}
public function testExpectationsAreNotTriggeredUntilPreviousMethodWasCalled(): void
{
$mock = $this->createMock(ClassWithImplicitProtocol::class);
$mock->expects($this->once())
->method('firstCall')
->id($firstCallId = 'first-call-id');
$mock->expects($this->once())
->method('secondCall')
->after($firstCallId);
$mock->secondCall();
$mock->firstCall();
$mock->secondCall();
}
public function testWillReturnAlreadyInstantiatedStubs(): void
{
$mock = $this->getMockBuilder(stdClass::class)
->setMethods(['foo', 'bar'])
->getMock();
$mock->expects($this->any())
->method('foo')
->willReturn(new ReturnStub('foo'));
$mock->expects($this->any())
->method('bar')
->willReturn(new ReturnSelf());
$this->assertSame('foo', $mock->foo());
$this->assertSame($mock, $mock->bar());
}
}
PK ! Y : Framework/MockObject/Matcher/ConsecutiveParametersTest.phpnu Iw
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
use PHPUnit\Framework\ExpectationFailedException;
use PHPUnit\Framework\InvalidParameterGroupException;
use PHPUnit\Framework\TestCase;
/**
* @small
*/
final class ConsecutiveParametersTest extends TestCase
{
public function testIntegration(): void
{
$mock = $this->getMockBuilder(stdClass::class)
->setMethods(['foo'])
->getMock();
$mock->expects($this->any())
->method('foo')
->withConsecutive(
['bar'],
[21, 42]
);
$this->assertNull($mock->foo('bar'));
$this->assertNull($mock->foo(21, 42));
}
public function testIntegrationWithLessAssertionsThanMethodCalls(): void
{
$mock = $this->getMockBuilder(stdClass::class)
->setMethods(['foo'])
->getMock();
$mock->expects($this->any())
->method('foo')
->withConsecutive(
['bar']
);
$this->assertNull($mock->foo('bar'));
$this->assertNull($mock->foo(21, 42));
}
public function testIntegrationExpectingException(): void
{
$mock = $this->getMockBuilder(stdClass::class)
->setMethods(['foo'])
->getMock();
$mock->expects($this->any())
->method('foo')
->withConsecutive(
['bar'],
[21, 42]
);
$mock->foo('bar');
$this->expectException(ExpectationFailedException::class);
$mock->foo('invalid');
}
public function testIntegrationFailsWithNonIterableParameterGroup(): void
{
$mock = $this->getMockBuilder(stdClass::class)
->setMethods(['foo'])
->getMock();
$this->expectException(InvalidParameterGroupException::class);
$this->expectExceptionMessage('Parameter group #1 must be an array or Traversable, got object');
$mock->expects($this->any())
->method('foo')
->withConsecutive(
['bar'],
$this->identicalTo([21, 42]) // this is not an array
);
}
}
PK ! ?; ' Framework/MockObject/MockMethodTest.phpnu Iw
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace PHPUnit\Framework\MockObject;
use PHPUnit\Framework\TestCase;
use PHPUnit\TestFixture\MockObject\ClassWithoutParentButParentReturnType;
use SebastianBergmann\Type\UnknownType;
/**
* @small
*/
final class MockMethodTest extends TestCase
{
public function testGetNameReturnsMethodName(): void
{
$method = new MockMethod(
'ClassName',
'methodName',
false,
'',
'',
'',
new UnknownType,
'',
false,
false,
null,
false
);
$this->assertEquals('methodName', $method->getName());
}
/**
* @requires PHP < 7.4
*/
public function testFailWhenReturnTypeIsParentButThereIsNoParentClass(): void
{
$class = new \ReflectionClass(ClassWithoutParentButParentReturnType::class);
$this->expectException(\RuntimeException::class);
MockMethod::fromReflection($class->getMethod('foo'), false, false);
}
}
PK ! q( ( & Framework/MockObject/GeneratorTest.phpnu Iw
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
use PHPUnit\Framework\MockObject\Generator;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;
/**
* @covers \PHPUnit\Framework\MockObject\Generator
*
* @uses \PHPUnit\Framework\MockObject\InvocationHandler
* @uses \PHPUnit\Framework\MockObject\Builder\InvocationMocker
* @uses \PHPUnit\Framework\MockObject\Invocation
* @uses \PHPUnit\Framework\MockObject\Matcher
* @uses \PHPUnit\Framework\MockObject\Rule\InvocationOrder
* @uses \PHPUnit\Framework\MockObject\Rule\MethodName
* @uses \PHPUnit\Framework\MockObject\Stub\ReturnStub
* @uses \PHPUnit\Framework\MockObject\Rule\InvokedCount
*
* @small
*/
final class GeneratorTest extends TestCase
{
/**
* @var Generator
*/
private $generator;
protected function setUp(): void
{
$this->generator = new Generator;
}
public function testGetMockThrowsExceptionWhenInvalidFunctionNameIsPassedInAsAFunctionToMock(): void
{
$this->expectException(\PHPUnit\Framework\MockObject\RuntimeException::class);
$this->generator->getMock(stdClass::class, [0]);
}
public function testGetMockThrowsExceptionWithInvalidClassArgumentType(): void
{
$this->expectException(\PHPUnit\Framework\InvalidArgumentException::class);
$this->generator->getMock(false);
}
public function testGetMockThrowsExceptionWithInvalidMethods(): void
{
$this->expectException(\PHPUnit\Framework\InvalidArgumentException::class);
$this->generator->getMock(stdClass::class, false);
}
public function testGetMockThrowsExceptionWithNonExistingClass(): void
{
$this->expectException(\PHPUnit\Framework\MockObject\RuntimeException::class);
$this->assertFalse(\class_exists('Tux'));
$this->generator->getMock('Tux', [], [], '', true, true, false, true, false, null, false);
}
public function testGetMockThrowsExceptionWithNonExistingClasses(): void
{
$this->expectException(\PHPUnit\Framework\MockObject\RuntimeException::class);
$this->assertFalse(\class_exists('Tux'));
$this->generator->getMock(['Tux', false], [], [], '', true, true, false, true, false, null, false);
}
public function testGetMockThrowsExceptionWithExistingClassAsMockName(): void
{
$this->expectException(\PHPUnit\Framework\MockObject\RuntimeException::class);
$this->generator->getMock(stdClass::class, [], [], RuntimeException::class);
}
public function testGetMockCanCreateNonExistingFunctions(): void
{
$mock = $this->generator->getMock(stdClass::class, ['testFunction']);
$this->assertTrue(\method_exists($mock, 'testFunction'));
}
public function testGetMockGeneratorThrowsException(): void
{
$this->expectException(\PHPUnit\Framework\MockObject\RuntimeException::class);
$this->expectExceptionMessage('duplicates: "foo, bar, foo" (duplicate: "foo")');
$this->generator->getMock(stdClass::class, ['foo', 'bar', 'foo']);
}
public function testGetMockBlacklistedMethodNamesPhp7(): void
{
$mock = $this->generator->getMock(InterfaceWithSemiReservedMethodName::class);
$this->assertTrue(\method_exists($mock, 'unset'));
$this->assertInstanceOf(InterfaceWithSemiReservedMethodName::class, $mock);
}
public function testGetMockForAbstractClassDoesNotFailWhenFakingInterfaces(): void
{
$mock = $this->generator->getMockForAbstractClass(Countable::class);
$this->assertTrue(\method_exists($mock, 'count'));
}
public function testGetMockForAbstractClassStubbingAbstractClass(): void
{
$mock = $this->generator->getMockForAbstractClass(AbstractMockTestClass::class);
$this->assertTrue(\method_exists($mock, 'doSomething'));
}
public function testGetMockForAbstractClassWithNonExistentMethods(): void
{
$mock = $this->generator->getMockForAbstractClass(
AbstractMockTestClass::class,
[],
'',
true,
true,
true,
['nonexistentMethod']
);
$this->assertTrue(\method_exists($mock, 'nonexistentMethod'));
$this->assertTrue(\method_exists($mock, 'doSomething'));
}
public function testGetMockForAbstractClassShouldCreateStubsOnlyForAbstractMethodWhenNoMethodsWereInformed(): void
{
$mock = $this->generator->getMockForAbstractClass(AbstractMockTestClass::class);
$mock->expects($this->any())
->method('doSomething')
->willReturn('testing');
$this->assertEquals('testing', $mock->doSomething());
$this->assertEquals(1, $mock->returnAnything());
}
public function testGetMockForAbstractClassAbstractClassDoesNotExist(): void
{
$this->expectException(\PHPUnit\Framework\MockObject\RuntimeException::class);
$this->generator->getMockForAbstractClass('Tux');
}
public function testGetMockForTraitWithNonExistentMethodsAndNonAbstractMethods(): void
{
$mock = $this->generator->getMockForTrait(
AbstractTrait::class,
[],
'',
true,
true,
true,
['nonexistentMethod']
);
$this->assertTrue(\method_exists($mock, 'nonexistentMethod'));
$this->assertTrue(\method_exists($mock, 'doSomething'));
$this->assertTrue($mock->mockableMethod());
$this->assertTrue($mock->anotherMockableMethod());
}
public function testGetMockForTraitStubbingAbstractMethod(): void
{
$mock = $this->generator->getMockForTrait(AbstractTrait::class);
$this->assertTrue(\method_exists($mock, 'doSomething'));
}
public function testGetMockForTraitWithNonExistantTrait(): void
{
$this->expectException(\PHPUnit\Framework\MockObject\RuntimeException::class);
$mock = $this->generator->getMockForTrait('Tux');
}
public function testGetObjectForTraitWithNonExistantTrait(): void
{
$this->expectException(\PHPUnit\Framework\MockObject\RuntimeException::class);
$mock = $this->generator->getObjectForTrait('Tux');
}
public function testGetMockClassMethodsForNonExistantClass(): void
{
$this->expectException(\PHPUnit\Framework\MockObject\RuntimeException::class);
$mock = $this->generator->mockClassMethods('Tux', true, true);
}
public function testGetMockForSingletonWithReflectionSuccess(): void
{
$mock = $this->generator->getMock(SingletonClass::class, ['doSomething'], [], '', false);
$this->assertInstanceOf('SingletonClass', $mock);
}
public function testExceptionIsRaisedForMutuallyExclusiveOptions(): void
{
$this->expectException(\PHPUnit\Framework\MockObject\RuntimeException::class);
$this->generator->getMock(stdClass::class, [], [], '', false, true, true, true, true);
}
public function testCanImplementInterfacesThatHaveMethodsWithReturnTypes(): void
{
$stub = $this->generator->getMock([AnInterfaceWithReturnType::class, AnInterface::class]);
$this->assertInstanceOf(AnInterfaceWithReturnType::class, $stub);
$this->assertInstanceOf(AnInterface::class, $stub);
$this->assertInstanceOf(MockObject::class, $stub);
}
public function testCanConfigureMethodsForDoubleOfNonExistentClass(): void
{
$className = 'X' . \md5(\microtime());
$mock = $this->generator->getMock($className, ['someMethod']);
$this->assertInstanceOf($className, $mock);
}
public function testCanInvokeMethodsOfNonExistentClass(): void
{
$className = 'X' . \md5(\microtime());
$mock = $this->generator->getMock($className, ['someMethod']);
$mock->expects($this->once())->method('someMethod');
$this->assertNull($mock->someMethod());
}
public function testMockingOfExceptionWithThrowable(): void
{
$stub = $this->generator->getMock(ExceptionWithThrowable::class);
$this->assertInstanceOf(ExceptionWithThrowable::class, $stub);
$this->assertInstanceOf(Exception::class, $stub);
$this->assertInstanceOf(MockObject::class, $stub);
}
public function testMockingOfThrowable(): void
{
$stub = $this->generator->getMock(Throwable::class);
$this->assertInstanceOf(Throwable::class, $stub);
$this->assertInstanceOf(Exception::class, $stub);
$this->assertInstanceOf(MockObject::class, $stub);
}
public function testMockingOfThrowableConstructorArguments(): void
{
$mock = $this->generator->getMock(Throwable::class, null, ['It works']);
$this->assertSame('It works', $mock->getMessage());
}
public function testVariadicArgumentsArePassedToOriginalMethod(): void
{
/** @var ClassWithVariadicArgumentMethod|MockObject $mock */
$mock = $this->generator->getMock(
ClassWithVariadicArgumentMethod::class,
[],
[],
'',
true,
false,
true,
false,
true
);
$arguments = [1, 'foo', false];
$this->assertSame($arguments, $mock->foo(...$arguments));
}
public function testVariadicArgumentsArePassedToMockedMethod(): void
{
/** @var ClassWithVariadicArgumentMethod|MockObject $mock */
$mock = $this->createMock(ClassWithVariadicArgumentMethod::class);
$arguments = [1, 'foo', false];
$mock->expects($this->once())
->method('foo')
->with(...$arguments);
$mock->foo(...$arguments);
}
public function testGetClassMethodsWithNonExistingClass(): void
{
$this->expectException(\PHPUnit\Framework\MockObject\RuntimeException::class);
$this->generator->getClassMethods('Tux');
}
public function testCannotMockFinalClass(): void
{
$this->expectException(\PHPUnit\Framework\MockObject\RuntimeException::class);
$mock = $this->createMock(FinalClass::class);
}
}
PK ! ^" / Framework/MockObject/ConfigurableMethodTest.phpnu Iw
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace PHPUnit\Framework\MockObject;
use PHPUnit\Framework\TestCase;
use SebastianBergmann\Type\Type;
final class ConfigurableMethodTest extends TestCase
{
public function testMethodMayReturnAssignableValue(): void
{
$assignableType = $this->createMock(Type::class);
$assignableType->method('isAssignable')
->willReturn(true);
$configurable = new ConfigurableMethod('foo', $assignableType);
$this->assertTrue($configurable->mayReturn('everything-is-valid'));
}
public function testMethodMayNotReturnUnassignableValue(): void
{
$unassignableType = $this->createMock(Type::class);
$unassignableType->method('isAssignable')
->willReturn(false);
$configurable = new ConfigurableMethod('foo', $unassignableType);
$this->assertFalse($configurable->mayReturn('everything-is-invalid'));
}
}
PK ! ,$Q Q $ Framework/MockObject/MatcherTest.phpnu Iw
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace PHPUnit\Framework\MockObject;
use PHPUnit\Framework\ExpectationFailedException;
use PHPUnit\Framework\MockObject\Rule\InvocationOrder;
use PHPUnit\Framework\MockObject\Rule\MethodName;
use PHPUnit\Framework\MockObject\Rule\ParametersRule;
use PHPUnit\Framework\TestCase;
/**
* @covers \PHPUnit\Framework\MockObject\Matcher
*/
class MatcherTest extends TestCase
{
public function testParameterRuleIsAppliedToInvocation(): void
{
$invocationMatcher = $this->createStub(InvocationOrder::class);
$invocation = new Invocation('Foo', 'bar', [], 'void', new \stdClass);
$parameterRule = $this->createMock(ParametersRule::class);
$parameterRule->expects($this->once())
->method('apply')
->with($invocation);
$matcher = new Matcher($invocationMatcher);
$matcher->setMethodNameRule(new MethodName('bar'));
$matcher->setParametersRule($parameterRule);
$matcher->invoked($invocation);
}
public function testParametersRuleTriggersFailOfInvocation(): void
{
$invocationMatcher = $this->createStub(InvocationOrder::class);
$invocation = new Invocation('Foo', 'bar', [], 'void', new \stdClass);
$parameterRule = $this->createStub(ParametersRule::class);
$parameterRule->method('apply')
->willThrowException(new ExpectationFailedException('rule is always violated.'));
$matcher = new Matcher($invocationMatcher);
$matcher->setMethodNameRule(new MethodName('bar'));
$matcher->setParametersRule($parameterRule);
$this->expectException(ExpectationFailedException::class);
$this->expectExceptionMessage("Expectation failed for method name is \"bar\" when \nrule is always violated.");
$matcher->invoked($invocation);
}
public function testParameterRuleDoesNotInfluenceMatches(): void
{
$invocationMatcher = $this->createStub(InvocationOrder::class);
$invocationMatcher->method('matches')
->willReturn(true);
$invocation = new Invocation('Foo', 'bar', [], 'void', new \stdClass);
$matcher = new Matcher($invocationMatcher);
$matcher->setMethodNameRule(new MethodName('bar'));
$parameterRule = $this->createStub(ParametersRule::class);
$parameterRule->method('apply')
->willThrowException(new \Exception('This method should not have been called.'));
$matcher->setParametersRule($parameterRule);
$this->assertTrue($matcher->matches($invocation));
}
public function testStubIsNotInvokedIfParametersRuleIsViolated(): void
{
$invocationMatcher = $this->createStub(InvocationOrder::class);
$invocation = new Invocation('Foo', 'bar', [], 'void', new \stdClass);
$stub = $this->createMock(Stub\Stub::class);
$stub->expects($this->never())
->method('invoke');
$parameterRule = $this->createStub(ParametersRule::class);
$parameterRule->method('apply')
->willThrowException(new ExpectationFailedException('rule is always violated.'));
$matcher = new Matcher($invocationMatcher);
$matcher->setMethodNameRule(new MethodName('bar'));
$matcher->setParametersRule($parameterRule);
$matcher->setStub($stub);
try {
$matcher->invoked($invocation);
} catch (ExpectationFailedException $e) {
}
}
public function testStubIsInvokedIfAllMatchersAndRulesApply(): void
{
$invocationMatcher = $this->createStub(InvocationOrder::class);
$invocation = new Invocation('Foo', 'bar', [], 'void', new \stdClass);
$stub = $this->createMock(Stub\Stub::class);
$stub->expects($this->once())
->method('invoke')
->with($invocation);
$parameterRule = $this->createStub(ParametersRule::class);
$matcher = new Matcher($invocationMatcher);
$matcher->setMethodNameRule(new MethodName('bar'));
$matcher->setParametersRule($parameterRule);
$matcher->setStub($stub);
$matcher->invoked($invocation);
}
}
PK ! I^ . Framework/MockObject/InvocationHandlerTest.phpnu Iw
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace PHPUnit\Framework\MockObject;
use PHPUnit\Framework\TestCase;
class InvocationHandlerTest extends TestCase
{
public function testExceptionThrownIn__ToStringIsDeferred(): void
{
$mock = $this->createMock(\StringableClass::class);
$mock->method('__toString')
->willThrowException(new \RuntimeException('planned error'));
$this->expectException(\RuntimeException::class);
$this->expectExceptionMessage('planned error');
$mock->__toString();
}
}
PK ! ^q ( Framework/MockObject/ProxyObjectTest.phpnu Iw
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;
/**
* @small
*/
final class ProxyObjectTest extends TestCase
{
public function testProxyingWorksForMethodThatReturnsUndeclaredScalarValue(): void
{
$proxy = $this->createTestProxy(TestProxyFixture::class);
$proxy->expects($this->once())
->method('returnString');
\assert($proxy instanceof MockObject);
\assert($proxy instanceof TestProxyFixture);
$this->assertSame('result', $proxy->returnString());
}
public function testProxyingWorksForMethodThatReturnsDeclaredScalarValue(): void
{
$proxy = $this->createTestProxy(TestProxyFixture::class);
$proxy->expects($this->once())
->method('returnTypedString');
\assert($proxy instanceof MockObject);
\assert($proxy instanceof TestProxyFixture);
$this->assertSame('result', $proxy->returnTypedString());
}
public function testProxyingWorksForMethodThatReturnsUndeclaredObject(): void
{
$proxy = $this->createTestProxy(TestProxyFixture::class);
$proxy->expects($this->once())
->method('returnObject');
\assert($proxy instanceof MockObject);
\assert($proxy instanceof TestProxyFixture);
$this->assertSame('bar', $proxy->returnObject()->foo);
}
public function testProxyingWorksForMethodThatReturnsDeclaredObject(): void
{
$proxy = $this->createTestProxy(TestProxyFixture::class);
$proxy->expects($this->once())
->method('returnTypedObject');
\assert($proxy instanceof MockObject);
\assert($proxy instanceof TestProxyFixture);
$this->assertSame('bar', $proxy->returnTypedObject()->foo);
}
public function testProxyingWorksForMethodThatReturnsUndeclaredObjectOfFinalClass(): void
{
$proxy = $this->createTestProxy(TestProxyFixture::class);
$proxy->expects($this->once())
->method('returnObjectOfFinalClass');
\assert($proxy instanceof MockObject);
\assert($proxy instanceof TestProxyFixture);
$this->assertSame('value', $proxy->returnObjectOfFinalClass()->value());
}
public function testProxyingWorksForMethodThatReturnsDeclaredObjectOfFinalClass(): void
{
$proxy = $this->createTestProxy(TestProxyFixture::class);
$proxy->expects($this->once())
->method('returnTypedObjectOfFinalClass');
\assert($proxy instanceof MockObject);
\assert($proxy instanceof TestProxyFixture);
$this->assertSame('value', $proxy->returnTypedObjectOfFinalClass()->value());
}
}
PK ! ^&# # ( Framework/MockObject/MockBuilderTest.phpnu Iw
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
use PHPUnit\Framework\MockObject\MockBuilder;
use PHPUnit\Framework\TestCase;
/**
* @small
*/
final class MockBuilderTest extends TestCase
{
public function testMockBuilderRequiresClassName(): void
{
$mock = $this->getMockBuilder(Mockable::class)->getMock();
$this->assertInstanceOf(Mockable::class, $mock);
}
public function testByDefaultMocksAllMethods(): void
{
$mock = $this->getMockBuilder(Mockable::class)->getMock();
$this->assertNull($mock->mockableMethod());
$this->assertNull($mock->anotherMockableMethod());
}
public function testMethodsToMockCanBeSpecified(): void
{
$mock = $this->getMockBuilder(Mockable::class)
->setMethods(['mockableMethod'])
->getMock();
$this->assertNull($mock->mockableMethod());
$this->assertTrue($mock->anotherMockableMethod());
}
public function testMethodExceptionsToMockCanBeSpecified(): void
{
$mock = $this->getMockBuilder(Mockable::class)
->setMethodsExcept(['mockableMethod'])
->getMock();
$this->assertTrue($mock->mockableMethod());
$this->assertNull($mock->anotherMockableMethod());
}
public function testSetMethodsAllowsNonExistentMethodNames(): void
{
$mock = $this->getMockBuilder(Mockable::class)
->setMethods(['mockableMethodWithCrazyName'])
->getMock();
$this->assertNull($mock->mockableMethodWithCrazyName());
}
public function testOnlyMethodsWithNonExistentMethodNames(): void
{
$this->expectException(RuntimeException::class);
$this->expectExceptionMessage('Trying to set mock method "mockableMethodWithCrazyName" with onlyMethods, but it does not exist in class "Mockable". Use addMethods() for methods that don\'t exist in the class.');
$this->getMockBuilder(Mockable::class)
->onlyMethods(['mockableMethodWithCrazyName'])
->getMock();
}
public function testOnlyMethodsWithExistingMethodNames(): void
{
$mock = $this->getMockBuilder(Mockable::class)
->onlyMethods(['mockableMethod'])
->getMock();
$this->assertNull($mock->mockableMethod());
$this->assertTrue($mock->anotherMockableMethod());
}
public function testOnlyMethodsWithEmptyArray(): void
{
$mock = $this->getMockBuilder(Mockable::class)
->onlyMethods([])
->getMock();
$this->assertTrue($mock->mockableMethod());
}
public function testAddMethodsWithNonExistentMethodNames(): void
{
$this->expectException(RuntimeException::class);
$this->expectExceptionMessage('Trying to set mock method "mockableMethod" with addMethods(), but it exists in class "Mockable". Use onlyMethods() for methods that exist in the class.');
$this->getMockBuilder(Mockable::class)
->addMethods(['mockableMethod'])
->getMock();
}
public function testAddMethodsWithExistingMethodNames(): void
{
$mock = $this->getMockBuilder(Mockable::class)
->addMethods(['mockableMethodWithFakeMethod'])
->getMock();
$this->assertNull($mock->mockableMethodWithFakeMethod());
$this->assertTrue($mock->anotherMockableMethod());
}
public function testAddMethodsWithEmptyArray(): void
{
$mock = $this->getMockBuilder(Mockable::class)
->addMethods([])
->getMock();
$this->assertTrue($mock->mockableMethod());
}
public function testEmptyMethodExceptionsToMockCanBeSpecified(): void
{
$mock = $this->getMockBuilder(Mockable::class)
->setMethodsExcept()
->getMock();
$this->assertNull($mock->mockableMethod());
$this->assertNull($mock->anotherMockableMethod());
}
public function testAbleToUseAddMethodsAfterOnlyMethods(): void
{
$mock = $this->getMockBuilder(Mockable::class)
->onlyMethods(['mockableMethod'])
->addMethods(['mockableMethodWithFakeMethod'])
->getMock();
$this->assertNull($mock->mockableMethod());
$this->assertNull($mock->mockableMethodWithFakeMethod());
}
public function testAbleToUseOnlyMethodsAfterAddMethods(): void
{
$mock = $this->getMockBuilder(Mockable::class)
->addMethods(['mockableMethodWithFakeMethod'])
->onlyMethods(['mockableMethod'])
->getMock();
$this->assertNull($mock->mockableMethodWithFakeMethod());
$this->assertNull($mock->mockableMethod());
}
public function testAbleToUseSetMethodsAfterOnlyMethods(): void
{
$mock = $this->getMockBuilder(Mockable::class)
->onlyMethods(['mockableMethod'])
->setMethods(['mockableMethodWithCrazyName'])
->getMock();
$this->assertNull($mock->mockableMethodWithCrazyName());
}
public function testAbleToUseSetMethodsAfterAddMethods(): void
{
$mock = $this->getMockBuilder(Mockable::class)
->addMethods(['notAMethod'])
->setMethods(['mockableMethodWithCrazyName'])
->getMock();
$this->assertNull($mock->mockableMethodWithCrazyName());
}
public function testAbleToUseAddMethodsAfterSetMethods(): void
{
$mock = $this->getMockBuilder(Mockable::class)
->setMethods(['mockableMethod'])
->addMethods(['mockableMethodWithFakeMethod'])
->getMock();
$this->assertNull($mock->mockableMethod());
$this->assertNull($mock->mockableMethodWithFakeMethod());
}
public function testAbleToUseOnlyMethodsAfterSetMethods(): void
{
$mock = $this->getMockBuilder(Mockable::class)
->setMethods(['mockableMethodWithFakeMethod'])
->onlyMethods(['mockableMethod'])
->getMock();
$this->assertNull($mock->mockableMethod());
$this->assertNull($mock->mockableMethodWithFakeMethod());
}
public function testAbleToUseAddMethodsAfterSetMethodsWithNull(): void
{
$mock = $this->getMockBuilder(Mockable::class)
->setMethods()
->addMethods(['mockableMethodWithFakeMethod'])
->getMock();
$this->assertNull($mock->mockableMethodWithFakeMethod());
}
public function testByDefaultDoesNotPassArgumentsToTheConstructor(): void
{
$mock = $this->getMockBuilder(Mockable::class)->getMock();
$this->assertEquals([null, null], $mock->constructorArgs);
}
public function testMockClassNameCanBeSpecified(): void
{
$mock = $this->getMockBuilder(Mockable::class)
->setMockClassName('ACustomClassName')
->getMock();
$this->assertInstanceOf(ACustomClassName::class, $mock);
}
public function testConstructorArgumentsCanBeSpecified(): void
{
$mock = $this->getMockBuilder(Mockable::class)
->setConstructorArgs([23, 42])
->getMock();
$this->assertEquals([23, 42], $mock->constructorArgs);
}
public function testOriginalConstructorCanBeDisabled(): void
{
$mock = $this->getMockBuilder(Mockable::class)
->disableOriginalConstructor()
->getMock();
$this->assertNull($mock->constructorArgs);
}
public function testByDefaultOriginalCloneIsPreserved(): void
{
$mock = $this->getMockBuilder(Mockable::class)
->getMock();
$cloned = clone $mock;
$this->assertTrue($cloned->cloned);
}
public function testOriginalCloneCanBeDisabled(): void
{
$mock = $this->getMockBuilder(Mockable::class)
->disableOriginalClone()
->getMock();
$mock->cloned = false;
$cloned = clone $mock;
$this->assertFalse($cloned->cloned);
}
public function testProvidesAFluentInterface(): void
{
$spec = $this->getMockBuilder(Mockable::class)
->setMethods(['mockableMethod'])
->setConstructorArgs([])
->setMockClassName('DummyClassName')
->disableOriginalConstructor()
->disableOriginalClone()
->disableAutoload();
$this->assertInstanceOf(MockBuilder::class, $spec);
}
}
PK ! hŃM M 0 Framework/MockObject/ConfigurableMethodsTest.phpnu Iw
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace PHPUnit\Framework\MockObject;
use PHPUnit\Framework\TestCase;
use PHPUnit\TestFixture\MockObject\AnotherClassUsingConfigurableMethods;
use PHPUnit\TestFixture\MockObject\ClassUsingConfigurableMethods;
use PHPUnit\TestFixture\MockObject\ReinitializeConfigurableMethods;
use SebastianBergmann\Type\SimpleType;
final class ConfigurableMethodsTest extends TestCase
{
public function testTwoClassesUsingConfigurableMethodsDontInterfere(): void
{
$configurableMethodsA = [new ConfigurableMethod('foo', SimpleType::fromValue('boolean', false))];
$configurableMethodsB = [];
ClassUsingConfigurableMethods::__phpunit_initConfigurableMethods(...$configurableMethodsA);
AnotherClassUsingConfigurableMethods::__phpunit_initConfigurableMethods(...$configurableMethodsB);
$this->assertSame($configurableMethodsA, ClassUsingConfigurableMethods::getConfigurableMethods());
$this->assertSame($configurableMethodsB, AnotherClassUsingConfigurableMethods::getConfigurableMethods());
}
public function testConfigurableMethodsAreImmutable(): void
{
ReinitializeConfigurableMethods::__phpunit_initConfigurableMethods();
$this->expectException(ConfigurableMethodsAlreadyInitializedException::class);
ReinitializeConfigurableMethods::__phpunit_initConfigurableMethods();
}
}
PK ! Ӑ Framework/TestListenerTest.phpnu Iw
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace PHPUnit\Framework;
use MyTestListener;
/**
* @small
*/
final class TestListenerTest extends TestCase
{
/**
* @var TestResult
*/
private $result;
/**
* @var MyTestListener
*/
private $listener;
protected function setUp(): void
{
$this->result = new TestResult;
$this->listener = new MyTestListener;
$this->result->addListener($this->listener);
}
public function testError(): void
{
$test = new \TestError;
$test->run($this->result);
$this->assertEquals(1, $this->listener->errorCount());
$this->assertEquals(1, $this->listener->endCount());
}
public function testFailure(): void
{
$test = new \Failure;
$test->run($this->result);
$this->assertEquals(1, $this->listener->failureCount());
$this->assertEquals(1, $this->listener->endCount());
}
public function testStartStop(): void
{
$test = new \Success;
$test->run($this->result);
$this->assertEquals(1, $this->listener->startCount());
$this->assertEquals(1, $this->listener->endCount());
}
}
PK ! :ГZ # Framework/TestSuiteIteratorTest.phpnu Iw
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace PHPUnit\Framework;
/**
* @small
*/
final class TestSuiteIteratorTest extends TestCase
{
public function testKeyForEmptyTestSuiteInitiallyReturnsZero(): void
{
$testSuite = new TestSuite;
$subject = new TestSuiteIterator($testSuite);
$this->assertSame(0, $subject->key());
}
public function testValidForEmptyTestSuiteInitiallyReturnsFalse(): void
{
$testSuite = new TestSuite;
$subject = new TestSuiteIterator($testSuite);
$this->assertFalse($subject->valid());
}
public function testKeyForNonEmptyTestSuiteInitiallyReturnsZero(): void
{
$subject = new TestSuiteIterator($this->suiteWithEmptyTestCase());
$this->assertSame(0, $subject->key());
}
public function testValidForNonEmptyTestSuiteInitiallyReturnsTrue(): void
{
$subject = new TestSuiteIterator($this->suiteWithEmptyTestCase());
$this->assertTrue($subject->valid());
}
public function testCurrentForNonEmptyTestSuiteInitiallyReturnsFirstTest(): void
{
$test = new \EmptyTestCaseTest;
$testSuite = new TestSuite;
$testSuite->addTest($test);
$subject = new TestSuiteIterator($testSuite);
$this->assertSame($test, $subject->current());
}
public function testRewindResetsKeyToZero(): void
{
$subject = new TestSuiteIterator($this->suiteWithEmptyTestCase());
$subject->next();
$subject->rewind();
$this->assertSame(0, $subject->key());
}
public function testRewindResetsCurrentToFirstElement(): void
{
$testSuite = new TestSuite;
$test = new \EmptyTestCaseTest;
$testSuite->addTest($test);
$subject = new TestSuiteIterator($testSuite);
$subject->next();
$subject->rewind();
$this->assertSame($test, $subject->current());
}
public function testNextIncreasesKeyFromZeroToOne(): void
{
$subject = new TestSuiteIterator($this->suiteWithEmptyTestCase());
$subject->next();
$this->assertSame(1, $subject->key());
}
public function testValidAfterLastElementReturnsFalse(): void
{
$subject = new TestSuiteIterator($this->suiteWithEmptyTestCase());
$subject->next();
$this->assertFalse($subject->valid());
}
public function testGetChildrenForEmptyTestSuiteThrowsException(): void
{
$subject = new TestSuiteIterator(new TestSuite);
$this->expectException(NoChildTestSuiteException::class);
$subject->getChildren();
}
public function testGetChildrenForCurrentTestThrowsException(): void
{
$subject = new TestSuiteIterator($this->suiteWithEmptyTestCase());
$this->expectException(NoChildTestSuiteException::class);
$subject->getChildren();
}
public function testGetChildrenReturnsNewInstanceWithCurrentTestSuite(): void
{
$childSuite = new TestSuite;
$test = new \EmptyTestCaseTest;
$childSuite->addTest($test);
$testSuite = new TestSuite;
$testSuite->addTest($childSuite);
$subject = new TestSuiteIterator($testSuite);
$children = $subject->getChildren();
$this->assertNotSame($subject, $children);
$this->assertSame($test, $children->current());
}
public function testHasChildrenForCurrentTestSuiteReturnsTrue(): void
{
$testSuite = new TestSuite;
$childSuite = new TestSuite;
$testSuite->addTest($childSuite);
$subject = new TestSuiteIterator($testSuite);
$this->assertTrue($subject->hasChildren());
}
public function testHasChildrenForCurrentTestReturnsFalse(): void
{
$subject = new TestSuiteIterator($this->suiteWithEmptyTestCase());
$this->assertFalse($subject->hasChildren());
}
public function testHasChildrenForNoTestsReturnsFalse(): void
{
$subject = new TestSuiteIterator(new TestSuite);
$this->assertFalse($subject->hasChildren());
}
private function suiteWithEmptyTestCase(): TestSuite
{
$suite = new TestSuite;
$suite->addTest(new \EmptyTestCaseTest);
return $suite;
}
}
PK ! GG?y y Framework/ConstraintTest.phpnu Iw
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace PHPUnit\Framework;
use PHPUnit\Framework\Constraint\Count;
use PHPUnit\Framework\Constraint\SameSize;
use PHPUnit\Framework\Constraint\TraversableContains;
use PHPUnit\Util\Filter;
/**
* @small
*/
final class ConstraintTest extends TestCase
{
public function testConstraintArrayNotHasKey(): void
{
$constraint = Assert::logicalNot(
Assert::arrayHasKey(0)
);
$this->assertFalse($constraint->evaluate([0 => 1], '', true));
$this->assertEquals('does not have the key 0', $constraint->toString());
$this->assertCount(1, $constraint);
try {
$constraint->evaluate([0 => 1]);
} catch (ExpectationFailedException $e) {
$this->assertEquals(
<<fail();
}
public function testConstraintArrayNotHasKey2(): void
{
$constraint = Assert::logicalNot(
Assert::arrayHasKey(0)
);
try {
$constraint->evaluate([0], 'custom message');
} catch (ExpectationFailedException $e) {
$this->assertEquals(
<<fail();
}
public function testConstraintFileNotExists(): void
{
$file = TEST_FILES_PATH . 'ClassWithNonPublicAttributes.php';
$constraint = Assert::logicalNot(
Assert::fileExists()
);
$this->assertFalse($constraint->evaluate($file, '', true));
$this->assertEquals('file does not exist', $constraint->toString());
$this->assertCount(1, $constraint);
try {
$constraint->evaluate($file);
} catch (ExpectationFailedException $e) {
$this->assertEquals(
<<fail();
}
public function testConstraintFileNotExists2(): void
{
$file = TEST_FILES_PATH . 'ClassWithNonPublicAttributes.php';
$constraint = Assert::logicalNot(
Assert::fileExists()
);
try {
$constraint->evaluate($file, 'custom message');
} catch (ExpectationFailedException $e) {
$this->assertEquals(
<<fail();
}
public function testConstraintNotGreaterThan(): void
{
$constraint = Assert::logicalNot(
Assert::greaterThan(1)
);
$this->assertTrue($constraint->evaluate(1, '', true));
$this->assertEquals('is not greater than 1', $constraint->toString());
$this->assertCount(1, $constraint);
try {
$constraint->evaluate(2);
} catch (ExpectationFailedException $e) {
$this->assertEquals(
<<fail();
}
public function testConstraintNotGreaterThan2(): void
{
$constraint = Assert::logicalNot(
Assert::greaterThan(1)
);
try {
$constraint->evaluate(2, 'custom message');
} catch (ExpectationFailedException $e) {
$this->assertEquals(
<<fail();
}
public function testConstraintGreaterThanOrEqual(): void
{
$constraint = Assert::greaterThanOrEqual(1);
$this->assertTrue($constraint->evaluate(1, '', true));
$this->assertFalse($constraint->evaluate(0, '', true));
$this->assertEquals('is equal to 1 or is greater than 1', $constraint->toString());
$this->assertCount(2, $constraint);
try {
$constraint->evaluate(0);
} catch (ExpectationFailedException $e) {
$this->assertEquals(
<<fail();
}
public function testConstraintGreaterThanOrEqual2(): void
{
$constraint = Assert::greaterThanOrEqual(1);
try {
$constraint->evaluate(0, 'custom message');
} catch (ExpectationFailedException $e) {
$this->assertEquals(
<<fail();
}
public function testConstraintNotGreaterThanOrEqual(): void
{
$constraint = Assert::logicalNot(
Assert::greaterThanOrEqual(1)
);
$this->assertFalse($constraint->evaluate(1, '', true));
$this->assertEquals('not( is equal to 1 or is greater than 1 )', $constraint->toString());
$this->assertCount(2, $constraint);
try {
$constraint->evaluate(1);
} catch (ExpectationFailedException $e) {
$this->assertEquals(
<<fail();
}
public function testConstraintNotGreaterThanOrEqual2(): void
{
$constraint = Assert::logicalNot(
Assert::greaterThanOrEqual(1)
);
try {
$constraint->evaluate(1, 'custom message');
} catch (ExpectationFailedException $e) {
$this->assertEquals(
<<fail();
}
public function testConstraintIsAnything(): void
{
$constraint = Assert::anything();
$this->assertTrue($constraint->evaluate(null, '', true));
$this->assertNull($constraint->evaluate(null));
$this->assertEquals('is anything', $constraint->toString());
$this->assertCount(0, $constraint);
}
public function testConstraintNotIsAnything(): void
{
$constraint = Assert::logicalNot(
Assert::anything()
);
$this->assertFalse($constraint->evaluate(null, '', true));
$this->assertEquals('is not anything', $constraint->toString());
$this->assertCount(0, $constraint);
try {
$constraint->evaluate(null);
} catch (ExpectationFailedException $e) {
$this->assertEquals(
<<fail();
}
public function testConstraintIsNotEqual(): void
{
$constraint = Assert::logicalNot(
Assert::equalTo(1)
);
$this->assertTrue($constraint->evaluate(0, '', true));
$this->assertFalse($constraint->evaluate(1, '', true));
$this->assertEquals('is not equal to 1', $constraint->toString());
$this->assertCount(1, $constraint);
try {
$constraint->evaluate(1);
} catch (ExpectationFailedException $e) {
$this->assertEquals(
<<fail();
}
public function testConstraintIsNotEqual2(): void
{
$constraint = Assert::logicalNot(
Assert::equalTo(1)
);
try {
$constraint->evaluate(1, 'custom message');
} catch (ExpectationFailedException $e) {
$this->assertEquals(
<<fail();
}
public function testConstraintIsNotIdentical(): void
{
$a = new \stdClass;
$b = new \stdClass;
$constraint = Assert::logicalNot(
Assert::identicalTo($a)
);
$this->assertTrue($constraint->evaluate($b, '', true));
$this->assertFalse($constraint->evaluate($a, '', true));
$this->assertEquals('is not identical to an object of class "stdClass"', $constraint->toString());
$this->assertCount(1, $constraint);
try {
$constraint->evaluate($a);
} catch (ExpectationFailedException $e) {
$this->assertEquals(
<<trimnl(TestFailure::exceptionToString($e))
);
return;
}
$this->fail();
}
public function testConstraintIsNotIdentical2(): void
{
$a = new \stdClass;
$constraint = Assert::logicalNot(
Assert::identicalTo($a)
);
try {
$constraint->evaluate($a, 'custom message');
} catch (ExpectationFailedException $e) {
$this->assertEquals(
<<fail();
}
public function testConstraintIsNotIdentical3(): void
{
$constraint = Assert::logicalNot(
Assert::identicalTo('a')
);
try {
$constraint->evaluate('a', 'custom message');
} catch (ExpectationFailedException $e) {
$this->assertEquals(
<<trimnl(TestFailure::exceptionToString($e))
);
return;
}
$this->fail();
}
public function testConstraintIsInstanceOf(): void
{
$constraint = Assert::isInstanceOf(\Exception::class);
$this->assertFalse($constraint->evaluate(new \stdClass, '', true));
$this->assertTrue($constraint->evaluate(new \Exception, '', true));
$this->assertEquals('is instance of class "Exception"', $constraint->toString());
$this->assertCount(1, $constraint);
$interfaceConstraint = Assert::isInstanceOf(\Countable::class);
$this->assertFalse($interfaceConstraint->evaluate(new \stdClass, '', true));
$this->assertTrue($interfaceConstraint->evaluate(new \ArrayObject, '', true));
$this->assertEquals('is instance of interface "Countable"', $interfaceConstraint->toString());
try {
$constraint->evaluate(new \stdClass);
} catch (ExpectationFailedException $e) {
$this->assertEquals(
<<fail();
}
public function testConstraintIsInstanceOf2(): void
{
$constraint = Assert::isInstanceOf(\Exception::class);
try {
$constraint->evaluate(new \stdClass, 'custom message');
} catch (ExpectationFailedException $e) {
$this->assertEquals(
<<fail();
}
public function testConstraintIsNotInstanceOf(): void
{
$constraint = Assert::logicalNot(
Assert::isInstanceOf(\stdClass::class)
);
$this->assertFalse($constraint->evaluate(new \stdClass, '', true));
$this->assertTrue($constraint->evaluate(new Exception, '', true));
$this->assertEquals('is not instance of class "stdClass"', $constraint->toString());
$this->assertCount(1, $constraint);
try {
$constraint->evaluate(new \stdClass);
} catch (ExpectationFailedException $e) {
$this->assertEquals(
<<fail();
}
public function testConstraintIsNotInstanceOf2(): void
{
$constraint = Assert::logicalNot(
Assert::isInstanceOf(\stdClass::class)
);
try {
$constraint->evaluate(new \stdClass, 'custom message');
} catch (ExpectationFailedException $e) {
$this->assertEquals(
<<fail();
}
public function testConstraintIsNotType(): void
{
$constraint = Assert::logicalNot(
Assert::isType('string')
);
$this->assertTrue($constraint->evaluate(0, '', true));
$this->assertFalse($constraint->evaluate('', '', true));
$this->assertEquals('is not of type "string"', $constraint->toString());
$this->assertCount(1, $constraint);
try {
$constraint->evaluate('');
} catch (ExpectationFailedException $e) {
$this->assertEquals(
<<fail();
}
public function testConstraintIsNotType2(): void
{
$constraint = Assert::logicalNot(
Assert::isType('string')
);
try {
$constraint->evaluate('', 'custom message');
} catch (ExpectationFailedException $e) {
$this->assertEquals(
<<fail();
}
public function testConstraintIsNotNull(): void
{
$constraint = Assert::logicalNot(
Assert::isNull()
);
$this->assertFalse($constraint->evaluate(null, '', true));
$this->assertTrue($constraint->evaluate(0, '', true));
$this->assertEquals('is not null', $constraint->toString());
$this->assertCount(1, $constraint);
try {
$constraint->evaluate(null);
} catch (ExpectationFailedException $e) {
$this->assertEquals(
<<fail();
}
public function testConstraintIsNotNull2(): void
{
$constraint = Assert::logicalNot(
Assert::isNull()
);
try {
$constraint->evaluate(null, 'custom message');
} catch (ExpectationFailedException $e) {
$this->assertEquals(
<<fail();
}
public function testConstraintNotLessThan(): void
{
$constraint = Assert::logicalNot(
Assert::lessThan(1)
);
$this->assertTrue($constraint->evaluate(1, '', true));
$this->assertFalse($constraint->evaluate(0, '', true));
$this->assertEquals('is not less than 1', $constraint->toString());
$this->assertCount(1, $constraint);
try {
$constraint->evaluate(0);
} catch (ExpectationFailedException $e) {
$this->assertEquals(
<<fail();
}
public function testConstraintNotLessThan2(): void
{
$constraint = Assert::logicalNot(
Assert::lessThan(1)
);
try {
$constraint->evaluate(0, 'custom message');
} catch (ExpectationFailedException $e) {
$this->assertEquals(
<<fail();
}
public function testConstraintLessThanOrEqual(): void
{
$constraint = Assert::lessThanOrEqual(1);
$this->assertTrue($constraint->evaluate(1, '', true));
$this->assertFalse($constraint->evaluate(2, '', true));
$this->assertEquals('is equal to 1 or is less than 1', $constraint->toString());
$this->assertCount(2, $constraint);
try {
$constraint->evaluate(2);
} catch (ExpectationFailedException $e) {
$this->assertEquals(
<<fail();
}
public function testConstraintLessThanOrEqual2(): void
{
$constraint = Assert::lessThanOrEqual(1);
try {
$constraint->evaluate(2, 'custom message');
} catch (ExpectationFailedException $e) {
$this->assertEquals(
<<fail();
}
public function testConstraintNotLessThanOrEqual(): void
{
$constraint = Assert::logicalNot(
Assert::lessThanOrEqual(1)
);
$this->assertTrue($constraint->evaluate(2, '', true));
$this->assertFalse($constraint->evaluate(1, '', true));
$this->assertEquals('not( is equal to 1 or is less than 1 )', $constraint->toString());
$this->assertCount(2, $constraint);
try {
$constraint->evaluate(1);
} catch (ExpectationFailedException $e) {
$this->assertEquals(
<<fail();
}
public function testConstraintNotLessThanOrEqual2(): void
{
$constraint = Assert::logicalNot(
Assert::lessThanOrEqual(1)
);
try {
$constraint->evaluate(1, 'custom message');
} catch (ExpectationFailedException $e) {
$this->assertEquals(
<<fail();
}
public function testConstraintClassNotHasAttribute(): void
{
$constraint = Assert::logicalNot(
Assert::classHasAttribute('privateAttribute')
);
$this->assertTrue($constraint->evaluate(\stdClass::class, '', true));
$this->assertFalse($constraint->evaluate(\ClassWithNonPublicAttributes::class, '', true));
$this->assertEquals('does not have attribute "privateAttribute"', $constraint->toString());
$this->assertCount(1, $constraint);
try {
$constraint->evaluate(\ClassWithNonPublicAttributes::class);
} catch (ExpectationFailedException $e) {
$this->assertEquals(
<<fail();
}
public function testConstraintClassNotHasAttribute2(): void
{
$constraint = Assert::logicalNot(
Assert::classHasAttribute('privateAttribute')
);
try {
$constraint->evaluate(\ClassWithNonPublicAttributes::class, 'custom message');
} catch (ExpectationFailedException $e) {
$this->assertEquals(
<<fail();
}
public function testConstraintClassNotHasStaticAttribute(): void
{
$constraint = Assert::logicalNot(
Assert::classHasStaticAttribute('privateStaticAttribute')
);
$this->assertTrue($constraint->evaluate(\stdClass::class, '', true));
$this->assertFalse($constraint->evaluate(\ClassWithNonPublicAttributes::class, '', true));
$this->assertEquals('does not have static attribute "privateStaticAttribute"', $constraint->toString());
$this->assertCount(1, $constraint);
try {
$constraint->evaluate(\ClassWithNonPublicAttributes::class);
} catch (ExpectationFailedException $e) {
$this->assertEquals(
<<fail();
}
public function testConstraintClassNotHasStaticAttribute2(): void
{
$constraint = Assert::logicalNot(
Assert::classHasStaticAttribute('privateStaticAttribute')
);
try {
$constraint->evaluate(\ClassWithNonPublicAttributes::class, 'custom message');
} catch (ExpectationFailedException $e) {
$this->assertEquals(
<<fail();
}
public function testConstraintObjectNotHasAttribute(): void
{
$constraint = Assert::logicalNot(
Assert::objectHasAttribute('privateAttribute')
);
$this->assertTrue($constraint->evaluate(new \stdClass, '', true));
$this->assertFalse($constraint->evaluate(new \ClassWithNonPublicAttributes, '', true));
$this->assertEquals('does not have attribute "privateAttribute"', $constraint->toString());
$this->assertCount(1, $constraint);
try {
$constraint->evaluate(new \ClassWithNonPublicAttributes);
} catch (ExpectationFailedException $e) {
$this->assertEquals(
<<fail();
}
public function testConstraintObjectNotHasAttribute2(): void
{
$constraint = Assert::logicalNot(
Assert::objectHasAttribute('privateAttribute')
);
try {
$constraint->evaluate(new \ClassWithNonPublicAttributes, 'custom message');
} catch (ExpectationFailedException $e) {
$this->assertEquals(
<<fail();
}
/**
* @testdox Constraint PCRE not match
*/
public function testConstraintPCRENotMatch(): void
{
$constraint = Assert::logicalNot(
Assert::matchesRegularExpression('/foo/')
);
$this->assertTrue($constraint->evaluate('barbazbar', '', true));
$this->assertFalse($constraint->evaluate('barfoobar', '', true));
$this->assertEquals('does not match PCRE pattern "/foo/"', $constraint->toString());
$this->assertCount(1, $constraint);
try {
$constraint->evaluate('barfoobar');
} catch (ExpectationFailedException $e) {
$this->assertEquals(
<<fail();
}
/**
* @testdox Constraint PCRE not match with custom message
*/
public function testConstraintPCRENotMatch2(): void
{
$constraint = Assert::logicalNot(
Assert::matchesRegularExpression('/foo/')
);
try {
$constraint->evaluate('barfoobar', 'custom message');
} catch (ExpectationFailedException $e) {
$this->assertEquals(
<<fail();
}
public function testConstraintStringStartsNotWith(): void
{
$constraint = Assert::logicalNot(
Assert::stringStartsWith('prefix')
);
$this->assertTrue($constraint->evaluate('foo', '', true));
$this->assertFalse($constraint->evaluate('prefixfoo', '', true));
$this->assertEquals('starts not with "prefix"', $constraint->toString());
$this->assertCount(1, $constraint);
try {
$constraint->evaluate('prefixfoo');
} catch (ExpectationFailedException $e) {
$this->assertEquals(
<<fail();
}
public function testConstraintStringStartsNotWith2(): void
{
$constraint = Assert::logicalNot(
Assert::stringStartsWith('prefix')
);
try {
$constraint->evaluate('prefixfoo', 'custom message');
} catch (ExpectationFailedException $e) {
$this->assertEquals(
<<fail();
}
public function testConstraintStringNotContains(): void
{
$constraint = Assert::logicalNot(
Assert::stringContains('foo')
);
$this->assertTrue($constraint->evaluate('barbazbar', '', true));
$this->assertFalse($constraint->evaluate('barfoobar', '', true));
$this->assertEquals('does not contain "foo"', $constraint->toString());
$this->assertCount(1, $constraint);
try {
$constraint->evaluate('barfoobar');
} catch (ExpectationFailedException $e) {
$this->assertEquals(
<<fail();
}
public function testConstraintStringNotContainsWhenIgnoreCase(): void
{
$constraint = Assert::logicalNot(
Assert::stringContains('oryginał')
);
$this->assertTrue($constraint->evaluate('original', '', true));
$this->assertFalse($constraint->evaluate('ORYGINAŁ', '', true));
$this->assertFalse($constraint->evaluate('oryginał', '', true));
$this->assertEquals('does not contain "oryginał"', $constraint->toString());
$this->assertCount(1, $constraint);
$this->expectException(ExpectationFailedException::class);
$constraint->evaluate('ORYGINAŁ');
}
public function testConstraintStringNotContainsForUtf8StringWhenNotIgnoreCase(): void
{
$constraint = Assert::logicalNot(
Assert::stringContains('oryginał', false)
);
$this->assertTrue($constraint->evaluate('original', '', true));
$this->assertTrue($constraint->evaluate('ORYGINAŁ', '', true));
$this->assertFalse($constraint->evaluate('oryginał', '', true));
$this->assertEquals('does not contain "oryginał"', $constraint->toString());
$this->assertCount(1, $constraint);
$this->expectException(ExpectationFailedException::class);
$constraint->evaluate('oryginał');
}
public function testConstraintStringNotContains2(): void
{
$constraint = Assert::logicalNot(
Assert::stringContains('foo')
);
try {
$constraint->evaluate('barfoobar', 'custom message');
} catch (ExpectationFailedException $e) {
$this->assertEquals(
<<fail();
}
public function testConstraintStringEndsNotWith(): void
{
$constraint = Assert::logicalNot(
Assert::stringEndsWith('suffix')
);
$this->assertTrue($constraint->evaluate('foo', '', true));
$this->assertFalse($constraint->evaluate('foosuffix', '', true));
$this->assertEquals('ends not with "suffix"', $constraint->toString());
$this->assertCount(1, $constraint);
try {
$constraint->evaluate('foosuffix');
} catch (ExpectationFailedException $e) {
$this->assertEquals(
<<fail();
}
public function testConstraintStringEndsNotWith2(): void
{
$constraint = Assert::logicalNot(
Assert::stringEndsWith('suffix')
);
try {
$constraint->evaluate('foosuffix', 'custom message');
} catch (ExpectationFailedException $e) {
$this->assertEquals(
<<fail();
}
public function testConstraintArrayNotContains(): void
{
$constraint = Assert::logicalNot(
new TraversableContains('foo')
);
$this->assertTrue($constraint->evaluate(['bar'], '', true));
$this->assertFalse($constraint->evaluate(['foo'], '', true));
$this->assertEquals("does not contain 'foo'", $constraint->toString());
$this->assertCount(1, $constraint);
try {
$constraint->evaluate(['foo']);
} catch (ExpectationFailedException $e) {
$this->assertEquals(
<<fail();
}
public function testConstraintArrayNotContains2(): void
{
$constraint = Assert::logicalNot(
new TraversableContains('foo')
);
try {
$constraint->evaluate(['foo'], 'custom message');
} catch (ExpectationFailedException $e) {
$this->assertEquals(
<<fail();
}
public function testConstraintCountWithAnArray(): void
{
$constraint = new Count(5);
$this->assertTrue($constraint->evaluate([1, 2, 3, 4, 5], '', true));
$this->assertFalse($constraint->evaluate([1, 2, 3, 4], '', true));
}
public function testConstraintCountWithAnIteratorWhichDoesNotImplementCountable(): void
{
$constraint = new Count(5);
$this->assertTrue($constraint->evaluate(new \TestIterator([1, 2, 3, 4, 5]), '', true));
$this->assertFalse($constraint->evaluate(new \TestIterator([1, 2, 3, 4]), '', true));
}
public function testConstraintCountWithAnObjectImplementingCountable(): void
{
$constraint = new Count(5);
$this->assertTrue($constraint->evaluate(new \ArrayObject([1, 2, 3, 4, 5]), '', true));
$this->assertFalse($constraint->evaluate(new \ArrayObject([1, 2, 3, 4]), '', true));
}
public function testConstraintCountFailing(): void
{
$constraint = new Count(5);
try {
$constraint->evaluate([1, 2]);
} catch (ExpectationFailedException $e) {
$this->assertEquals(
<<fail();
}
public function testConstraintNotCountFailing(): void
{
$constraint = Assert::logicalNot(
new Count(2)
);
try {
$constraint->evaluate([1, 2]);
} catch (ExpectationFailedException $e) {
$this->assertEquals(
<<fail();
}
public function testConstraintNotSameSizeFailing(): void
{
$constraint = Assert::logicalNot(
new SameSize([1, 2])
);
try {
$constraint->evaluate([3, 4]);
} catch (ExpectationFailedException $e) {
$this->assertEquals(
<<fail();
}
public function testConstraintException(): void
{
$constraint = new Constraint\Exception('FoobarException');
$exception = new \DummyException('Test');
$stackTrace = Filter::getFilteredStacktrace($exception);
try {
$constraint->evaluate($exception);
} catch (ExpectationFailedException $e) {
$this->assertEquals(
<<fail();
}
/**
* Removes spaces in front of newlines
*
* @param string $string
*
* @return string
*/
private function trimnl($string)
{
return \preg_replace('/[ ]*\n/', "\n", $string);
}
}
PK ! .t Framework/TestSuiteTest.phpnu Iw
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace PHPUnit\Framework;
/**
* @small
*/
final class TestSuiteTest extends TestCase
{
/**
* @var TestResult
*/
private $result;
protected function setUp(): void
{
$this->result = new TestResult;
}
protected function tearDown(): void
{
$this->result = null;
}
/**
* @testdox TestSuite can be created with name of existing non-TestCase class
*/
public function testSuiteNameCanBeSameAsExistingNonTestClassName(): void
{
$suite = new TestSuite('stdClass');
$suite->addTestSuite(\OneTestCase::class);
$suite->run($this->result);
$this->assertCount(1, $this->result);
}
public function testAddTestSuite(): void
{
$suite = new TestSuite(\OneTestCase::class);
$suite->run($this->result);
$this->assertCount(1, $this->result);
}
public function testInheritedTests(): void
{
$suite = new TestSuite(\InheritedTestCase::class);
$suite->run($this->result);
$this->assertTrue($this->result->wasSuccessful());
$this->assertCount(2, $this->result);
}
public function testNoTestCases(): void
{
$suite = new TestSuite(\NoTestCases::class);
$suite->run($this->result);
$this->assertNotTrue($this->result->wasSuccessful());
$this->assertEquals(0, $this->result->failureCount());
$this->assertEquals(1, $this->result->warningCount());
$this->assertCount(1, $this->result);
}
public function testNotPublicTestCase(): void
{
$suite = new TestSuite(\NotPublicTestCase::class);
$this->assertCount(2, $suite);
}
public function testNotVoidTestCase(): void
{
$suite = new TestSuite(\NotVoidTestCase::class);
$this->assertCount(1, $suite);
}
public function testOneTestCase(): void
{
$suite = new TestSuite(\OneTestCase::class);
$suite->run($this->result);
$this->assertEquals(0, $this->result->errorCount());
$this->assertEquals(0, $this->result->failureCount());
$this->assertCount(1, $this->result);
$this->assertTrue($this->result->wasSuccessful());
}
public function testShadowedTests(): void
{
$suite = new TestSuite(\OverrideTestCase::class);
$suite->run($this->result);
$this->assertCount(1, $this->result);
}
public function testBeforeClassAndAfterClassAnnotations(): void
{
$suite = new TestSuite(\BeforeClassAndAfterClassTest::class);
\BeforeClassAndAfterClassTest::resetProperties();
$suite->run($this->result);
$this->assertEquals(1, \BeforeClassAndAfterClassTest::$beforeClassWasRun, '@beforeClass method was not run once for the whole suite.');
$this->assertEquals(1, \BeforeClassAndAfterClassTest::$afterClassWasRun, '@afterClass method was not run once for the whole suite.');
}
public function testBeforeClassWithDataProviders(): void
{
$suite = new TestSuite(\BeforeClassWithOnlyDataProviderTest::class);
\BeforeClassWithOnlyDataProviderTest::resetProperties();
$suite->run($this->result);
$this->assertTrue(\BeforeClassWithOnlyDataProviderTest::$setUpBeforeClassWasCalled, 'setUpBeforeClass method was not run.');
$this->assertTrue(\BeforeClassWithOnlyDataProviderTest::$beforeClassWasCalled, '@beforeClass method was not run.');
}
public function testBeforeAnnotation(): void
{
$test = new TestSuite(\BeforeAndAfterTest::class);
\BeforeAndAfterTest::resetProperties();
$test->run();
$this->assertEquals(2, \BeforeAndAfterTest::$beforeWasRun);
$this->assertEquals(2, \BeforeAndAfterTest::$afterWasRun);
}
public function testTestWithAnnotation(): void
{
$test = new TestSuite(\TestWithTest::class);
\BeforeAndAfterTest::resetProperties();
$result = $test->run();
$this->assertCount(4, $result->passed());
}
public function testSkippedTestDataProvider(): void
{
$suite = new TestSuite(\DataProviderSkippedTest::class);
$suite->run($this->result);
$this->assertEquals(3, $this->result->count());
$this->assertEquals(1, $this->result->skippedCount());
}
public function testItErrorsOnlyOnceOnHookException(): void
{
$suite = new TestSuite(\TestCaseWithExceptionInHook::class);
$suite->run($this->result);
$this->assertEquals(2, $this->result->count());
$this->assertEquals(1, $this->result->errorCount());
$this->assertEquals(1, $this->result->skippedCount());
}
public function testTestDataProviderDependency(): void
{
$suite = new TestSuite(\DataProviderDependencyTest::class);
$suite->run($this->result);
$skipped = $this->result->skipped();
$lastSkippedResult = \array_pop($skipped);
$message = $lastSkippedResult->thrownException()->getMessage();
$this->assertStringContainsString('Test for DataProviderDependencyTest::testDependency skipped by data provider', $message);
}
public function testIncompleteTestDataProvider(): void
{
$suite = new TestSuite(\DataProviderIncompleteTest::class);
$suite->run($this->result);
$this->assertEquals(3, $this->result->count());
$this->assertEquals(1, $this->result->notImplementedCount());
}
public function testRequirementsBeforeClassHook(): void
{
$suite = new TestSuite(\RequirementsClassBeforeClassHookTest::class);
$suite->run($this->result);
$this->assertEquals(0, $this->result->errorCount());
$this->assertEquals(1, $this->result->skippedCount());
}
public function testDoNotSkipInheritedClass(): void
{
$suite = new TestSuite(
'DontSkipInheritedClass'
);
$dir = TEST_FILES_PATH . \DIRECTORY_SEPARATOR . 'Inheritance' . \DIRECTORY_SEPARATOR;
$suite->addTestFile($dir . 'InheritanceA.php');
$suite->addTestFile($dir . 'InheritanceB.php');
$result = $suite->run();
$this->assertCount(2, $result);
}
/**
* @testdox Handles exceptions in tearDownAfterClass()
*/
public function testTearDownAfterClassInTestSuite(): void
{
$suite = new TestSuite(\ExceptionInTearDownAfterClassTest::class);
$suite->run($this->result);
$this->assertSame(3, $this->result->count());
$this->assertCount(1, $this->result->failures());
$failure = $this->result->failures()[0];
$this->assertSame(
'Exception in ExceptionInTearDownAfterClassTest::tearDownAfterClass' . \PHP_EOL .
'throw Exception in tearDownAfterClass()',
$failure->thrownException()->getMessage()
);
}
}
PK ! ?xMw w Framework/AssertTest.phpnu Iw
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace PHPUnit\Framework;
use PHPUnit\Util\Xml;
/**
* @small
*/
final class AssertTest extends TestCase
{
public static function validInvalidJsonDataprovider(): array
{
return [
'error syntax in expected JSON' => ['{"Mascott"::}', '{"Mascott" : "Tux"}'],
'error UTF-8 in actual JSON' => ['{"Mascott" : "Tux"}', '{"Mascott" : :}'],
];
}
public function testFail(): void
{
try {
$this->fail();
} catch (AssertionFailedError $e) {
return;
}
throw new AssertionFailedError('Fail did not throw fail exception');
}
public function testAssertContainsOnlyInstancesOf(): void
{
$test = [new \Book, new \Book];
$this->assertContainsOnlyInstancesOf(\Book::class, $test);
$this->assertContainsOnlyInstancesOf(\stdClass::class, [new \stdClass]);
$test2 = [new \Author('Test')];
$this->expectException(AssertionFailedError::class);
$this->assertContainsOnlyInstancesOf(\Book::class, $test2);
}
public function testAssertArrayHasKeyThrowsExceptionForInvalidFirstArgument(): void
{
$this->expectException(Exception::class);
$this->assertArrayHasKey(null, []);
}
public function testAssertArrayHasKeyThrowsExceptionForInvalidSecondArgument(): void
{
$this->expectException(Exception::class);
$this->assertArrayHasKey(0, null);
}
public function testAssertArrayHasIntegerKey(): void
{
$this->assertArrayHasKey(0, ['foo']);
$this->expectException(AssertionFailedError::class);
$this->assertArrayHasKey(1, ['foo']);
}
public function testAssertArrayNotHasKeyThrowsExceptionForInvalidFirstArgument(): void
{
$this->expectException(Exception::class);
$this->assertArrayNotHasKey(null, []);
}
public function testAssertArrayNotHasKeyThrowsExceptionForInvalidSecondArgument(): void
{
$this->expectException(Exception::class);
$this->assertArrayNotHasKey(0, null);
}
public function testAssertArrayNotHasIntegerKey(): void
{
$this->assertArrayNotHasKey(1, ['foo']);
$this->expectException(AssertionFailedError::class);
$this->assertArrayNotHasKey(0, ['foo']);
}
public function testAssertArrayHasStringKey(): void
{
$this->assertArrayHasKey('foo', ['foo' => 'bar']);
$this->expectException(AssertionFailedError::class);
$this->assertArrayHasKey('bar', ['foo' => 'bar']);
}
public function testAssertArrayNotHasStringKey(): void
{
$this->assertArrayNotHasKey('bar', ['foo' => 'bar']);
$this->expectException(AssertionFailedError::class);
$this->assertArrayNotHasKey('foo', ['foo' => 'bar']);
}
public function testAssertArrayHasKeyAcceptsArrayObjectValue(): void
{
$array = new \ArrayObject;
$array['foo'] = 'bar';
$this->assertArrayHasKey('foo', $array);
}
public function testAssertArrayHasKeyProperlyFailsWithArrayObjectValue(): void
{
$array = new \ArrayObject;
$array['bar'] = 'bar';
$this->expectException(AssertionFailedError::class);
$this->assertArrayHasKey('foo', $array);
}
public function testAssertArrayHasKeyAcceptsArrayAccessValue(): void
{
$array = new \SampleArrayAccess;
$array['foo'] = 'bar';
$this->assertArrayHasKey('foo', $array);
}
public function testAssertArrayHasKeyProperlyFailsWithArrayAccessValue(): void
{
$array = new \SampleArrayAccess;
$array['bar'] = 'bar';
$this->expectException(AssertionFailedError::class);
$this->assertArrayHasKey('foo', $array);
}
public function testAssertArrayNotHasKeyAcceptsArrayAccessValue(): void
{
$array = new \ArrayObject;
$array['foo'] = 'bar';
$this->assertArrayNotHasKey('bar', $array);
}
public function testAssertArrayNotHasKeyPropertlyFailsWithArrayAccessValue(): void
{
$array = new \ArrayObject;
$array['bar'] = 'bar';
$this->expectException(AssertionFailedError::class);
$this->assertArrayNotHasKey('bar', $array);
}
public function testAssertArrayContainsOnlyIntegers(): void
{
$this->assertContainsOnly('integer', [1, 2, 3]);
$this->expectException(AssertionFailedError::class);
$this->assertContainsOnly('integer', ['1', 2, 3]);
}
public function testAssertArrayNotContainsOnlyIntegers(): void
{
$this->assertNotContainsOnly('integer', ['1', 2, 3]);
$this->expectException(AssertionFailedError::class);
$this->assertNotContainsOnly('integer', [1, 2, 3]);
}
public function testAssertArrayContainsOnlyStdClass(): void
{
$this->assertContainsOnly('StdClass', [new \stdClass]);
$this->expectException(AssertionFailedError::class);
$this->assertContainsOnly('StdClass', ['StdClass']);
}
public function testAssertArrayNotContainsOnlyStdClass(): void
{
$this->assertNotContainsOnly('StdClass', ['StdClass']);
$this->expectException(AssertionFailedError::class);
$this->assertNotContainsOnly('StdClass', [new \stdClass]);
}
public function equalProvider(): array
{
// same |= equal
return \array_merge($this->equalValues(), $this->sameValues());
}
public function notEqualProvider()
{
return $this->notEqualValues();
}
public function sameProvider(): array
{
return $this->sameValues();
}
public function notSameProvider(): array
{
// not equal |= not same
// equal, ¬same |= not same
return \array_merge($this->notEqualValues(), $this->equalValues());
}
/**
* @dataProvider equalProvider
*
* @throws ExpectationFailedException
* @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
*/
public function testAssertEqualsSucceeds($a, $b): void
{
$this->assertEquals($a, $b);
}
/**
* @dataProvider notEqualProvider
*
* @throws ExpectationFailedException
* @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
*/
public function testAssertEqualsFails($a, $b): void
{
$this->expectException(AssertionFailedError::class);
$this->assertEquals($a, $b);
}
/**
* @dataProvider notEqualProvider
*
* @throws ExpectationFailedException
* @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
*/
public function testAssertNotEqualsSucceeds($a, $b): void
{
$this->assertNotEquals($a, $b);
}
/**
* @testdox assertNotEquals($a, $b) with delta $delta, canoicalize $canonicalize, ignoreCase $ignoreCase
* @dataProvider equalProvider
*
* @throws ExpectationFailedException
* @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
*/
public function testAssertNotEqualsFails($a, $b): void
{
$this->expectException(AssertionFailedError::class);
$this->assertNotEquals($a, $b);
}
/**
* @testdox assertNotSame($a, $b) fails
* @dataProvider sameProvider
*
* @throws ExpectationFailedException
* @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
*/
public function testAssertSameSucceeds($a, $b): void
{
$this->assertSame($a, $b);
}
/**
* @testdox assertNotSame($a, $b)
* @dataProvider notSameProvider
*
* @throws ExpectationFailedException
* @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
*/
public function testAssertSameFails($a, $b): void
{
$this->expectException(AssertionFailedError::class);
$this->assertSame($a, $b);
}
/**
* @testdox assertSame($a, $b) fails
* @dataProvider notSameProvider
*
* @throws ExpectationFailedException
* @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
*/
public function testAssertNotSameSucceeds($a, $b): void
{
$this->assertNotSame($a, $b);
}
/**
* @testdox assertSame($a, $b)
* @dataProvider sameProvider
*
* @throws ExpectationFailedException
* @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
*/
public function testAssertNotSameFails($a, $b): void
{
$this->expectException(AssertionFailedError::class);
$this->assertNotSame($a, $b);
}
public function testAssertXmlFileEqualsXmlFile(): void
{
$this->assertXmlFileEqualsXmlFile(
TEST_FILES_PATH . 'foo.xml',
TEST_FILES_PATH . 'foo.xml'
);
$this->expectException(AssertionFailedError::class);
$this->assertXmlFileEqualsXmlFile(
TEST_FILES_PATH . 'foo.xml',
TEST_FILES_PATH . 'bar.xml'
);
}
public function testAssertXmlFileNotEqualsXmlFile(): void
{
$this->assertXmlFileNotEqualsXmlFile(
TEST_FILES_PATH . 'foo.xml',
TEST_FILES_PATH . 'bar.xml'
);
$this->expectException(AssertionFailedError::class);
$this->assertXmlFileNotEqualsXmlFile(
TEST_FILES_PATH . 'foo.xml',
TEST_FILES_PATH . 'foo.xml'
);
}
public function testAssertXmlStringEqualsXmlFile(): void
{
$this->assertXmlStringEqualsXmlFile(
TEST_FILES_PATH . 'foo.xml',
\file_get_contents(TEST_FILES_PATH . 'foo.xml')
);
$this->expectException(AssertionFailedError::class);
$this->assertXmlStringEqualsXmlFile(
TEST_FILES_PATH . 'foo.xml',
\file_get_contents(TEST_FILES_PATH . 'bar.xml')
);
}
public function testXmlStringNotEqualsXmlFile(): void
{
$this->assertXmlStringNotEqualsXmlFile(
TEST_FILES_PATH . 'foo.xml',
\file_get_contents(TEST_FILES_PATH . 'bar.xml')
);
$this->expectException(AssertionFailedError::class);
$this->assertXmlStringNotEqualsXmlFile(
TEST_FILES_PATH . 'foo.xml',
\file_get_contents(TEST_FILES_PATH . 'foo.xml')
);
}
public function testAssertXmlStringEqualsXmlString(): void
{
$this->assertXmlStringEqualsXmlString('', '');
}
/**
* @ticket 1860
*/
public function testAssertXmlStringEqualsXmlString3(): void
{
$expected = <<
XML;
$actual = <<
XML;
$this->assertXmlStringEqualsXmlString($expected, $actual);
}
public function testAssertXmlStringNotEqualsXmlString(): void
{
$this->assertXmlStringNotEqualsXmlString(' bar '),
Xml::load(' bar '),
Xml::load(' bir '),
],
[
new \DateTime('2013-03-29 04:13:35', new \DateTimeZone('America/New_York')),
new \DateTime('2013-03-29 03:13:35', new \DateTimeZone('America/New_York')),
],
[
new \DateTime('2013-03-29 04:13:35', new \DateTimeZone('America/New_York')),
new \DateTime('2013-03-29 03:13:35', new \DateTimeZone('America/New_York')),
3500,
],
[
new \DateTime('2013-03-29 04:13:35', new \DateTimeZone('America/New_York')),
new \DateTime('2013-03-29 05:13:35', new \DateTimeZone('America/New_York')),
3500,
],
[
new \DateTime('2013-03-29', new \DateTimeZone('America/New_York')),
new \DateTime('2013-03-30', new \DateTimeZone('America/New_York')),
],
[
new \DateTime('2013-03-29', new \DateTimeZone('America/New_York')),
new \DateTime('2013-03-30', new \DateTimeZone('America/New_York')),
43200,
],
[
new \DateTime('2013-03-29 04:13:35', new \DateTimeZone('America/New_York')),
new \DateTime('2013-03-29 04:13:35', new \DateTimeZone('America/Chicago')),
],
[
new \DateTime('2013-03-29 04:13:35', new \DateTimeZone('America/New_York')),
new \DateTime('2013-03-29 04:13:35', new \DateTimeZone('America/Chicago')),
3500,
],
[
new \DateTime('2013-03-30', new \DateTimeZone('America/New_York')),
new \DateTime('2013-03-30', new \DateTimeZone('America/Chicago')),
],
[
new \DateTime('2013-03-29T05:13:35-0600'),
new \DateTime('2013-03-29T04:13:35-0600'),
],
[
new \DateTime('2013-03-29T05:13:35-0600'),
new \DateTime('2013-03-29T05:13:35-0500'),
],
// Exception
//array(new Exception('Exception 1'), new Exception('Exception 2')),
// different types
[new \SampleClass(4, 8, 15), false],
[false, new \SampleClass(4, 8, 15)],
[[0 => 1, 1 => 2], false],
[false, [0 => 1, 1 => 2]],
[[], new \stdClass],
[new \stdClass, []],
// PHP: 0 == 'Foobar' => true!
// We want these values to differ
[0, 'Foobar'],
['Foobar', 0],
[3, \acos(8)],
[\acos(8), 3],
];
}
protected function equalValues(): array
{
// cyclic dependencies
$book1 = new \Book;
$book1->author = new \Author('Terry Pratchett');
$book1->author->books[] = $book1;
$book2 = new \Book;
$book2->author = new \Author('Terry Pratchett');
$book2->author->books[] = $book2;
$object1 = new \SampleClass(4, 8, 15);
$object2 = new \SampleClass(4, 8, 15);
$storage1 = new \SplObjectStorage;
$storage1->attach($object1);
$storage2 = new \SplObjectStorage;
$storage2->attach($object1);
return [
// arrays
[['a' => 1, 'b' => 2], ['b' => 2, 'a' => 1]],
[[1], ['1']],
// objects
[$object1, $object2],
[$book1, $book2],
// SplObjectStorage
[$storage1, $storage2],
// DOMDocument
[
Xml::load('\n "),
Xml::load('assertDirectoryNotExists($directoryPathThatDoesNotExist);
$filterConfiguration = [
'include' => [
'directory' => [
[
'path' => __DIR__,
'suffix' => '.php',
'prefix' => '',
],
[
'path' => \sprintf('%s/', __DIR__),
'suffix' => '.php',
'prefix' => '',
],
[
'path' => \sprintf('%s/./%s', \dirname(__DIR__), \basename(__DIR__)),
'suffix' => '.php',
'prefix' => '',
],
[
'path' => $directoryPathThatDoesNotExist,
'suffix' => '.php',
'prefix' => '',
],
],
'file' => [
'src/foo.php',
'src/bar.php',
],
],
'exclude' => [
'directory' => [],
'file' => [],
],
];
$writer = new XdebugFilterScriptGenerator;
$actual = $writer->generate($filterConfiguration);
$this->assertSame($expected, $actual);
}
}
PK ! b b Util/GlobalStateTest.phpnu Iw
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace PHPUnit\Util;
use PHPUnit\Framework\TestCase;
/**
* @small
*/
final class GlobalStateTest extends TestCase
{
public function testIncludedFilesAsStringSkipsVfsProtocols(): void
{
$dir = __DIR__;
$files = [
'phpunit', // The 0 index is not used
$dir . '/ConfigurationTest.php',
$dir . '/GlobalStateTest.php',
'vfs://' . $dir . '/RegexTest.php',
'phpvfs53e46260465c7://' . $dir . '/TestClassTest.php',
'file://' . $dir . '/XmlTest.php',
];
$this->assertEquals(
"require_once '" . $dir . "/ConfigurationTest.php';\n" .
"require_once '" . $dir . "/GlobalStateTest.php';\n" .
"require_once 'file://" . $dir . "/XmlTest.php';\n",
GlobalState::processIncludedFilesAsString($files)
);
}
}
PK ! Mr Util/ColorTest.phpnu Iw
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace PHPUnit\Util;
use PHPUnit\Framework\TestCase;
/**
* @testdox Basic ANSI color highlighting support
* @small
*/
final class ColorTest extends TestCase
{
/**
* @testdox Colorize with $_dataName
* @dataProvider colorizeProvider
*/
public function testColorize(string $color, string $buffer, string $expected): void
{
$this->assertSame($expected, Color::colorize($color, $buffer));
}
/**
* @testdox Colorize path $path after $prevPath
* @dataProvider colorizePathProvider
*/
public function testColorizePath(?string $prevPath, string $path, bool $colorizeFilename, string $expected): void
{
$this->assertSame($expected, Color::colorizePath($path, $prevPath, $colorizeFilename));
}
/**
* @testdox dim($m) and colorize('dim',$m) return different ANSI codes
*/
public function testDimAndColorizeDimAreDifferent(): void
{
$buffer = 'some string';
$this->assertNotSame(Color::dim($buffer), Color::colorize('dim', $buffer));
}
/**
* @testdox Visualize all whitespace characters in $actual
* @dataProvider whitespacedStringProvider
*/
public function testVisibleWhitespace(string $actual, string $expected): void
{
$this->assertSame($expected, Color::visualizeWhitespace($actual, true));
}
/**
* @testdox Visualize whitespace but ignore EOL
*/
public function testVisibleWhitespaceWithoutEOL(): void
{
$string = "line1\nline2\n";
$this->assertSame($string, Color::visualizeWhitespace($string, false));
}
/**
* @dataProvider unnamedDataSetProvider
*/
public function testPrettifyUnnamedDataprovider(int $value): void
{
$this->assertSame($value, $value);
}
/**
* @dataProvider namedDataSetProvider
*/
public function testPrettifyNamedDataprovider(int $value): void
{
$this->assertSame($value, $value);
}
/**
* @testdox TestDox shows name of data set $_dataName with value $value
* @dataProvider namedDataSetProvider
*/
public function testTestdoxDatanameAsParameter(int $value): void
{
$this->assertSame($value, $value);
}
public function colorizeProvider(): array
{
return [
'no color' => ['', 'string', 'string'],
'one color' => ['fg-blue', 'string', "\x1b[34mstring\x1b[0m"],
'multiple colors' => ['bold,dim,fg-blue,bg-yellow', 'string', "\x1b[1;2;34;43mstring\x1b[0m"],
'invalid color' => ['fg-invalid', 'some text', 'some text'],
'valid and invalid colors' => ['fg-invalid,bg-blue', 'some text', "\e[44msome text\e[0m"],
];
}
public function colorizePathProvider(): array
{
$sep = \DIRECTORY_SEPARATOR;
$sepDim = Color::dim($sep);
return [
'null previous path' => [
null,
$sep . 'php' . $sep . 'unit' . $sep . 'test.phpt',
false,
$sepDim . 'php' . $sepDim . 'unit' . $sepDim . 'test.phpt',
],
'empty previous path' => [
'',
$sep . 'php' . $sep . 'unit' . $sep . 'test.phpt',
false,
$sepDim . 'php' . $sepDim . 'unit' . $sepDim . 'test.phpt',
],
'from root' => [
$sep,
$sep . 'php' . $sep . 'unit' . $sep . 'test.phpt',
false,
$sepDim . 'php' . $sepDim . 'unit' . $sepDim . 'test.phpt',
],
'partial part' => [
$sep . 'php' . $sep,
$sep . 'php' . $sep . 'unit' . $sep . 'test.phpt',
false,
Color::dim($sep . 'php' . $sep) . 'unit' . $sepDim . 'test.phpt',
],
'colorize filename' => [
'',
$sep . '_d-i.r' . $sep . 't-e_s.t.phpt',
true,
$sepDim . '_d-i.r' . $sepDim . 't' . Color::dim('-') . 'e' . Color::dim('_') . 's' . Color::dim('.') . 't' . Color::dim('.phpt'),
],
];
}
public function whitespacedStringProvider(): array
{
return [
['no-spaces',
'no-spaces',
],
[
' space invaders ',
"\e[2m·\e[22mspace\e[2m···\e[22minvaders\e[2m·\e[22m",
],
[
"\tindent, space and \\n\n\\r\r",
"\e[2m⇥\e[22mindent,\e[2m·\e[22mspace\e[2m·\e[22mand\e[2m·\e[22m\\n\e[2m↵\e[22m\\r\e[2m⟵\e[22m",
],
];
}
public function unnamedDataSetProvider(): array
{
return [
[1],
[2],
];
}
public function namedDataSetProvider(): array
{
return [
'one' => [1],
'two' => [2],
];
}
}
PK ! ͏= = # Util/ConfigurationGeneratorTest.phpnu Iw
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace PHPUnit\Util;
use PHPUnit\Framework\TestCase;
/**
* @small
* @covers \PHPUnit\Util\ConfigurationGenerator
*/
final class ConfigurationGeneratorTest extends TestCase
{
public function testGeneratesConfigurationCorrectly(): void
{
$generator = new ConfigurationGenerator;
$this->assertEquals(
'
tests
src
',
$generator->generateDefaultConfiguration(
'X.Y.Z',
'vendor/autoload.php',
'tests',
'src'
)
);
}
}
PK ! #h h Util/GetoptTest.phpnu Iw
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace PHPUnit\Util;
use PHPUnit\Framework\Exception;
use PHPUnit\Framework\TestCase;
/**
* @small
*/
final class GetoptTest extends TestCase
{
public function testItIncludeTheLongOptionsAfterTheArgument(): void
{
$args = [
'command',
'myArgument',
'--colors',
];
$actual = Getopt::getopt($args, '', ['colors==']);
$expected = [
[
[
'--colors',
null,
],
],
[
'myArgument',
],
];
$this->assertEquals($expected, $actual);
}
public function testItIncludeTheShortOptionsAfterTheArgument(): void
{
$args = [
'command',
'myArgument',
'-v',
];
$actual = Getopt::getopt($args, 'v');
$expected = [
[
[
'v',
null,
],
],
[
'myArgument',
],
];
$this->assertEquals($expected, $actual);
}
public function testShortOptionUnrecognizedException(): void
{
$args = [
'command',
'myArgument',
'-v',
];
$this->expectException(Exception::class);
$this->expectExceptionMessage('unrecognized option -- v');
Getopt::getopt($args, '');
}
public function testShortOptionRequiresAnArgumentException(): void
{
$args = [
'command',
'myArgument',
'-f',
];
$this->expectException(Exception::class);
$this->expectExceptionMessage('option requires an argument -- f');
Getopt::getopt($args, 'f:');
}
public function testShortOptionHandleAnOptionalValue(): void
{
$args = [
'command',
'myArgument',
'-f',
];
$actual = Getopt::getopt($args, 'f::');
$expected = [
[
[
'f',
null,
],
],
[
'myArgument',
],
];
$this->assertEquals($expected, $actual);
}
public function testLongOptionIsAmbiguousException(): void
{
$args = [
'command',
'--col',
];
$this->expectException(Exception::class);
$this->expectExceptionMessage('option --col is ambiguous');
Getopt::getopt($args, '', ['columns', 'colors']);
}
public function testLongOptionUnrecognizedException(): void
{
// the exception 'unrecognized option --option' is not thrown
// if the there are not defined extended options
$args = [
'command',
'--foo',
];
$this->expectException(Exception::class);
$this->expectExceptionMessage('unrecognized option --foo');
Getopt::getopt($args, '', ['colors']);
}
public function testLongOptionRequiresAnArgumentException(): void
{
$args = [
'command',
'--foo',
];
$this->expectException(Exception::class);
$this->expectExceptionMessage('option --foo requires an argument');
Getopt::getopt($args, '', ['foo=']);
}
public function testLongOptionDoesNotAllowAnArgumentException(): void
{
$args = [
'command',
'--foo=bar',
];
$this->expectException(Exception::class);
$this->expectExceptionMessage("option --foo doesn't allow an argument");
Getopt::getopt($args, '', ['foo']);
}
public function testItHandlesLongParametesWithValues(): void
{
$command = 'command parameter-0 --exec parameter-1 --conf config.xml --optn parameter-2 --optn=content-of-o parameter-n';
$args = \explode(' ', $command);
unset($args[0]);
$expected = [
[
['--exec', null],
['--conf', 'config.xml'],
['--optn', null],
['--optn', 'content-of-o'],
],
[
'parameter-0',
'parameter-1',
'parameter-2',
'parameter-n',
],
];
$actual = Getopt::getopt($args, '', ['exec', 'conf=', 'optn==']);
$this->assertEquals($expected, $actual);
}
public function testItHandlesShortParametesWithValues(): void
{
$command = 'command parameter-0 -x parameter-1 -c config.xml -o parameter-2 -ocontent-of-o parameter-n';
$args = \explode(' ', $command);
unset($args[0]);
$expected = [
[
['x', null],
['c', 'config.xml'],
['o', null],
['o', 'content-of-o'],
],
[
'parameter-0',
'parameter-1',
'parameter-2',
'parameter-n',
],
];
$actual = Getopt::getopt($args, 'xc:o::');
$this->assertEquals($expected, $actual);
}
}
PK ! úPg g Util/ConfigurationTest.phpnu Iw
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace PHPUnit\Util;
use PHPUnit\Framework\Exception;
use PHPUnit\Framework\TestCase;
use PHPUnit\Runner\TestSuiteSorter;
use PHPUnit\TextUI\ResultPrinter;
use PHPUnit\Util\TestDox\CliTestDoxPrinter;
/**
* @small
*/
final class ConfigurationTest extends TestCase
{
/**
* @var Configuration
*/
protected $configuration;
protected function setUp(): void
{
$this->configuration = Configuration::getInstance(
TEST_FILES_PATH . 'configuration.xml'
);
}
public function testExceptionIsThrownForNotExistingConfigurationFile(): void
{
$this->expectException(Exception::class);
Configuration::getInstance('not_existing_file.xml');
}
public function testShouldReadColorsWhenTrueInConfigurationFile(): void
{
$configurationFilename = TEST_FILES_PATH . 'configuration.colors.true.xml';
$configurationInstance = Configuration::getInstance($configurationFilename);
$configurationValues = $configurationInstance->getPHPUnitConfiguration();
$this->assertEquals(ResultPrinter::COLOR_AUTO, $configurationValues['colors']);
}
public function testShouldReadColorsWhenFalseInConfigurationFile(): void
{
$configurationFilename = TEST_FILES_PATH . 'configuration.colors.false.xml';
$configurationInstance = Configuration::getInstance($configurationFilename);
$configurationValues = $configurationInstance->getPHPUnitConfiguration();
$this->assertEquals(ResultPrinter::COLOR_NEVER, $configurationValues['colors']);
}
public function testShouldReadColorsWhenEmptyInConfigurationFile(): void
{
$configurationFilename = TEST_FILES_PATH . 'configuration.colors.empty.xml';
$configurationInstance = Configuration::getInstance($configurationFilename);
$configurationValues = $configurationInstance->getPHPUnitConfiguration();
$this->assertEquals(ResultPrinter::COLOR_NEVER, $configurationValues['colors']);
}
public function testShouldReadColorsWhenInvalidInConfigurationFile(): void
{
$configurationFilename = TEST_FILES_PATH . 'configuration.colors.invalid.xml';
$configurationInstance = Configuration::getInstance($configurationFilename);
$configurationValues = $configurationInstance->getPHPUnitConfiguration();
$this->assertEquals(ResultPrinter::COLOR_NEVER, $configurationValues['colors']);
}
public function testInvalidConfigurationGeneratesValidationErrors(): void
{
$configurationFilename = TEST_FILES_PATH . 'configuration.colors.invalid.xml';
$configurationInstance = Configuration::getInstance($configurationFilename);
$this->assertTrue($configurationInstance->hasValidationErrors());
}
public function testShouldUseDefaultValuesForInvalidIntegers(): void
{
$configurationFilename = TEST_FILES_PATH . 'configuration.columns.default.xml';
$configurationInstance = Configuration::getInstance($configurationFilename);
$configurationValues = $configurationInstance->getPHPUnitConfiguration();
$this->assertEquals(80, $configurationValues['columns']);
}
/**
* @testdox Parse XML configuration root attribute $optionName = $optionValue
* @dataProvider configurationRootOptionsProvider
*
* @group test-reorder
*
* @param bool|int|string $expected
*/
public function testShouldParseXmlConfigurationRootAttributes(string $optionName, string $optionValue, $expected): void
{
$tmpFilename = \sys_get_temp_dir() . \DIRECTORY_SEPARATOR . 'phpunit.' . $optionName . \uniqid() . '.xml';
$xml = "$escapedString ";
$dom = new \DOMDocument('1.0', 'UTF-8');
try {
$dom->loadXML($xml);
} catch (Exception $e) {
}
$this->assertNull(
$e,
\sprintf(
'\PHPUnit\Util\Xml::prepareString("\x%02x") should not crash DomDocument',
\ord($char)
)
);
}
public function charProvider(): array
{
$data = [];
for ($i = 0; $i < 256; $i++) {
$data[] = [\chr($i)];
}
return $data;
}
public function testLoadEmptyString(): void
{
$this->expectException(Exception::class);
$this->expectExceptionMessage('Could not load XML from empty string');
Xml::load('');
}
public function testLoadArray(): void
{
$this->expectException(Exception::class);
$this->expectExceptionMessage('Could not load XML from array');
Xml::load([1, 2, 3]);
}
public function testLoadBoolean(): void
{
$this->expectException(Exception::class);
$this->expectExceptionMessage('Could not load XML from boolean');
Xml::load(false);
}
/**
* @testdox Nested xmlToVariable()
*/
public function testNestedXmlToVariable(): void
{
$xml = 'foo bar a b c one 0 two Framework/Constraint/IsIdenticalTest.phpnu Iw PK ! % kO Framework/Constraint/SameSizeTest.phpnu Iw PK ! W W / fW Framework/Constraint/ObjectHasAttributeTest.phpnu Iw PK ! :+; ; # _ Framework/Constraint/IsTypeTest.phpnu Iw PK ! ȟ . m Framework/Constraint/RegularExpressionTest.phpnu Iw PK ! >î5 5 # t Framework/Constraint/IsNullTest.phpnu Iw PK ! blT " { Framework/Constraint/CountTest.phpnu Iw PK ! N`o o ( Framework/Constraint/GreaterThanTest.phpnu Iw PK ! 5. . ; k Framework/Constraint/StringMatchesFormatDescriptionTest.phpnu Iw PK ! + Framework/Constraint/StringEndsWithTest.phpnu Iw PK ! JJa@ @ 3 1 Framework/Constraint/ExceptionMessageRegExpTest.phpnu Iw PK ! |E ( Framework/Constraint/ArrayHasKeyTest.phpnu Iw PK ! F ( Framework/Constraint/JsonMatchesTest.phpnu Iw PK ! 56 % | Framework/Constraint/CallbackTest.phpnu Iw PK ! A A ' Framework/Constraint/IsReadableTest.phpnu Iw PK ! Su u 4 Framework/Constraint/ClassHasStaticAttributeTest.phpnu Iw PK ! n%W W % Framework/Constraint/LessThanTest.phpnu Iw PK ! Sn Framework/TestCaseTest.phpnu Iw PK ! D ' Framework/MockObject/MockObjectTest.phpnu Iw PK ! f & 9 Framework/MockObject/MockTraitTest.phpnu Iw PK ! & V> Framework/MockObject/MockClassTest.phpnu Iw PK ! 7K# # 5 D Framework/MockObject/Builder/InvocationMockerTest.phpnu Iw PK ! Y :
i Framework/MockObject/Matcher/ConsecutiveParametersTest.phpnu Iw PK ! ?; ' s Framework/MockObject/MockMethodTest.phpnu Iw PK ! q( ( & ix Framework/MockObject/GeneratorTest.phpnu Iw PK ! ^" / { Framework/MockObject/ConfigurableMethodTest.phpnu Iw PK ! ,$Q Q $ \ Framework/MockObject/MatcherTest.phpnu Iw PK ! I^ . Framework/MockObject/InvocationHandlerTest.phpnu Iw PK ! ^q ( c Framework/MockObject/ProxyObjectTest.phpnu Iw PK ! ^&# # ( ? Framework/MockObject/MockBuilderTest.phpnu Iw PK ! hŃM M 0 = Framework/MockObject/ConfigurableMethodsTest.phpnu Iw PK ! Ӑ Framework/TestListenerTest.phpnu Iw PK ! :ГZ # Framework/TestSuiteIteratorTest.phpnu Iw PK ! GG?y y Framework/ConstraintTest.phpnu Iw PK ! .t Framework/TestSuiteTest.phpnu Iw PK ! ?xMw w ݹ Framework/AssertTest.phpnu Iw PK ! |ا Framework/TestFailureTest.phpnu Iw PK ! " Framework/Assert/FunctionsTest.phpnu Iw PK ! B4< Framework/TestBuilderTest.phpnu Iw PK ! Wh h 4 Framework/Exception/InvalidArgumentExceptionTest.phpnu Iw PK ! O % } Framework/Exception/ExceptionTest.phpnu Iw PK ! j> " U Framework/ExceptionWrapperTest.phpnu Iw PK ! ]Xٴ ! 8 Framework/TestImplementorTest.phpnu Iw PK ! 8M = Util/Annotation/RegistryTest.phpnu Iw PK ! 2kq q ( i Util/XDebugFilterScriptGeneratorTest.phpnu Iw PK ! b b 2 Util/GlobalStateTest.phpnu Iw PK ! Mr Util/ColorTest.phpnu Iw PK ! ͏= = # 3 Util/ConfigurationGeneratorTest.phpnu Iw PK ! #h h 7: Util/GetoptTest.phpnu Iw PK ! úPg g O Util/ConfigurationTest.phpnu Iw PK ! O f f Util/XmlTest.phpnu Iw PK ! ƴ
Util/JsonTest.phpnu Iw PK ! ZGA` ` Util/RegularExpressionTest.phpnu Iw PK ! / Util/TestClassTest.phpnu Iw PK ! x"Ѥ
# Util/PHP/AbstractPhpProcessTest.phpnu Iw PK ! 4r + Util/TestDox/CliTestDoxPrinterColorTest.phpnu Iw PK ! ; # Util/TestDox/NamePrettifierTest.phpnu Iw PK ! Dv I I & Util/TestDox/CliTestDoxPrinterTest.phpnu Iw PK ! dna d SetUpBeforeClassTest.phpnu Iw PK ! p p \ TearDownAfterClassTest.phpnu Iw PK !
)
SetUpTest.phpnu Iw PK ! <
StatusTest.phpnu Iw PK q q *