Algo-Web / ODataMetadata

        $this->assertEquals(0, count($foo->getReturnType()));

    }

    public function testSetReturnTypeBadData()

    {

        $expected = "";

        $actual = null;

        $entitySet = m::mock(TFunctionImportReturnTypeType::class)->makePartial();

        $entitySet->shouldReceive('isOK')->andReturn(false)->once();

        $foo = new FunctionImportAnonymousType();

        try {

            $foo->setReturnType([$entitySet]);

        } catch (\InvalidArgumentException $e) {

            $actual = $e->getMessage();

        }

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

    }

    public function testSetNameBadData()

    {

        $this->assertFalse($foo->issetOnDelete(1));

    }

    public function testSetOnDeleteBadItem()

    {

        $expected = "";

        $actual = null;

        $foo = new TAssociationEndType();

        $onDelete = m::mock(TOnActionType::class)->makePartial();

        $onDelete->shouldReceive('isOK')->andReturn(false)->once();

        $delete = [$onDelete];

        try {

            $foo->setOnDelete($delete);

        } catch (\InvalidArgumentException $e) {

            $actual = $e->getMessage();

        }

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

    }

    public function testIsTOperationsOKBadData()

    {

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

    }

    public function testIsTOperationsOKBadData()

    {

        $expected = "";

        $actual = null;

        $foo = new TAssociationEndType();

        $onDelete = m::mock(TOnActionType::class)->makePartial();

        $onDelete->shouldReceive('isOK')->andReturn(true, false)->twice();

        $delete = [$onDelete];

        $foo->setOnDelete($delete);

        $this->assertFalse($foo->isTOperationsOK($actual));

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

    }

}

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

    }

    public function testIsExtensibilityElementOKNoGoodnik()

    {

        $expected = "";

        $actual = null;

        $foo = new TEnumTypeMemberType();

        $documentation = m::mock(TDocumentationType::class);

        $documentation->shouldReceive('isOK')->andReturn(true, false)->twice();

        $foo->setDocumentation($documentation);

        $this->assertFalse($foo->isExtensibilityElementOK($actual));

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

    }

}

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

    }

    public function testTryToAddBadSchema()

    {

        $expected = "";

        $actual = null;

        $schema = m::mock(Schema::class);

        $schema->shouldReceive('isOK')->andReturn(false)->once();

        $foo = new TDataServicesType();

        try {

            $foo->addToSchema($schema);

        } catch (\InvalidArgumentException $e) {

            $actual = $e->getMessage();

        }

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

    }

    public function testCheckSchemaExists()

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

    }

    public function testIsOKWhenSchemaNotOk()

    {

        $expected = "";

        $actual = null;

        $schema = m::mock(Schema::class);

        $schema->shouldReceive('isOK')->andReturn(true, false)->twice();

        $foo = new TDataServicesType();

        $foo->addToSchema($schema);

        $this->assertFalse($foo->isOK($actual));

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

    }

}

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

    }

    public function testSetDataServiceTypeNotOK()

    {

        $dataServiceType = m::mock(TDataServicesType::class);

        $dataServiceType->shouldReceive('isOK')->andReturn(false)->once();

        $foo = new TEdmxType();

        $expected = "";

        $actual = null;

        try {

            $foo->setDataServiceType($dataServiceType);

        } catch (\InvalidArgumentException $e) {

            $actual = $e->getMessage();

        }

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

    }

    public function testSetDesignerTypeNotOK()

    {

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

    }

    public function testSetDesignerTypeNotOK()

    {

        $designer = m::mock(TDesignerType::class);

        $designer->shouldReceive('isOK')->andReturn(false)->once();

        $foo = new TEdmxType();

        $expected = "";

        $actual = null;

        try {

            $foo->setDesigner($designer);

        } catch (\InvalidArgumentException $e) {

            $actual = $e->getMessage();

        }

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

    }

    public function testSetDesignerTypeOK()

    {

        $this->assertTrue($foo->getDesigner()->isOK());

    }

    public function testSetRuntimeNotOK()

    {

        $runtime = m::mock(TRuntimeType::class);

        $runtime->shouldReceive('isOK')->andReturn(false)->once();

        $foo = new TEdmxType();

        $expected = "";

        $actual = null;

        try {

            $foo->setRuntime($runtime);

        } catch (\InvalidArgumentException $e) {

            $actual = $e->getMessage();

        }

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

    }

    public function testSetRuntimeOK()

    {

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

    }

    public function testIsObjectWithBadDataServiceOK()

    {

        $unwanted2 = "Version cannot be null or empty";

        $actual = null;

        $dataServiceType = m::mock(TDataServicesType::class);

        $dataServiceType->shouldReceive('isOK')->andReturn(true, false)->twice();

        $foo = new TEdmxType();

        $foo->setVersion("1.5");

        $foo->setDataServiceType($dataServiceType);

        $this->assertFalse($foo->isOK($actual));

        $this->assertNotEquals($unwanted2, $actual);

    }

    public function testIsObjectWithBadDesignerServiceOK()