phpOMS\tests\Account\AccountManager: Account/user manager to handle/access loaded accounts

• The manager has the expected default values after initialization
• An account can be added to the manager
• An account can be retrieved from the manager
• An account can only be added once to the account manager (no duplication)
• An account can be removed from the account manager
• Only a valid account can be removed from the manager

phpOMS\tests\Account\AccountStatus: Account status

• Enum count
• The account status enum has only unique values
• The account status enum has the correct values

phpOMS\tests\Account\Account: Base account/user representation

• The account has the expected default values after initialization
• The account names can be set and retrieved correctly
• Groups can be added to an account
• An account can have a valid email address
• The default status of the account can be changed to a different valid status
• The default type of the account can be changed to a different valid type
• Account permissions can be added
• Account permissions can be checked for existence
• Group pmerission exists
• Account permissions can be removed
• An account can have it's own localization
• An account 'last activity' timestamp can be updated and retrieved
• An account can only have a valid email
• An account can only have valid account status
• An account can only have valid account types

phpOMS\tests\Account\AccountType: Account type

• The account type enum has the correct number of type codes
• The account type enum has only unique values
• The account type enum has the correct values

phpOMS\tests\Account\GroupStatus: Group status

• The group status enum has the correct number of status codes
• The group status enum has only unique values
• The group status enum has the correct values

phpOMS\tests\Account\Group: Base group representation

• The group has the expected default values after initialization
• The group name and description can be set and retrieved correctly
• Group permissions can be added
• Group permissions can be checked for existence
• Group permissions can be removed
• The default status of the group can be changed to a different valid status
• A group can only have valid group status

phpOMS\tests\Account\NullAccount: Null account

• The null account is an instance of the account class
• The null account can get initialized with an id
• Json serialization

phpOMS\tests\Account\NullGroup: Null group

• The null group is an instance of the group class
• The null group can get initialized with an id
• Json serialization

phpOMS\tests\Account\PermissionAbstractTest: Base permission representation

• The permission has the expected default values after initialization
• The permission can be set and returned correctly
• Two permissions can be checked for equality
• Full permissions
• Correct permissions are validated
• Invalid permissions are not validated
• Correct permission flags are validated
• Invalid permission flags are not validated

phpOMS\tests\Account\PermissionType: Permission type

• The permission type enum has the correct number of type codes
• The permission type enum has only unique values
• The permission type enum has the correct values

Basic Ocr (phpOMS\tests\Ai\Ocr\BasicOcr)

• Ocr
• Custom mnist files
• Invalid image path
• Invalid label path

Tesseract Ocr (phpOMS\tests\Ai\Ocr\Tesseract\TesseractOcr)

• Ocr basic
• Invalid ocr path
• Ocr with thresholding

phpOMS\tests\Algorithm\Clustering\KmeansTest: Clustering points/elements with the K-means algorithm

• The clustering of points and dynamic check of new points works as expected

phpOMS\tests\Algorithm\Clustering\PointTest: Default point in a cluster

• The point has the expected default values after initialization
• Coordinates of a point can be set and returned
• The group/cluster of a point can be set and returned
• The name of a point can be set and returned

phpOMS\tests\Algorithm\CoinMatching\MinimumCoinProblemTest: Match a value by using the minimum quantity of available sub values (Minimum Coin Problem)

• A value is matched with the minimum quantity of available coins.

phpOMS\tests\Algorithm\JobScheduling\JobTest: Default job for the job scheduling

• The job has the expected values after initialization

phpOMS\tests\Algorithm\JobScheduling\WeightedTest: Job scheduling based on values/profit

• The optimal job combination is selected to maximize the value/profit without overlapping jobs
• A job list with only one job simply returns one job

phpOMS\tests\Algorithm\Knapsack\BackpackTest: The default backpack or basket which holds all items for the Knapsack algorithm

• The backpack has the expected values after initialization
• Items can be added to the backpack and automatically change the value and cost the backpack contains

phpOMS\tests\Algorithm\Knapsack\BoundedTest: A Knapsack implementation for discrete quantities, values and costs and bounded item quantities

• The optimal item selection in a backpack is calculated in order to optimize the value/profit while considering the available capacity/cost limit

phpOMS\tests\Algorithm\Knapsack\ContinuousTest: A Knapsack implementation for continuous quantities, values and costs

• The optimal item selection in a backpack is calculated in order to optimize the value/profit while considering the available capacity/cost limit [discrete quantities]
• The optimal item selection in a backpack is calculated in order to optimize the value/profit while considering the available capacity/cost limit [continuous quantities]

phpOMS\tests\Algorithm\Knapsack\ItemTest: The default item to be added to the backpack or basket

• The item has the expected values after initialization

phpOMS\tests\Algorithm\Maze\MazeGeneratorTest: Maze generation

• A random maze can be generated
• A random maze can be rendered

phpOMS\tests\Algorithm\PathFinding\AStarNode: AStarNode on grid for path finding

• The node has the expected values after initialization
• The node can be set closed and checked
• The node can be set opened and checked
• The g value cen be set and returned
• The h value cen be set and returned
• The f value cen be set and returned

phpOMS\tests\Algorithm\PathFinding\AStarTest: AStar path finding

• The correct path is found for diagonal movement
• The correct path is found for straight movement
• The correct path is found for diagonal movement [one obstacle]
• The correct path is found for diagonal movement [no obstacle]
• A invalid start or end node returns the grid

phpOMS\tests\Algorithm\PathFinding\GridTest: Grid for path finding

• By default a grid is empty
• A grid can be created from an array
• A node can be set and returned from the grid
• Out of bounds nodes cannot be returned
• All horizontal neighbors can be found correctly
• All vertical neighbors can be found correctly
• No straight neighbors are found if no straight neighbors exist
• All straight neighbors can be found correctly
• All neighbors except blocked diagonal neighbors can be found correctly
• All neighbors except blocked diagonal neighbors can be found correctly
• No diagonal neighbors are found if no neighbors exist
• All diagonal neighbors can be found correctly
• All neighbors can be found correctly
• All neighbors can be found correctly even if one obstacle exists
• No diagonal neighbors are found if they are blocked on two sides
• All neighbors can be found correctly if no obstacles exists
• No diagonal neighbors are found if one obstacle exists
• All neighbors can be found correctly if no obstacles exist

phpOMS\tests\Algorithm\PathFinding\HeuristicTest: Heuristic for path finding

• The heuristics return the correct metric results

phpOMS\tests\Algorithm\PathFinding\JumpPointNode: JumpPointNode on grid for path finding

• The node has the expected values after initialization
• The node can be set closed and checked
• The node can be set opened and checked
• The node can be set tested and checked
• The g value cen be set and returned
• The h value cen be set and returned
• The f value cen be set and returned

phpOMS\tests\Algorithm\PathFinding\JumpPointSearchTest: JumpPoint path finding

• The correct path is found for diagonal movement
• The correct path is found for straight movement
• The correct path is found for diagonal movement [one obstacle]
• The correct path is found for diagonal movement [no obstacle]
• A invalid start or end node returns the grid

phpOMS\tests\Algorithm\PathFinding\NodeTest: Node on grid for path finding

• The node has the expected values after initialization
• Nodes with equal coordinates are equal
• Nodes with different coordinates are not equal
• A parent node can be set and returned

phpOMS\tests\Algorithm\PathFinding\PathTest: Path on grid

• The path has the expected values after initialization
• The diagonal euclidean path length is calculated correctly
• The straight euclidean path length is calculated correctly
• The path is correctly expanded in case only jump points are defined

phpOMS\tests\Algorithm\Rating\EloTest: Rating generation

• 1v1 rating test
• group rating test

phpOMS\tests\Algorithm\Rating\Glicko1Test: Rating generation

• 1v1 rating test
• group rating test

phpOMS\tests\Algorithm\Rating\Glicko2Test: Rating generation

• 1v1 rating test
• group rating test

phpOMS\tests\Algorithm\Sort\BitonicSortTest: Bitonic sort

• A list with one element returns the list with the element itself
• A list ot elements can be sorted in ASC order
• A list ot elements can be sorted in DESC order

phpOMS\tests\Algorithm\Sort\BubbleSortTest: Bubble sort

• A list with one element returns the list with the element itself
• A list ot elements can be sorted in ASC order
• A list ot elements can be sorted in DESC order

phpOMS\tests\Algorithm\Sort\BucketSortTest: Bucket sort

• A list with one element returns the list with the element itself
• A list ot elements can be sorted in ASC order
• A list ot elements can be sorted in DESC order
• If no buckets are specified the elements cannot be sorted and an empty result is returned

phpOMS\tests\Algorithm\Sort\CocktailShakerSortTest: CocktailShaker sort

• A list with one element returns the list with the element itself
• A list ot elements can be sorted in ASC order
• A list ot elements can be sorted in DESC order

phpOMS\tests\Algorithm\Sort\CombSortTest: Comb sort

• A list with one element returns the list with the element itself
• A list ot elements can be sorted in ASC order
• A list ot elements can be sorted in DESC order

phpOMS\tests\Algorithm\Sort\CycleSortTest: Cycle sort

• A list with one element returns the list with the element itself
• A list ot elements can be sorted in ASC order
• A list ot elements can be sorted in DESC order

phpOMS\tests\Algorithm\Sort\GnomeSortTest: Gnome sort

• A list with one element returns the list with the element itself
• A list ot elements can be sorted in ASC order
• A list ot elements can be sorted in DESC order

phpOMS\tests\Algorithm\Sort\HeapSortTest: Heap sort

• A list with one element returns the list with the element itself
• A list ot elements can be sorted in ASC order
• A list ot elements can be sorted in DESC order

phpOMS\tests\Algorithm\Sort\InsertionSortTest: Insertion sort

• A list with one element returns the list with the element itself
• A list ot elements can be sorted in ASC order
• A list ot elements can be sorted in DESC order

phpOMS\tests\Algorithm\Sort\IntroSortTest: Intro sort

• A list with one element returns the list with the element itself
• A list ot elements can be sorted in ASC order
• A list ot elements can be sorted in DESC order

phpOMS\tests\Algorithm\Sort\MergeSortTest: Merge sort

• A list with one element returns the list with the element itself
• A list ot elements can be sorted in ASC order
• A list ot elements can be sorted in DESC order

phpOMS\tests\Algorithm\Sort\OddEvenSortTest: OddEven sort

• A list with one element returns the list with the element itself
• A list ot elements can be sorted in ASC order
• A list ot elements can be sorted in DESC order

phpOMS\tests\Algorithm\Sort\PancakeSortTest: Pancake sort

• A list with one element returns the list with the element itself
• A list ot elements can be sorted in ASC order
• A list ot elements can be sorted in DESC order

phpOMS\tests\Algorithm\Sort\QuickSortTest: Quick sort

• A list with one element returns the list with the element itself
• A list ot elements can be sorted in ASC order
• A list ot elements can be sorted in DESC order

phpOMS\tests\Algorithm\Sort\SelectionSortTest: Selection sort

• A list with one element returns the list with the element itself
• A list ot elements can be sorted in ASC order
• A list ot elements can be sorted in DESC order

phpOMS\tests\Algorithm\Sort\ShellSortTest: Shell sort

• A list with one element returns the list with the element itself
• A list ot elements can be sorted in ASC order
• A list ot elements can be sorted in DESC order

phpOMS\tests\Algorithm\Sort\StoogeSortTest: Stooge sort

• A list with one element returns the list with the element itself
• A list ot elements can be sorted in ASC order
• A list ot elements can be sorted in DESC order

phpOMS\tests\Algorithm\Sort\TimSortTest: Tim sort

• A list with one element returns the list with the element itself
• A list ot elements can be sorted in ASC order
• A list ot elements can be sorted in DESC order

phpOMS\tests\Api\EUVAT\EUVATBffOnlineTest: EU VAT German BFF Online validation

• The BFF Online service can validate a valid VAT ID
• Validate qualified invalid id

phpOMS\tests\Api\EUVAT\EUVATViesTest: EU VAT Vies validation

• The VIES service can validate a valid VAT ID
• Validate qualified invalid id

phpOMS\tests\Application\ApplicationAbstractTest: Application abstraction

• Application values can be set and returned
• Application values cannot be overwritten

phpOMS\tests\Application\ApplicationInfoTest: Module info file manager

• An application info file can be correctly loaded
• A info file can be modified
• A invalid info file path load throws a PathException
• A invalid info file path update throws a PathException
• A invalid change data throws a InvalidArgumentException

phpOMS\tests\Application\ApplicationManagerTest: Application manager

• An application can be installed and uninstalled
• An application can be re-initialized
• A invalid application path results in no installation
• A missing installation file results in no installation
• A missing info file results in no installation
• A invalid application path results in no uninstallation
• A missing uninstallation file results in no uninstallation

phpOMS\tests\Application\InstallerAbstractTest: Abstract application installer

• An invalid theme cannot be installed

phpOMS\tests\Application\StatusAbstractTest: Abstract application status

• A invalid application path cannot be activated

phpOMS\tests\Application\UninstallerAbstractTest: Abstract application uninstaller

• A missing database schema will not perform any database operations

phpOMS\tests\Asset\AssetManagerTest: Asset manager to handle/access assets

• The manager has the expected default values after initialization
• An asset can be added to the manager
• An asset can be retrieved from the manager
• An asset can only be added once to the manager (no duplication unless overwritten)
• An asset can be replaced upon request
• An asset can be removed from the manager

phpOMS\tests\Asset\AssetType: Asset type

• The asset type enum has the correct number of status codes
• The asset type enum has only unique values
• The asset type enum has the correct values

phpOMS\tests\Auth\AuthTest: Account and session authentication

• The default http session doesn't authenticate an account

phpOMS\tests\Auth\LoginReturnType: Login return type

• The login return type enum has the correct number of type codes
• The login return type enum has only unique values
• The login return type enum has the correct values

Autoload Exception (phpOMS\tests\AutoloadException)

• Exception

phpOMS\tests\AutoloaderTest: Class autoloader

• Classes can be checked for existence
• Loading
• Manual path loading
• Path finding
• Opcode cache invalidation
• Uncached invalidation

phpOMS\tests\Business\Finance\DepreciationTest: Depreciation calculations

• The straight line depreciation and reverse value calculations are correct
• The arithmetic degressive depreciation and reverse value calculations are correct
• The arithmetic progressive depreciation and reverse value calculations are correct
• The geometric progressive depreciation and reverse value calculations are correct
• The geometric degressive depreciation and reverse value calculations are correct

phpOMS\tests\Business\Finance\FinanceFormulasTest: Finance formulas

• The annual percentage yield (APY) and reverse value calculations are correct
• The future value of annuity (FVA) and reverse value calculations are correct
• The future value of annuity continuous compounding (FVACC) and reverse value calculations are correct
• The annuity payment from the present value (PV) and reverse value calculations are correct
• The annuity payment from the future value (FV) and reverse value calculations are correct
• The annuity payment from the present value (PV) and reverse value calculations are correct
• The present value of the annuity is correct
• The present value annuity factor of the annuity is correct
• The due present value the annuity is correct
• The due future value the annuity is correct
• The relative market share calculations by shares and ales are correct
• The asset ratio calculations are correct
• Balance ratio calculations for DII, Receivables/Turnover, and more are correct
• Dept ratios for dept coverage, dept to equity and dept to income are correct
• Return on balance statement positions are correct (e.g. return on assets, on equity)
• Balance / P&L ratios are correct (e.g. inventory turnover, net profit margin)
• Various ratios are correct (e.g. interest coverage, quick ratio, rate of inflation)
• Compound calculations for interest, principal and periods are correct
• Continuous compound calculations for interest, principal and periods are correct
• Calculations for interest, principal and periods are correct
• The discounted payback period is correct
• Test the correct calculation of the growth rate in order to double and vice versa
• Test the correct calculation of the growth rate in order to double and vice versa with continuous compounding
• Calculations for equivalent annual annuity are correct
• The free cash flow to equity calculation is correct (how much cash is available after expenses and dept payments)
• The free cash flow to firm calculation is correct (how much cash is available after expenses)
• The future value calculation is correct
• The future value calculation including continuous compounding is correct
• The future value factor calculation is correct
• The calculation of the geometric mean of multiple return rates is correct
• The calculation of the future value of the growing annuity is correct
• The calculation of the payment based on the present value of the growing annuity is correct
• The calculation of the payment based on the future value of the growing annuity is correct
• The calculation of the present value of the growing annuity is correct
• The calculation of the present value of the growing perpetuity is correct
• The calculation of the net present value is correct
• No cash flows in the net present value calculation result in 0
• The calculation of the real rate of return is correct
• The calculation of the net working capital is correct
• The periods to reach a future value based on the present value is calculated correctly
• The calculation of the present value is correct
• The calculation of the present value using continuous compounding is correct

