diff options
Diffstat (limited to 'qa/libcmis-c/test-dummies.cxx')
| -rw-r--r-- | qa/libcmis-c/test-dummies.cxx | 633 |
1 files changed, 633 insertions, 0 deletions
diff --git a/qa/libcmis-c/test-dummies.cxx b/qa/libcmis-c/test-dummies.cxx new file mode 100644 index 0000000..5056bcf --- /dev/null +++ b/qa/libcmis-c/test-dummies.cxx @@ -0,0 +1,633 @@ +/* libcmis + * Version: MPL 1.1 / GPLv2+ / LGPLv2+ + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License or as specified alternatively below. You may obtain a copy of + * the License at http://www.mozilla.org/MPL/ + * + * 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. + * + * Major Contributor(s): + * Copyright (C) 2011 SUSE <cbosdonnat@suse.com> + * + * + * All Rights Reserved. + * + * For minor contributions see the git repository. + * + * Alternatively, the contents of this file may be used under the terms of + * either the GNU General Public License Version 2 or later (the "GPLv2+"), or + * the GNU Lesser General Public License Version 2 or later (the "LGPLv2+"), + * in which case the provisions of the GPLv2+ or the LGPLv2+ are applicable + * instead of those above. + */ + +#include "test-dummies.hxx" + +using namespace std; +using libcmis::PropertyPtrMap; + +bool isOutOfMemory = false; + +/// Ignore all tests results depending on this when running in valgrind +void * operator new ( size_t requestedSize ) +{ + if ( isOutOfMemory ) + { + throw bad_alloc( ); + } + + return malloc( requestedSize ); +} + +void operator delete ( void* ptr ) throw ( ) +{ + free( ptr ); +} + +#if __cplusplus > 201103L +void operator delete ( void* ptr, std::size_t ) throw ( ) +{ + free( ptr ); +} +#endif + +namespace dummies +{ + Session::Session( ) + { + } + + Session::~Session( ) + { + } + + libcmis::RepositoryPtr Session::getRepository( ) + { + libcmis::RepositoryPtr repo( new Repository( ) ); + return repo; + } + + + bool Session::setRepository( std::string ) + { + return true; + } + + vector< libcmis::RepositoryPtr > Session::getRepositories( ) + { + vector< libcmis::RepositoryPtr > repos; + libcmis::RepositoryPtr repo1( new Repository( ) ); + libcmis::RepositoryPtr repo2( new Repository( ) ); + repos.push_back( repo1 ); + repos.push_back( repo2 ); + return repos; + } + + libcmis::FolderPtr Session::getRootFolder() + { + libcmis::FolderPtr root( new Folder( true, false ) ); + return root; + } + + libcmis::ObjectPtr Session::getObject( string id ) + { + return getFolder( id ); + } + + libcmis::ObjectPtr Session::getObjectByPath( string path ) + { + return getFolder( path ); + } + + libcmis::FolderPtr Session::getFolder( string ) + { + libcmis::FolderPtr result( new Folder( false, false ) ); + return result; + } + + libcmis::ObjectTypePtr Session::getType( string ) + { + libcmis::ObjectTypePtr type( new ObjectType( true, false ) ); + return type; + } + + vector< libcmis::ObjectTypePtr > Session::getBaseTypes( ) + { + vector< libcmis::ObjectTypePtr > types; + libcmis::ObjectTypePtr type( new ObjectType( true, false ) ); + types.push_back( type ); + return types; + } + + std::string Session::getRefreshToken( ) + { + return string( ); + } + + Repository::Repository( ) : + libcmis::Repository( ) + { + m_id = string( "Repository::Id" ); + m_name = string( "Repository::Name" ); + m_description = string( "Repository::Description" ); + m_vendorName = string( "Repository::VendorName" ); + m_productName = string( "Repository::ProductName" ); + m_productVersion = string( "Repository::ProductVersion" ); + m_rootId = string( "Repository::RootId" ); + m_cmisVersionSupported = string( "Repository::CmisVersionSupported" ); + m_thinClientUri.reset( new string( "Repository::ThinClientUri" ) ); + m_principalAnonymous.reset( new string( "Repository::PrincipalAnonymous" ) ); + m_principalAnyone.reset( new string( "Repository::PrincipalAnyone" ) ); + } + + Repository::~Repository( ) + { + } + + PropertyType::PropertyType( string id, string xmlType ) : + libcmis::PropertyType( ) + { + setId( id ); + setLocalName( string( "PropertyType::LocalName" ) ); + setLocalNamespace( string( "PropertyType::LocalNamespace" ) ); + setDisplayName( string( "PropertyType::DisplayName" ) ); + setQueryName( string( "PropertyType::QueryName" ) ); + setTypeFromXml( xmlType ); + + // Setting true for the tests to see a difference with + // the default false result of the tested functions + setMultiValued( true ); + setUpdatable( true ); + setInherited( true ); + setRequired( true ); + setQueryable( true ); + setOrderable( true ); + setOpenChoice( true ); + } + + PropertyType::~PropertyType( ) + { + } + + AllowableActions::AllowableActions( ) : + libcmis::AllowableActions( ) + { + m_states.insert( pair< libcmis::ObjectAction::Type, bool >( libcmis::ObjectAction::GetProperties, true ) ); + m_states.insert( pair< libcmis::ObjectAction::Type, bool >( libcmis::ObjectAction::GetFolderParent, false ) ); + } + + AllowableActions::~AllowableActions( ) + { + } + + ObjectType::ObjectType( ) : + libcmis::ObjectType( ), + m_typeId( ), + m_childrenIds( ), + m_triggersFaults( false ) + { + } + + ObjectType::ObjectType( bool rootType, bool triggersFaults ) : + libcmis::ObjectType( ), + m_typeId( ), + m_childrenIds( ), + m_triggersFaults( triggersFaults ) + { + if ( rootType ) + m_typeId = "RootType"; + else + { + m_typeId = "ObjectType"; + m_parentTypeId = "ParentType"; + m_childrenIds.push_back( "ChildType1" ); + m_childrenIds.push_back( "ChildType2" ); + } + + m_baseTypeId = "RootType"; + libcmis::PropertyTypePtr propType1( new PropertyType( "Property1", "string" ) ); + m_propertiesTypes.insert( pair< string, libcmis::PropertyTypePtr >( propType1->getId( ), propType1 ) ); + libcmis::PropertyTypePtr propType2( new PropertyType( "Property2", "string" ) ); + m_propertiesTypes.insert( pair< string, libcmis::PropertyTypePtr >( propType2->getId( ), propType2 ) ); + libcmis::PropertyTypePtr propType3( new PropertyType( "Property3", "string" ) ); + m_propertiesTypes.insert( pair< string, libcmis::PropertyTypePtr >( propType3->getId( ), propType3 ) ); + + initMembers( ); + } + + void ObjectType::initMembers( ) + { + + m_id = m_typeId + "::Id"; + m_localName = m_typeId + "::LocalName"; + m_localNamespace = m_typeId + "::LocalNamespace"; + m_displayName = m_typeId + "::DisplayName"; + m_queryName = m_typeId + "::QueryName"; + m_description = m_typeId + "::Description"; + + m_creatable = true; + m_fileable = true; + m_queryable = true; + m_fulltextIndexed = true; + m_includedInSupertypeQuery = true; + m_controllablePolicy = true; + m_controllableAcl = true; + m_versionable = true; + m_contentStreamAllowed = libcmis::ObjectType::Allowed; + } + + ObjectType::~ObjectType( ) + { + } + + libcmis::ObjectTypePtr ObjectType::getParentType( ) + { + if ( m_triggersFaults ) + throw libcmis::Exception( "Fault triggered" ); + + ObjectType* parent = NULL; + if ( !m_parentTypeId.empty( ) ) + { + parent = new ObjectType( ); + parent->m_typeId = m_parentTypeId; + parent->m_parentTypeId = m_baseTypeId; + parent->m_baseTypeId = m_baseTypeId; + parent->m_childrenIds.push_back( m_id ); + parent->m_triggersFaults = m_triggersFaults; + parent->m_propertiesTypes = m_propertiesTypes; + + parent->initMembers( ); + } + + libcmis::ObjectTypePtr result( parent ); + return result; + } + + libcmis::ObjectTypePtr ObjectType::getBaseType( ) + { + if ( m_triggersFaults ) + throw libcmis::Exception( "Fault triggered" ); + + ObjectType* base = this; + if ( m_typeId != m_baseTypeId ) + { + base = new ObjectType( ); + base->m_typeId = m_baseTypeId; + base->m_baseTypeId = m_baseTypeId; + base->m_childrenIds.push_back( m_id ); + base->m_triggersFaults = m_triggersFaults; + base->m_propertiesTypes = m_propertiesTypes; + + base->initMembers( ); + } + + libcmis::ObjectTypePtr result( base ); + return result; + } + + vector< libcmis::ObjectTypePtr > ObjectType::getChildren( ) + { + if ( m_triggersFaults ) + throw libcmis::Exception( "Fault triggered" ); + + vector< libcmis::ObjectTypePtr > children; + + for ( vector< string >::iterator it = m_childrenIds.begin( ); it != m_childrenIds.end( ); ++it ) + { + ObjectType* child = new ObjectType( ); + child->m_typeId = *it; + child->m_parentTypeId = m_typeId; + child->m_baseTypeId = m_baseTypeId; + child->m_triggersFaults = m_triggersFaults; + child->m_propertiesTypes = m_propertiesTypes; + + child->initMembers( ); + + libcmis::ObjectTypePtr result( child ); + children.push_back( result ); + } + + return children; + } + + string ObjectType::toString( ) + { + return m_typeId + "::toString"; + } + + Object::Object( bool triggersFaults, string type ): + libcmis::Object( NULL ), + m_type( type ), + m_triggersFaults( triggersFaults ) + { + libcmis::PropertyTypePtr propertyType( new PropertyType( "Property1", "string" ) ); + vector< string > values; + values.push_back( "Value1" ); + libcmis::PropertyPtr property( new libcmis::Property( propertyType, values ) ); + m_properties.insert( pair< string, libcmis::PropertyPtr >( propertyType->getId( ), property ) ); + } + + string Object::getId( ) + { + return m_type + "::Id"; + } + + string Object::getName( ) + { + return m_type + "::Name"; + } + + vector< string > Object::getPaths( ) + { + vector< string > paths; + paths.push_back( string( "/Path1/" ) ); + paths.push_back( string( "/Path2/" ) ); + + return paths; + } + + string Object::getBaseType( ) + { + return m_type + "::BaseType"; + } + + string Object::getType( ) + { + return m_type + "::Type"; + } + + boost::posix_time::ptime Object::getCreationDate( ) + { + boost::posix_time::ptime now( boost::posix_time::second_clock::local_time( ) ); + return now; + } + + boost::posix_time::ptime Object::getLastModificationDate( ) + { + boost::posix_time::ptime now( boost::posix_time::second_clock::local_time( ) ); + return now; + } + + libcmis::ObjectPtr Object::updateProperties( + const PropertyPtrMap& ) + { + if ( m_triggersFaults ) + throw libcmis::Exception( "Fault triggered" ); + + time( &m_refreshTimestamp ); + libcmis::ObjectPtr result( new Object( false ) ); + return result; + } + + libcmis::ObjectTypePtr Object::getTypeDescription( ) + { + libcmis::ObjectTypePtr type( new ObjectType( false, m_triggersFaults ) ); + return type; + } + + libcmis::AllowableActionsPtr Object::getAllowableActions( ) + { + libcmis::AllowableActionsPtr allowableActions( new AllowableActions( ) ); + return allowableActions; + } + + void Object::refresh( ) + { + if ( m_triggersFaults ) + throw libcmis::Exception( "Fault triggered" ); + + time( &m_refreshTimestamp ); + } + + void Object::remove( bool ) + { + if ( m_triggersFaults ) + throw libcmis::Exception( "Fault triggered" ); + + time( &m_refreshTimestamp ); + } + + void Object::move( libcmis::FolderPtr, libcmis::FolderPtr ) + { + if ( m_triggersFaults ) + throw libcmis::Exception( "Fault triggered" ); + + time( &m_refreshTimestamp ); + } + + void Object::toXml( xmlTextWriterPtr ) + { + } + + Folder::Folder( bool isRoot, bool triggersFaults ) : + libcmis::Object( NULL ), + libcmis::Folder( NULL ), + dummies::Object( triggersFaults, "Folder" ), + m_isRoot( isRoot ) + { + } + + libcmis::FolderPtr Folder::getFolderParent( ) + { + if ( m_triggersFaults ) + throw libcmis::Exception( "Fault triggered" ); + + libcmis::FolderPtr parent; + + if ( !m_isRoot ) + parent.reset( new Folder( true, m_triggersFaults ) ); + + return parent; + } + + vector< libcmis::ObjectPtr > Folder::getChildren( ) + { + if ( m_triggersFaults ) + throw libcmis::Exception( "Fault triggered" ); + + vector< libcmis::ObjectPtr > children; + + libcmis::ObjectPtr child1( new Object( m_triggersFaults ) ); + children.push_back( child1 ); + libcmis::ObjectPtr child2( new Object( m_triggersFaults ) ); + children.push_back( child2 ); + + return children; + } + + string Folder::getPath( ) + { + return string( "/Path/" ); + } + + bool Folder::isRootFolder( ) + { + return m_isRoot; + } + + libcmis::FolderPtr Folder::createFolder( const PropertyPtrMap& ) + { + if ( m_triggersFaults ) + throw libcmis::Exception( "Fault triggered" ); + + libcmis::FolderPtr created( new Folder( true, m_triggersFaults ) ); + return created; + } + + libcmis::DocumentPtr Folder::createDocument( const PropertyPtrMap& properties, + boost::shared_ptr< ostream > os, string contentType, string filename ) + { + if ( m_triggersFaults ) + throw libcmis::Exception( "Fault triggered" ); + + dummies::Document* document = new dummies::Document( true, false ); + + PropertyPtrMap propertiesCopy( properties ); + document->getProperties( ).swap( propertiesCopy ); + document->setContentStream( os, contentType, filename ); + + libcmis::DocumentPtr created( document ); + return created; + } + + vector< string > Folder::removeTree( bool, libcmis::UnfileObjects::Type, + bool ) + { + if ( m_triggersFaults ) + throw libcmis::Exception( "Fault triggered" ); + + time( &m_refreshTimestamp ); + + vector< string > failed; + failed.push_back( "failed 1" ); + return failed; + } + + Document::Document( bool isFiled, bool triggersFaults ) : + libcmis::Object( NULL ), + libcmis::Document( NULL ), + dummies::Object( triggersFaults, "Document" ), + m_isFiled( isFiled ), + m_contentString( "Document::ContentStream" ) + { + } + + vector< libcmis::FolderPtr > Document::getParents( ) + { + if ( m_triggersFaults ) + throw libcmis::Exception( "Fault triggered" ); + + vector< libcmis::FolderPtr > parents; + if ( m_isFiled ) + { + libcmis::FolderPtr parent1( new Folder( true, m_triggersFaults ) ); + parents.push_back( parent1 ); + libcmis::FolderPtr parent2( new Folder( false, m_triggersFaults ) ); + parents.push_back( parent2 ); + } + + return parents; + } + + boost::shared_ptr< istream > Document::getContentStream( string /*streamId*/ ) + { + if ( m_triggersFaults ) + throw libcmis::Exception( "Fault triggered" ); + + bool oldOutOfMem = isOutOfMemory; + isOutOfMemory = false; + boost::shared_ptr< istream > stream( new stringstream( m_contentString ) ); + isOutOfMemory = oldOutOfMem; + return stream; + } + + void Document::setContentStream( boost::shared_ptr< ostream > os, string, string, bool ) + { + if ( m_triggersFaults ) + throw libcmis::Exception( "Fault triggered" ); + + istream is( os->rdbuf( ) ); + stringstream out; + is.seekg( 0 ); + int bufSize = 2048; + char* buf = new char[ bufSize ]; + while ( !is.eof( ) ) + { + is.read( buf, bufSize ); + size_t read = is.gcount( ); + out.write( buf, read ); + } + delete[] buf; + + m_contentString = out.str( ); + + time( &m_refreshTimestamp ); + } + + string Document::getContentType( ) + { + return "Document::ContentType"; + } + + string Document::getContentFilename( ) + { + return "Document::ContentFilename"; + } + + long Document::getContentLength( ) + { + return long( 12345 ); + } + + libcmis::DocumentPtr Document::checkOut( ) + { + if ( m_triggersFaults ) + throw libcmis::Exception( "Fault triggered" ); + + time( &m_refreshTimestamp ); + + libcmis::DocumentPtr result( new Document( true, m_triggersFaults ) ); + return result; + } + + void Document::cancelCheckout( ) + { + if ( m_triggersFaults ) + throw libcmis::Exception( "Fault triggered" ); + + time( &m_refreshTimestamp ); + } + + libcmis::DocumentPtr Document::checkIn( bool, string, const PropertyPtrMap& properties, + boost::shared_ptr< ostream > os, string contentType, string filename ) + { + if ( m_triggersFaults ) + throw libcmis::Exception( "Fault triggered" ); + + m_properties = properties; + setContentStream( os, contentType, filename ); + time( &m_refreshTimestamp ); + + return libcmis::DocumentPtr( new Document( true, false ) ); + } + + vector< libcmis::DocumentPtr > Document::getAllVersions( ) + { + if ( m_triggersFaults ) + throw libcmis::Exception( "Fault triggered" ); + + vector< libcmis::DocumentPtr > versions; + + libcmis::DocumentPtr version1( new Document( true, false ) ); + versions.push_back( version1 ); + libcmis::DocumentPtr version2( new Document( true, false ) ); + versions.push_back( version2 ); + + return versions; + } +} |