[prev in list] [next in list] [prev in thread] [next in thread]
List: helix-server-cvs
Subject: [Server-cvs] tools/unittest/services ut_server_request.cpp, NONE,
From: srao () helixcommunity ! org
Date: 2008-08-02 0:32:12
Message-ID: 200808020035.m720Z6UD025969 () mailer ! progressive-comp ! com
[Download RAW message or body]
Update of /cvsroot/server/tools/unittest/services
In directory cvs01.internal.helixcommunity.org:/tmp/cvs-serv12645
Added Files:
Tag: SERVER_12_1
ut_server_request.cpp
Log Message:
Synopsis
========
PhaseII: Implement Unit Test frame work for PlaylistManager and test the phase-1 \
functionality using frame work
Branches: SERVER_12_1_RN, SERVER_CURRENT_RN Suggested Reviewer: Jamie, JJ
Description
===========
1. Added new target server-restricted_dataype_playlist_unittest to build system to \
down load PlaylistManager unit test code and related modules. (attached \
build_diff.txt)
2. Modified frame work to (ut_fw_diff.txt, playlist_piids.h)
1. Support Playlist Manager objects
2. xalan helper to support empty strings.
3. smil is only working with expat parser, so modified UT class factory to generate \
expat parser instead old XML parser. 4. Added Mock classes for fs-manager and \
server-request.
3. Fixed bugs found while doing unit testing and added couple of methods to process \
other parameters (plmgr_diff.txt) 4. PlaylistManager unit test frame work files added \
(which includes new source code and test cases in xml format) 5. Modified smil parser \
header file to make parseClockValue() method public. This method is needed in \
Playlist Manager to parse src-duration.
Files Affected
==============
/server-restricted/build/BIF/SERVER_12_1_COMMON_restricted.bif
/home/source/build/BIF/SERVER_12_1-internal.bif
/server/tools/unittest/framework/ut_testdriver.h
/server/tools/unittest/services/Umakefil
/server/tools/unittest/services/pub/ut_fsmanager.h [new file] \
/server/tools/unittest/services/pub/ut_server_request.h [new file] \
/server/tools/unittest/services/ut_fsmanager.cpp [new file] \
/server/tools/unittest/services/ut_server_request.cpp [new file]
/server/tools/unittest/services/ut_clfact.cpp
/server/tools/unittest/services/ut_context.cpp
/server/tools/unittest/services/pub/ut_clfact.h
/server/tools/unittest/utils/Umakefil
/server/tools/unittest/utils/iids.cpp
/server/tools/unittest/xalanhelper/ut_xalanhelper.cpp
/server/tools/unittest/utils/pub/playlist_piids.h [new file]
/server-restricted/datatype/playlist/unittest/plmgr_test_driver.cpp [new file] \
/server-restricted/datatype/playlist/unittest/plmgr_test_driver.h [new file] \
/server-restricted/datatype/playlist/unittest/ut_main.cpp [new file] \
/server-restricted/datatype/playlist/unittest/Umakefil [new file] \
/server-restricted/datatype/playlist/unittest/UnitTestConfig.xsd [new file] \
/server-restricted/datatype/playlist/unittest/ut_plmgr.xml [new file] \
/server-restricted/datatype/playlist/plmgr.cpp \
/server-restricted/datatype/playlist/pub/plmgr.h
/server/include/hxplaylist.h
/datatype/smil/renderer/smil2/pub/smlparse.h
Testing Performed
=================
Executed 23 test cases (written in file ut_plmgr.xml) and found all tests are passing
Build verified: win32-i386-vc7
Platforms tested: win32-i386-vc7
QA Hints
===============
None
--- NEW FILE: ut_server_request.cpp ---
/* ***** BEGIN LICENSE BLOCK *****
*
* Portions Copyright (c) 1995-2008 RealNetworks, Inc. All Rights Reserved.
*
* The contents of this file, and the files included with this file,
* are subject to the current version of the RealNetworks Public
* Source License (the "RPSL") available at
* http://www.helixcommunity.org/content/rpsl unless you have licensed
* the file under the current version of the RealNetworks Community
* Source License (the "RCSL") available at
* http://www.helixcommunity.org/content/rcsl, in which case the RCSL
* will apply. You may also obtain the license terms directly from
* RealNetworks. You may not use this file except in compliance with
* the RPSL or, if you have a valid RCSL with RealNetworks applicable
* to this file, the RCSL. Please see the applicable RPSL or RCSL for
* the rights, obligations and limitations governing use of the
* contents of the file.
*
* This file is part of the Helix DNA Technology. RealNetworks is the
* developer of the Original Code and owns the copyrights in the
* portions it created.
*
* This file, and the files included with this file, is distributed
* and made available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY
* KIND, EITHER EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS
* ALL SUCH WARRANTIES, INCLUDING WITHOUT LIMITATION, ANY WARRANTIES
* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, QUIET
* ENJOYMENT OR NON-INFRINGEMENT.
*
* Technology Compatibility Kit Test Suite(s) Location:
* http://www.helixcommunity.org/content/tck
*
* Contributor(s):
*
* ***** END LICENSE BLOCK ***** */
#include "hxtypes.h"
#include "hxcom.h"
#include "hxassert.h"
#include "ihxpckts.h"
#include "hxstrutl.h"
#include "chxpckts.h"
#include "ut_server_request.h"
#include "clone_values.h"
#include "urlparser.h"
CUTServerRequest::CUTServerRequest()
: m_lRefCount(0)
, m_pURL(NULL)
, m_pFSRequestHeaders(NULL)
, m_pFSResponseHeaders(NULL)
, m_pFFRequestHeaders(NULL)
, m_pFFResponseHeaders(NULL)
, m_pIUnknownUserContext(NULL)
, m_pIUnknownRequester(NULL)
{
}
CUTServerRequest::~CUTServerRequest()
{
HX_RELEASE(m_pURL);
if (m_pFSRequestHeaders)
{
m_pFSRequestHeaders->Release();
}
if (m_pFSResponseHeaders)
{
m_pFSResponseHeaders->Release();
}
if (m_pFFRequestHeaders)
{
m_pFFRequestHeaders->Release();
}
if (m_pFFResponseHeaders)
{
m_pFFResponseHeaders->Release();
}
HX_RELEASE(m_pIUnknownUserContext);
HX_RELEASE(m_pIUnknownRequester);
}
CUTServerRequest* CUTServerRequest::Clone(IHXCommonClassFactory* pCCF)
{
const char* pEncUrl = NULL;
CUTServerRequest* pNew = new CUTServerRequest();
pNew->AddRef();
m_pURL->GetEncodedUrl(pEncUrl);
pNew->SetURL(pEncUrl);
if(this->m_pFSRequestHeaders)
{
pNew->m_pFSRequestHeaders = this->m_pFSRequestHeaders;
pNew->m_pFSRequestHeaders->AddRef();
}
if(this->m_pFSResponseHeaders)
{
pNew->m_pFSResponseHeaders = this->m_pFSResponseHeaders;
pNew->m_pFSResponseHeaders->AddRef();
}
if(this->m_pFFRequestHeaders)
{
pNew->m_pFFRequestHeaders = this->m_pFFRequestHeaders;
pNew->m_pFFRequestHeaders->AddRef();
}
if(this->m_pFFResponseHeaders)
{
pNew->m_pFFResponseHeaders = this->m_pFFResponseHeaders;
pNew->m_pFFResponseHeaders->AddRef();
}
pNew->m_pIUnknownUserContext = this->m_pIUnknownUserContext;
if(pNew->m_pIUnknownUserContext)
{
m_pIUnknownUserContext->AddRef();
}
pNew->m_pIUnknownRequester = this->m_pIUnknownRequester;
if(pNew->m_pIUnknownRequester)
{
m_pIUnknownRequester->AddRef();
}
return pNew;
}
STDMETHODIMP_(ULONG32)
CUTServerRequest::AddRef()
{
return InterlockedIncrement(&m_lRefCount);
}
STDMETHODIMP_(ULONG32)
CUTServerRequest::Release()
{
if (InterlockedDecrement(&m_lRefCount) > 0)
{
return m_lRefCount;
}
delete this;
return 0;
}
STDMETHODIMP
CUTServerRequest::SetRequestHeaders(REQUEST_HEADER_TYPE HeaderType,
IHXValues* pRequestHeaders)
{
if(HeaderType == FS_HEADERS)
{
if(m_pFSRequestHeaders)
{
m_pFSRequestHeaders->Release();
}
m_pFSRequestHeaders = pRequestHeaders;
m_pFSRequestHeaders->AddRef();
}
else if(HeaderType == FF_HEADERS)
{
if(m_pFFRequestHeaders)
{
m_pFFRequestHeaders->Release();
}
m_pFFRequestHeaders = pRequestHeaders;
m_pFFRequestHeaders->AddRef();
}
return HXR_OK;
}
STDMETHODIMP
CUTServerRequest::GetRequestHeaders(REQUEST_HEADER_TYPE HeaderType,
REF(IHXValues*) pRequestHeaders)
{
IHXValues* pHeaders;
pHeaders = _GetRequestHeaders(HeaderType);
if (pHeaders)
{
pHeaders->AddRef();
}
pRequestHeaders = pHeaders;
return HXR_OK;
}
STDMETHODIMP
CUTServerRequest::SetResponseHeaders(REQUEST_HEADER_TYPE HeaderType,
IHXValues* pResponseHeaders)
{
if(HeaderType == FS_HEADERS)
{
if(m_pFSResponseHeaders)
{
m_pFSResponseHeaders->Release();
}
m_pFSResponseHeaders = pResponseHeaders;
m_pFSResponseHeaders->AddRef();
}
else if(HeaderType == FF_HEADERS)
{
if(m_pFFResponseHeaders)
{
m_pFFResponseHeaders->Release();
}
m_pFFResponseHeaders = pResponseHeaders;
m_pFFResponseHeaders->AddRef();
}
return HXR_OK;
}
STDMETHODIMP
CUTServerRequest::GetResponseHeaders(REQUEST_HEADER_TYPE HeaderType,
REF(IHXValues*) pResponseHeaders)
{
IHXValues* pHeaders;
pHeaders = _GetResponseHeaders(HeaderType);
if (pHeaders)
{
pHeaders->AddRef();
}
pResponseHeaders = pHeaders;
return HXR_OK;
}
STDMETHODIMP
CUTServerRequest::SetURL(const char* pURL)
{
HX_RELEASE(m_pURL);
if (pURL)
{
m_pURL = new CHXURLParser(pURL,strlen(pURL));
m_pURL->AddRef();
}
return HXR_OK;
}
STDMETHODIMP
CUTServerRequest::GetURL(REF(const char*) pURL)
{
m_pURL->GetDecodedUrl(pURL);
return HXR_OK;
}
/************************************************************************
* Method:
* IHXURLParser::GetHXURL
* Purpose:
* Gets the IHXURL object
*/
STDMETHODIMP
CUTServerRequest::GetHXURL(REF(IHXURL*) pURL)
{
pURL = m_pURL;
if(pURL)
{
pURL->AddRef();
}
return HXR_OK;
}
/************************************************************************
* Method:
* IHXRequest::SetUserContext
* Purpose:
* Sets the Authenticated users Context.
*/
STDMETHODIMP
CUTServerRequest::SetUserContext(IUnknown* pIUnknownNewContext)
{
HX_RELEASE(m_pIUnknownUserContext);
m_pIUnknownUserContext = pIUnknownNewContext;
if(m_pIUnknownUserContext)
{
m_pIUnknownUserContext->AddRef();
}
return HXR_OK;
}
/************************************************************************
* Method:
* IHXRequest::GetUserContext
* Purpose:
* Gets the Authenticated users Context.
*/
STDMETHODIMP
CUTServerRequest::GetUserContext(REF(IUnknown*) pIUnknownCurrentContext)
{
pIUnknownCurrentContext = m_pIUnknownUserContext;
if(pIUnknownCurrentContext)
{
pIUnknownCurrentContext->AddRef();
return HXR_OK;
}
return HXR_FAIL;
}
/************************************************************************
* Method:
* IHXRequest::SetRequester
* Purpose:
* Sets the Object that made the request.
*/
STDMETHODIMP
CUTServerRequest::SetRequester(IUnknown* pIUnknownNewRequester)
{
// Don't allow the Requester object to be erased or reset.
if (!pIUnknownNewRequester || m_pIUnknownRequester)
{
return HXR_FAIL;
}
m_pIUnknownRequester = pIUnknownNewRequester;
if(m_pIUnknownRequester)
{
m_pIUnknownRequester->AddRef();
}
return HXR_OK;
}
/************************************************************************
* Method:
* IHXRequest::GetRequester
* Purpose:
* Gets the Object that made the request.
*/
STDMETHODIMP
CUTServerRequest::GetRequester(REF(IUnknown*) pIUnknownCurrentRequester)
{
pIUnknownCurrentRequester = m_pIUnknownRequester;
if(pIUnknownCurrentRequester)
{
pIUnknownCurrentRequester->AddRef();
return HXR_OK;
}
return HXR_FAIL;
}
CUTServerRequestWrapper::CUTServerRequestWrapper(REQUEST_HEADER_TYPE pHeaderType,
CUTServerRequest* pServerRequest)
{
m_lRefCount = 0;
m_HeaderType = pHeaderType;
m_pServerRequest = pServerRequest;
if (m_pServerRequest)
{
m_pServerRequest->AddRef();
}
}
CUTServerRequestWrapper::~CUTServerRequestWrapper()
{
if (m_pServerRequest)
{
m_pServerRequest->Release();
}
}
STDMETHODIMP_(ULONG32)
CUTServerRequestWrapper::AddRef()
{
return InterlockedIncrement(&m_lRefCount);
}
STDMETHODIMP_(ULONG32)
CUTServerRequestWrapper::Release()
{
if (InterlockedDecrement(&m_lRefCount) > 0)
{
return m_lRefCount;
}
delete this;
return 0;
}
STDMETHODIMP
CUTServerRequestWrapper::QueryInterface(REFIID riid, void** ppvObj)
{
if (IsEqualIID(riid, IID_IUnknown))
{
AddRef();
*ppvObj = (IUnknown*)(IHXRequest*)this;
return HXR_OK;
}
else if (IsEqualIID(riid, IID_IHXRequest))
{
AddRef();
*ppvObj = (IHXRequest*)this;
return HXR_OK;
}
else if (IsEqualIID(riid, IID_IHXRequestContext))
{
AddRef();
*ppvObj = (IHXRequestContext*)this;
return HXR_OK;
}
else if (IsEqualIID(riid, IID_IHXURLParser))
{
AddRef();
*ppvObj = (IHXURLParser*)this;
return HXR_OK;
}
*ppvObj = NULL;
return HXR_NOINTERFACE;
}
HX_RESULT
CUTServerRequestWrapper::RemoveRequest(void)
{
HX_RELEASE(m_pServerRequest);
return HXR_OK;
}
HX_RESULT
CUTServerRequestWrapper::ReplaceRequest(CUTServerRequest* pRequest)
{
RemoveRequest();
if (pRequest != NULL)
{
pRequest->AddRef();
m_pServerRequest = pRequest;
}
return HXR_OK;
}
STDMETHODIMP
CUTServerRequestWrapper::SetRequestHeaders(IHXValues* pRequestHeaders)
{
return m_pServerRequest->SetRequestHeaders(m_HeaderType,
pRequestHeaders);
}
STDMETHODIMP
CUTServerRequestWrapper::GetRequestHeaders(REF(IHXValues*) pRequestHeaders)
{
return m_pServerRequest->GetRequestHeaders(m_HeaderType,
pRequestHeaders);
}
STDMETHODIMP
CUTServerRequestWrapper::SetResponseHeaders(IHXValues* pResponseHeaders)
{
return m_pServerRequest->SetResponseHeaders(m_HeaderType,
pResponseHeaders);
}
STDMETHODIMP
CUTServerRequestWrapper::GetResponseHeaders(REF(IHXValues*) pResponseHeaders)
{
return m_pServerRequest->GetResponseHeaders(m_HeaderType,
pResponseHeaders);
}
STDMETHODIMP
CUTServerRequestWrapper::SetURL(const char* pURL)
{
return m_pServerRequest->SetURL(pURL);
}
STDMETHODIMP
CUTServerRequestWrapper::GetURL(REF(const char*) pURL)
{
return m_pServerRequest->GetURL(pURL);
}
/************************************************************************
* Method:
* IHXURLParser::GetHXURL
* Purpose:
* Gets the IHXURL object
*/
STDMETHODIMP
CUTServerRequestWrapper::GetHXURL(REF(IHXURL*) pURL)
{
return m_pServerRequest->GetHXURL(pURL);
}
/************************************************************************
* Method:
* IHXRequest::SetUserContext
* Purpose:
* Sets the Authenticated users Context.
*/
STDMETHODIMP
CUTServerRequestWrapper::SetUserContext(IUnknown* pIUnknownNewContext)
{
return m_pServerRequest->SetUserContext(pIUnknownNewContext);
}
/************************************************************************
* Method:
* IHXRequest::GetUserContext
* Purpose:
* Gets the Authenticated users Context.
*/
STDMETHODIMP
CUTServerRequestWrapper::GetUserContext(REF(IUnknown*) pIUnknownCurrentContext)
{
return m_pServerRequest->GetUserContext(pIUnknownCurrentContext);
}
/************************************************************************
* Method:
* IHXRequest::SetRequester
* Purpose:
* Sets the Object that made the request.
*/
STDMETHODIMP
CUTServerRequestWrapper::SetRequester(IUnknown* pIUnknownNewRequester)
{
return m_pServerRequest->SetRequester(pIUnknownNewRequester);
}
/************************************************************************
* Method:
* IHXRequest::GetRequester
* Purpose:
* Gets the Object that made the request.
*/
STDMETHODIMP
CUTServerRequestWrapper::GetRequester(REF(IUnknown*) pIUnknownCurrentRequester)
{
return m_pServerRequest->GetRequester(pIUnknownCurrentRequester);
}
_______________________________________________
Server-cvs mailing list
Server-cvs@helixcommunity.org
http://lists.helixcommunity.org/mailman/listinfo/server-cvs
[prev in list] [next in list] [prev in thread] [next in thread]
Configure |
About |
News |
Add a list |
Sponsored by KoreLogic