Algo-Web / ODataMetadata

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

    }

    public function testSetGetIfRoundTrip()

    {

        $if = m::mock(TIfExpressionType::class);

        $if->shouldReceive('isOK')->andReturn(true);

        $foo = new TOperandType();

        $foo->setIf($if);

        $result = $foo->getIf();

        $this->assertTrue($result instanceof TIfExpressionType, get_class($result));

        $this->assertTrue($result->isOK());

    }

    public function testSetBadRecord()

    {

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

    }

    public function testSetGetRecordRoundTrip()

    {

        $if = m::mock(TRecordExpressionType::class);

        $if->shouldReceive('isOK')->andReturn(true);

        $foo = new TOperandType();

        $foo->setRecord($if);

        $result = $foo->getRecord();

        $this->assertTrue($result instanceof TRecordExpressionType, get_class($result));

        $this->assertTrue($result->isOK());

    }

    public function testSetBadCollection()

    {

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

    }

    public function testSetGetCollectionRoundTrip()

    {

        $if = m::mock(TCollectionExpressionType::class);

        $if->shouldReceive('isOK')->andReturn(true);

        $foo = new TOperandType();

        $foo->setCollection($if);

        $result = $foo->getCollection();

        $this->assertTrue($result instanceof TCollectionExpressionType, get_class($result));

        $this->assertTrue($result->isOK());

    }

    public function testSetBadTypeAssert()

    {

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

    }

    public function testSetGetTypeAssertRoundTrip()

    {

        $if = m::mock(TTypeAssertExpressionType::class);

        $if->shouldReceive('isOK')->andReturn(true);

        $foo = new TOperandType();

        $foo->setTypeAssert($if);

        $result = $foo->getTypeAssert();

        $this->assertTrue($result instanceof TTypeAssertExpressionType, get_class($result));

        $this->assertTrue($result->isOK());

    }

    public function testSetBadTypeTest()

    {

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

    }

    public function testSetGetTypeTestRoundTrip()

    {

        $if = m::mock(TTypeTestExpressionType::class);

        $if->shouldReceive('isOK')->andReturn(true);

        $foo = new TOperandType();

        $foo->setTypeTest($if);

        $result = $foo->getTypeTest();

        $this->assertTrue($result instanceof TTypeTestExpressionType, get_class($result));

        $this->assertTrue($result->isOK());

    }

    public function testSetBadFunctionReference()

    {

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

    }

    public function testSetGetFunctionReferenceRoundTrip()

    {

        $if = m::mock(TFunctionReferenceExpressionType::class);

        $if->shouldReceive('isOK')->andReturn(true);

        $foo = new TOperandType();

        $foo->setFunctionReference($if);

        $result = $foo->getFunctionReference();

        $this->assertTrue($result instanceof TFunctionReferenceExpressionType, get_class($result));

        $this->assertTrue($result->isOK());

    }

    public function testSetBadEntitySetReference()

    {

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

    }

    public function testSetGetEntitySetReferenceRoundTrip()

    {

        $if = m::mock(TEntitySetReferenceExpressionType::class);

        $if->shouldReceive('isOK')->andReturn(true);

        $foo = new TOperandType();

        $foo->setEntitySetReference($if);

        $result = $foo->getEntitySetReference();

        $this->assertTrue($result instanceof TEntitySetReferenceExpressionType, get_class($result));

        $this->assertTrue($result->isOK());

    }

    public function testSetBadAnonymousFunction()

    {

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

    }

    public function testSetGetAnonymousFunctionRoundTrip()

    {

        $if = m::mock(TAnonymousFunctionExpressionType::class);

        $if->shouldReceive('isOK')->andReturn(true);

        $foo = new TOperandType();

        $foo->setAnonymousFunction($if);

        $result = $foo->getAnonymousFunction();

        $this->assertTrue($result instanceof TAnonymousFunctionExpressionType, get_class($result));

        $this->assertTrue($result->isOK());

    }

    public function testSetBadParameterReference()

    {

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

    }

    public function testSetGetParameterReferenceRoundTrip()

    {

        $if = m::mock(TParameterReferenceExpressionType::class);

        $if->shouldReceive('isOK')->andReturn(true);

        $foo = new TOperandType();

        $foo->setParameterReference($if);

        $result = $foo->getParameterReference();

        $this->assertTrue($result instanceof TParameterReferenceExpressionType, get_class($result));

        $this->assertTrue($result->isOK());

    }

    public function testSetBadApply()

    {

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

    }

    public function testSetGetApplyRoundTrip()

    {

        $if = m::mock(TApplyExpressionType::class);

        $if->shouldReceive('isOK')->andReturn(true);

        $foo = new TOperandType();

        $foo->setApply($if);

        $result = $foo->getApply();

        $this->assertTrue($result instanceof TApplyExpressionType, get_class($result));

        $this->assertTrue($result->isOK());

    }

    public function testSetBadPropertyReference()

    {

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

    }

    public function testSetGetPropertyReferenceRoundTrip()

    {

        $if = m::mock(TPropertyReferenceExpressionType::class);

        $if->shouldReceive('isOK')->andReturn(true);

        $foo = new TOperandType();

        $foo->setPropertyReference($if);

        $result = $foo->getPropertyReference();

        $this->assertTrue($result instanceof TPropertyReferenceExpressionType, get_class($result));

        $this->assertTrue($result->isOK());

    }

    public function testSetBadValueTermReference()

    {

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

    }

    public function testSetGetValueTermReferenceRoundTrip()

    {

        $if = m::mock(TValueTermReferenceExpressionType::class);

        $if->shouldReceive('isOK')->andReturn(true);

        $foo = new TOperandType();

        $foo->setValueTermReference($if);

        $result = $foo->getValueTermReference();

        $this->assertTrue($result instanceof TValueTermReferenceExpressionType, get_class($result));

        $this->assertTrue($result->isOK());

    }

    public function testGExpressionNotValidWhenMoreThanOneBasicExpressionSet()

    {