[aaf-commits] AAF/Utilities/AAFAnalyzer/EditProtocolTestImpl EPNameTest.h,NONE,1.1 EPNamedVisitor.cp

SourceForge Headquarters 225 Broadway Suite 1600 San Diego, CA 92101 +1 (858) 454-5900

Update of /cvsroot/aaf/AAF/Utilities/AAFAnalyzer/EditProtocolTestImpl
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv24816/EditProtocolTestImpl

Modified Files:
	EPMobDepPhase.cpp EPMobDepPhase.h 
Added Files:
	EPNameTest.h EPNamedVisitor.cpp EPNameTest.cpp EPNameVisitor.h 
Log Message:
Added Edit Protocol Naming Test

--- NEW FILE: EPNameTest.h ---
//=---------------------------------------------------------------------=
//
// $Id$
//
// The contents of this file are subject to the AAF SDK Public
// Source License Agreement (the "License"); You may not use this file
// except in compliance with the License.  The License is available in
// AAFSDKPSL.TXT, or you may obtain a copy of the License from the AAF
// Association or its successor.
//
// Software distributed under the License is distributed on an "AS IS"
// basis, WITHOUT WARRANTY OF ANY KIND, either express or implied.  See
// the License for the specific language governing rights and limitations
// under the License.
//
// The Original Code of this file is Copyright 1998-2004, Licensor of the
// AAF Association.
//
//=---------------------------------------------------------------------=

#ifndef __EPNameTest_h_
#define __EPNameTest_h_

//Test/Result files
#include <Test.h>

//Ax files
#include <AxTypes.h>

namespace aafanalyzer {

class TestLevelTestResult;

using namespace boost;

class EPNameTest : public Test
{
 public:

  EPNameTest( wostream& log,
            shared_ptr<const TestGraph> spGraph );
  virtual ~EPNameTest();

  virtual shared_ptr<TestLevelTestResult> Execute();
  virtual AxString GetName() const;
  virtual AxString GetDescription() const;
  static const TestInfo GetTestInfo();

 private:

  // prohibited
  EPNameTest();
  EPNameTest( const EPNameTest& );
  EPNameTest& operator=( const EPNameTest& );

};

} // end of namespace diskstream

#endif /*__EPNameTest_h_*/

--- NEW FILE: EPNameTest.cpp ---
//=---------------------------------------------------------------------=
//
// $Id$
//
// The contents of this file are subject to the AAF SDK Public
// Source License Agreement (the "License"); You may not use this file
// except in compliance with the License.  The License is available in
// AAFSDKPSL.TXT, or you may obtain a copy of the License from the AAF
// Association or its successor.
//
// Software distributed under the License is distributed on an "AS IS"
// basis, WITHOUT WARRANTY OF ANY KIND, either express or implied.  See
// the License for the specific language governing rights and limitations
// under the License.
//
// The Original Code of this file is Copyright 1998-2004, Licensor of the
// AAF Association.
//
//=---------------------------------------------------------------------=

//Edit Protocol Test files
#include "EPNameTest.h"
#include "EPNameVisitor.h"

//Test/Result files
#include <TestLevelTestResult.h>
#include <DetailLevelTestResult.h>

//AAF Analyzer Base files
#include <TestGraph.h>

//Requirement files
#include <Requirement.h>

//Analyzer Base files
#include <DepthFirstTraversal.h>

//STL files
#include <vector>

namespace {

const wchar_t* TEST_NAME = L"Edit Protocol Naming Test";
const wchar_t* TEST_DESC = L"Verify the correctness of mob names.";

} // end of namespace

//======================================================================

