SpecSpec::it_create_bit_and_operand() - Code Metrics - Happyr/Doctrine-Specification - Measure and Improve Code Quality continuously with Scrutinizer

SpecSpec::it_create_bit_and_operand() A
last analyzed 2021-01-20 15:15 UTC

↳ Parent: SpecSpec

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	4
rs	10
c	0
b	0
f	0
cc	1
nc	1
nop	0

<?php

/**
 * This file is part of the Happyr Doctrine Specification package.
 *
 * (c) Tobias Nyholm <[email protected]>
 *     Kacper Gunia <[email protected]>
 *     Peter Gribanov <[email protected]>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace tests\Happyr\DoctrineSpecification;

use Happyr\DoctrineSpecification\Filter\MemberOfX;
use Happyr\DoctrineSpecification\Logic\LogicX;
use Happyr\DoctrineSpecification\Operand\Addition;
use Happyr\DoctrineSpecification\Operand\Alias;
use Happyr\DoctrineSpecification\Operand\BitAnd;
use Happyr\DoctrineSpecification\Operand\BitOr;
use Happyr\DoctrineSpecification\Operand\CountDistinct;
use Happyr\DoctrineSpecification\Operand\Division;
use Happyr\DoctrineSpecification\Operand\Modulo;
use Happyr\DoctrineSpecification\Operand\Multiplication;
use Happyr\DoctrineSpecification\Operand\PlatformFunction;
use Happyr\DoctrineSpecification\Operand\Subtraction;
use Happyr\DoctrineSpecification\Query\AddSelect;
use Happyr\DoctrineSpecification\Query\Distinct;
use Happyr\DoctrineSpecification\Query\Select;
use Happyr\DoctrineSpecification\Query\Selection\SelectAs;
use Happyr\DoctrineSpecification\Query\Selection\SelectEntity;
use Happyr\DoctrineSpecification\Query\Selection\SelectHiddenAs;
use Happyr\DoctrineSpecification\Spec;
use PhpSpec\ObjectBehavior;

/**
 * @mixin Spec
 */
class SpecSpec extends ObjectBehavior
{
    public function it_creates_an_x_specification()
    {
        $this->andX()->shouldReturnAnInstanceOf(LogicX::class);
    }

    public function it_creates_distinct()
    {
        $this->distinct()->shouldReturnAnInstanceOf(Distinct::class);
    }

    public function it_creates_count_distinct()
    {
        $this->countDistinct('foo')->shouldReturnAnInstanceOf(CountDistinct::class);
    }

    public function it_creates_add_operand()
    {
        $this->add('foo', 'bar')->shouldReturnAnInstanceOf(Addition::class);
    }

    public function it_creates_sub_operand()
    {
        $this->sub('foo', 'bar')->shouldReturnAnInstanceOf(Subtraction::class);
    }

    public function it_creates_mul_operand()
    {
        $this->mul('foo', 'bar')->shouldReturnAnInstanceOf(Multiplication::class);
    }

    public function it_creates_div_operand()
    {
        $this->div('foo', 'bar')->shouldReturnAnInstanceOf(Division::class);
    }

    public function it_creates_mod_operand()
    {
        $this->mod('foo', 'bar')->shouldReturnAnInstanceOf(Modulo::class);
    }

    public function it_create_bit_and_operand()
    {
        $this->bAnd('foo', 'bar')->shouldReturnAnInstanceOf(BitAnd::class);
    }

    public function it_create_bit_or_operand()
    {
        $this->bOr('foo', 'bar')->shouldReturnAnInstanceOf(BitOr::class);
    }

    public function it_creates_an_function()
    {
        $this->fun('UPPER', 'arg')->shouldReturnAnInstanceOf(PlatformFunction::class);
    }

    public function it_creates_an_function_with_many_args()
    {
        $this->fun('CONCAT', 'a', 'b')->shouldReturnAnInstanceOf(PlatformFunction::class);
    }

    public function it_creates_an_function_with_many_args_as_array()
    {
        $this->fun('CONCAT', ['a', 'b'])->shouldReturnAnInstanceOf(PlatformFunction::class);
    }