phpOMS\tests\Business\Finance\ForensicsTest: Forensics formulas

• Benford analysis
• Expected benford distribution

phpOMS\tests\Business\Finance\LoanTest: Loan formulas

• The loan to deposit ratio is correct
• The loan to value ratio is correct
• The balloon loan payments are correct for a given balloon
• The balloon loan residual value (balloon) is correct for given payments
• The loan payments are correct for a given interest rate and period [continuous compounding]
• The residual value is correct for a given payment amount, interest rate and period [continuous compounding]

phpOMS\tests\Business\Finance\LorenzkurveTest: Lorenz kurve

• The gini coefficient calculation is correct

phpOMS\tests\Business\Finance\StockBondsTest: Stock & bond related formulas

• The calculation of various stock/bond related ratios/yields is correct
• The calculation of the bond yield based on face value and price is correct
• The calculation of the return of the capital asset pricing model is correct
• The capital gains yield calculation is correct
• The diluted earnings per share calculation is correct
• The calculation of the absolute return for multiple holding periods is correct
• The tax equivalent yield is calculated correctly
• The net asset value is calculated correctly
• The calculation of the present value of a stock with constant growth rate is correct
• The total stock return including dividends and sales price is correct
• The calculation of the yield of a bond is correct
• The calculation of value of the zero coupon bond is correct
• The calculation of the yield of a zero coupon bond is correct

phpOMS\tests\Business\Marketing\CustomerValueTest: Customer value

• The simple customer life time value is correctly calculated
• The monthly recurring revenue (MRR) is correctly calculated

phpOMS\tests\Business\Marketing\MetricsTest: General marketing metrics

• Test the correctness of the customer retention calculation
• The profit according to Berry can be correctly calculated
• The purchase probability of customers can be calculated based on historic information using the migration model
• The CLTV can be calculated using the migration model
• The migration model can be used in order to determin which buying/none-buying customer group should receive a mailing
• The probability of a customer buying can be calculated based on his previous purchase behavior

phpOMS\tests\Business\Marketing\NetPromoterScoreTest: Net promoter

• The net promoter has the expected default values after initialization
• The net promoter score, detractors, passives and promoters are correct

phpOMS\tests\Business\Marketing\PageRankTest: Page rank algorithm

• Test the correctness of the page rank algorithm
• Test the correctness of the page rank algorithm with custom damping and starting values

phpOMS\tests\Business\Programming\MetricsTest: General programming metrics

• Test correctness of the ABC calculation
• Test correctness of CRAP score

phpOMS\tests\Business\Recommendation\ArticleCorrelationAffinityTest: Article affinity/correlation

• The highest affinities between articles purchased are calculated correctly
• The affinity of a new article is empty

phpOMS\tests\Business\Sales\MarketShareEstimationTest: Market share calculations

• The rank calculated with Zipf is correct
• The market share by rank calculated with Zipf is correct

phpOMS\tests\Config\OptionsTrait: Helper for managing options

• The option helper has the expected default values after initialization
• Options can be added to the helper
• Options can be overwritten/changed
• Multiple options can be added to the helper in one go
• Multiple options can be retrieved

phpOMS\tests\DataStorage\Cache\CachePoolTest: Pool for caches

• The pool has the expected default values after initialization
• New cache connections can be added to the pool
• Cache connections cannot be overwritten with a different cache connection
• Cache connections can be accessed with an identifier
• By default a null cache is returned if no cache connection exists for the identifier
• Cache connections can created by the pool and automatically get added but not overwritten
• Cache connections can be removed from the pool
• Removing a cache with an invalid identifier will result in no actions

Cache Status (phpOMS\tests\DataStorage\Cache\CacheStatus)

• Enum count
• Unique
• Enums

Cache Type (phpOMS\tests\DataStorage\Cache\CacheType)

• Enum count
• Unique
• Enums

Cache Value Type (phpOMS\tests\DataStorage\Cache\Connection\CacheValueType)

• Enum count
• Unique
• Enums

phpOMS\tests\DataStorage\Cache\Connection\ConnectionFactoryTest: Factory for generating cache connections

• The file cache can be created
• The memcached cache can be created
• The redis cache can be created
• A invalid cache type results in an exception

phpOMS\tests\DataStorage\Cache\Connection\FileCacheTest: File cache connection

• The file cache connection has the expected default values after initialization
• The connection to a dedicated cache directory can be established (none-existing directories get created)
• Different cache data (types) can be set and returned
• Cache data can bet added and returned
• Exists
• Expired exists
• Exists invalid status
• Get like
• Expired get like
• Get like invalid status
• Increment
• Invalid key increment
• Increment invalid status
• Decrement
• Invalid key decrement
• Decrement invalid status
• Rename
• Rename invalid status
• Delete invalid status
• Delete like
• Expired delte like
• Delete like invalid status
• Update expire
• Update expire invalid status
• Cache data cannot be added if it already exists
• Existing cache data can be replaced
• None-existing cache data cannot be replaced
• Existing cache data can be deleted
• Invalid key delete
• The cache correctly handles general cache information
• The cache can be flushed
• Cache data can be set and returned with expiration limits
• Expired cache data cannot be returned
• Expired cache data can be forced to return
• Unexpired cache data cannot be delete if lower expiration is defined
• Expired cache data can be deleted if equal expiration is defined
• Unexpired data can be force deleted with lower expiration date
• Cache data can be flushed by expiration date
• A bad cache status will prevent all cache actions
• A invalid cache connection will throw an InvalidConnectionConfigException
• Adding a invalid data type will throw an InvalidArgumentException
• Setting a invalid data type will throw an InvalidArgumentException

phpOMS\tests\DataStorage\Cache\Connection\MemCachedTest: Memcache connection

• The memcached connection has the expected default values after initialization
• The connection to a cache can be established (none-existing directories get created)
• Different cache data (types) can be set and returned
• Cache data can bet added and returned
• Exists
• Expired exists
• Exists invalid status
• Increment
• Invalid key increment
• Increment invalid status
• Decrement
• Decrement invalid status
• Invalid key decrement
• Rename
• Rename invalid status
• Update expire
• Update expire invalid status
• Cache data cannot be added if it already exists
• Existing cache data can be replaced
• None-existing cache data cannot be replaced
• Existing cache data can be deleted
• Delete invalid status
• Invalid key delete
• The cache correctly handles general cache information
• The cache can be flushed
• Cache data can be set and returned with expiration limits
• Expired cache data cannot be returned
• Cache data can be flushed by expiration date
• A bad cache status will prevent all cache actions
• Adding a invalid data type will throw an InvalidArgumentException
• Setting a invalid data type will throw an InvalidArgumentException
• A invalid host throws a InvalidConnectionConfigException
• A invalid port throws a InvalidConnectionConfigException

phpOMS\tests\DataStorage\Cache\Connection\NullCacheTest: Null cache connection if no cache is available

• The default cache has the expected default values after initialization
• Connect
• Set input output
• Add input output
• Get like
• Increment
• Decrement
• Replace
• Rename
• Delete
• Delete like
• Flush
• Flush all
• Exists
• Update expire
• Stats

phpOMS\tests\DataStorage\Cache\Connection\RedisCache: Redis cache connection

• The redis cache connection has the expected default values after initialization
• The connection to a cache can be established (none-existing directories get created)
• Different cache data (types) can be set and returned
• Cache data can bet added and returned
• Exists
• Expired exists
• Exists invalid status
• Get like
• Expired get like
• Get like invalid status
• Increment
• Increment invalid status
• Invalid key increment
• Decrement
• Decrement invalid status
• Invalid key decrement
• Rename
• Rename invalid status
• Delete like
• Delete like invalid status
• Update expire
• Update expire invalid status
• Cache data cannot be added if it already exists
• Existing cache data can be replaced
• None-existing cache data cannot be replaced
• Existing cache data can be deleted
• Delete invalid status
• Invalid key delete
• The cache correctly handles general cache information
• The cache can be flushed
• Cache data can be set and returned with expiration limits
• Expired cache data cannot be returned
• A bad cache status will prevent all cache actions
• Adding a invalid data type will throw an InvalidArgumentException
• Setting a invalid data type will throw an InvalidArgumentException
• A invalid host throws a InvalidConnectionConfigException
• A invalid port throws a InvalidConnectionConfigException
• A invalid database throws a InvalidConnectionConfigException

Invalid Connection Config Exception (phpOMS\tests\DataStorage\Cache\Exception\InvalidConnectionConfigException)

• Exception

phpOMS\tests\DataStorage\Cookie\CookieJar: CookieJar to handle http cookies

• The cookie jar has the expected default values and functionality after initialization
• Cookie values can be set and returned
• Cookie values cannot be overwritten
• Cookie values can be forced to overwrite
• Cookie values can be removed
• None-existing cookie values cannot be removed
• Values cannot be removed from a locked cookie and throws a LockException
• A locked cookie cannot be saved and throws a LockException

phpOMS\tests\DataStorage\Database\Connection\ConnectionFactory: Database connection factory

• The mysql connection can be successfully created
• The postgresql connection can be successfully created
• The sqlserver connection can be successfully created
• The sqlite connection can be successfully created
• A invalid database type throws a InvalidArgumentException

phpOMS\tests\DataStorage\Database\Connection\MysqlConnectionTest: Mysql connection

• Valid mysql connection data result in a valid database connection
• A missing database type returns a failure
• A missing database host returns a failure
• A missing database port returns a failure
• A missing database returns a failure
• A missing database login returns a failure
• A missing database password returns a failure
• A invalid database type returns a failure
• A invalid database returns a failure

phpOMS\tests\DataStorage\Database\Connection\NullConnectionTest: Null connection

• A null connection can be created as placeholder

phpOMS\tests\DataStorage\Database\Connection\PostgresConnectionTest: Postgresql connection

• Valid postgresql connection data result in a valid database connection
• A missing database type returns a failure
• A missing database host returns a failure
• A missing database port returns a failure
• A missing database returns a failure
• A missing database login returns a failure
• A missing database password returns a failure
• A invalid database returns a failure
• A invalid database returns a failure

phpOMS\tests\DataStorage\Database\Connection\SQLiteConnectionTest: SQLite connection

• Valid sqlite connection data result in a valid database connection
• A missing database type returns a failure
• Valid sqlite connection data result in a valid database connection
• A missing database returns a failure
• A invalid database returns a failure

phpOMS\tests\DataStorage\Database\Connection\SqlServerConnectionTest: Sqlserver connection

• Valid sqlserver connection data result in a valid database connection
• A missing database type returns a failure
• A missing database host returns a failure
• A missing database port returns a failure
• A missing database returns a failure
• A missing database login returns a failure
• A missing database password returns a failure
• A invalid database type returns a failure
• A invalid database returns a failure

phpOMS\tests\DataStorage\Database\Mapper\DataMapperAbstractTest: Datamapper for database models

• The datamapper successfully creates a database entry of a model
• Create null model
• Create already created model
• Create has many relation
• The datamapper successfully returns a database entry as model
• Get all
• Get for
• Get by
• Get newest
• Get null model
• Find
• Find
• With conditional
• The datamapper successfully updates a database entry from a model
• The datamapper successfully deletes a database entry from a model
• Delete has many relation
• Reader
• Writer
• Updater
• Remover

phpOMS\tests\DataStorage\Database\DatabasePool: Pool for database connections

• The pool has the expected default values after initialization
• A database connection can be created by the pool
• Database connections cannot be overwritten
• Existing database connections can be added to the pool
• Database connections can be removed from the pool
• Invalid database connections cannot be removed
• The first connection added to the pool is the default connection

Database Status (phpOMS\tests\DataStorage\Database\DatabaseStatus)

• Enum count
• Unique
• Enums

Database Type (phpOMS\tests\DataStorage\Database\DatabaseType)

• Enum count
• Unique
• Enums

Invalid Connection Config Exception (phpOMS\tests\DataStorage\Database\Exception\InvalidConnectionConfigException)

• Exception

Invalid Database Type Exception (phpOMS\tests\DataStorage\Database\Exception\InvalidDatabaseTypeException)

• Exception

Invalid Mapper Exception (phpOMS\tests\DataStorage\Database\Exception\InvalidMapperException)

• Exception

phpOMS\tests\DataStorage\Database\Query\BuilderTest: Query builder for sql queries

• Mysql selects form a valid query with data set #0
• Mysql selects form a valid query with data set #1
• Mysql selects form a valid query with data set #2
• Mysql selects form a valid query with data set #3
• Random mysql
• Random postgresql
• Random s q lite
• Random sql server
• Mysql orders form a valid query with data set #0
• Mysql orders form a valid query with data set #1
• Mysql orders form a valid query with data set #2
• Mysql orders form a valid query with data set #3
• Mysql offsets and limits form a valid query with data set #0
• Mysql offsets and limits form a valid query with data set #1
• Mysql offsets and limits form a valid query with data set #2
• Mysql offsets and limits form a valid query with data set #3
• Mysql groupings form a valid query with data set #0
• Mysql groupings form a valid query with data set #1
• Mysql groupings form a valid query with data set #2
• Mysql groupings form a valid query with data set #3
• Mysql wheres form a valid query with data set #0
• Mysql wheres form a valid query with data set #1
• Mysql wheres form a valid query with data set #2
• Mysql wheres form a valid query with data set #3
• Mysql joins form a valid query with data set #0
• Mysql joins form a valid query with data set #1
• Mysql joins form a valid query with data set #2
• Mysql joins form a valid query with data set #3
• Mysql inserts form a valid query with data set #0
• Mysql inserts form a valid query with data set #1
• Mysql inserts form a valid query with data set #2
• Mysql inserts form a valid query with data set #3
• Mysql deletes form a valid query with data set #0
• Mysql deletes form a valid query with data set #1
• Mysql deletes form a valid query with data set #2
• Mysql deletes form a valid query with data set #3
• Mysql updates form a valid query with data set #0
• Mysql updates form a valid query with data set #1
• Mysql updates form a valid query with data set #2
• Mysql updates form a valid query with data set #3
• Raw queries get output as defined with data set #0
• Raw queries get output as defined with data set #1
• Raw queries get output as defined with data set #2
• Raw queries get output as defined with data set #3
• Read only queries allow selects with data set #0
• Read only queries allow selects with data set #1
• Read only queries allow selects with data set #2
• Read only queries allow selects with data set #3
• Read only queries don't allow drops with data set #0
• Read only queries don't allow drops with data set #1
• Read only queries don't allow drops with data set #2
• Read only queries don't allow drops with data set #3
• Read only queries don't allow deletes with data set #0
• Read only queries don't allow deletes with data set #1
• Read only queries don't allow deletes with data set #2
• Read only queries don't allow deletes with data set #3
• Read only queries don't allow creates with data set #0
• Read only queries don't allow creates with data set #1
• Read only queries don't allow creates with data set #2
• Read only queries don't allow creates with data set #3
• Read only queries don't allow modifications with data set #0
• Read only queries don't allow modifications with data set #1
• Read only queries don't allow modifications with data set #2
• Read only queries don't allow modifications with data set #3
• Read only queries don't allow inserts with data set #0
• Read only queries don't allow inserts with data set #1
• Read only queries don't allow inserts with data set #2
• Read only queries don't allow inserts with data set #3
• Read only queries don't allow updates with data set #0
• Read only queries don't allow updates with data set #1
• Read only queries don't allow updates with data set #2
• Read only queries don't allow updates with data set #3
• Read only queries don't allow deletes with data set #0
• Read only queries don't allow deletes with data set #1
• Read only queries don't allow deletes with data set #2
• Read only queries don't allow deletes with data set #3
• Invalid select types throw a InvalidArgumentException with data set #0
• Invalid select types throw a InvalidArgumentException with data set #1
• Invalid select types throw a InvalidArgumentException with data set #2
• Invalid select types throw a InvalidArgumentException with data set #3
• Invalid from types throw a InvalidArgumentException with data set #0
• Invalid from types throw a InvalidArgumentException with data set #1
• Invalid from types throw a InvalidArgumentException with data set #2
• Invalid from types throw a InvalidArgumentException with data set #3
• Invalid group types throw a InvalidArgumentException with data set #0
• Invalid group types throw a InvalidArgumentException with data set #1
• Invalid group types throw a InvalidArgumentException with data set #2
• Invalid group types throw a InvalidArgumentException with data set #3
• Invalid where operators throw a InvalidArgumentException with data set #0
• Invalid where operators throw a InvalidArgumentException with data set #1
• Invalid where operators throw a InvalidArgumentException with data set #2
• Invalid where operators throw a InvalidArgumentException with data set #3
• Invalid join operators throw a InvalidArgumentException with data set #0
• Invalid join operators throw a InvalidArgumentException with data set #1
• Invalid join operators throw a InvalidArgumentException with data set #2
• Invalid join operators throw a InvalidArgumentException with data set #3