namespace aafanalyzer {

using namespace std;

EPNameTest::EPNameTest( wostream& log,
                    shared_ptr<const TestGraph> spGraph )
  : Test( log, GetTestInfo() )
{
    SetTestGraph(spGraph);
}

EPNameTest::~EPNameTest()
{}

shared_ptr<TestLevelTestResult> EPNameTest::Execute()
{
    
    shared_ptr<EPNameVisitor> spVisitor(new EPNameVisitor( GetOutStream() ) );

    DepthFirstTraversal dfs(GetTestGraph()->GetEdgeMap(), GetTestGraph()->GetRootNode());
    
    const shared_ptr<const Test> me = this->shared_from_this();
    Requirement::RequirementMapSP spMyReqs(new Requirement::RequirementMap(this->GetCoveredRequirements()));
    shared_ptr<TestLevelTestResult> spResult( new TestLevelTestResult(TEST_NAME,
                                 TEST_DESC,
                                 L"-", // explain
                                 L"-",  // DOCREF REQUIRED
                                 TestResult::PASS,
                                 me, 
                                 spMyReqs ) );

    dfs.TraverseDown( spVisitor, GetTestGraph()->GetRootNode() );
    spVisitor->CheckForUniqueNames();  

    spResult->AppendSubtestResult( spVisitor->GetResult() );

    spResult->SetResult( spResult->GetAggregateResult() );
    if ( spResult->GetResult() == TestResult::FAIL )
    {
        spResult->SetExplanation(L"Test Failed - See \"Edit Protocol Naming Visitor\" Visitor for details");
    }
    
    //Update the requirement status based upon the status of the requirements in
    //the visitor.
    for (int reqLevel = TestResult::PASS; reqLevel <= TestResult::FAIL; reqLevel++)
    {
      Requirement::RequirementMap childReqs = spVisitor->GetResult()->GetRequirements( (TestResult::Result)reqLevel );
      Requirement::RequirementMap::const_iterator iter;
      for( iter = childReqs.begin(); iter != childReqs.end(); ++iter )
      {
        spResult->SetRequirementStatus( (TestResult::Result)reqLevel, iter->second );
      }
    }

    return spResult;

}

AxString EPNameTest::GetName() const
{
  return TEST_NAME;
}

AxString EPNameTest::GetDescription() const
{
  return TEST_DESC;
}

const TestInfo EPNameTest::GetTestInfo()
{
    shared_ptr<vector<AxString> > spReqIds(new vector<AxString>);
    spReqIds->push_back(L"REQ_EP_027");     //Top-Level Composition
    spReqIds->push_back(L"REQ_EP_032");     //Lower-Level Composition
    spReqIds->push_back(L"REQ_EP_038");     //Sub-Clip Composition
    spReqIds->push_back(L"REQ_EP_047");     //Adjusted Clip Composition
    spReqIds->push_back(L"REQ_EP_052");     //Template Clip
    spReqIds->push_back(L"REQ_EP_057");     //Clip
    spReqIds->push_back(L"REQ_EP_073");     //Recording Source
    spReqIds->push_back(L"REQ_EP_081");     //Tape Source
    spReqIds->push_back(L"REQ_EP_086");     //Film Source
    return TestInfo(L"EPNameTest", spReqIds);
}

} // end of namespace aafanalyzer

--- NEW FILE: EPNameVisitor.h ---
//=---------------------------------------------------------------------=
//
// $Id$
//
// The contents of this file are subject to the AAF SDK Public
// Source License Agreement (the "License"); You may not use this file
// except in compliance with the License.  The License is available in
// AAFSDKPSL.TXT, or you may obtain a copy of the License from the AAF
// Association or its successor.
//
// Software distributed under the License is distributed on an "AS IS"
// basis, WITHOUT WARRANTY OF ANY KIND, either express or implied.  See
// the License for the specific language governing rights and limitations
// under the License.
//
// The Original Code of this file is Copyright 1998-2004, Licensor of the
// AAF Association.
//
//=---------------------------------------------------------------------=

#ifndef __EPNameVisitor_h_
#define __EPNameVisitor_h_

