TOperandTypeTest - Code Metrics - Inspection of "Merge pull request #118 from c-harris/CoverGExpres..." - Algo-Web/ODataMetadata - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( a97862...37982b )

by Alex

created 2017-06-29 09:14 UTC

TOperandTypeTest D

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	567
Duplicated Lines	59.26 %

Coupling/Cohesion

Components	2
Dependencies	16

Importance

Changes	2
Bugs	0	Features	0

Metric	Value
wmc	61
c	2
b	0
f	0
lcom	2
cbo	16
dl	336
loc	567
rs	4.054

43 Methods

Rating	Name	Duplication	Size	Complexity
A	testSetStringNullString()	0	6	1
A	testSetStringActualString()	0	6	1
A	testSetStringEmptyArrayAsString()	0	13	2
A	testSetStringNonEmptyArrayAsString()	0	13	2
A	testSetStringObjectAsString()	0	13	2
A	testSetGetBinaryRoundTrip()	0	7	1
A	testSetGetIntRoundTrip()	0	7	1
A	testSetGetFloatRoundTrip()	0	7	1
A	testSetGetDecimalRoundTrip()	0	7	1
A	testSetGetBoolRoundTrip()	0	6	1
A	testSetGetDateTimeRoundTrip()	0	7	1
A	testSetGetDateTimeOffsetRoundTrip()	0	7	1
A	testSetBadIf()	17	17	2
A	testSetGetIfRoundTrip()	11	11	1
A	testSetBadRecord()	17	17	2
A	testSetGetRecordRoundTrip()	11	11	1
A	testSetBadCollection()	17	17	2
A	testSetGetCollectionRoundTrip()	11	11	1
A	testSetBadTypeAssert()	17	17	2
A	testSetGetTypeAssertRoundTrip()	11	11	1
A	testSetBadTypeTest()	17	17	2
A	testSetGetTypeTestRoundTrip()	11	11	1
A	testSetBadFunctionReference()	17	17	2
A	testSetGetFunctionReferenceRoundTrip()	11	11	1
A	testSetBadEntitySetReference()	17	17	2
A	testSetGetEntitySetReferenceRoundTrip()	11	11	1
A	testSetBadAnonymousFunction()	17	17	2
A	testSetGetAnonymousFunctionRoundTrip()	11	11	1
A	testSetBadParameterReference()	17	17	2
A	testSetGetParameterReferenceRoundTrip()	11	11	1
A	testSetBadApply()	17	17	2
A	testSetGetApplyRoundTrip()	11	11	1
A	testSetBadPropertyReference()	17	17	2
A	testSetGetPropertyReferenceRoundTrip()	11	11	1
A	testSetBadValueTermReference()	17	17	2
A	testSetGetValueTermReferenceRoundTrip()	11	11	1
A	testGExpressionNotValidWhenMoreThanOneBasicExpressionSet()	0	18	1
A	testSetBadEnum()	0	13	2
A	testSetGetEnumRoundTrip()	0	10	1
A	testSetBadPath()	0	13	2
A	testSetGetPathRoundTrip()	0	10	1
A	testSetBadGuid()	0	13	2
A	testSetGetGuidRoundTrip()	0	10	1

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like TOperandTypeTest often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use TOperandTypeTest, and based on these observations, apply Extract Interface, too.

<?php

namespace AlgoWeb\ODataMetadata\Tests\v3\edm;

use AlgoWeb\ODataMetadata\MetadataV3\edm\TAnonymousFunctionExpressionType;
use AlgoWeb\ODataMetadata\MetadataV3\edm\TApplyExpressionType;
use AlgoWeb\ODataMetadata\MetadataV3\edm\TCollectionExpressionType;
use AlgoWeb\ODataMetadata\MetadataV3\edm\TEntitySetReferenceExpressionType;
use AlgoWeb\ODataMetadata\MetadataV3\edm\TFunctionReferenceExpressionType;
use AlgoWeb\ODataMetadata\MetadataV3\edm\TIfExpressionType;
use AlgoWeb\ODataMetadata\MetadataV3\edm\TOperandType;
use AlgoWeb\ODataMetadata\MetadataV3\edm\TParameterReferenceExpressionType;
use AlgoWeb\ODataMetadata\MetadataV3\edm\TPropertyReferenceExpressionType;
use AlgoWeb\ODataMetadata\MetadataV3\edm\TRecordExpressionType;
use AlgoWeb\ODataMetadata\MetadataV3\edm\TTypeAssertExpressionType;
use AlgoWeb\ODataMetadata\MetadataV3\edm\TTypeTestExpressionType;
use AlgoWeb\ODataMetadata\MetadataV3\edm\TValueTermReferenceExpressionType;
use AlgoWeb\ODataMetadata\Tests\TestCase;
use Mockery as m;