    public function it_creates_an_magic_function()
    {
        $this->__callStatic('UPPER', ['arg'])->shouldReturnAnInstanceOf(PlatformFunction::class);
    }

    public function it_creates_an_magic_function_many_args()
    {
        $this->__callStatic('CONCAT', ['a', 'b'])->shouldReturnAnInstanceOf(PlatformFunction::class);
    }

    public function it_creates_an_magic_function_many_args_inner()
    {
        $this->__callStatic('CONCAT', [['a', 'b']])->shouldReturnAnInstanceOf(PlatformFunction::class);
    }

    public function it_creates_select_query_modifier()
    {
        $this->select('foo')->shouldReturnAnInstanceOf(Select::class);
    }

    public function it_creates_add_select_query_modifier()
    {
        $this->addSelect('foo')->shouldReturnAnInstanceOf(AddSelect::class);
    }

    public function it_creates_select_entity_selection()
    {
        $this->selectEntity('u')->shouldReturnAnInstanceOf(SelectEntity::class);
    }

    public function it_creates_select_as_selection()
    {
        $this->selectAs('foo', 'bar')->shouldReturnAnInstanceOf(SelectAs::class);
    }

    public function it_creates_select_hidden_as_selection()
    {
        $this->selectHiddenAs('foo', 'bar')->shouldReturnAnInstanceOf(SelectHiddenAs::class);
    }

    public function it_creates_alias_operand()
    {
        $this->alias('foo')->shouldReturnAnInstanceOf(Alias::class);
    }

    public function it_creates_member_of_filter()
    {
        $this->memberOfX('foo', 'bar')->shouldReturnAnInstanceOf(MemberOfX::class);
    }
}