//Edit Protocol Analyzer Base files
#include <EPTypedVisitor.h>
#include <EPTypedObjNode.h>

//Ax files
#include <AxMob.h>

//STL files
#include <map>
#include <set>

namespace aafanalyzer {

class DetailLevelTestResult;

using namespace boost;
using namespace std;

class EPNameVisitor : public EPTypedVisitor
{

  public:
  
    EPNameVisitor( wostream& log );

    virtual ~EPNameVisitor();

    virtual bool PreOrderVisit( EPTypedObjNode<IAAFCompositionMob, EPTopLevelComposition>& node ); 
    virtual bool PreOrderVisit( EPTypedObjNode<IAAFCompositionMob, EPLowerLevelComposition>& node );
    virtual bool PreOrderVisit( EPTypedObjNode<IAAFCompositionMob, EPSubClipComposition>& node );
    virtual bool PreOrderVisit( EPTypedObjNode<IAAFCompositionMob, EPAdjustedClipComposition>& node );
    virtual bool PreOrderVisit( EPTypedObjNode<IAAFMasterMob, EPTemplateClip>& node );
    virtual bool PreOrderVisit( EPTypedObjNode<IAAFMasterMob, EPClip>& node );
    virtual bool PreOrderVisit( EPTypedObjNode<IAAFSourceMob, EPRecordingSource>& node );
    virtual bool PreOrderVisit( EPTypedObjNode<IAAFSourceMob, EPTapeSource>& node );
    virtual bool PreOrderVisit( EPTypedObjNode<IAAFSourceMob, EPFilmSource>& node );
       
    virtual bool EdgeVisit(AAFComponentReference& edge);
    virtual bool EdgeVisit(AAFSlotReference& edge);
    
    shared_ptr<DetailLevelTestResult> GetResult();
    
    void CheckForUniqueNames();

  private:
  
    typedef map<AxString, unsigned int> NameMap;
    typedef set<AxString> NameSet;
  
    wostream& _log;
    shared_ptr<DetailLevelTestResult> _spResult;
    NameMap _compositionNames;
    NameSet _topLevelNames;
    NameSet _lowerLevelNames;
    
    bool VisitComposition( const AxString& type, const AxString& reqId, AxCompositionMob& axCompMob );
    bool VisitNonComposition( const AxString& type, const AxString& reqId, AxMob& axMob );
    shared_ptr<DetailLevelTestResult> InitializeResult();
    void CheckForUniqueNames( NameSet& names, const AxString& reqId, const AxString& type );

    // prohibited
    EPNameVisitor();
    EPNameVisitor( const EPNameVisitor& );
    EPNameVisitor& operator=( const EPNameVisitor& );
  
};

} // end of namespace diskstream

#endif /*__EPNameVisitor_h_*/

Index: EPMobDepPhase.cpp
===================================================================
RCS file: /cvsroot/aaf/AAF/Utilities/AAFAnalyzer/EditProtocolTestImpl/EPMobDepPhase.cpp,v
retrieving revision 1.6
retrieving revision 1.7
diff -C2 -d -r1.6 -r1.7
*** EPMobDepPhase.cpp	13 Oct 2005 19:33:58 -0000	1.6
--- EPMobDepPhase.cpp	19 Oct 2005 21:01:36 -0000	1.7
***************
*** 99,102 ****
--- 99,106 ----
    shared_ptr<EPDerivationTest> derivationTest( new EPDerivationTest(_log, _spGraph, spRootNodes) );
    spPhaseResult->AppendSubtestResult( derivationTest->Execute() );
+   
+   // Fourth, run the naming test
+   shared_ptr<EPNameTest> nameTest( new EPNameTest( _log, _spGraph ) );
+   spPhaseResult->AppendSubtestResult( nameTest->Execute() );
  
    spPhaseResult->SetResult( spPhaseResult->GetAggregateResult() );

