if __name__ == '__main__':
unittest.main(verbosity=2)
The argv argument can be a list of options passed to the program, with the first
element being the program name. If not specified or 
None
, the values of 
sys.argv
are
used.
The testRunner argument can either be a test runner class or an already created
instance of it. By default 
main
calls 
sys.exit()
with an exit code indicating success or
failure of the tests run.
The testLoader  argument  has  to  be  a 
TestLoader
instance,  and  defaults  to
defaultTestLoader
.
main
supports being used from the interactive interpreter by passing in the argument
exit=False
. This displays the result on standard output without calling 
sys.exit()
:
>>> from unittest import main
>>> main(module='test_module'exit=False)
The failfast, catchbreak and buffer parameters have the same effect as the same-
name command-line options.
Calling 
main
actually returns an instance of the 
TestProgram
class. This stores the
result of the tests run as the 
result
attribute.
Changed in version 2.7: The exit, verbosity, failfast, catchbreak and buffer parameters
were added.
25.3.7.3.1. load_tests Protocol
New in version 2.7.
Modules or packages can customize how tests are loaded from them during normal test
runs or test discovery by implementing a function called 
load_tests
.
If 
test 
module 
defines 
load_tests
it 
will 
be 
called 
by
TestLoader.loadTestsFromModule()
with the following arguments:
load_tests(loader, standard_tests, None)
It should return a 
TestSuite
.
Pdf security options - C# PDF Digital Signature Library: add, remove, update PDF digital signatures in C#.net, ASP.NET, MVC, WPF
Help to Improve the Security of Your PDF File by Adding Digital Signatures
convert locked pdf to word doc; can print pdf security
Pdf security options - VB.NET PDF Digital Signature Library: add, remove, update PDF digital signatures in vb.net, ASP.NET, MVC, WPF
Guide VB.NET Programmers to Improve the Security of Your PDF File by Adding Digital Signatures
creating a secure pdf document; pdf security
loader is the instance of 
TestLoader
doing the loading. standard_tests are the tests that
would be loaded by default from the module. It is common for test modules to only want
to add or remove tests from the standard set of tests. The third argument is used when
loading packages as part of test discovery.
A typical 
load_tests
function that loads tests from a specific set of 
TestCase
classes
may look like:
test_cases = (TestCase1, TestCase2, TestCase3)
def load_tests(loader, tests, pattern):
suite = TestSuite()
for test_class in test_cases:
tests = loader.loadTestsFromTestCase(test_class)
suite.addTests(tests)
return suite
If  discovery  is  started,  either  from  the  command  line  or  by  calling
TestLoader.discover()
, with a pattern that matches a package name then the package
__init__.py
will be checked for 
load_tests
.
Note:  The default pattern is 
'test*.py'
. This matches all Python files that start with
'test'
but won’t match any test directories.
A pattern like 
'test*'
will match test packages as well as modules.
If the package 
__init__.py
defines 
load_tests
then it will be called and discovery not
continued into the package. 
load_tests
is called with the following arguments:
load_tests(loader, standard_tests, pattern)
This  should  return  a 
TestSuite
representing  all  the  tests  from  the  package.
(
standard_tests
will only contain tests collected from 
__init__.py
.)
Because the pattern is passed into 
load_tests
the package is free to continue (and
potentially modify) test discovery. A ‘do nothing’ 
load_tests
function for a test package
would look like:
def load_tests(loader, standard_tests, pattern):
# top level directory cached on loader instance
this_dir = os.path.dirname(__file__)
package_tests = loader.discover(start_dir=this_dir, pattern=pattern)
standard_tests.addTests(package_tests)
return standard_tests
.NET PDF SDK - Description of All PDF Processing Control Feastures
Easy to change PDF original password; Options for setting PDF security level; PDF text content, image and pages redact options. PDF Digital Signature.
decrypt pdf password online; pdf encryption
.NET Annotation SDK| Annotate, Redact Images
Rich options to move, resize, rotate, scale any kind of annotation; Provide enhanced redaction & encryption objects for sensitive information & security;
copy locked pdf; cannot print pdf security
25.3.8. Class and Module Fixtures
Class and module level fixtures are implemented in 
TestSuite
. When the test suite
encounters a test from a new class then 
tearDownClass()
from the previous class (if
there is one) is called, followed by 
setUpClass()
from the new class.
Similarly if a test is from a different module from the previous test then 
tearDownModule
from the previous module is run, followed by 
setUpModule
from the new module.
After all the tests have run the final 
tearDownClass
and 
tearDownModule
are run.
Note that shared fixtures do not play well with [potential] features like test parallelization
and they break test isolation. They should be used with care.
The default ordering of tests created by the unittest test loaders is to group all tests from
the same modules and classes together. This will lead to 
setUpClass
setUpModule
(etc)
being called exactly once per class and module. If you randomize the order, so that tests
from different modules and classes are adjacent to each other, then these shared fixture
functions may be called multiple times in a single test run.
Shared fixtures are not intended to work with suites with non-standard ordering. A
BaseTestSuite
still exists for frameworks that don’t want to support shared fixtures.
If there are any exceptions raised during one of the shared fixture functions the test is
reported as an error. Because there is no corresponding test instance an 
_ErrorHolder
object (that has the same interface as a 
TestCase
) is created to represent the error. If
you are just using the standard unittest test runner then this detail doesn’t matter, but if
you are a framework author it may be relevant.
25.3.8.1. setUpClass and tearDownClass
These must be implemented as class methods:
import unittest
class Test(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls._connection = createExpensiveConnectionObject()
@classmethod
def tearDownClass(cls):
cls._connection.destroy()
If you want the 
setUpClass
and 
tearDownClass
on base classes called then you must call
BMP to JPEG Converter | Convert Bitmap to JPEG, Convert JPEG to
to JPEG Converter provides flexible image processing related options to resize JPEG conversion; Add morphing effects, watermarks to images to protect security;
secure pdf remove; copy text from locked pdf
DICOM to PDF Converter | Convert DICOM to PDF, Convert PDF to
Start DICOM - PDF image conversion through drag &drop method; Security protection provided with comment, logo, date or watermarks added to files;
pdf password unlock; pdf secure signature
up to them yourself. The implementations in 
TestCase
are empty.
If an exception is raised during a 
setUpClass
then the tests in the class are not run and
the 
tearDownClass
is not run. Skipped classes will not have 
setUpClass
or 
tearDownClass
run. If the exception is a 
SkipTest
exception then the class will be reported as having
been skipped instead of as an error.
25.3.8.2. setUpModule and tearDownModule
These should be implemented as functions:
def setUpModule():
createConnection()
def tearDownModule():
closeConnection()
If an exception is raised in a 
setUpModule
then none of the tests in the module will be run
and the 
tearDownModule
will not be run. If the exception is a 
SkipTest
exception then the
module will be reported as having been skipped instead of as an error.
25.3.9. Signal Handling
The -c/--catch command-line option to unittest, along with the 
catchbreak
parameter to
unittest.main()
, provide more friendly handling of control-C during a test run. With
catch break behavior enabled control-C will allow the currently running test to complete,
and the test run will then end and report all the results so far. A second control-c will raise
KeyboardInterrupt
in the usual way.
The control-c handling signal handler attempts to remain compatible with code or tests
that install their own 
signal.SIGINT
handler. If the 
unittest
handler is called but isn’t the
installed 
signal.SIGINT
handler, i.e. it has been replaced by the system under test and
delegated to, then it calls the default handler. This will normally be the expected behavior
by code that replaces an installed handler and delegates to it. For individual tests that
need 
unittest
control-c handling disabled the 
removeHandler()
decorator can be used.
There are a few utility functions for framework authors to enable control-c handling
functionality within test frameworks.
unittest.
installHandler
()
Install the control-c handler. When a 
signal.SIGINT
is received (usually in response
to the user pressing control-c) all registered results have 
stop()
called.
C# Image: Run RasterEdge Web Viewer Sample Project
Right-click the correspond site-> Edit Permissions -> Security -> Group or user names to provide powerful & profession imaging controls, PDF document, image to
convert secure webpage to pdf; convert locked pdf to word online
JPEG2000 to JBIG2 Converter | Convert JPEG2000 to JBIG2, Convert
or batch conversion method; Convert GIF & JBIG2 image with morphing effects, watermarks added to protect security; Can be used as
pdf secure; change security settings on pdf
New in version 2.7.
unittest.
registerResult
(
result
)
Register a 
TestResult
object for control-c handling. Registering a result stores a weak
reference to it, so it doesn’t prevent the result from being garbage collected.
Registering  a 
TestResult
object  has  no side-effects if control-c handling  is not
enabled, so  test frameworks  can  unconditionally register all  results they create
independently of whether or not handling is enabled.
New in version 2.7.
unittest.
removeResult
(
result
)
Remove a registered result. Once a result has been removed then 
stop()
will no
longer be called on that result object in response to a control-c.
New in version 2.7.
unittest.
removeHandler
(
function=None
)
When called without arguments this function removes the control-c handler if it has
been installed. This function can also be used as a test decorator to temporarily
remove the handler whilst the test is being executed:
@unittest.removeHandler
def test_signal_handling(self):
...
New in version 2.7.
index
modules |
next |
previous |
Python » Python v2.7.6 documentation » The Python Standard Library » 25. Development
Tools »
© Copyright
1990-2013, Python Software Foundation. 
The Python Software Foundation is a non-profit corporation. Please donate.
Last updated on Nov 10, 2013. Found a bug
Created using Sphinx
1.0.7.
GIF to JBIG2 Converter | Convert GIF to JBIG2, Convert JBIG2 to
brightness and more; Convert GIF & JBIG2 image with morphing effects, watermarks added to protect security; Save original images &
decrypt pdf; pdf password security
index
modules |
next |
previous |
25.4. 2to3 - Automated Python 2 to 3 code
translation
2to3 is a Python program that reads Python 2.x source code and applies a series of
fixers to transform it into valid Python 3.x code. The standard library contains a rich set of
fixers that will handle almost all code. 2to3 supporting library 
lib2to3
is, however, a
flexible and generic library, so it is possible to write your own fixers for 2to3. 
lib2to3
could also be adapted to custom applications in which Python code needs to be edited
automatically.
25.4.1. Using 2to3
2to3 will usually be installed with the Python interpreter as a script. It is also located in the
Tools/scripts
directory of the Python root.
2to3’s basic arguments are a list of files or directories to transform. The directories are
recursively traversed for Python sources.
Here is a sample Python 2.x source file, 
example.py
:
def greet(name):
print "Hello, {0}!".format(name)
print "What's your name?"
name = raw_input()
greet(name)
It can be converted to Python 3.x code via 2to3 on the command line:
$ 2to3 example.py
 diff  against  the  original  source  file  is  printed. 2to3  can  also  write  the  needed
modifications right back to the source file. (A backup of the original file is made unless -n
is also given.) Writing the changes back is enabled with the -w flag:
$ 2to3 -w example.py
After transformation, 
example.py
looks like this:
Python » Python v2.7.6 documentation » The Python Standard Library » 25. Development
Tools »
def greet(name):
print("Hello, {0}!".format(name))
print("What's your name?")
name = input()
greet(name)
Comments and exact indentation are preserved throughout the translation process.
By default, 2to3 runs a set of predefined fixers. The -l flag lists all available fixers. An
explicit set of fixers to run can be given with -f. Likewise the -x explicitly disables a fixer.
The following example runs only the 
imports
and 
has_key
fixers:
$ 2to3 -f imports -f has_key example.py
This command runs every fixer except the 
apply
fixer:
$ 2to3 -x apply example.py
Some fixers are explicit, meaning they aren’t run by default and must be listed on the
command line to be run. Here, in addition to the default fixers, the 
idioms
fixer is run:
$ 2to3 -f all -f idioms example.py
Notice how passing 
all
enables all default fixers.
Sometimes 2to3 will find a place in your source code that needs to be changed, but 2to3
cannot fix automatically. In this case, 2to3 will print a warning beneath the diff for a file.
You should address the warning in order to have compliant 3.x code.
2to3 can also refactor doctests. To enable this mode, use the -d flag. Note that only
doctests will be refactored. This also doesn’t require the module to be valid Python. For
example, doctest like examples in a reST document could also be refactored with this
option.
The -v option enables output of more information on the translation process.
Since some print statements can be parsed as function calls or statements, 2to3 cannot
always read files containing the print function. When 2to3 detects the presence of the
from  __future__ import  print_function
compiler directive,  it modifies  its  internal
grammar to interpret 
print()
as a function. This change can also be enabled manually
with the -p flag. Use -p to run fixers on code that already has had its print statements
converted.
The -o or --output-dir option allows specification of an alternate directory for processed
output files to be written to. The -n flag is required when using this as backup files do not
make sense when not overwriting the input files.
New in version 2.7.3: The -o option was added.
The -W  or --write-unchanged-files flag tells 2to3 to always write output files even if no
changes were required to the file. This is most useful with -o so that an entire Python
source tree is copied with translation from one directory to another. This option implies
the -w flag as it would not make sense otherwise.
New in version 2.7.3: The -W  flag was added.
The --add-suffix option specifies a string to append to all output filenames. The -n flag is
required when specifying this as backups are not necessary when writing to different
filenames. Example:
$ 2to3 -n -W --add-suffix=3 example.py
Will cause a converted file named 
example.py3
to be written.
New in version 2.7.3: The --add-suffix option was added.
To translate an entire project from one directory tree to another use:
$ 2to3 --output-dir=python3-version/mycode -W -n python2-version/mycode
25.4.2. Fixers
Each step of transforming code is encapsulated in a fixer. The command 
2to3 -l
lists
them. As documented above, each can be turned on and off individually. They are
described here in more detail.
apply
Removes  usage  of 
apply()
. For  example 
apply(function, *args, **kwargs)
is
converted to 
function(*args, **kwargs)
.
basestring
Converts 
basestring
to 
str
.
buffer
Converts 
buffer
to 
memoryview
. This fixer is optional because the 
memoryview
API is
similar but not exactly the same as that of 
buffer
.
callable
Converts 
callable(x)
to 
isinstance(x, collections.Callable)
, adding an import to
collections
if needed. Note 
callable(x)
has returned in Python 3.2, so if you do not
intend to support Python 3.1, you can disable this fixer.
dict
Fixes dictionary iteration methods. 
dict.iteritems()
is converted to 
dict.items()
,
dict.iterkeys()
to 
dict.keys()
 and 
dict.itervalues()
to 
dict.values()
.
Similarly, 
dict.viewitems()
dict.viewkeys()
and 
dict.viewvalues()
are converted
respectively to 
dict.items()
dict.keys()
and 
dict.values()
. It also wraps existing
usages of 
dict.items()
dict.keys()
, and 
dict.values()
in a call to 
list
.
except
Converts 
except X, T
to 
except X as T
.
exec
Converts the 
exec
statement to the 
exec()
function.
execfile
Removes usage of 
execfile()
. The argument to 
execfile()
is wrapped in calls to
open()
compile()
, and 
exec()
.
exitfunc
Changes assignment of 
sys.exitfunc
to use of the 
atexit
module.
filter
Wraps 
filter()
usage in a 
list
call.
funcattrs
Fixes 
function 
attributes 
that  have  been  renamed. For  example,
my_function.func_closure
is converted to 
my_function.__closure__
.
future
Removes 
from __future__ import new_feature
statements.
getcwdu
Renames 
os.getcwdu()
to 
os.getcwd()
.
has_key
Changes 
dict.has_key(key)
to 
key in dict
.
idioms
This optional fixer performs several transformations that make Python code more
idiomatic. Type comparisons like 
type(x) is SomeClass
and 
type(x) == SomeClass
are converted to 
isinstance(x, SomeClass)
while 1
becomes 
while True
. This fixer
also tries to make use of 
sorted()
in appropriate places. For example, this block
= list(some_iterable)
L.sort()
is changed to
= sorted(some_iterable)
import
Detects sibling imports and converts them to relative imports.
imports
Handles module renames in the standard library.
imports2
Handles other modules renames in the  standard  library. It is separate from the
imports
fixer only because of technical limitations.
input
Converts 
input(prompt)
to 
eval(input(prompt))
intern
Converts 
intern()
to 
sys.intern()
.
isinstance
Fixes  duplicate  types  in  the  second  argument  of 
isinstance()
 For  example,
isinstance(x, (int, int))
is converted to 
isinstance(x, (int))
.
itertools_imports
Removes 
imports 
of 
itertools.ifilter()
itertools.izip()
and
itertools.imap()
 Imports  of 
itertools.ifilterfalse()
are  also  changed  to
itertools.filterfalse()
.
itertools
Changes usage of 
itertools.ifilter()
itertools.izip()
, and 
itertools.imap()
to 
their 
built-in 
equivalents. 
itertools.ifilterfalse()
is  changed  to
itertools.filterfalse()
.
long
Renames 
long
to 
int
.
Documents you may be interested
Documents you may be interested