Column (phpOMS\tests\DataStorage\Database\Query\Column)

• Default

Count (phpOMS\tests\DataStorage\Database\Query\Count)

• Default

Expression (phpOMS\tests\DataStorage\Database\Query\Expression)

• Default

From (phpOMS\tests\DataStorage\Database\Query\From)

• Default

phpOMS\tests\DataStorage\Database\Query\GrammarTest: Basic sql query grammar

• The grammar has the expected default values after initialization

phpOMS\tests\DataStorage\Database\Query\MysqlGrammarTest: Mysql sql query grammar

• The grammar has the expected default values after initialization

Oracle Grammar (phpOMS\tests\DataStorage\Database\Query\Grammar\OracleGrammar)

• Default

Postgres Grammar (phpOMS\tests\DataStorage\Database\Query\Grammar\PostgresGrammar)

• Default

phpOMS\tests\DataStorage\Database\Query\SQLiteGrammarTest: SQLite sql query grammar

• The grammar has the expected default values after initialization

Sql Server Grammar (phpOMS\tests\DataStorage\Database\Query\Grammar\SqlServerGrammar)

• Default

Into (phpOMS\tests\DataStorage\Database\Query\Into)

• Default

Join Type (phpOMS\tests\DataStorage\Database\Query\JoinType)

• Enum count
• Unique
• Enums

Query Type (phpOMS\tests\DataStorage\Database\Query\QueryType)

• Enum count
• Unique
• Enums

Select (phpOMS\tests\DataStorage\Database\Query\Select)

• Default

Where (phpOMS\tests\DataStorage\Database\Query\Where)

• Default

Relation Type (phpOMS\tests\DataStorage\Database\RelationType)

• Enum count
• Unique
• Enums

phpOMS\tests\DataStorage\Database\Schema\BuilderTest: Query builder for sql schemas

• Mysql database drop forms a valid query with data set #0
• Mysql database drop forms a valid query with data set #1
• Mysql database drop forms a valid query with data set #2
• Mysql database drop forms a valid query with data set #3
• Mysql table drop forms a valid query with data set #0
• Mysql table drop forms a valid query with data set #1
• Mysql table drop forms a valid query with data set #2
• Mysql table drop forms a valid query with data set #3
• Mysql show tables form a valid query with data set #0
• Mysql show tables form a valid query with data set #1
• Mysql show tables form a valid query with data set #2
• Mysql show tables form a valid query with data set #3
• Mysql show fields form a valid query with data set #0
• Mysql show fields form a valid query with data set #1
• Mysql show fields form a valid query with data set #2
• Mysql show fields form a valid query with data set #3
• Mysql create tables form a valid query with data set #0
• Mysql create tables form a valid query with data set #1
• Mysql create tables form a valid query with data set #2
• Mysql create tables form a valid query with data set #3
• The grammar correctly deletes a table with data set #0
• The grammar correctly deletes a table with data set #1
• The grammar correctly deletes a table with data set #2
• The grammar correctly deletes a table with data set #3

phpOMS\tests\DataStorage\Database\Schema\GrammarTest: Basic sql query grammar

• The grammar has the expected default values after initialization

phpOMS\tests\DataStorage\Database\Schema\Grammar\MysqlGrammarTest: Mysql sql schema grammar

• The grammar has the expected default values after initialization
• The the grammar correctly creates and returns a database table
• The grammar correctly deletes a table

Oracle Grammar (phpOMS\tests\DataStorage\Database\Schema\Grammar\OracleGrammar)

• Default

Postgres Grammar (phpOMS\tests\DataStorage\Database\Schema\Grammar\PostgresGrammar)

• Default

phpOMS\tests\DataStorage\Database\Schema\Grammar\SQLiteGrammarTest: SQLite sql schema grammar

• The grammar has the expected default values after initialization

Sql Server Grammar (phpOMS\tests\DataStorage\Database\Schema\Grammar\SqlServerGrammar)

• Default

Query Type (phpOMS\tests\DataStorage\Database\Schema\QueryType)

• Enum count
• Unique
• Enums

phpOMS\tests\DataStorage\Database\SchemaMapperTest: Mapper for the database schema

• The tables can be returned
• The fields of a table can be returned

phpOMS\tests\DataStorage\LockExceptionTest: Lock exception

• The lock exception is an instance of the runtime exception

phpOMS\tests\DataStorage\Session\HttpSessionTest: Session data handler for http sessions

• The session has the expected default values after initialization
• Session data can be set and returned
• Session data cannot be overwritten
• Session data can be forced to overwrite
• Session data can be removed
• None-existing session data cannot be removed
• A session id can be set and returned
• A session can be locked
• Locked sessions cannot be saved
• A locked session cannot add or change data
• A locked session cannot remove data

phpOMS\tests\Dispatcher\DispatcherTest: Dispatcher for executing request endpoints

• A route can be added and dispatched
• The dispatcher can dispatch a function/closure
• The dispatcher can dispatch a method as string representation of a controller
• The dispatcher can dispatch a method as array representation of a controller
• The dispatcher can dispatch a static method as string representation
• The dispatcher can dispatch multiple destinations after another
• The dispatcher can pass additional data to the destination
• A invalid controller path throws a PathException
• A invalid function path throws a Exception
• A malformed dispatch path throws UnexpectedValueException

phpOMS\tests\Event\EventManager: Event manager for managing and executing events

• The event manager has the expected default values after initialization
• New events can be added
• Events can be cleared
• Multiple callbacks can be added to an event
• An event gets executed if all conditions and sub conditions are met
• An event doesn't get executed if not all conditions and sub conditions are met
• None-existing events cannot be executed/triggered
• An event can be triggered with group and id regex matches
• An event can be triggered with a fixed group definition and id regex matches
• An event can be triggered with regex group matches and fixed id definition
• A invalid regex match will not triggered an event
• An event can be defined to reset after all conditions and subconditions are met. Then all conditions and sub conditions must be met again before it gets triggered again.
• An event can be defined to not reset after all conditions and subconditions are met. Then an event can be triggered any time.
• An event can be manually removed/detached
• None-existing events cannot be manually removed/detached
• An event can be defined to automatically remove itself after all conditions and subconditions are met and it is executed
• Events can be imported from a file
• Invalid event files cannot be imported and return a failure

Extension (phpOMS\tests\Extension)

• Extension mbstring
• Extension curl
• Extension imap
• Extension pdo
• Extension g d

phpOMS\tests\Image\ThresholdingTest: Image thresholding

• The thresholding is correctly applied to the image

phpOMS\tests\Localization\Defaults\CityMapperTest: City database mapper

• The model can be read from the database

phpOMS\tests\Localization\Defaults\CityTest: City database model

• The model has the expected member variables and default values

phpOMS\tests\Localization\Defaults\CountryMapperTest: Country database mapper

• The model can be read from the database

phpOMS\tests\Localization\Defaults\CountryTest: Country database model

• The model has the expected member variables and default values

phpOMS\tests\Localization\Defaults\CurrencyMapperTest: Currency database mapper

• The model can be read from the database

phpOMS\tests\Localization\Defaults\CurrencyTest: Currency database model

• The model has the expected member variables and default values

phpOMS\tests\Localization\Defaults\IbanMapperTest: Iban database mapper

• The model can be read from the database

phpOMS\tests\Localization\Defaults\IbanTest: Iban database model

• The model has the expected member variables and default values

phpOMS\tests\Localization\Defaults\LanguageMapperTest: Language database mapper

• The model can be read from the database

phpOMS\tests\Localization\Defaults\LanguageTest: Language database model

• The model has the expected member variables and default values

phpOMS\tests\Localization\ISO3166CharEnumTest: ISO 3166 country codes

• The ISO 3166 country code enum has the correct format of country codes
• The ISO 3166 enum has only unique values
• Region

phpOMS\tests\Localization\ISO3166NameEnumTest: ISO 3166 country names

• The ISO 3166 enum has only unique values
• Region

phpOMS\tests\Localization\ISO3166NumEnumTest: ISO 3166 country codes

• The ISO 3166 country code enum has the correct format of country codes
• Region

phpOMS\tests\Localization\ISO3166NumEnumTest: ISO 3166 country codes

• The ISO 3166 country code enum has the correct format of country codes
• The ISO 3166 enum has only unique values
• Region

phpOMS\tests\Localization\ISO4217CharEnumTest: ISO 4217 currency codes

• The ISO 4217 currency code enum has the correct format of currency codes
• The ISO 4217 enum has only unique values

phpOMS\tests\Localization\ISO4217DecimalEnumTest: ISO 4217 currency codes

• The ISO 4217 currency code enum has the correct format of currency decimal places

phpOMS\tests\Localization\ISO4217EnumTest: ISO 4217 currency codes

• The ISO 4217 currency code enum has only unique values

phpOMS\tests\Localization\ISO4217NumEnumTest: ISO 4217 currency codes

• The ISO 4217 currency code enum has the correct format of currency codes

phpOMS\tests\Localization\ISO4217SubUnitEnumTest: ISO 4217 currency codes

• The ISO 4217 currency code enum has the correct format of currency sub units

phpOMS\tests\Localization\ISO4217SymbolEnumTest: ISO 4217 currency codes

• The ISO 4217 currency code enum has the correct number of currency symbols

phpOMS\tests\Localization\ISO639EnumTest: ISO 639 language codes

• The ISO 639 language code enum has only unique values
• Language

phpOMS\tests\Localization\ISO639x1EnumTest: ISO 639-1 language codes

• The ISO 639-1 language code enum has the correct format of language codes
• The ISO 639-1 enum has only unique values
• Language

phpOMS\tests\Localization\ISO639x2EnumTest: ISO 639-2 language codes

• The ISO 639-2 language code enum has the correct format of language codes
• The ISO 639-2 enum has only unique values
• Language

phpOMS\tests\Localization\ISO8601EnumArrayTest: ISO 8601 date time formats

• The ISO 8601 date time format enum has the correct number of date time formats
• The ISO 8601 enum has only unique values

phpOMS\tests\Localization\L11nManagerTest: Localization manager for view templates

• The localization manager has the expected default values after initialization
• Language data can be loaded and output as plain text or html
• An invalid localization source returns an error string
• Language data can be loaded from a file
• Multiple languages can be loaded from a file
• The numeric value can be printed based on the localization
• The percentage value can be printed based on the localization
• The currency value can be printed based on the localization
• The datetime value can be printed based on the localization

phpOMS\tests\Localization\LanguageDetection\LanguageTest: Language detection

• Detection

phpOMS\tests\Localization\LocalizationTest: Localization for information such as language, currency, location, language specific formatting etc.

• The localization has the expected default values after initialization
• Setting a invalid language code throws InvalidEnumValue
• Setting a invalid country code throws InvalidEnumValue
• Setting a invalid timezone code throws InvalidEnumValue
• Setting a invalid currency code throws InvalidEnumValue
• Setting a invalid angle throws InvalidEnumValue
• Setting a invalid temperature throws InvalidEnumValue
• The country can be set and returned
• The timezone can be set and returned
• The language can be set and returned
• The currency can be set and returned
• The datetime can be set and returned
• The decimal can be set and returned
• The thousands can be set and returned
• The angle can be set and returned
• The temperature can be set and returned
• The weight can be set and returned
• The currency format can be set and returned
• The precision can be set and returned
• The length can be set and returned
• The area can be set and returned
• The volume can be set and returned
• The speed can be set and returned
• Localization data can be loaded from a locale file
• Localization data can be loaded from a locale file
• Localization data can be serialized and unserialized
• If no locale file for a specified country exists or a wild card country is used the first match of a locale file based on the defined language is loaded
• By default the english locale file will be loaded if no other locale file can be found

phpOMS\Localization\Money: Money datatype for internal representation of money