Index: EPMobDepPhase.h
===================================================================
RCS file: /cvsroot/aaf/AAF/Utilities/AAFAnalyzer/EditProtocolTestImpl/EPMobDepPhase.h,v
retrieving revision 1.3
retrieving revision 1.4
diff -C2 -d -r1.3 -r1.4
*** EPMobDepPhase.h	13 Oct 2005 19:33:58 -0000	1.3
--- EPMobDepPhase.h	19 Oct 2005 21:01:36 -0000	1.4
***************
*** 27,30 ****
--- 27,31 ----
  #include <CompMobDependency.h>
  #include <EPDerivationTest.h>
+ #include <EPNameTest.h>
  
  //Test/Result files

--- NEW FILE: EPNamedVisitor.cpp ---
//=---------------------------------------------------------------------=
//
// $Id$
//
// The contents of this file are subject to the AAF SDK Public
// Source License Agreement (the "License"); You may not use this file
// except in compliance with the License.  The License is available in
// AAFSDKPSL.TXT, or you may obtain a copy of the License from the AAF
// Association or its successor.
//
// Software distributed under the License is distributed on an "AS IS"
// basis, WITHOUT WARRANTY OF ANY KIND, either express or implied.  See
// the License for the specific language governing rights and limitations
// under the License.
//
// The Original Code of this file is Copyright 1998-2004, Licensor of the
// AAF Association.
//
//=---------------------------------------------------------------------=

//Edit Protocol Test files
#include "EPNameVisitor.h"
#include "EPNameTest.h"

//Test/Result files
#include <DetailLevelTestResult.h>
#include <TestRegistry.h>

//Requirement files
#include <RequirementRegistry.h>
#include <Requirement.h>

//Ax files
#include <AxUtil.h>

//AAF files
#include <AAFResult.h>

namespace {

} // end of namespace

//======================================================================