1			<?php
2
3			/**
4			* This file is part of the Happyr Doctrine Specification package.
5			*
6			* (c) Tobias Nyholm <[email protected]>
7			* Kacper Gunia <[email protected]>
8			* Peter Gribanov <[email protected]>
9			*
10			* For the full copyright and license information, please view the LICENSE
11			* file that was distributed with this source code.
12			*/
13
14			namespace tests\Happyr\DoctrineSpecification;
15
16			use Happyr\DoctrineSpecification\Filter\MemberOfX;
17			use Happyr\DoctrineSpecification\Logic\LogicX;
18			use Happyr\DoctrineSpecification\Operand\Addition;
19			use Happyr\DoctrineSpecification\Operand\Alias;
20			use Happyr\DoctrineSpecification\Operand\BitAnd;
21			use Happyr\DoctrineSpecification\Operand\BitOr;
22			use Happyr\DoctrineSpecification\Operand\CountDistinct;
23			use Happyr\DoctrineSpecification\Operand\Division;
24			use Happyr\DoctrineSpecification\Operand\Modulo;
25			use Happyr\DoctrineSpecification\Operand\Multiplication;
26			use Happyr\DoctrineSpecification\Operand\PlatformFunction;
27			use Happyr\DoctrineSpecification\Operand\Subtraction;
28			use Happyr\DoctrineSpecification\Query\AddSelect;
29			use Happyr\DoctrineSpecification\Query\Distinct;
30			use Happyr\DoctrineSpecification\Query\Select;
31			use Happyr\DoctrineSpecification\Query\Selection\SelectAs;
32			use Happyr\DoctrineSpecification\Query\Selection\SelectEntity;
33			use Happyr\DoctrineSpecification\Query\Selection\SelectHiddenAs;
34			use Happyr\DoctrineSpecification\Spec;
35			use PhpSpec\ObjectBehavior;
36
37			/**
38			* @mixin Spec
39			*/
40			class SpecSpec extends ObjectBehavior
41			{
42			public function it_creates_an_x_specification()
43			{
44			$this->andX()->shouldReturnAnInstanceOf(LogicX::class);
45			}
46
47			public function it_creates_distinct()
48			{
49			$this->distinct()->shouldReturnAnInstanceOf(Distinct::class);
50			}
51
52			public function it_creates_count_distinct()
53			{
54			$this->countDistinct('foo')->shouldReturnAnInstanceOf(CountDistinct::class);
55			}
56
57			public function it_creates_add_operand()
58			{
59			$this->add('foo', 'bar')->shouldReturnAnInstanceOf(Addition::class);
60			}
61
62			public function it_creates_sub_operand()
63			{
64			$this->sub('foo', 'bar')->shouldReturnAnInstanceOf(Subtraction::class);
65			}
66
67			public function it_creates_mul_operand()
68			{
69			$this->mul('foo', 'bar')->shouldReturnAnInstanceOf(Multiplication::class);
70			}
71
72			public function it_creates_div_operand()
73			{
74			$this->div('foo', 'bar')->shouldReturnAnInstanceOf(Division::class);
75			}
76
77			public function it_creates_mod_operand()
78			{
79			$this->mod('foo', 'bar')->shouldReturnAnInstanceOf(Modulo::class);
80			}
81
82			public function it_create_bit_and_operand()
83			{
84			$this->bAnd('foo', 'bar')->shouldReturnAnInstanceOf(BitAnd::class);
85			}
86
87			public function it_create_bit_or_operand()
88			{
89			$this->bOr('foo', 'bar')->shouldReturnAnInstanceOf(BitOr::class);
90			}
91
92			public function it_creates_an_function()
93			{
94			$this->fun('UPPER', 'arg')->shouldReturnAnInstanceOf(PlatformFunction::class);
95			}
96
97			public function it_creates_an_function_with_many_args()
98			{
99			$this->fun('CONCAT', 'a', 'b')->shouldReturnAnInstanceOf(PlatformFunction::class);
100			}
101
102			public function it_creates_an_function_with_many_args_as_array()
103			{
104			$this->fun('CONCAT', ['a', 'b'])->shouldReturnAnInstanceOf(PlatformFunction::class);
105			}
106
107			public function it_creates_an_magic_function()
108			{
109			$this->__callStatic('UPPER', ['arg'])->shouldReturnAnInstanceOf(PlatformFunction::class);
110			}
111
112			public function it_creates_an_magic_function_many_args()
113			{
114			$this->__callStatic('CONCAT', ['a', 'b'])->shouldReturnAnInstanceOf(PlatformFunction::class);
115			}
116
117			public function it_creates_an_magic_function_many_args_inner()
118			{
119			$this->__callStatic('CONCAT', [['a', 'b']])->shouldReturnAnInstanceOf(PlatformFunction::class);
120			}
121
122			public function it_creates_select_query_modifier()
123			{
124			$this->select('foo')->shouldReturnAnInstanceOf(Select::class);
125			}
126
127			public function it_creates_add_select_query_modifier()
128			{
129			$this->addSelect('foo')->shouldReturnAnInstanceOf(AddSelect::class);
130			}
131
132			public function it_creates_select_entity_selection()
133			{
134			$this->selectEntity('u')->shouldReturnAnInstanceOf(SelectEntity::class);
135			}
136
137			public function it_creates_select_as_selection()
138			{
139			$this->selectAs('foo', 'bar')->shouldReturnAnInstanceOf(SelectAs::class);
140			}
141
142			public function it_creates_select_hidden_as_selection()
143			{
144			$this->selectHiddenAs('foo', 'bar')->shouldReturnAnInstanceOf(SelectHiddenAs::class);
145			}
146
147			public function it_creates_alias_operand()
148			{
149			$this->alias('foo')->shouldReturnAnInstanceOf(Alias::class);
150			}
151
152			public function it_creates_member_of_filter()
153			{
154			$this->memberOfX('foo', 'bar')->shouldReturnAnInstanceOf(MemberOfX::class);
155			}
156			}
157

Happyr / Doctrine-Specification

SpecSpec::it_create_bit_and_operand() A last analyzed 2021-01-20 15:15 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

SpecSpec::it_create_bit_and_operand() A
last analyzed 2021-01-20 15:15 UTC