• The datatype has the expected member variables and default values
• The datatype returns the correct default string representation (#,###.##)
• The datatype returns up to 4 decimal places if requested (#,###.####)
• The datatype returns the correct integer representation of a string with up to 4 decimal places also considering differences in decimal and thousands characters if requested for different localizations
• The datatype allows to modify the value by overwriting it with new string characters or integers correctly
• The datatype can print out money with different thousands, decimals and currency symbols as per definition by the user
• The string character input is correctly serialized to the numeric representation
• The string character input is correctly unserialized from a numeric representation
• The datatype correctly adds and subtracts the different money representations in string, numeric or Money type
• The datatype correctly multiplies and divides the money with numerics
• The datatype correctly handles the absolute value
• The datatype correctly handles the power operator

phpOMS\tests\Localization\PhoneEnumTest: Country phone codes

• The phone enum has the correct format of country phone numbers

phpOMS\tests\Localization\TimeZoneEnumArrayTest: Time zone enum array

• The time zone enum array has only unique values

phpOMS\tests\Log\FileLoggerTest: File logger for saving log information in a local file

• The logger has the expected default values after initialization
• The file logger can automatically create a new instance if none exists
• A log file for the output can be specified for the file logger
• If no log file name is specified a log file per date is created
• If no logs are performed no log file will be created
• Logs with different levels get correctly stored in the log file
• Log files can be analyzed for the highest perpetrator (IP address)
• Logs can be read from the log file
• Invalid log reads return empty log data
• A line can be read from a log file
• None-existing lines return on read empty log data
• A verbose file logger automatically outputs log data
• A verbose console log outputs log data
• A invalid log type throws a InvalidEnumValue
• The logger can perform timings for internal duration logging

phpOMS\tests\Log\LogLevelTest: Log level enum

• The log level enum has the correct number of log levels
• The log level enum has only unique values
• The log level enum has the correct values

Zero Division Exception (phpOMS\tests\Math\Exception\ZeroDivisionException)

• Exception

phpOMS\tests\Math\Functions\BetaTest: Beta function

• The log beta function can be approximated
• The incomplete beta function can be approximated
• The regularized beta function can be approximated

phpOMS\tests\Math\Functions\FibonacciTest: Fibonacci functions

• A number can be checked if it is a fibonacci number
• A fibonacci number can be returned by index
• The binet formula returns fibonacci numbers
• The binet formula and the fibonacci formula return the same results

phpOMS\tests\Math\Functions\FunctionsTest: Various math functions

• The factorial of a number can be calculated
• The binomial coefficient can be calculated
• The ackerman function can be calculated
• The multiplicative inverse module can be calculated
• A number can be checked if it is odd
• A number can be checked if it is even
• The relative number can be calculated on a circular number system (e.g. month in a diverging business year)
• The error function can be correctly approximated
• The complementary error function can be correctly approximated
• The generalized hypergeometric function can be correctly calculated

phpOMS\tests\Math\Functions\GammaTest: Gamma function

• The gamma function can be approximated
• The gamma function can be calculated for integers
• The gamma function can be approximated with the spouge formula
• The gamma function can be approximated with the stirling formula
• The gamma function can be approximated with the lanzos formula
• The log gamma function can be approximated
• The first incomplete gamma function can be approximated
• The second incomplete gamma function can be approximated
• The regularized incomplete gamma function can be approximated

phpOMS\tests\Math\Geometry\ConvexHull\MonotoneChainTest: Monotone chain

• A convex hull can be formed from multiple points on a plane

phpOMS\tests\Math\Geometry\Shape\D2\CircleTest: Circle shape

• The surface can be calculated
• The perimeter can be calculated
• The radius can be calculated with the surface
• The radius can be calculated with the perimeter

phpOMS\tests\Math\Geometry\Shape\D2\EllipseTest: Ellipse shape

• The surface can be calculated
• The perimeter can be calculated

phpOMS\tests\Math\Geometry\Shape\D2\PolygonTest: Polygon shape

• The location of a point can be checked relative to a polygon
• The interior angle can be calculated
• The exterior angle can be calculated
• The perimeter can be calculated
• The area can be calculated
• The barycenter can be calculated
• The regular area can be calculated with the side length
• The regular area can be calculated with the radius

phpOMS\tests\Math\Geometry\Shape\D2\QuadrilateralTest: Quadrilateral shape

• The area can be calculated

phpOMS\tests\Math\Geometry\Shape\D2\RectangleTest: Rectangle shape

• The surface can be calculated
• The perimeter can be calculated
• The diagonal can be calculated

phpOMS\tests\Math\Geometry\Shape\D2\TrapezoidTest: Trapezoid shape

• The surface can be calculated
• The perimeter can be calculated
• The height can be calculated
• The side lengths can be calculated

phpOMS\tests\Math\Geometry\Shape\D2\TriangleTest: Triangle shape

• The surface can be calculated
• The perimeter can be calculated
• The height can be calculated
• The hypotenuse can be calculated

phpOMS\tests\Math\Geometry\Shape\D3\ConeTest: Cone shape

• The volume can be calculated
• The surface can be calculated
• The slant height can be calculated
• The height can be calculated with the volume

phpOMS\tests\Math\Geometry\Shape\D3\CuboidTest: Cuboid shape

• The volume can be calculated
• The surface can be calculated

phpOMS\tests\Math\Geometry\Shape\D3\CylinderTest: Cylinder shape

• The volume can be calculated
• The surface can be calculated
• The lateral surface can be calculated

phpOMS\tests\Math\Geometry\Shape\D3\PrismTest: Prism shape

• The volume can be calculated with the length
• The volume can be calculated with the radius
• The surface can be calculated

phpOMS\tests\Math\Geometry\Shape\D3\RectangularPyramidTest: Rectangular pyramid shape

• The volume can be calculated
• The surface can be calculated
• The lateral surface can be calculated

phpOMS\tests\Math\Geometry\Shape\D3\SphereTest: Sphere shape

• The volume can be calculated
• The surface can be calculated
• The distance on a sphere can be calculated
• The sphere can be created by its radius
• The sphere can be created by its volume
• The sphere can be created by its surface

phpOMS\tests\Math\Geometry\Shape\D3\TetrahedronTest: Tetrahedron shape

• The volume can be calculated
• The surface can be calculated
• The face area can be calculated

phpOMS\tests\Math\Matrix\CholeskyDecompositionTest: Cholesky decomposition

• The decomposition can be created and the original matrix can be computed
• The decomposition matrix has the expected values
• A matrix can be checked for symmetric positivity
• The equation Ax = b can be solved
• A invalid vector throws a InvalidDimensionException

phpOMS\tests\Math\Matrix\EigenvalueDecompositionTest: Eigenvalue decomposition

• A matrix can be checked for symmetry
• The eigenvalues can be calculated for a symmetric matrix
• The V matrix of the decomposition can be calculated for a symmetric matrix
• The D matrix of the decomposition can be calculated for a symmetric matrix
• The eigenvalues can be calculated for a none-symmetric matrix
• The D matrix of the decomposition can be calculated for a none-symmetric matrix
• The decomposition can be created and the original matrix can be computed for a symmetric matrix
• The decomposition can be created and the original matrix can be computed for a none-symmetric matrix
• Complex eigenvalue decomposition
• Complex division
• Complex division
• Complex division
• Complex division

Invalid Dimension Exception (phpOMS\tests\Math\Matrix\Exception\InvalidDimensionException)

• Exception

phpOMS\tests\Math\Matrix\IdentityMatrixTest: Identity matrix

• The identity matrix is the identity

phpOMS\tests\Math\Matrix\LUDecompositionTest: LU decomposition

• The L matrix of the decomposition can be calculated
• The U matrix of the decomposition can be calculated
• The matrix can be checked for singularity
• The equation Ax = b can be solved for a none-singular matrix
• The pivots of the decomposition can be calculated
• The equation Ax = b can be solved for a singular matrix
• The decomposition can be created and the original matrix can be computed
• The determinat can be calculated
• A invalid vector throws a InvalidDimensionException

phpOMS\tests\Math\Matrix\MatrixTest: Matrix operations

• A matrix can return its dimension
• A matrix can be right-hand multiplied with a matrix
• A matrix can be right-hand multiplied with a scalar
• A scalar can be added to every matrix element
• A scalar can be subtracted from every matrix element
• Two matrices can be added to each other
• Two matrices can be subtracted from each other
• The determinant of a matrix can be calculated
• A symmetric matrix can be validated for symmetry
• A none-symmetric matrix cannot be validated for symmetry
• A matrix can be transposed
• A matrix equation Ax = b can be solved for x
• The rank of a matrix can be calculated
• Inverse
• The upper triangular matrix can be calculated
• Lower triangular
• The matrix elements can be set and returned
• A matrix can be accessed like a 1-dimensional array
• Sub matrices can be extracted from a matrix
• Setting a matrix element outside of the dimensions throws a InvalidDimensionException
• Returning a matrix element outside of the dimensions throws a InvalidDimensionException
• Adding a matrix with a different dimension to a matrix throws a InvalidDimensionException
• Subtracting a matrix from a different dimension to a matrix throws a InvalidDimensionException
• Multiplying a matrix with a different n x m dimension to a matrix throws a InvalidDimensionException

phpOMS\tests\Math\Matrix\QRDecompositionTest: QR decomposition

• A matrix can be checked if it has a full rank
• The Q matrix of the decomposition can be calculated
• The R matrix of the decomposition can be calculated
• The decomposition can be created and the original matrix can be computed
• The equation Ax = b can be solved

phpOMS\tests\Math\Matrix\VectorTest: Vector operations

• The vector has the expected default values after initialization
• The vector values can be set and returned
• The vector dimension can be returned

phpOMS\tests\Math\Number\ComplexTest: Complex number operations

• The complex number has the expected default values after initialization
• The real and imaginary part can be set during initialization and returned
• A complex number can be added to a complex number
• A real number can be added to a complex number
• A complex number can be subtracted from a complex number
• A real number can be subtracted from a complex number
• A complex number can be multiplied with a complex number
• A real number can be multiplied with a complex number
• A complex number can be divided by a complex number number
• A complex number can be divided by a real number
• A complex number can be conjugated
• The reciprocal of a complex number can be calculated
• A complex number can be squared
• The real power of a complex number can be calculated
• The absolute value of a complex number can be calculated
• The square root of a complex number can be calculated

phpOMS\tests\Math\Number\IntegerTest: Integer operations

• A value can be checked to be an integer
• An integer can be factorized
• The Pollard's Roh algorithm calculates a factor of an integer
• The Fermat factorization calculates a factor of an integer
• A even number for the fermat factorization throws a InvalidArgumentException
• The greatest common divisor can be calculated

phpOMS\tests\Math\Number\NaturalTest: Natural number operations

• A number can be checked to be natural

Number Type (phpOMS\tests\Math\Number\NumberType)

• Enum count
• Unique
• Enums

phpOMS\tests\Math\Number\NumbersTest: General number utilities

• A number can be checked to be perfect
• A number can be checked to be self-describing
• A number can be checked to be squared
• The amount of trailing zeros can be counted

phpOMS\tests\Math\Number\PrimeTest: Prime number utilities

• A number can be checked to be a prime number
• A prime number can be generated with the sieve of erathosthenes
• A number can be checked to be prime with the rabin test
• Mersenne numbers can be calculated
• A number can be checked to be a mersenne number

phpOMS\tests\Math\Numerics\IntegrationTest: Numeric integration

• Integration by summing up rectangle areas from the left side
• Integration by summing up rectangle areas from the right side
• Integration by summing up rectangle areas from the middle
• Integration by summing up trapezoid areas
• Integration by using the simpson formula

phpOMS\tests\Math\Numerics\Interpolation\CubicSplineInterpolationTest: Cubic spline interpolation

• The spline interpolation using the first derivative is correct
• The spline interpolation using the second derivative is correct
• The spline interpolation for out of bounds values uses linear extrapolation

phpOMS\tests\Math\Numerics\Interpolation\LagrangeInterpolationTest: Lagrange interpolation

• The lagrange interpolation is correct

phpOMS\tests\Math\Numerics\Interpolation\LinearInterpolationTest: Linear interpolation

• The linear interpolation is correct

phpOMS\tests\Math\Parser\EvaluatorTest: Evaluator for simple math formulas

• Basic formulas using +, -, *, /, () and ^ can be evaluated
• Badly formed formulas return null as result

phpOMS\tests\Math\Statistic\AverageTest: Averages

• The average change of a dataset is correctly calculated
• The average mean of angles is calculated correctly
• The arithmetic mean is correctly calculated
• The weighted mean is correctly calculated
• The geometric mean is correctly calculated
• The harmonic mean is correctly calculated
• The moving average is correctly calculated
• The weighted moving average is correctly calculated
• Different weight and dataset dimensions throw a InvalidDimensionException
• An empty dataset for the arithmetic mean throws a ZeroDivisionException
• An empty dataset for the moving average throws a Exception
• An empty dataset for the harmonic mean throws a ZeroDivisionException
• An empty dataset for the geometric mean throws a ZeroDivisionException
• Invalid angle mean
• Invalid angle mean
• A dataset with a 0 element throws a ZeroDivisionException
• The mode is correctly calculated
• The median is correctly calculated

Basic (phpOMS\tests\Math\Statistic\Basic)

• Frequency

phpOMS\tests\Math\Statistic\CorrelationTest: Correlations

• The correlation coefficient (Bravis Person) is calculated correctly
• The correlation coefficient (Bravis Person) is calculated correctly on a sample
• The autocorrelation coefficient is calculated correctly
• The portmanteau test (Box Pierce) is correct
• The portmanteau test (Ljung Box) is correct

Error (phpOMS\tests\Math\Statistic\Forecast\Error)

• Forecast error
• Error percentage
• Mean errors
• M a s e
• M s s e
• Scaled error
• S s e
• Coefficient of determination
• M a p e
• S m a p e
• M a d

Forecasts (phpOMS\tests\Math\Statistic\Forecast\Forecasts)

• Forecast interval

phpOMS\tests\Math\Statistic\Forecast\Regression\LevelLevelRegressionTest: Level level regression

• The regression parameters are calculated correctly
• The slope is calculated correctly
• The elasticity is calculated correctly
• The standard error of the population is calculated correctly
• The standard error of the sample is calculated correctly
• The prediction interval is calculated correctly
• Different dimension sizes for x and y coordinates throw a InvalidDimensionException

phpOMS\tests\Math\Statistic\Forecast\Regression\LevelLogRegressionTest: Level log regression

• The regression parameters are calculated correctly
• The slope is calculated correctly
• The elasticity is calculated correctly
• Different dimension sizes for x and y coordinates throw a InvalidDimensionException

phpOMS\tests\Math\Statistic\Forecast\Regression\LogLevelRegressionTest: Log level regression

• The regression parameters are calculated correctly
• The slope is calculated correctly
• The elasticity is calculated correctly
• Different dimension sizes for x and y coordinates throw a InvalidDimensionException

phpOMS\tests\Math\Statistic\Forecast\Regression\LogLogRegressionTest: Log log regression

• The regression parameters are calculated correctly
• The slope is calculated correctly
• The elasticity is calculated correctly
• Different dimension sizes for x and y coordinates throw a InvalidDimensionException

phpOMS\tests\Math\Statistic\Forecast\Regression\PolynomialRegressionTest: Polynomial regression

• The regression parameters are calculated correctly
• Different dimension sizes for x and y coordinates throw a InvalidDimensionException

phpOMS\tests\Math\Statistic\MeasureOfDispersionTest: Measure of dispersion

• The range of a dataset is correctly calculated
• The standard deviation is correctly calculated
• The empirical covariance is correctly calculated
• The empirical covariance on a sample is correctly calculated
• The sample variance is correctly calculated
• The population/empirical variance is correctly calculated
• The mean deviations are correctly calculated
• The mean deviations for every dataset element is correctly calculated
• The empirical variation coefficient is correctly calculated
• The interquartile range is correctly calculated
• The empirical variation coefficient with a mean of 0 throws a ZeroDivisionException
• An empty dataset in the empirical covariance throws a ZeroDivisionException
• Different dataset sizes in the empirical covariance throw a InvalidDimensionException
• An empty dataset in the sample variance throws a ZeroDivisionException
• An empty dataset in the empirical/population variance throws a ZeroDivisionException
• Invalid sample covariance dimension

Bernoulli Distribution (phpOMS\tests\Math\Stochastic\Distribution\BernoulliDistribution)

• Pmf
• Mode
• Mean
• Cdf
• Median
• Variance
• Standard deviation
• Skewness
• Ex kurtosis
• Entropy
• Mgf
• Fisher information
• Invalid pmf parameter

Beta Distribution (phpOMS\tests\Math\Stochastic\Distribution\BetaDistribution)

• Mean
• Mode
• Variance
• Standard deviation
• Skewness
• Ex kurtosis
• Pdf
• Cdf
• Mgf

Binomial Distribution (phpOMS\tests\Math\Stochastic\Distribution\BinomialDistribution)

• Pmf
• Cdf
• Mean
• Median
• Mode
• Variance
• Standard deviation
• Skewness
• Ex kurtosis
• Mgf
• Fisher information

Cauchy Distribution (phpOMS\tests\Math\Stochastic\Distribution\CauchyDistribution)

• Median mode
• Pdf
• Cdf
• Entropy

Chi Squared Distribution (phpOMS\tests\Math\Stochastic\Distribution\ChiSquaredDistribution)

• Hypothesis false
• Degrees of freedom
• Mode
• Mean
• Variance
• Standard deviation
• Median
• Skewness
• Ex kurtosis
• Mgdf
• Pdf
• Cdf
• Hypothesis size exception
• Hypothesis degrees of freedom exception
• Pdf out of bounds exception
• Mgf out of bounds exception

Exponential Distribution (phpOMS\tests\Math\Stochastic\Distribution\ExponentialDistribution)

• Pdf
• Cdf
• Mean
• Mode
• Median
• Mgf
• Variance
• Standard deviation
• Ex kurtosis
• Skewness
• Mgf exception

FDistribution (phpOMS\tests\Math\Stochastic\Distribution\FDistribution)

• Mean
• Mode
• Variance
• Standard deviation
• Skewness
• Pdf
• Cdf

Gamma Distribution (phpOMS\tests\Math\Stochastic\Distribution\GammaDistribution)

• Pdf scale
• Pdf alpha bete
• Cdf scale
• Cdf alpha bete
• Pdf integer scale
• Pdf integer rate
• Mean scale
• Mean rate
• Variance scale
• Variance rate
• Standard deviation scale
• Standard deviation rate
• Ex kurtosis
• Skewness
• Mgf scale
• Mgf rate
• Mode scale
• Mode rate

Geometric Distribution (phpOMS\tests\Math\Stochastic\Distribution\GeometricDistribution)

• Pmf
• Cdf
• Mode
• Mean
• Variance
• Get standard deviation
• Skewness
• Ex kurtosis
• Median
• Mgf

Hypergeometric Distribution (phpOMS\tests\Math\Stochastic\Distribution\HypergeometricDistribution)

• Mean
• Variance
• Standard deviation
• Skewness
• Ex kurtosis
• Mode
• Pmf
• Cdf

Laplace Distribution (phpOMS\tests\Math\Stochastic\Distribution\LaplaceDistribution)

• Pdf
• Cdf
• Mode
• Mean
• Median
• Ex kurtosis
• Skewness
• Variance
• Standard deviation
• Mgf
• Mgf exception

Log Distribution (phpOMS\tests\Math\Stochastic\Distribution\LogDistribution)

• Pmf
• Cdf
• Mean
• Mode
• Variance
• Standard deviation
• Mgf

Log Normal Distribution (phpOMS\tests\Math\Stochastic\Distribution\LogNormalDistribution)

• Pdf
• Cdf
• Mean
• Variance
• Standard deviation
• Skewness
• Ex kurtosis
• Median
• Mode
• Entropy
• Fisher information

Logistic Distribution (phpOMS\tests\Math\Stochastic\Distribution\LogisticDistribution)

• Pdf
• Cdf
• Mode
• Mean
• Median
• Variance
• Standard deviation
• Skewness
• Ex kurtosis
• Entropy

Normal Distribution (phpOMS\tests\Math\Stochastic\Distribution\NormalDistribution)

• Pdf
• Cdf
• Mean
• Median
• Mode
• Skewness
• Ex kurtosis
• Variance
• Standard deviation
• Sample size calculation
• Sample size infinite calculation
• Mgf
• Fisher information

Pareto Distribution (phpOMS\tests\Math\Stochastic\Distribution\ParetoDistribution)

• Pdf
• Cdf
• Mean
• Variance
• Standard deviation
• Ex kurtosis
• Skewness
• Median
• Mode
• Entropy
• Fisher information

Poisson Distribution (phpOMS\tests\Math\Stochastic\Distribution\PoissonDistribution)

• Pmf
• Cdf
• Mode
• Mean
• Variance
• Standard deviation
• Skewness
• Ex kurtosis
• Median
• Fisher information
• Mgf

TDistribution (phpOMS\tests\Math\Stochastic\Distribution\TDistribution)

• Mean
• Median
• Mode
• Variance
• Standard deviation
• Ex kurtosis
• Skewness
• Cdf

Uniform Distribution Continuous (phpOMS\tests\Math\Stochastic\Distribution\UniformDistributionContinuous)

• Pdf
• Cdf
• Mode
• Mean
• Median
• Variance
• Standard deviation
• Skewness
• Ex kurtosis
• Mgf

Uniform Distribution Discrete (phpOMS\tests\Math\Stochastic\Distribution\UniformDistributionDiscrete)

• Pmf
• Cdf
• Skewness
• Mean
• Median
• Variance
• Standard deviation
• Ex kurtosis
• Mgf
• Cdf exception upper
• Cdf exception lower

Weibull Distribution (phpOMS\tests\Math\Stochastic\Distribution\WeibullDistribution)

• Pdf
• Cdf
• Mean
• Median
• Mode
• Variance
• Standard deviation
• Entropy
• Skewness

ZTesting (phpOMS\tests\Math\Stochastic\Distribution\ZTesting)

• Hypothesis false
• Z test
• Z test values

phpOMS\tests\Math\Stochastic\NaiveBayesClassifierTest: Naive bayes classifier for numeric values and strings/attributes

• The classification of strings/attributes is correct
• The classification of numeric values is correct

phpOMS\tests\Math\Topology\Metrics2DTest: Metric/distance calculations

• The manhattan distance can be calculated
• The euclidean distance can be calculated
• The chebyshev distance can be calculated
• The octile distance can be calculated
• The minkowski distance can be calculated
• The canberra distance can be calculated
• The bray-curtis distance can be calculated
• The angular distance can be calculated
• The hamming distance can be calculated
• The ulam distance can be calculated
• Different dimension sizes for the coordinates in the hamming metric throw a InvalidDimensionException
• Different dimension sizes for the coordinates in the ulam metric throw a InvalidDimensionException

phpOMS\tests\Math\Topology\MetricsNDTest: Metric/distance calculations

• The manhattan distance can be calculated
• The euclidean distance can be calculated
• The chebyshev distance can be calculated
• The minkowski distance can be calculated
• The canberra distance can be calculated
• The bray-curtis distance can be calculated
• The angular distance can be calculated
• The hamming distance can be calculated
• Different dimension sizes for the coordinates in the manhattan metric throw a InvalidDimensionException
• Different dimension sizes for the coordinates in the euclidean metric throw a InvalidDimensionException
• Different dimension sizes for the coordinates in the chebyshev metric throw a InvalidDimensionException
• Different dimension sizes for the coordinates in the minkowski metric throw a InvalidDimensionException
• Different dimension sizes for the coordinates in the canberra metric throw a InvalidDimensionException
• Different dimension sizes for the coordinates in the Bray Curtis metric throw a InvalidDimensionException
• Different dimension sizes for the coordinates in the angular separation metric throw a InvalidDimensionException
• Different dimension sizes for the coordinates in the hamming metric throw a InvalidDimensionException

Cli Header (phpOMS\tests\Message\Cli\CliHeader)

• Defaults
• Value input output
• Has key
• Invalid overwrite
• Overwrite
• Remove
• The header can generate default http headers based on status codes
• Account
• Locked header set
• Locked header remove

Cli Request (phpOMS\tests\Message\Cli\CliRequest)

• Default
• O s input output
• Method input output
• Input output uri string
• The url hashes for the different paths get correctly generated
• Input output l 11n
• Data input output
• Has data
• Invalid overwrite
• Overwrite
• To string

Cli Response (phpOMS\tests\Message\Cli\CliResponse)

• Default
• Set get
• Response data can be turned into an array
• A response with json as content-type is automatically rendered as json data
• Invalid response data results in an empty array
• Invalid response data results in an empty render

phpOMS\tests\Message\HeaderAbstractTest: Abstract header for requests/responses

• The the status code can be set and returned

Browser Type (phpOMS\tests\Message\Http\BrowserType)

• Enum count
• Unique
• Enums

phpOMS\tests\Message\Http\HttpHeaderTest: Header for http requests/responses

• The header has the expected default values after initialization
• Security policy headers get correctly identified
• Header data can be set, checked for existence and returned
• Header data can be forced to get overwritten
• By default header data doesn't get overwritten
• Header data can be removed
• None-existing header data cannot be removed
• Account data can be set and returned
• Data can be defined as downloadable
• A header can be locked
• A locked header cannot add new data
• A locked header cannot remove data
• The header can generate default http headers based on status codes
• Security header data cannot be changed once defined

phpOMS\tests\Message\Http\HttpRequestTest: HttpRequest wrapper for http requests

• The request has the expected default values after initialization
• The OS can be set and returned
• The browser can be set and returned
• The request method can be set and returned
• The request referer can be returned
• The route verb gets correctly inferred from the request method
• The request is correctly constructed
• The request langauge can be returned
• The url hashes for the different paths get correctly generated
• Request data can be forcefully overwritten
• Request data is not overwritten by default
• The uri can be changed and returned
• Json data can be read from the request
• None-existing json data reads return empty data
• Invalid json data returns empty data
• List data can be read from the request
• None-existing list data reads return empty data
• Request data can be read with pattern matching
• In case of no pattern matches empty data is returned
• A request with a path can be correctly casted to a string
• A request with a path and manually added data can be correctly casted to a string
• A request with a path, query parameters and manually added data can be correctly casted to a string
• A rest request can be made from a request and the result can be read
• A request can be made with post data
• A request can be made with json data
• A request can be made with multipart data
• If no language can be identified en is returned
• If no locale can be identified en_US is returned
• A none-mobile request is recognized as none-mobile
• If the OS type is unknown a unknwon OS type is returned
• If the browser type is unknown a unknwon browser type is returned
• A invalid https port throws a OutOfRangeException
• A Invalid route verb throws a Exception

phpOMS\tests\Message\Http\ResponseTest: HttpResponse wrapper for http responses

• The response has the expected default values after initialization
• Response data can be set and returned
• Response data can be removed
• None-existing response data cannot be removed
• Test disabling output buffering
• The response langauge can be returned
• Response data can be turned into an array
• A response with json as content-type is automatically rendered as json data
• Json data can be decoded from the response data
• A html response can be forced to minimize the content by removing newlines and whitespaces
• None-html responses cannot be forced to minimize the content by removing newlines and whitespaces
• Invalid response data results in an empty array
• Invalid response data results in an empty render

OSType (phpOMS\tests\Message\Http\OSType)

• Enum count
• Unique

Request Method (phpOMS\tests\Message\Http\RequestMethod)

• Enum count
• Unique
• Enums

Request Status Code (phpOMS\tests\Message\Http\RequestStatusCode)

• Enum count
• Unique
• Enums

Request Status (phpOMS\tests\Message\Http\RequestStatus)

• Enum count
• Unique
• Enums

phpOMS\tests\Message\Http\RestTest: Rest request wrapper

• A get request successfully returns the expected result
• A post request with data successfully returns the expected result
• A put request with data successfully returns the expected result
• A delete request with data successfully returns the expected result
• A get request with data successfully returns the expected result
• Json request
• Multi request

phpOMS\tests\Message\MailHandlerTest: Abstract mail handler

• Default
• From input output
• Invalid from input output
• Content type input output
• Add to
• Invalid add to
• Add c c
• Invalid add c c
• Add b c c
• Invalid add b c c
• Add reply to
• Invalid add reply to
• Missing address pre send
• Addr format
• Custom header input output
• Invalid custom header input output
• Email parsing
• Html
• Attachment
• String attachment
• Embedded image
• String embedded image
• Invalid attachment path
• Invalid embedded image
• Quoted printable dkim header
• Canonicalized dkim header
• Canonicalized dkim body

phpOMS\tests\Message\MailHandlerTest: Abstract mail handler

• Connect
• Boxes
• Boxes input output delte
• Mailbox info
• Count mail
• Count recent
• With actual mail

phpOMS\tests\Message\MailHandlerTest: Abstract mail handler

• Send text with mail
• Send html with mail
• Send inline with mail
• Send attachment with mail
• Send alt with mail
• Send alt inline with mail
• Send alt attachment with mail
• Send plain with mail
• Send plain d k i m with mail
• Send plain d k i m sign with mail
• Send plain sign with mail
• Send i cal alt with mail with data set "Valid method: request (default)"
• Send i cal alt with mail with data set "Invalid method"
• Send i cal alt with mail with data set "Missing method"
• Send i cal alt attachment with mail with data set "Valid method: request (default)"
• Send i cal alt attachment with mail with data set "Invalid method"
• Send i cal alt attachment with mail with data set "Missing method"
• Send text with sendmail
• Send html with sendmail
• Send inline with sendmail
• Send attachment with sendmail
• Send alt with sendmail
• Send alt inline with sendmail
• Send alt attachment with sendmail
• Send plain with sendmail
• Send plain d k i m with sendmail
• Send plain d k i m sign with sendmail
• Send plain sign with sendmail
• Send i cal alt with sendmail with data set "Valid method: request (default)"
• Send i cal alt with sendmail with data set "Invalid method"
• Send i cal alt with sendmail with data set "Missing method"
• Send i cal alt attachment with sendmail with data set "Valid method: request (default)"
• Send i cal alt attachment with sendmail with data set "Invalid method"
• Send i cal alt attachment with sendmail with data set "Missing method"
• Send text with smtp
• Send html with smtp
• Send inline with smtp
• Send attachment with smtp
• Send alt with smtp
• Send alt inline with smtp
• Send alt attachment with smtp
• Send plain with smtp
• Send plain d k i m with smtp
• Send plain d k i m sign with smtp
• Send plain sign with smtp
• Send i cal alt with smtp with data set "Valid method: request (default)"
• Send i cal alt with smtp with data set "Invalid method"
• Send i cal alt with smtp with data set "Missing method"
• Send i cal alt attachment with smtp with data set "Valid method: request (default)"
• Send i cal alt attachment with smtp with data set "Invalid method"
• Send i cal alt attachment with smtp with data set "Missing method"

phpOMS\tests\Message\MailHandlerTest: Abstract mail handler

• Connect
• Boxes
• With actual mail
• Mailbox info
• Count mail
• Count recent

phpOMS\tests\Message\RequestAbstractTest: Abstract request

• Request data can be set and returned
• A invalid data key returns null
• Request data can be set and returned with correct types

phpOMS\tests\Message\ResponseAbstractTest: Abstract response

• The response has the expected default values after initialization
• The response can be json serialized
• Data can be set and returned for the response

Header (phpOMS\tests\Message\Socket\Header)

• Placeholder

Packet Manager (phpOMS\tests\Message\Socket\PacketManager)

• Placeholder

Packet Type (phpOMS\tests\Message\Socket\PacketType)

• Enum count
• Unique
• Enums

Request (phpOMS\tests\Message\Socket\Request)

• Placeholder

Response (phpOMS\tests\Message\Socket\Response)

• Placeholder

phpOMS\tests\Model\Html\FormElementGeneratorTest: Form element generator

• A text input element can be generated
• A text input element can be generated with a custom value
• A datetime input element can be generated with custom formatting
• A checkbox element can be generated
• A checkbox element can be generated with a localized label element
• A radio element can be generated
• A radio element can be generated with a localized label element
• A label element can be generated
• A localized label element can be generated
• A textarea element can be generated
• A textarea element can be generated with a custom value
• A select element can be generated
• A localized select element can be generated
• A missing or invalid element type generates a INVALID output

phpOMS\tests\Model\Html\HeadTest: Html head

• The head has the expected default values after initialization
• The title can be set and returned
• The style can be set and returned
• The script can be set and returned
• The language can be set and returned
• The assets can be set and rendered
• The assets can be set and rendered at the end of the document
• The assets can be set and rendered with attributes
• The assets can be set and rendered at the end of the document with attributes

phpOMS\tests\Model\Html\MetaTest: Html meta data

• The meta data has the expected default values after initialization
• A keyword can be added and returned
• The author can be set and returned
• The charset can be set and returned
• The description can be set and returned
• A property can be set and returned
• A itemprop can be set and returned
• A name can be set and returned
• The meta data can be rendered

Dom Action (phpOMS\tests\phpOMS\Model\Message\DomAction)

• Enum count
• Unique
• Enums

Dom (phpOMS\tests\phpOMS\Model\Message\Dom)

• Default
• Set get

Form Validation (phpOMS\tests\phpOMS\Model\Message\FormValidation)

• Default
• Set get

Notify (phpOMS\tests\phpOMS\Model\Message\Notify)

• Default
• Set get

Redirect (phpOMS\tests\phpOMS\Model\Message\Redirect)

• Default
• Set get

Reload (phpOMS\tests\phpOMS\Model\Message\Reload)

• Default
• Set get

Invalid Module Exception (phpOMS\tests\Module\Exception\InvalidModuleException)

• Exception

Invalid Theme Exception (phpOMS\tests\Module\Exception\InvalidThemeException)

• Exception

phpOMS\tests\Module\InstallerAbstractTest: Abstract module installer

• Invalid or missing module status file throws exception during installation

phpOMS\tests\Module\ModuleAbstractTest: Abstract module

• The constant values of the abstract module are overwritten by the extension
• The name of the module can be returned
• The dependencies of the module can be returned
• The providings of the module can be returned
• A module can receive information and functionality from another module
• A module can load its own localization/language dataset
• A invalid language or theme returns in an empty localization/language dataset
• The module can automatically generate a json response based on provided data for the frontend
• The module can automatically generate a json response based on provided data
• A model can be created
• Multiple models can be generated
• A model can be updated
• A model can be deleted
• A model relation can be created
• The model CRUD functions can be called with a closure

phpOMS\tests\Module\ModuleInfoTest: Module info file manager

• A info file can be correctly loaded
• A info file can be modified
• A invalid info file path load throws a PathException
• A invalid info file path update throws a PathException
• A invalid change data throws a InvalidArgumentException

phpOMS\tests\Module\NullModuleTest: Basic module functionality

• The null module is an instance of the module abstract
• A invalid module method call will create an error log

phpOMS\tests\Module\PackageManagerTest: Manager for install/update packages

• A package can be installed
• A package which didn't get extracted cannot be loaded and throws a PathException
• A invalid package cannot be installed and throws a Exception
• A invalid package key doesn't validate the package
• A invalid package content doesn't validate the package
• The temporarily extracted package can be cleaned up

phpOMS\tests\Module\StatusAbstractTest: Abstract module status

• Invalid module path activation

phpOMS\tests\Module\UninstallerAbstractTest: Abstract module uninstaller

• A missing database schema will not perform any database operations

phpOMS\tests\PreloaderTest: Class preloader

• Preloading

phpOMS\tests\WebRouter\RouteVerbTest: Route verb enum

• The route verb enum has the correct values
• The route verb enum has only unique values

phpOMS\tests\Router\SocketRouterTest: Router for socket requests

• The route result for an empty request is empty
• A none-existing routing file cannot be imported
• A existing routing file can be imported
• A matching route returns the destinations
• The routes can be removed from the router
• Routes can be added dynamically
• Routes only match if the permissions match
• Routes don't match if the permissions don't match
• A data validation pattern validates matches correctly
• A data validation pattern invalidates missmatches
• A uri can be used for data population

phpOMS\tests\Router\WebRouterTest: Router for web requests

• The route result for an empty request is empty
• A none-existing routing file cannot be imported
• A existing routing file can be imported
• A matching route returns the destinations
• The routes can be removed from the router
• Invalid routing verbs don't match even if the route matches
• Routes can be added dynamically
• Routes which require a CSRF token can only match with a CSRF token
• Routes which require a CSRF token don't match without a CSRF token
• Routes only match if the permissions match
• Routes don't match if the permissions don't match
• A data validation pattern validates matches correctly
• A data validation pattern invalidates missmatches
• A uri can be used for data population

phpOMS\tests\Security\EncryptionHelperTest: Basic php source code security inspection

• Shared key
• Paired key
• File encryption

phpOMS\tests\Security\GuardTest: Basic php source code security inspection

• Safe path
• Unslash

phpOMS\tests\Security\PhpCodeTest: Basic php source code security inspection

• A file with unicode characters gets correctly identified
• A file with no unicode characters gets correctly identified
• A file with no disabled functions gets correctly identified
• A file with deprecated functions gets correctly identified
• A file with no deprecated functions gets correctly identified
• A file hash comparison is successful if the file generates the same hash
• A file hash comparison is unsuccessful if the file generates a different hash
• Two equal strings validate as the same
• Two different strings don't validate as the same

Client Connection (phpOMS\tests\Socket\Client\ClientConnection)

• Placeholder

Client (phpOMS\tests\Socket\Client\Client)

• Setup t c p socket

Null Client Connection (phpOMS\tests\Socket\Client\NullClientConnection)

• Default

Client Manager (phpOMS\tests\Socket\Server\ClientManager)

• Placeholder

Server (phpOMS\tests\Socket\Server\Server)

• Setup t c p socket

phpOMS\tests\Stdlib\Base\AddressTest: Address type

• The address has the expected default values after initialization
• The fao can be set and returned
• The recipient can be set and returned
• The location can be set and returned
• The address can be turned into array data
• The address can be json serialized

Address Type (phpOMS\tests\Stdlib\Base\AddressType)

• Enum count
• Unique
• Enums

phpOMS\tests\Stdlib\Base\EnumArrayTest: Enum array type

• A valid enum name returns the enum value
• A valid enum name can be validated
• A invalid enum name doesn't validate
• All enum name/value pairs can be returned
• A valid enum value can be checked for existence
• A invalid enum value doesn't validate
• A invalid enum name throws a OutOfBoundsException
• The amount of enum values can be returned
• A random enum value can be returned

phpOMS\tests\Stdlib\Base\EnumTest: Enum type

• A valid enum name can be validated
• A invalid enum name doesn't validate
• All enum name/value pairs can be returned
• A valid enum value can be checked for existence
• A invalid enum value doesn't validate
• A random enum value can be returned
• A valid enum name returns the enum value
• The amount of enum values can be returned
• A valid enum value returns the enum name
• Binary flags validate if they are set
• Binary flags don't validate if they are not set
• A invalid enum name returns null

Invalid Enum Name (phpOMS\tests\Stdlib\Base\Exception\InvalidEnumName)

• Exception

Invalid Enum Value (phpOMS\tests\Stdlib\Base\Exception\InvalidEnumValue)

• Exception

phpOMS\tests\Stdlib\Base\HeapTest: Heap

• A list of elements can be turned into a heap
• Elements get correctly pushed to the heap
• A element can be added to a heap at the correct position
• Heap elements get returned in the correct order
• Heap elements get returned in the correct order by using a custom comparator
• The heap can be turned into an array
• Heap elements can be replaced
• A heap element can be returned while adding a new one
• The heap can be checked if it contains certain elements
• The heap can be checked if it contains certain custom elements
• A heap item can be updated if it exists while maintaining the correct order
• The first heap element can be returned without removing it
• The n smallest elements can be returned from the heap
• The n largest elements can be returned from the heap
• The heap can be cleared of all elements
• The heap can be checked if it has elements

phpOMS\tests\Stdlib\Base\IbanTest: Iban type

• A iban can be correctly parsed into its different components
• A iban can be serialized and unserialized
• A invalid iban country code throws a InvalidArgumentException
• A invalid iban length throws a InvalidArgumentException
• A invalid iban checksum throws a InvalidArgumentException

phpOMS\tests\Stdlib\Base\LocationTest: Location type

• The location has the expected default values after initialization
• The postal can be set and returned
• The type can be set and returned
• The city can be set and returned
• The country can be set and returned
• The address can be set and returned
• The state can be set and returned
• The location can be turned into an array
• The location can be json serialized
• The location can unserialized

Null Location (phpOMS\tests\Stdlib\Base\NullLocation)

• Null location

Phone Type (phpOMS\tests\Stdlib\Base\PhoneType)

• Enum count
• Unique
• Enums

phpOMS\tests\Stdlib\Base\SmartDateTimeTest: DateTime type with additional functionality

• The smart datetime extends the datetime
• The smart datetime can be formatted like the datetime
• The smart datetime can be modified an creates a new smart datetime
• The days of the month can be returned
• The week day index of the first day of the month can be returned
• A smart datetime can be created from a datetime
• A smart datetime can be returned of the last day of the month
• A smart datetime can be returned of the fist day of the month
• A smart datetime can be returned of the last day of the week
• A smart datetime can be returned of the fist day of the week
• A smart datetime can be returned of the end of the day
• A smart datetime can be returned of the start of the day
• A date or year can be checked if it is a leap year
• The day of the week index can be returned from a date
• A invalid day of the week returns a negative week index
• A calendar sheet is returned containing all days of the month and some days of the previous and next month

phpOMS\tests\Stdlib\Graph\EdgeTest: Edge between nodes

• The edge has the expected default values after initialization
• An edge can be directed
• An edge weight can be set and returned
• Two edge weights can be compared

hpOMS\tests\Stdlib\Graph\Graph: Graph

• The graph has the expected default values after initialization
• A graph can ge set as directed
• A node can be add to a graph and returned
• The existence of a node in a graph can be checked
• A graph can be checked for bridges
• Multiple bridges are correctly identified in a graph
• A graph without bridges is correctly classified
• Edges can be add and returned from a graph
• An edge can be found by two edge ids
• The existence of cycles in undirected graphs can be checked
• The existence of cycles in directed graphs can be checked
• The cost of a graph can be calculated
• The Kruskal minimal spanning tree can be created
• Find all reachable nodes d f s
• Get all paths between nodes
• Count all paths between nodes
• Longest path between nodes
• Shortest path between nodes
• Shortest path floyd warshall
• Longest paths dfs
• Unconnected graph
• Connected graph
• Diameter
• Girth
• Circuit rank
• Strongly connected
• Invalid strongly connected
• Bipartite
• Triangles

phpOMS\tests\Stdlib\Graph\NodeTest: Node in a graph

• The node has the expected default values after initialization
• The node data can be set and returned
• Two equal nodes are equal
• Two different nodes are not equal
• An edge for a node can be defined
• Edges can be removed from a node
• An edge for a node can be defined by key
• A node relationship can be defined
• All neighbors of a node can be returned
• Find edge from neighbor

Key Type (phpOMS\tests\Stdlib\Map\KeyType)

• Enum count
• Unique
• Enums

phpOMS\tests\Stdlib\Map\MultiMapTest: Map which associates multiple keys with the same value

• The map has the expected default values and functionality after initialization
• Elements with multiple optional keys can be added
• Elements with multiple optional keys can be returned if any of the keys matches
• Elements can be forcefully overwritten
• By default elements are not overwritten
• If a element with partially matching keys is already in the map it will be only added for the new key
• If all keys exist in the map no new element will be created
• Values can be set/replaced by key
• Values cannot be set/replaced if the key doesn't exist
• A key cannot be remapped to a none-existing key
• A key can be remapped to the value of an existing key
• If no more keys are associated with a value after a remap the value is removed from the map
• All keys of the map can be returned
• All values of the map can be returned
• Sibling keys can be found
• If a key doesn't exist or has no siblings no siblings are returned
• A key for a value can be removed
• If the last key of a value is removed the value is also removed from the map
• If a key doesn't exist it cannot be removed
• Elements with multiple required keys can be added
• Elements with multiple required keys can be returned if all match
• Elements with multiple required keys cannot be returned if they don't match exactly
• Elements with multiple required and ordered keys can be added
• Elements with multiple required ordered keys can be if all match in the correct order
• Elements with multiple required keys cannot be returned if they don't match exactly in the correct order
• Elements with multiple required keys can be forcefully overwritten
• Elements with multiple required ordered keys can be forcefully overwritten
• An element cannot be added to for multiple required keys if the keys already exist in a different order
• If a element with partially matching multiple keys is already in the map it will be only added for the new key
• Adding differently ordered keys for multiple required keys will create a new entry in the map
• If all keys for multiple required keys exist in the map no new element will be created
• If all keys for multiple required ordered keys exist in the map no new element will be created
• Values can be set/replaced by multiple required keys
• Values cannot be set/replaced if the multiple required keys don't match or exist
• Values can be set/replaced by multiple required ordered keys if the order is correct
• Values cannot be set/replaced if the multiple required ordered keys don't match or exist in the correct order
• Multiple keys cannot be remapped
• All sibling key combinations can be found for multiple required keys
• For multiple required ordered keys don't exist any siblings
• A multiple required key combination for a value can be removed
• If a multiple required key combination doesn't exist it cannot be removed
• A multiple required ordered key combination for a value can be removed
• If a multiple required ordered key combination doesn't exist it cannot be removed

Order Type (phpOMS\tests\Stdlib\Map\OrderType)

• Enum count
• Unique
• Enums

Priority Mode (phpOMS\tests\Stdlib\Queue\PriorityMode)

• Enum count
• Unique
• Enums

phpOMS\tests\Stdlib\Queue\PriorityQueueTest: Priority queue

• The queue has the expected default values and functionality after initialization
• Queue elements can be added with the default value of 1.0 and returned
• Queue elements can be added with a priority
• The priority queue returns the correct amount of elements it holds
• A queue element can be removed
• A none-existing queue element id cannot be removed
• A removed or none-existing queue element returns a empty data
• The priority of all queue elements can be uniformly increased
• The priority or a queue element can be changed
• The queue can be serialized and unserialized
• A queue element can be popped from the que which also removes it from the queue
• A FIFO queue returns the elements in FIFO order
• A LIFO queue returns the elements in LIFO order
• A highest queue returns the elements in highest priority order
• A lowest queue returns the elements in lowest priority order
• A invalid priority queue type throws a InvalidEnumValue

phpOMS\tests\System\CharsetTypeTest: Character set type enum

• The character set type enum has the correct amount of values
• The character set type enum has only unique values
• The character set type enum has the correct values

Content Put Mode (phpOMS\tests\System\File\ContentPutMode)

• Enum count
• Unique
• Enums

Extension Type (phpOMS\tests\System\File\ExtensionType)

• Enum count
• Unique
• Enums

phpOMS\tests\System\File\FileUtilsTest: File utilities

• File extensions can be categorized
• A relative path can be turned into an absolute path
• Permissions can be turned into octal values
• The encoding of a file can be changed
• The file information can be resolved from a path

phpOMS\tests\System\File\Ftp\DirectoryTest: Directory handler for a ftp server

• Connection
• Invalid connection
• A directory can be created
• A directory can be checked for existence
• An existing directory cannot be overwritten
• A directory can be forced to be created recursively
• By default a directory is not created recursively
• The name of a directory is just its name without its path
• The basename is the same as the name of the directory
• The dirname is the same as the name of the directory
• The parent of a directory can be returned
• The full absolute path of a directory can be returned
• The directories creation date can be returned
• The directories last change date can be returned
• A directory can be deleted
• A none-existing directory cannot be deleted
• The size of a directory can be returned
• The size of a none-existing directory is negative
• The recursive size of a directory is equals or greater than the size of the same directory none-recursive
• The permission of a directory can be returned
• The permission of a none-existing directory is negative
• A directory can be copied recursively
• Static copy overwrite
• Static invalid copy overwrite
• A directory can be moved/renamed to a different path
• Static invalid move overwrite
• Static move overwrite
• The amount of files in a directory can be returned recursively
• The amount of files in a directory can be returned none-recursively
• The amount of files of a none-existing directory is negative
• All files and sub-directories of a directory can be listed
• Static list files by extension
• Static owner
• Directory name sanitizing
• A none-existing directory returns a empty list of files and sub-directories
• Invalid list files by extension
• A invalid directory cannot be copied to a new destination
• A invalid directory cannot be moved to a new destination
• Reading the creation date of a none-existing directory throws a PathException
• Reading the last change date of a none-existing directory throws a PathException
• Reading the owner of a none-existing directory throws a PathException
• List
• Node output
• Node create
• Node delete
• Node copy
• Node move
• Node exists
• Parent output
• Node next
• Node current
• Node key
• Node array read
• Node array set
• Node array remove
• Node array exists
• Node created at
• Node changed at
• Node owner
• Node permission
• Dirname
• Name
• Baseame
• Dirpath
• Node valid
• Node invalid

phpOMS\tests\System\File\Ftp\FileTest: File handler for a ftp server

• Connection
• Invalid connection
• A file without content can be created
• A file cannot be created if it already exists
• A file with content can be created
• A file cannot be replaced if it doesn't exists
• A file cannot be appended if it doesn't exists
• A file cannot be prepended if it doesn't exists
• A file can be checked for existence
• A file can be replaced with a new one
• The set alias works like the replace flag
• A file can be appended with additional content
• The append alias works like the append flag
• A file can be prepended with additional content
• The prepend alias works like the prepend flag
• The content of a file can be read
• The parent directory of a file can be returned
• The extension of a file can be returned
• The name of a file can be returned
• The basename of a file can be returned
• The file name of a file can be returned
• The file path of a file can be returned
• The count of a file is always 1
• The directories creation date can be returned
• The directories last change date can be returned
• A file can be deleted
• A none-existing file cannot be deleted
• The size of a file can be returned
• The permission of a file can be returned
• The permission of a none-existing file is negative
• A file can be copied to a different location
• A file cannot be copied to a different location if the destination already exists
• A file can be forced to be copied to a different location even if the destination already exists
• A file can be moved to a different location
• A file cannot be moved to a different location if the destination already exists
• A file can be forced to be moved to a different location even if the destination already exists
• Static owner
• File name sanitizing
• The size of a none-existing file is negative
• A none-existing file cannot be copied
• A none-existing file cannot be moved
• Reading the content of a none-existing file returns an empty string
• Reading the created date of a none-existing file throws a PathException
• Reading the last change date of a none-existing file throws a PathException
• Reading the owner of a none-existing file throws a PathException
• Node input output
• Node replace
• Node append
• Node prepend
• Node extension
• Node created at
• Node changed at
• Node owner
• Node permission
• Dirname
• Name
• Baseame
• Dirpath
• Parent output
• Node create
• Node delete
• Node copy
• Node move
• Node exists
• Node parent
• Node directory

phpOMS\tests\System\File\Ftp\FtpStorageTest: Directory & File handler for local file system

• A directory can be created
• A directory can be checked for existence
• An existing directory cannot be overwritten
• A directory can be forced to be created recursively
• The name of a directory is just its name without its path
• The basename is the same as the name of the directory
• The dirname is the same as the name of the directory
• The parent of a directory can be returned
• The full absolute path of a directory can be returned
• The directories creation date can be returned
• The directories last change date can be returned
• A directory can be deleted
• A none-existing directory cannot be deleted
• The size of a directory can be returned
• The size of a none-existing directory is negative
• The recursive size of a directory is equals or greater than the size of the same directory none-recursive
• The permission of a directory can be returned
• The permission of a none-existing directory is negative
• A directory can be copied recursively
• A directory can be moved/renamed to a different path
• The amount of files in a directory can be returned recursively
• The amount of files in a directory can be returned none-recursively
• The amount of files of a none-existing directory is negative
• All files and sub-directories of a directory can be listed
• A none-existing directory returns a empty list of files and sub-directories
• A invalid directory cannot be copied to a new destination
• A invalid directory cannot be moved to a new destination
• Reading the creation date of a none-existing directory throws a PathException
• Reading the last change date of a none-existing directory throws a PathException
• Reading the owner of a none-existing directory throws a PathException
• A file without content can be created
• A file cannot be created if it already exists
• A file with content can be created
• A file cannot be replaced if it doesn't exists
• A file cannot be appended if it doesn't exists
• A file cannot be prepended if it doesn't exists
• A file can be checked for existence
• A file can be replaced with a new one
• The set alias works like the replace flag
• A file can be appended with additional content
• The append alias works like the append flag
• A file can be prepended with additional content
• The prepend alias works like the prepend flag
• The content of a file can be read
• The parent directory of a file can be returned
• The extension of a file can be returned
• The name of a file can be returned
• The basename of a file can be returned
• The file name of a file can be returned
• The file path of a file can be returned
• The count of a file is always 1
• The directories creation date can be returned
• The directories last change date can be returned
• A file can be deleted
• A none-existing file cannot be deleted
• The size of a file can be returned
• The permission of a file can be returned
• The permission of a none-existing file is negative
• A file can be copied to a different location
• A file cannot be copied to a different location if the destination already exists
• A file can be forced to be copied to a different location even if the destination already exists
• A file can be moved to a different location
• A file cannot be moved to a different location if the destination already exists
• A file can be forced to be moved to a different location even if the destination already exists
• Sanitize
• The size of a none-existing file is negative
• A none-existing file cannot be copied
• A none-existing file cannot be moved
• Reading the content of a none-existing file returns an empty result
• Reading the created date of a none-existing file throws a PathException
• Reading the last change date of a none-existing file throws a PathException
• Reading the owner of a none-existing file throws a PathException
• Writing data to a destination which looks like a directory throws a PathException
• Reading data from a directory throws a PathException
• Trying to run list on a file throws a PathException
• Setting data to a destination which looks like a directory throws a PathException
• Appending data to a destination which looks like a directory throws a PathException
• Prepending data to a destination which looks like a directory throws a PathException
• Reading the extension of a destination which looks like a directory throws a PathException

phpOMS\tests\System\File\Local\DirectoryTest: Directory handler for local file system

• A directory can be created
• A directory can be checked for existence
• An existing directory cannot be overwritten
• A directory can be forced to be created recursively
• By default a directory is not created recursively
• The name of a directory is just its name without its path
• The basename is the same as the name of the directory
• The dirname is the same as the name of the directory
• The parent of a directory can be returned
• The full absolute path of a directory can be returned
• The directories creation date can be returned
• The directories last change date can be returned
• A directory can be deleted
• A none-existing directory cannot be deleted
• The size of a directory can be returned
• The size of a none-existing directory is negative
• The recursive size of a directory is equals or greater than the size of the same directory none-recursive
• The permission of a directory can be returned
• The permission of a none-existing directory is negative
• A directory can be copied recursively
• A directory can be forced to be copied to a different location even if the destination already exists
• By default a directory is not overwritten on copy
• A directory can be moved/renamed to a different path
• By default a directory is not overwritten on move
• A directory can be forced to be moved/renamed to a different path even if the destination already exists
• The amount of files in a directory can be returned recursively
• The amount of files in a directory can be returned none-recursively
• The amount of files of a none-existing directory is negative
• All files and sub-directories of a directory can be listed
• All files of a directory can be listed by file extension
• The owner of a directory can be returned
• Invalid directory names and paths can be sanitized
• A none-existing directory returns a empty list of files and sub-directories
• A none-existing directory returns a empty list of files for the extension
• A invalid directory cannot be copied to a new destination
• A invalid directory cannot be moved to a new destination
• Reading the creation date of a none-existing directory throws a PathException
• Reading the last change date of a none-existing directory throws a PathException
• Reading the owner of a none-existing directory throws a PathException
• List
• Node output
• Node create
• Node delete
• Node copy
• Node move
• Node exists
• Parent output
• Node next
• Node current
• Node key
• Node array read
• Node array set
• Node array remove
• Node array exists
• Node created at
• Node changed at
• Node owner
• Node permission
• Dirname
• Name
• Baseame
• Dirpath

phpOMS\tests\System\File\Local\FileTest: File handler for local file system

• A file without content can be created
• A file cannot be created if it already exists
• A file with content can be created
• A file cannot be replaced if it doesn't exists
• A file cannot be appended if it doesn't exists
• A file cannot be prepended if it doesn't exists
• A file can be checked for existence
• A file can be replaced with a new one
• The set alias works like the replace flag
• A file can be appended with additional content
• The append alias works like the append flag
• A file can be prepended with additional content
• The prepend alias works like the prepend flag
• The content of a file can be read
• The parent directory of a file can be returned
• The extension of a file can be returned
• The name of a file can be returned
• The basename of a file can be returned
• The file name of a file can be returned
• The file path of a file can be returned
• The count of a file is always 1
• The directories creation date can be returned
• The directories last change date can be returned
• A file can be deleted
• A none-existing file cannot be deleted
• The size of a file can be returned
• The permission of a file can be returned
• The permission of a none-existing file is negative
• Path info
• A file can be copied to a different location
• A file cannot be copied to a different location if the destination already exists
• A file can be forced to be copied to a different location even if the destination already exists
• A file can be moved to a different location
• A file cannot be moved to a different location if the destination already exists
• A file can be forced to be moved to a different location even if the destination already exists
• Static owner
• File name sanitizing
• The size of a none-existing file is negative
• A none-existing file cannot be copied
• A none-existing file cannot be moved
• Reading the content of a none-existing file throws a PathException
• Reading the created date of a none-existing file throws a PathException
• Reading the last change date of a none-existing file throws a PathException
• Reading the owner of a none-existing file throws a PathException
• Node input output
• Node replace
• Node append
• Node prepend
• Node extension
• Node created at
• Node changed at
• Node owner
• Node permission
• Dirname
• Name
• Baseame
• Dirpath
• Parent output
• Node create
• Node delete
• Node copy
• Node move
• Node exists
• Node parent
• Node directory

phpOMS\tests\System\File\Local\LocalStorageTest: Directory & File handler for local file system

• A directory can be created
• A directory can be checked for existence
• An existing directory cannot be overwritten
• A directory can be forced to be created recursively
• The name of a directory is just its name without its path
• The basename is the same as the name of the directory
• The dirname is the same as the name of the directory
• The parent of a directory can be returned
• The full absolute path of a directory can be returned
• The directories creation date can be returned
• The directories last change date can be returned
• A directory can be deleted
• A none-existing directory cannot be deleted
• The size of a directory can be returned
• The size of a none-existing directory is negative
• The recursive size of a directory is equals or greater than the size of the same directory none-recursive
• The permission of a directory can be returned
• The permission of a none-existing directory is negative
• A directory can be copied recursively
• A directory can be moved/renamed to a different path
• The amount of files in a directory can be returned recursively
• The amount of files in a directory can be returned none-recursively
• The amount of files of a none-existing directory is negative
• All files and sub-directories of a directory can be listed
• A none-existing directory returns a empty list of files and sub-directories
• A invalid directory cannot be copied to a new destination
• A invalid directory cannot be moved to a new destination
• Reading the creation date of a none-existing directory throws a PathException
• Reading the last change date of a none-existing directory throws a PathException
• Reading the owner of a none-existing directory throws a PathException
• A file without content can be created
• A file cannot be created if it already exists
• A file with content can be created
• A file cannot be replaced if it doesn't exists
• A file cannot be appended if it doesn't exists
• A file cannot be prepended if it doesn't exists
• A file can be checked for existence
• A file can be replaced with a new one
• The set alias works like the replace flag
• A file can be appended with additional content
• The append alias works like the append flag
• A file can be prepended with additional content
• The prepend alias works like the prepend flag
• The content of a file can be read
• The parent directory of a file can be returned
• The extension of a file can be returned
• The name of a file can be returned
• The basename of a file can be returned
• The file name of a file can be returned
• The file path of a file can be returned
• The count of a file is always 1
• The directories creation date can be returned
• The directories last change date can be returned
• A file can be deleted
• A none-existing file cannot be deleted
• The size of a file can be returned
• The permission of a file can be returned
• The permission of a none-existing file is negative
• A file can be copied to a different location
• A file cannot be copied to a different location if the destination already exists
• A file can be forced to be copied to a different location even if the destination already exists
• A file can be moved to a different location
• A file cannot be moved to a different location if the destination already exists
• A file can be forced to be moved to a different location even if the destination already exists
• Sanitize
• The size of a none-existing file is negative
• A none-existing file cannot be copied
• A none-existing file cannot be moved
• Reading the content of a none-existing file throws a PathException
• Reading the created date of a none-existing file throws a PathException
• Reading the last change date of a none-existing file throws a PathException
• Reading the owner of a none-existing file throws a PathException
• Writing data to a destination which looks like a directory throws a PathException
• Reading data from a directory throws a PathException
• Trying to run list on a file throws a PathException
• Setting data to a destination which looks like a directory throws a PathException
• Appending data to a destination which looks like a directory throws a PathException
• Prepending data to a destination which looks like a directory throws a PathException
• Reading the extension of a destination which looks like a directory throws a PathException

Path Exception (phpOMS\tests\System\File\PathException)

• Constructor

Permission Exception (phpOMS\tests\System\File\PermissionException)

• Constructor

phpOMS\tests\System\File\StorageTest: Storage handler for the different storage handler types

• By default the local storage handler is returned
• The pre-defined storage handlers can be returned by their name
• Storages can be registered and returned
• Registered storage handlers cannot be overwritten
• A invalid or none-existing storage throws a Exception

phpOMS\tests\System\MimeTypeTest: MimeType

• The mime type enum vales have the correct format
• The mime type enum vales can be retreived by extension
• A unknown extension returns application/octet-stream

phpOMS\tests\System\OperatingSystemTest: Operating system

• The current operating system can be returned

phpOMS\tests\System\Search\StringSearchTest: Search utilities

• Knut morris pratt search
• Invalid knut morris pratt search
• Boyer moore horspool simple search
• Invalid boyer moore horspool simple search
• Boyer moore horspool search
• Invalid boyer moore horspool search

phpOMS\tests\System\SystemTypeTest: System type

• The system type enum has the correct amount of values
• The system type enum has only unique values
• The system type enum has the correct values

phpOMS\tests\System\SystemUtilsTest: System information

• Test if it is possible to get information about the available RAM and usage
• Test if it is possible to get information about the CPU usage

Unhandled Handler (phpOMS\tests\UnhandledHandler)

• Error handling

phpOMS\tests\Uri\ArgumentTest: Argument uri / uri

• A uri can be validated
• The argument uri has the expected default values after initialization
• The path can be parsed correctly from a uri
• The path can be set and returned
• The path offset can be set and returned
• The route can be parsed correctly from a uri
• The query data can be parsed correctly from a uri
• The fragment can be parsed correctly from a uri
• The uri can be turned into a string
• The root path can be set and returned

phpOMS\tests\Uri\HttpUriTest: Http uri / url

• A url can be validated
• The http url has the expected default values after initialization
• The url schema can be parsed correctly from a url and overwritten
• The port can be parsed correctly from a url and overwritten
• The host can be parsed correctly from a url
• The username can be parsed correctly from a url
• The password can be parsed correctly from a url
• The base can be parsed correctly from a url
• The url can be turned into a string
• The authority can be parsed correctly from a url
• The user info can be parsed correctly from a url
• The root path can be set and returned
• A path can be overwritten
• The path elements can be parsed from a url and overwritten
• The path offset can be set and returned
• The subdomain can be parsed correctly from a url
• The query data can be parsed correctly from a url
• The fragment data can be parsed correctly from a url
• The path data can be parsed correctly from a url
• The route can be parsed correctly from a url
• A invalid uri cannot get parsed

phpOMS\tests\Uri\InvalidUriExceptionTest: Invalid uri exception

• The invalid uri exception is an unexpected value exception

phpOMS\tests\Uri\UriFactoryTest: Http uri / url factory

• The http url factory has the expected default values after initialization
• Data can be set to the factory and returned
• Data can be forcefully overwritten
• By default data is not overwritten in the factory
• Data can be removed/cleared from the factory
• None-existing data cannot be cleared from the factory
• Data can be removed from the factory by category
• All data can be removed from the factory with a wildcard
• Data can be removed from the factory with regular expression matches
• Data which doesn't match the regular expression is not removed
• A url can be build with the defined factory data and/or build specific data
• The uri factory can be set up with default values from a url and build with these default values
• In case of duplicated query elements the last element is used
• The uri variables can be unescaped
• In case of missing ? for query the builder automatically fixes it
• A normal url will not be changed

Uri Scheme (phpOMS\tests\Uri\UriScheme)

• Enums
• Enum unique

phpOMS\tests\Utils\ArrayUtilsTest: Array utilities

• Array values can be set and returned with a path
• A invalid array path returns null
• Test recursively if a value is in an array
• An array element can be removed by its path
• Deleting an invalid array path returns the original array
• The recursive sum of all values in an array can be calculated
• A multi-dimensional array can be flatten to a one-dimensional array
• The sum of an array can be calculated
• An array can be checked if it contains multiple defined elements
• An array can be checked if it contains any of the defined elements
• An array can be turned into a csv string
• An array can be checked if it has an element and returns its index
• A none-existing argument in an array returns a negative value
• The argument value in an array can be returned
• A none-existing argument in an array returns null
• All array values in an array can be potentiated by a numeric value
• All array values in an array can be square rooted
• All array values in an array can be turned into their absolute value
• The difference of two arrays can be evaluated recursively

Aztec (phpOMS\tests\Utils\Barcode\Aztec)

• Placeholder

Bar Abstract (phpOMS\tests\Utils\Barcode\BarAbstract)

• Set get
• Invalid dimension width
• Invalid dimension height
• Invalid orientation

C128a (phpOMS\tests\Utils\Barcode\C128a)

• Image png
• Image jpg
• Orientation and margin
• Valid string

C128b (phpOMS\tests\Utils\Barcode\C128b)

• Image png
• Image jpg
• Orientation and margin
• Valid string

C128c (phpOMS\tests\Utils\Barcode\C128c)

• Image png
• Image jpg
• Orientation and margin

C25 (phpOMS\tests\Utils\Barcode\C25)

• Image png
• Image jpg
• Orientation and margin
• Valid string
• Invalid orientation

C39 (phpOMS\tests\Utils\Barcode\C39)

• Image png
• Image jpg
• Orientation and margin
• Valid string

Codebar (phpOMS\tests\Utils\Barcode\Codebar)

• Image png
• Image jpg
• Orientation and margin
• Valid string

Datamatrix (phpOMS\tests\Utils\Barcode\Datamatrix)

• Image png
• Image jpg

HIBCC (phpOMS\tests\Utils\Barcode\HIBCC)

• Placeholder

Orientation Type (phpOMS\tests\Utils\Barcode\OrientationType)

• Enum count
• Unique
• Enums

QR (phpOMS\tests\Utils\Barcode\QR)

• Image png
• Image jpg

phpOMS\tests\Utils\ColorUtilsTest: Color utilities

• A integer can be converted to rgb
• Rgb can be converted to a integer

phpOMS\tests\Utils\Compression\LZWTest: LZW compression

• A string can be LZW compressed and uncompressed

Angle Type (phpOMS\tests\Utils\Converter\AngleType)

• Enum count
• Unique
• Enums

Area Type (phpOMS\tests\Utils\Converter\AreaType)

• Enum count
• Unique
• Enums

phpOMS\tests\Utils\Converter\CurrencyTest: Currency converter

• A currency can be converted from euro to another currency
• A currency can be converted to euro from another currency
• A currency can be converted from one currency to another currency
• A currency conversion from eur to a invalid currency throws a InvalidArgumentException
• A currency conversion from a invalid currency to eur throws a InvalidArgumentException
• A currency conversion from a invalid currency to a invalid currency throws a InvalidArgumentException

Energy Power Type (phpOMS\tests\Utils\Converter\EnergyPowerType)

• Enum count
• Unique
• Enums

phpOMS\tests\Utils\Converter\FileSizeTypeTest: File size types

• Enum count
• Unique
• Enums
• File sizes can get automatically formatted according to their size

phpOMS\tests\Utils\Converter\FileTest: File size converter

• A byte number can be converted to a string representation
• A kilobyte number can be converted to a string representation

phpOMS\tests\Utils\Converter\IpTest: IP converter

• An ip can be converted to a float

Length Type (phpOMS\tests\Utils\Converter\LengthType)

• Enum count
• Unique
• Enums

phpOMS\tests\Utils\Converter\MeasurementTest: Measurement converter

• Temperatures can be converted
• Weights can be converted
• Lengths can be converted
• Areas can be converted
• Volumes can be converted
• Speeds can be converted
• Times can be converted
• Angles can be converted
• Pressures can be converted
• Energies can be converted
• Filesizes can be converted
• Invalid conversion from unknown temperature throws a InvalidArgumentException
• Invalid conversion to unknown temperature throws a InvalidArgumentException
• Invalid conversion from unknown weight throws a InvalidArgumentException
• Invalid conversion to unknown weight throws a InvalidArgumentException
• Invalid conversion from unknown length throws a InvalidArgumentException
• Invalid conversion to unknown length throws a InvalidArgumentException
• Invalid conversion from unknown area throws a InvalidArgumentException
• Invalid conversion to unknown area throws a InvalidArgumentException
• Invalid conversion from unknown volume throws a InvalidArgumentException
• Invalid conversion to unknown volume throws a InvalidArgumentException
• Invalid conversion from unknown speed throws a InvalidArgumentException
• Invalid conversion to unknown speed throws a InvalidArgumentException
• Invalid conversion from unknown time throws a InvalidArgumentException
• Invalid conversion to unknown time throws a InvalidArgumentException
• Invalid conversion from unknown angle throws a InvalidArgumentException
• Invalid conversion to unknown angle throws a InvalidArgumentException
• Invalid conversion from unknown pressure throws a InvalidArgumentException
• Invalid conversion to unknown pressure throws a InvalidArgumentException
• Invalid conversion from unknown energy throws a InvalidArgumentException
• Invalid conversion to unknown energy throws a InvalidArgumentException
• Invalid conversion from unknown filesize throws a InvalidArgumentException
• Invalid conversion to unknown filesize throws a InvalidArgumentException

phpOMS\tests\Utils\Converter\NumericTest: Numeric converter

• Arabic numbers can be converted to roman numbers
• Roman numbers can be converted to arabic numbers
• Letters can be converted to numbers
• Numbers can be converted to letters
• Numbers can be converted between bases

Pressure Type (phpOMS\tests\Utils\Converter\PressureType)

• Enum count
• Unique
• Enums

Speed Type (phpOMS\tests\Utils\Converter\SpeedType)

• Enum count
• Unique
• Enums

Temperature Type (phpOMS\tests\Utils\Converter\TemperatureType)

• Enum count
• Unique
• Enums

Time Type (phpOMS\tests\Utils\Converter\TimeType)

• Enum count
• Unique
• Enums

Volume Type (phpOMS\tests\Utils\Converter\VolumeType)

• Enum count
• Unique
• Enums

Weight Type (phpOMS\tests\Utils\Converter\WeightType)

• Enum count
• Unique
• Enums

phpOMS\tests\Utils\Encoding\CaesarTest: Caesar text encoding/decoding

• Text can be encoded and decoded with the ceasar encoding

phpOMS\tests\Utils\Encoding\GrayTest: Gray text encoding/decoding

• Text can be encoded and decoded with the gray encoding

phpOMS\tests\Utils\Encoding\Huffman\DictionaryTest: Dictionary for the huffman encoding

• Only single characters can be returned from the dictionary. Multiple characters throw a InvalidArgumentException
• A none-existing character throws a InvalidArgumentException
• Only single characters can be set in the dictionary. Multiple characters throw a InvalidArgumentException
• Dictionary elements cannot be overwritten and throw a InvalidArgumentException
• Invalid dictionary values throw a InvalidArgumentException

phpOMS\tests\Utils\Encoding\Huffman\HuffmanTest: Data can be encoded with huffman

• Encoding and decoding empty data results in an empty output
• Data can be huffman encoded and decoded

phpOMS\tests\Utils\Encoding\XorEncodingTest: XOR text encoding/decoding

• Text can be encoded and decoded with the xor encoding

Excel (phpOMS\tests\Utils\Excel\Excel)

• Placeholder

phpOMS\tests\Utils\Git\AuthorTest: Git author

• The author has the expected default values after initialization
• The author name and email can be set during initialization and returned
• The commit count can be set and returned
• The addition count can be set and returned
• The removal count can be set and returned

phpOMS\tests\Utils\Git\BranchTest: Git branch

• The branch has the expected default values after initialization
• The branch name can be set during initialization and returned

phpOMS\tests\Utils\Git\CommitTest: Git commit

• The commit has the expected default values after initialization
• A file can be added and returned
• A file can only be added one time
• A file can be removed
• A none-existing file cannot be removed
• A change can be added and returned
• Adding the same change throws a Exception
• A commit message can be set and returned
• The author can be set and returned
• The branch can be set and returned
• The tag can be set and returned
• The date can be set and returned
• The repository can be set and returned

phpOMS\tests\Utils\Git\GitTest: Git utilities

• The git path can be returned

phpOMS\tests\Utils\Git\RepositoryTest: Git repository

• The repository has the expected default values after initialization

phpOMS\tests\Utils\Git\TagTest: Git tag

• The tag has the expected default values after initialization
• The tag name can be set during initialization and returned
• The message can be set and returned

phpOMS\tests\Utils\IO\Csv\CsvSettingsTest: Csv file settings

• The delimiter in a csv file can be guessed
• The delimiter in a csv string can be guessed

IODatabase Mapper (phpOMS\tests\Utils\IO\IODatabaseMapper)

• Placeholder

Invalid Json Exception (phpOMS\tests\Utils\IO\Json\InvalidJsonException)

• Exception

phpOMS\tests\Utils\IO\Spreadsheet\SpreadsheetDatabaseMapperTest: Spreadsheet database mapper

• Data can be inserted into a database from an ods files
• Data can be inserted into a database from a xls files
• Data can be inserted into a database from a xlsx files
• Data can be updated in a database from an ods files
• Data can be updated in a database from a xls files
• Data can be updated in a database from a xlsx files
• Data can be inserted into an ods files from a database
• Data can be inserted into a xls files from a database
• Data can be inserted into a xlsx files from a database

phpOMS\tests\Utils\IO\Zip\GzTest: Gz archive

• Data can be gz packed and unpacked
• A gz archive cannot be overwritten by default
• A none-existing source cannot be unpacked
• A destination cannot be overwritten

phpOMS\tests\Utils\IO\Zip\TarGzTest: TarGz archive

• Data can be tar gz packed and unpacked
• A tar gz archive cannot be overwritten by default
• A none-existing source cannot be unpacked
• A destination cannot be overwritten

phpOMS\tests\Utils\IO\Zip\TarTest: Tar archive

• Data can be tar packed and unpacked
• Invalid archive unpack
• Extracting invalid tar files fail
• A tar archive cannot be overwritten by default
• A none-existing source cannot be unpacked
• A destination cannot be overwritten

phpOMS\tests\Utils\IO\Zip\ZipTest: Zip archive

• Data can be zip packed and unpacked
• The output of the zip archive needs to be properly defined
• Extracting invalid zip files fail
• A zip archive cannot be overwritten by default
• Invalid archive unpack
• A none-existing source cannot be unpacked
• A destination cannot be overwritten

phpOMS\tests\Utils\ImageUtilsTest: Image utilities

• Lightness
• Lightness from rgb
• Resize
• Difference
• Base64 image data can be decoded to an image

phpOMS\tests\Utils\MbStringUtilsTest: Multi-Byte string utilities

• The entropy of a string can be calculated
• A string can be checked for multi-byte characters
• A multi-byte string can be checked if it starts with a defined string
• A multi-byte string can be checked if it ends with a defined string
• The first character of a multi-byte string can be turned into upper case
• The first character of a multi-byte string can be turned into lower case
• A multi-byte string can be trimmed
• A multi-byte string can be right-trimmed
• A multi-byte string can be left-trimmed
• A multi-byte string can be checked if it contains at least one defined string element
• The characters of a multi-byte string can be counted
• The previous boundary of a utf-8 encoded quoted printable is identified correctly

phpOMS\tests\Utils\NumericUtilsTest: Numeric utilities

• Integers can be unsigned right shifted

Pdf (phpOMS\tests\Utils\PDF\Pdf)

• Placeholder

Markdown (phpOMS\tests\Utils\Parser\Markdown\Markdown)

• Parsing
• Safe mode

phpOMS\tests\Utils\Parser\Php\ArrayParserTest: Array data serializer as code

• An array can be encoded and decoded as php code
• A value can be encoded and decoded into php code

phpOMS\tests\Utils\PermutationTest: Permutation utilities

• An array can be permuted
• Two string can be checked if they are a permutation of each other
• A string can be checked if it is a palindrome
• An array can be permuted with a permutation key
• A none-existing permutation key throws a OutOfBoundsException

phpOMS\tests\Utils\RnG\ArrayRandomizeTest: Array randomizer

• An array can be randomized using the yates algorithm
• An array can be randomized using the knuth algorithm

phpOMS\tests\Utils\RnG\DateTimeTest: Date time randomizer

• A random date time can be generated

Distribution Type (phpOMS\tests\Utils\RnG\DistributionType)

• Enum count
• Unique
• Enums

phpOMS\tests\Utils\RnG\FileTest: File extension randomizer

• A random file extension can be generated

phpOMS\tests\Utils\RnG\LinearCongruentialGeneratorTest: Random number generator

• The bsd random number generator starts with the correct sequence
• The same bsd seed generates the same random number
• Different bsd seeds generate different random numbers
• The msvcrt random number generator starts with the correct sequence
• The same msvcrt seed generates the same random number
• Different msvcrt seeds generate different random numbers

phpOMS\tests\Utils\RnG\NameTest: Random name generator

• Random female and male names can be generated

phpOMS\tests\Utils\RnG\PhoneTest: Random phone number generator

• Random phone numbers can be generated

phpOMS\tests\Utils\RnG\StringUtilsTest: Random string generator

• Random strings can be generated

phpOMS\tests\Utils\RnG\TextTest: Random text generator

• Random text can be generated

phpOMS\tests\Utils\StringCompareTest: String comparison / dictionary

• A string can be matched with a dictionary entry
• A string doesn't match a dictionary entry if it is very different
• A new dictionary entry can be created and returned
• Two texts can be compared on a per word basis for similarity
• Jaro
• Jaro empty

phpOMS\tests\Utils\StringUtilsTest: String utilities

• The entropy of a string can be calculated
• A string can be checked if it starts with a defined string
• A string can be checked if it ends with a defined string
• A string can be checked if it contains at least one defined string element
• The amount of a defined characters in the beginning of a string can be counted
• A string creates a integer hash
• The same string creates the same hash
• Different strings create different hashes
• Various data types can be stringified
• Stringify/rendering a unknown data type returns null
• The difference between two strings can be evaluated
• A string can be validated for shell safety

phpOMS\tests\Utils\TaskSchedule\CronJobTest: Cron job

• The cron job has the expected default values after initialization
• A cron job can be created from an array and rendered

phpOMS\tests\Utils\TaskSchedule\CronTest: Cron handler

• The cron handler has the expected default values after initialization
• The cron binary location path can be guessed
• A cron job can be created and returned
• A none-existing cron name cannot be returned
• A cron job can be updated
• A cron job can be deleted

phpOMS\tests\Utils\TaskSchedule\IntervalTest: Cron interval

• The interval has the expected default values after initialization
• The start date can be set during initialization and returned
• The start date can set and returned
• The end date can set and returned
• The maximum execution duration can set and returned
• An execution minute can be added and returned
• An execution minute can be overwritten
• An execution hour can be added and returned
• An execution hour can be overwritten
• An execution year can be added and returned
• An execution year can be overwritten
• An execution day of month can be added and returned
• An execution day of month can be overwritten
• An execution day of week can be added and returned
• An execution day of week can be overwritten
• A interval can be serialized
• A serialized interval can be unserialized

phpOMS\tests\Utils\TaskSchedule\ScheduleTest: Schedule/task

• The task has the expected default values after initialization
• A task can be created from an array and rendered

phpOMS\tests\Utils\TaskSchedule\SchedulerAbstractTest: Scheduler abstraction

• The scheduler has the expected default values after initialization
• The scheduler binary location path can be guessed

phpOMS\tests\Utils\TaskSchedule\SchedulerFactoryTest: Scheduler factory for creating cron/task handlers

• The correct scheduler is crated depending on the operating system

phpOMS\tests\Utils\TaskSchedule\TaskAbstractTest: Job/task abstraction

• The task abstraction has the expected default values after initialization
• The command can be set and returned
• The interval can be set and returned
• The status can be set and returned
• The comment can be set and returned
• The last runtime can be set and returned
• The next runtime can be set and returned

phpOMS\tests\Utils\TaskSchedule\TaskFactoryTest: Task factory for creating cron jobs/tasks

• The correct task is crated depending on the operating system

phpOMS\tests\Utils\TaskSchedule\TaskSchedulerTest: Task schedule handler

• The task handler has the expected default values after initialization
• The task binary location path can be guessed
• A task can be created and returned
• A none-existing task name cannot be returned
• A task can be updated
• A task can be deleted

phpOMS\tests\Utils\TestUtilsTest: Test utilities

• A member value can be returned
• Invalid member variable returns null
• A member value can be set and returned
• A none-existing member variable cannot be set

phpOMS\tests\Validation\Base\DateTimeTest: Datetime validator

• A date time string can be validated

phpOMS\tests\Validation\Base\JsonTest: Json validator

• A json string can be validated
• A json string can be validated against a template definition
• A json string can be validated against a template definition with additional data
• A json string cannot be validated against a template definition with additional data if an exact match is enforced
• A json string cannot be validated against a template definition with missing data if an exact match is enforced
• A json string cannot be validated against a template definition if it doesn't match the template

phpOMS\tests\Validation\Finance\BICTest: BIC validator

• A BIC can be validated

phpOMS\tests\Validation\Finance\CreditCardTest: Credit card validator

• A credit card can be validated
• A invalid type cannot be validated

Iban Enum (phpOMS\tests\Validation\Finance\IbanEnum)

• Enums

Iban Error Type (phpOMS\tests\Validation\Finance\IbanErrorType)

• Enum count
• Unique
• Enums

phpOMS\tests\Validation\Finance\IbanTest: Iban validator

• A iban can be validated
• Numeric
• Zero
• Invalid name
• Invalid length
• Invalid checksum

phpOMS\tests\Validation\Network\EmailTest: Email validator

• A email can be validated

phpOMS\tests\Validation\Network\HostnameTest: Hostname validator

• A hostname can be validated
• A IP can be validated as hostname

phpOMS\tests\Validation\Network\IpTest: IP validator

• A ip can be validated
• A ip4 can be validated
• A ip6 can be validated

phpOMS\tests\Validation\ValidatorTest: General validator

• A string can be checked if it contains a substring
• A string can be checked if it has a certain length
• A value can be checked if it is in range
• A value can be checked to be of a defined type
• The error message and error code have the expected default values
• Custom validators can be specified in order to validate a value
• Invalid validator call
• A value can be checked to match a regular expression
• Error message
• Error code
• Reset error

phpOMS\tests\Version\VersionTest: Version handler

• Versions can be compared with each other

phpOMS\tests\Views\PaginationViewTest: View for pagination

• The pagination view has the expected default values after initialization
• The max pages can be set and returned
• The pages can be set and returned
• The page can be set and returned
• The results can be set and returned

phpOMS\tests\Views\ViewTest: View for response rendering

• The view has the expected default values after initialization
• The view data can be checked for existence
• The view can output text from the localization manager
• The view can output html escaped text from the localization manager
• The numeric value can be printed based on the localization
• The percentage value can be printed based on the localization
• The currency value can be printed based on the localization
• The datetime value can be printed based on the localization
• View data can be set and returned
• View data can be added and returned
• View data can be removed
• None-existing view data cannot be removed
• The request can be returned
• The response can be returned
• Text can be html escaped
• Views can be added and returned from a view
• None-existing views cannot be returned
• Views can be removed
• None-existing views cannot be removed
• A view can be forcefully overwritten
• By default a view is not overwritten
• A view template can be rendered
• A view template can be build
• A view template can be serialized
• A view can be turned into an array containing the rendered templates
• Rendering a invalid template throws a PathException
• Building a invalid template throws a PathException
• Serializing a invalid template throws a PathException
• Getting the text without defining a module throws a InvalidModuleException exception
• Getting the text with an invalid template path throws a InvalidModuleException exception
• Getting the text without defining a template throws a InvalidThemeException exception