namespace aafanalyzer {

using namespace boost;

EPNameVisitor::EPNameVisitor( wostream& log )
    : EPTypedVisitor(),
      _log( log ),
      _spResult( this->InitializeResult()  )
{}

EPNameVisitor::~EPNameVisitor()
{}

bool EPNameVisitor::PreOrderVisit( EPTypedObjNode<IAAFCompositionMob, EPTopLevelComposition>& node )
{
    AxCompositionMob axCompMob( node.GetAAFObjectOfType() );
    if ( !this->VisitComposition( L"Top-Level Composition", L"REQ_EP_027", axCompMob ) )
    {
        return false;
    }
    _topLevelNames.insert( axCompMob.GetName() );
    return true;
}

bool EPNameVisitor::PreOrderVisit( EPTypedObjNode<IAAFCompositionMob, EPLowerLevelComposition>& node )
{
    AxCompositionMob axCompMob( node.GetAAFObjectOfType() );
    if ( !this->VisitComposition( L"Lower-Level Composition", L"REQ_EP_032", axCompMob ) )
    {
        return false;
    }
    _lowerLevelNames.insert( axCompMob.GetName() );
    return true;
}

bool EPNameVisitor::PreOrderVisit( EPTypedObjNode<IAAFCompositionMob, EPSubClipComposition>& node )
{
    AxCompositionMob axCompMob( node.GetAAFObjectOfType() );
    return this->VisitComposition( L"Sub-Clip Composition", L"REQ_EP_038", axCompMob );
}

bool EPNameVisitor::PreOrderVisit( EPTypedObjNode<IAAFCompositionMob, EPAdjustedClipComposition>& node )
{
    AxCompositionMob axCompMob( node.GetAAFObjectOfType() );
    return this->VisitComposition( L"Adjusted Clip Composition", L"REQ_EP_047", axCompMob );
}

bool EPNameVisitor::PreOrderVisit( EPTypedObjNode<IAAFMasterMob, EPTemplateClip>& node )
{
    AxMasterMob axMastMob( node.GetAAFObjectOfType() );
    return this->VisitNonComposition( L"Template Clip", L"REQ_EP_052", axMastMob );
}

bool EPNameVisitor::PreOrderVisit( EPTypedObjNode<IAAFMasterMob, EPClip>& node )
{
    AxMasterMob axMastMob( node.GetAAFObjectOfType() );
    return this->VisitNonComposition( L"Clip", L"REQ_EP_057", axMastMob );
}

bool EPNameVisitor::PreOrderVisit( EPTypedObjNode<IAAFSourceMob, EPRecordingSource>& node )
{
    AxSourceMob axSrcMob( node.GetAAFObjectOfType() );
    return this->VisitNonComposition( L"Recording Source", L"REQ_EP_073", axSrcMob );
}

bool EPNameVisitor::PreOrderVisit( EPTypedObjNode<IAAFSourceMob, EPTapeSource>& node )
{
    AxSourceMob axSrcMob( node.GetAAFObjectOfType() );
    return this->VisitNonComposition( L"Tape Source", L"REQ_EP_081", axSrcMob );
}

bool EPNameVisitor::PreOrderVisit( EPTypedObjNode<IAAFSourceMob, EPFilmSource>& node )
{
    AxSourceMob axSrcMob( node.GetAAFObjectOfType() );
    return this->VisitNonComposition( L"Film Source", L"REQ_EP_086", axSrcMob );
}

bool EPNameVisitor::EdgeVisit(AAFComponentReference& edge)
{
    return false;
}

bool EPNameVisitor::EdgeVisit(AAFSlotReference& edge)
{
    return false;
}
    
shared_ptr<DetailLevelTestResult> EPNameVisitor::GetResult()
{
    return _spResult;
}

bool EPNameVisitor::VisitComposition( const AxString& type, const AxString& reqId, AxCompositionMob& axCompMob )
{
    AxString nodeName;

    try
    {
        nodeName = axCompMob.GetName();
    }
    catch ( const AxExHResult& ex )
    {
        if ( ex.getHResult() == AAFRESULT_PROP_NOT_PRESENT )
        {
            
            shared_ptr<const Requirement> failingReq = RequirementRegistry::GetInstance().GetRequirement( reqId );
            Requirement::RequirementMapSP reqMapSP(new Requirement::RequirementMap);
            (*reqMapSP)[reqId] = failingReq;
            
            AxString explain( type + L" does not have a valid name." );
            shared_ptr<DetailLevelTestResult> spFailure( new DetailLevelTestResult( _spResult->GetName(),
                                        L"-", // desc
                                        explain,
                                        L"-", // docref
                                        TestResult::FAIL,
                                        reqMapSP ) );
            spFailure->AddDetail( L"Mob ID: " + AxStringUtil::mobid2Str( axCompMob.GetMobID() ) );
            spFailure->SetRequirementStatus( TestResult::FAIL, failingReq );
            
            _spResult->AppendSubtestResult( spFailure );
            _spResult->SetResult( _spResult->GetAggregateResult() );
            _spResult->SetRequirementStatus( TestResult::FAIL, failingReq );
            
            return false;
        }
        else
        {
            throw ex;
        }
    }
    
    if ( _compositionNames.find( nodeName ) != _compositionNames.end() )
    {
        _compositionNames[nodeName] = _compositionNames[nodeName] + 1;
    }
    else
    {
        _compositionNames[nodeName] = 1;
    }
    
    return true;
    
}

bool EPNameVisitor::VisitNonComposition( const AxString& type, const AxString& reqId, AxMob& axMob )
{
    AxString nodeName;

    try
    {
        nodeName = axMob.GetName();
    }
    catch ( const AxExHResult& ex )
    {
        if ( ex.getHResult() == AAFRESULT_PROP_NOT_PRESENT )
        {
            
            shared_ptr<const Requirement> failingReq = RequirementRegistry::GetInstance().GetRequirement( reqId );
            Requirement::RequirementMapSP reqMapSP(new Requirement::RequirementMap);
            (*reqMapSP)[reqId] = failingReq;
            
            AxString explain( type + L" does not have a valid name." );
            shared_ptr<DetailLevelTestResult> spFailure( new DetailLevelTestResult( _spResult->GetName(),
                                        L"-", // desc
                                        explain,
                                        L"-", // docref
                                        TestResult::FAIL,
                                        reqMapSP ) );
            spFailure->AddDetail( L"Mob ID: " + AxStringUtil::mobid2Str( axMob.GetMobID() ) );
            spFailure->SetRequirementStatus( TestResult::FAIL, failingReq );
            
            _spResult->AppendSubtestResult( spFailure );
            _spResult->SetResult( _spResult->GetAggregateResult() );
            _spResult->SetRequirementStatus( TestResult::FAIL, failingReq );
            
            return false;
            
        }
        else
        {
            throw ex;
        }
    }
    
    return true;
}

void EPNameVisitor::CheckForUniqueNames()
{
    this->CheckForUniqueNames( _topLevelNames, L"REQ_EP_027", L"Top-Level Composition" );
    this->CheckForUniqueNames( _lowerLevelNames, L"REQ_EP_032", L"Lower-Level Composition" );
}

void EPNameVisitor::CheckForUniqueNames( NameSet& names, const AxString& reqId, const AxString& type )
{
    
    NameSet::const_iterator iter;

    for ( iter = names.begin(); iter != names.end(); iter++ )
    {

        if ( _compositionNames[*iter] != 1 )
        {
           
            shared_ptr<const Requirement> failingReq = RequirementRegistry::GetInstance().GetRequirement( reqId );
            Requirement::RequirementMapSP reqMapSP(new Requirement::RequirementMap);
            (*reqMapSP)[reqId] = failingReq;
                
            AxString explain( type + L" \"" + *iter + L"\" does not have a unique composition name." );
            shared_ptr<DetailLevelTestResult> spFailure( new DetailLevelTestResult( _spResult->GetName(),
                                        L"-", // desc
                                        explain,
                                        L"-", // docref
                                        TestResult::FAIL,
                                        reqMapSP ) );
            spFailure->SetRequirementStatus( TestResult::FAIL, failingReq );
                
            _spResult->AppendSubtestResult( spFailure );
            _spResult->SetResult( _spResult->GetAggregateResult() );
            _spResult->SetRequirementStatus( TestResult::FAIL, failingReq );
                       
        }
    }
}

shared_ptr<DetailLevelTestResult> EPNameVisitor::InitializeResult()
{
    
    shared_ptr<const Requirement::RequirementMap> spConstReqs = TestRegistry::GetInstance().GetRequirementsForTest( EPNameTest::GetTestInfo().GetName() );
    Requirement::RequirementMapSP spReqs( new Requirement::RequirementMap( *spConstReqs) );
    
    shared_ptr<DetailLevelTestResult> retVal(   
        new DetailLevelTestResult( L"Edit Protocol Naming Visitor",
                                   L"Visit derivation chain mobs and verify they have valid names.",
                                   L"", // explain
                                   L"", // DOCREF REQUIRED
                                   TestResult::PASS,
                                   spReqs
                                 ) );

    return retVal;
    
}

} // end of namespace aafanalyzer

[aaf-commits] AAF/Utilities/AAFAnalyzer/EditProtocolTestImpl EPNameTest.h,NONE,1.1 EPNamedVisitor.cp

[aaf-commits] AAF/Utilities/AAFAnalyzer/EditProtocolTestImpl EPNameTest.h,NONE,1.1 EPNamedVisitor.cpp,NONE,1.1 EPNameTest.cpp,NONE,1.1 EPNameVisitor.h,NONE,1.1 EPMobDepPhase.cpp,1.6,1.7 EPMobDepPhase.h,1.3,1.4