class TOperandTypeTest extends TestCase
{
    public function testSetStringNullString()
    {
        $foo = new TOperandType();
        $foo->setString(null);
        $this->assertEquals(null, $foo->getString());
    }

    public function testSetStringActualString()
    {
        $foo = new TOperandType();
        $foo->setString("string");
        $this->assertEquals('string', $foo->getString());
    }

    public function testSetStringEmptyArrayAsString()
    {
        $expected = "String must be a string";
        $actual = null;

        $foo = new TOperandType();
        try {
            $foo->setString([]);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        } catch (\InvalidArgumentException $e) {
            $actual = $e->getMessage();
        }
        $this->assertEquals($expected, $actual);
    }

    public function testSetStringNonEmptyArrayAsString()
    {
        $expected = "String must be a string";
        $actual = null;

        $foo = new TOperandType();
        try {
            $foo->setString(['a']);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        } catch (\InvalidArgumentException $e) {
            $actual = $e->getMessage();
        }
        $this->assertEquals($expected, $actual);
    }

    public function testSetStringObjectAsString()
    {
        $expected = "String must be a string";
        $actual = null;

        $foo = new TOperandType();
        try {
            $foo->setString(new \DateTime());
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        } catch (\InvalidArgumentException $e) {
            $actual = $e->getMessage();
        }
        $this->assertEquals($expected, $actual);
    }

    public function testSetGetBinaryRoundTrip()
    {
        $expected = 'zyxvut';
        $foo = new TOperandType();
        $foo->setBinary("zyxvut");
        $this->assertEquals($expected, $foo->getBinary());
    }

    public function testSetGetIntRoundTrip()
    {
        $expected = 'zyxvut';
        $foo = new TOperandType();
        $foo->setInt("zyxvut");
        $this->assertEquals($expected, $foo->getInt());
    }

    public function testSetGetFloatRoundTrip()
    {
        $expected = 'zyxvut';
        $foo = new TOperandType();
        $foo->setFloat("zyxvut");
        $this->assertEquals($expected, $foo->getFloat());
    }

    public function testSetGetDecimalRoundTrip()
    {
        $expected = 'zyxvut';
        $foo = new TOperandType();
        $foo->setDecimal("zyxvut");
        $this->assertEquals($expected, $foo->getDecimal());
    }

    public function testSetGetBoolRoundTrip()
    {
        $foo = new TOperandType();
        $foo->setBool(null);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        $this->assertFalse($foo->getBool());
    }

    public function testSetGetDateTimeRoundTrip()
    {
        $expected = new \DateTime();
        $foo = new TOperandType();
        $foo->setDateTime($expected);
        $this->assertEquals($expected, $foo->getDateTime());
    }

    public function testSetGetDateTimeOffsetRoundTrip()
    {
        $expected = new \DateTime();
        $foo = new TOperandType();
        $foo->setDateTimeOffset($expected);
        $this->assertEquals($expected, $foo->getDateTimeOffset());
    }

    public function testSetBadIf()

    {
        $expected = "";
        $actual = null;

        $if = m::mock(TIfExpressionType::class);
        $if->shouldReceive('isOK')->andReturn(false);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}

        $foo = new TOperandType();

        try {
            $foo->setIf($if);
        } catch (\InvalidArgumentException $e) {
            $actual = $e->getMessage();
        }
        $this->assertEquals($expected, $actual);
    }

    public function testSetGetIfRoundTrip()

    {
        $if = m::mock(TIfExpressionType::class);
        $if->shouldReceive('isOK')->andReturn(true);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}

        $foo = new TOperandType();
        $foo->setIf($if);
        $result = $foo->getIf();
        $this->assertTrue($result instanceof TIfExpressionType, get_class($result));
        $this->assertTrue($result->isOK());
    }

    public function testSetBadRecord()

    {
        $expected = "";
        $actual = null;

        $if = m::mock(TRecordExpressionType::class);
        $if->shouldReceive('isOK')->andReturn(false);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}

        $foo = new TOperandType();

        try {
            $foo->setRecord($if);
        } catch (\InvalidArgumentException $e) {
            $actual = $e->getMessage();
        }
        $this->assertEquals($expected, $actual);
    }

    public function testSetGetRecordRoundTrip()

    {
        $if = m::mock(TRecordExpressionType::class);
        $if->shouldReceive('isOK')->andReturn(true);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}

        $foo = new TOperandType();
        $foo->setRecord($if);
        $result = $foo->getRecord();
        $this->assertTrue($result instanceof TRecordExpressionType, get_class($result));
        $this->assertTrue($result->isOK());
    }

    public function testSetBadCollection()

    {
        $expected = "";
        $actual = null;

        $if = m::mock(TCollectionExpressionType::class);
        $if->shouldReceive('isOK')->andReturn(false);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}

        $foo = new TOperandType();

        try {
            $foo->setCollection($if);
        } catch (\InvalidArgumentException $e) {
            $actual = $e->getMessage();
        }
        $this->assertEquals($expected, $actual);
    }

    public function testSetGetCollectionRoundTrip()

    {
        $if = m::mock(TCollectionExpressionType::class);
        $if->shouldReceive('isOK')->andReturn(true);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}

        $foo = new TOperandType();
        $foo->setCollection($if);
        $result = $foo->getCollection();
        $this->assertTrue($result instanceof TCollectionExpressionType, get_class($result));
        $this->assertTrue($result->isOK());
    }

    public function testSetBadTypeAssert()

    {
        $expected = "";
        $actual = null;

        $if = m::mock(TTypeAssertExpressionType::class);
        $if->shouldReceive('isOK')->andReturn(false);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}

        $foo = new TOperandType();

        try {
            $foo->setTypeAssert($if);
        } catch (\InvalidArgumentException $e) {
            $actual = $e->getMessage();
        }
        $this->assertEquals($expected, $actual);
    }

    public function testSetGetTypeAssertRoundTrip()

    {
        $if = m::mock(TTypeAssertExpressionType::class);
        $if->shouldReceive('isOK')->andReturn(true);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}

        $foo = new TOperandType();
        $foo->setTypeAssert($if);
        $result = $foo->getTypeAssert();
        $this->assertTrue($result instanceof TTypeAssertExpressionType, get_class($result));
        $this->assertTrue($result->isOK());
    }

    public function testSetBadTypeTest()

    {
        $expected = "";
        $actual = null;

        $if = m::mock(TTypeTestExpressionType::class);
        $if->shouldReceive('isOK')->andReturn(false);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}

        $foo = new TOperandType();

        try {
            $foo->setTypeTest($if);
        } catch (\InvalidArgumentException $e) {
            $actual = $e->getMessage();
        }
        $this->assertEquals($expected, $actual);
    }

    public function testSetGetTypeTestRoundTrip()

    {
        $if = m::mock(TTypeTestExpressionType::class);
        $if->shouldReceive('isOK')->andReturn(true);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}

        $foo = new TOperandType();
        $foo->setTypeTest($if);
        $result = $foo->getTypeTest();
        $this->assertTrue($result instanceof TTypeTestExpressionType, get_class($result));
        $this->assertTrue($result->isOK());
    }

    public function testSetBadFunctionReference()

    {
        $expected = "";
        $actual = null;

        $if = m::mock(TFunctionReferenceExpressionType::class);
        $if->shouldReceive('isOK')->andReturn(false);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}

        $foo = new TOperandType();

        try {
            $foo->setFunctionReference($if);
        } catch (\InvalidArgumentException $e) {
            $actual = $e->getMessage();
        }
        $this->assertEquals($expected, $actual);
    }

    public function testSetGetFunctionReferenceRoundTrip()

    {
        $if = m::mock(TFunctionReferenceExpressionType::class);
        $if->shouldReceive('isOK')->andReturn(true);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}

        $foo = new TOperandType();
        $foo->setFunctionReference($if);
        $result = $foo->getFunctionReference();
        $this->assertTrue($result instanceof TFunctionReferenceExpressionType, get_class($result));
        $this->assertTrue($result->isOK());
    }

    public function testSetBadEntitySetReference()

    {
        $expected = "";
        $actual = null;

        $if = m::mock(TEntitySetReferenceExpressionType::class);
        $if->shouldReceive('isOK')->andReturn(false);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}

        $foo = new TOperandType();

        try {
            $foo->setEntitySetReference($if);
        } catch (\InvalidArgumentException $e) {
            $actual = $e->getMessage();
        }
        $this->assertEquals($expected, $actual);
    }

    public function testSetGetEntitySetReferenceRoundTrip()

    {
        $if = m::mock(TEntitySetReferenceExpressionType::class);
        $if->shouldReceive('isOK')->andReturn(true);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}

        $foo = new TOperandType();
        $foo->setEntitySetReference($if);
        $result = $foo->getEntitySetReference();
        $this->assertTrue($result instanceof TEntitySetReferenceExpressionType, get_class($result));
        $this->assertTrue($result->isOK());
    }

    public function testSetBadAnonymousFunction()

    {
        $expected = "";
        $actual = null;

        $if = m::mock(TAnonymousFunctionExpressionType::class);
        $if->shouldReceive('isOK')->andReturn(false);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}

        $foo = new TOperandType();

        try {
            $foo->setAnonymousFunction($if);
        } catch (\InvalidArgumentException $e) {
            $actual = $e->getMessage();
        }
        $this->assertEquals($expected, $actual);
    }

    public function testSetGetAnonymousFunctionRoundTrip()

    {
        $if = m::mock(TAnonymousFunctionExpressionType::class);
        $if->shouldReceive('isOK')->andReturn(true);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}

        $foo = new TOperandType();
        $foo->setAnonymousFunction($if);
        $result = $foo->getAnonymousFunction();
        $this->assertTrue($result instanceof TAnonymousFunctionExpressionType, get_class($result));
        $this->assertTrue($result->isOK());
    }

    public function testSetBadParameterReference()

    {
        $expected = "";
        $actual = null;

        $if = m::mock(TParameterReferenceExpressionType::class);
        $if->shouldReceive('isOK')->andReturn(false);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}

        $foo = new TOperandType();

        try {
            $foo->setParameterReference($if);
        } catch (\InvalidArgumentException $e) {
            $actual = $e->getMessage();
        }
        $this->assertEquals($expected, $actual);
    }

    public function testSetGetParameterReferenceRoundTrip()

    {
        $if = m::mock(TParameterReferenceExpressionType::class);
        $if->shouldReceive('isOK')->andReturn(true);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}

        $foo = new TOperandType();
        $foo->setParameterReference($if);
        $result = $foo->getParameterReference();
        $this->assertTrue($result instanceof TParameterReferenceExpressionType, get_class($result));
        $this->assertTrue($result->isOK());
    }

    public function testSetBadApply()

    {
        $expected = "";
        $actual = null;

        $if = m::mock(TApplyExpressionType::class);
        $if->shouldReceive('isOK')->andReturn(false);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}

        $foo = new TOperandType();

        try {
            $foo->setApply($if);
        } catch (\InvalidArgumentException $e) {
            $actual = $e->getMessage();
        }
        $this->assertEquals($expected, $actual);
    }

    public function testSetGetApplyRoundTrip()

    {
        $if = m::mock(TApplyExpressionType::class);
        $if->shouldReceive('isOK')->andReturn(true);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}

        $foo = new TOperandType();
        $foo->setApply($if);
        $result = $foo->getApply();
        $this->assertTrue($result instanceof TApplyExpressionType, get_class($result));
        $this->assertTrue($result->isOK());
    }

    public function testSetBadPropertyReference()

    {
        $expected = "";
        $actual = null;

        $if = m::mock(TPropertyReferenceExpressionType::class);
        $if->shouldReceive('isOK')->andReturn(false);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}

        $foo = new TOperandType();

        try {
            $foo->setPropertyReference($if);
        } catch (\InvalidArgumentException $e) {
            $actual = $e->getMessage();
        }
        $this->assertEquals($expected, $actual);
    }

    public function testSetGetPropertyReferenceRoundTrip()

    {
        $if = m::mock(TPropertyReferenceExpressionType::class);
        $if->shouldReceive('isOK')->andReturn(true);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}

        $foo = new TOperandType();
        $foo->setPropertyReference($if);
        $result = $foo->getPropertyReference();
        $this->assertTrue($result instanceof TPropertyReferenceExpressionType, get_class($result));
        $this->assertTrue($result->isOK());
    }

    public function testSetBadValueTermReference()

    {
        $expected = "";
        $actual = null;

        $if = m::mock(TValueTermReferenceExpressionType::class);
        $if->shouldReceive('isOK')->andReturn(false);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}

        $foo = new TOperandType();

        try {
            $foo->setValueTermReference($if);
        } catch (\InvalidArgumentException $e) {
            $actual = $e->getMessage();
        }
        $this->assertEquals($expected, $actual);
    }

    public function testSetGetValueTermReferenceRoundTrip()

    {
        $if = m::mock(TValueTermReferenceExpressionType::class);
        $if->shouldReceive('isOK')->andReturn(true);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}

        $foo = new TOperandType();
        $foo->setValueTermReference($if);
        $result = $foo->getValueTermReference();
        $this->assertTrue($result instanceof TValueTermReferenceExpressionType, get_class($result));
        $this->assertTrue($result->isOK());
    }

    public function testGExpressionNotValidWhenMoreThanOneBasicExpressionSet()
    {
        $expected = '2 fields not null.  Need maximum of 1: AlgoWeb\ODataMetadata\MetadataV3\edm\TOperandType';
        $actual = null;

        $if = m::mock(TValueTermReferenceExpressionType::class);
        $if->shouldReceive('isOK')->andReturn(true);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}

        $apply = m::mock(TApplyExpressionType::class);
        $apply->shouldReceive('isOK')->andReturn(true);

        $foo = new TOperandType();
        $foo->setValueTermReference($if);
        $foo->setApply($apply);

        $this->assertFalse($foo->isGExpressionValid($actual));
        $this->assertEquals($expected, $actual);
    }

    public function testSetBadEnum()
    {
        $expected = "Enum must be a valid TQualifiedName";
        $actual = null;

        $foo = new TOperandType();
        try {
            $foo->setEnum(' _ ');
        } catch (\InvalidArgumentException $e) {
            $actual = $e->getMessage();
        }
        $this->assertEquals($expected, $actual);
    }

    public function testSetGetEnumRoundTrip()
    {
        $expected = "Org.OData.Publication.V1.DocumentationUrl";

        $foo = new TOperandType();
        $foo->setEnum($expected);
        $actual = $foo->getEnum();

        $this->assertEquals($expected, $actual);
    }

    public function testSetBadPath()
    {
        $expected = "Path must be a valid TQualifiedName";
        $actual = null;

        $foo = new TOperandType();
        try {
            $foo->setPath(' _ ');
        } catch (\InvalidArgumentException $e) {
            $actual = $e->getMessage();
        }
        $this->assertEquals($expected, $actual);
    }

    public function testSetGetPathRoundTrip()
    {
        $expected = "Org.OData.Publication.V1.DocumentationUrl";

        $foo = new TOperandType();
        $foo->setPath($expected);
        $actual = $foo->getPath();

        $this->assertEquals($expected, $actual);
    }

    public function testSetBadGuid()
    {
        $expected = "Guid must be a valid TGuidLiteral";
        $actual = null;

        $foo = new TOperandType();
        try {
            $foo->setGuid(' _ ');
        } catch (\InvalidArgumentException $e) {
            $actual = $e->getMessage();
        }
        $this->assertEquals($expected, $actual);
    }

    public function testSetGetGuidRoundTrip()
    {
        $expected = "00000000-0000-0000-0000-000000000000";
        $actual = null;
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}

        $foo = new TOperandType();
        $foo->setGuid($expected);
        $actual = $foo->getGuid();
        $this->assertEquals($expected, $actual);
    }
}


Push — master ( a97862...37982b )

TOperandTypeTest D

Complexity

Size/Duplication

Coupling/Cohesion

Importance

43 Methods

How to fix Duplicated Code Complexity

Duplicated Code

Complex Class

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Algo-Web / ODataMetadata

Push — master ( a97862...37982b )

TOperandTypeTest D

Complexity

Size/Duplication

Coupling/Cohesion

Importance

43 Methods

How to fix Duplicated Code Complexity

Duplicated Code

Complex Class

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like