1999-12-07 05:32:34 +03:00
|
|
|
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 4 -*-
|
|
|
|
*
|
|
|
|
* The contents of this file are subject to the Netscape Public License
|
|
|
|
* Version 1.0 (the "NPL"); you may not use this file except in
|
|
|
|
* compliance with the NPL. You may obtain a copy of the NPL at
|
|
|
|
* http://www.mozilla.org/NPL/
|
|
|
|
*
|
|
|
|
* Software distributed under the NPL is distributed on an "AS IS" basis,
|
|
|
|
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
|
|
|
|
* for the specific language governing rights and limitations under the
|
|
|
|
* NPL.
|
|
|
|
*
|
|
|
|
* The Initial Developer of this code under the NPL is Netscape
|
|
|
|
* Communications Corporation. Portions created by Netscape are
|
|
|
|
* Copyright (C) 1998 Netscape Communications Corporation. All Rights
|
|
|
|
* Reserved.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "nsIStreamListener.h"
|
|
|
|
#include "nsIStreamObserver.h"
|
|
|
|
#include "nsIServiceManager.h"
|
|
|
|
#include "nsIInputStream.h"
|
|
|
|
#include "nsIOutputStream.h"
|
|
|
|
#include "nsIEventQueue.h"
|
|
|
|
#include "nsIEventQueueService.h"
|
|
|
|
#include "nsIChannel.h"
|
|
|
|
#include "nsCOMPtr.h"
|
|
|
|
|
|
|
|
#include "nsINetDataCache.h"
|
|
|
|
#include "nsINetDataCacheManager.h"
|
|
|
|
#include "nsICachedNetData.h"
|
|
|
|
|
2000-01-04 02:34:15 +03:00
|
|
|
#include "nsCRT.h"
|
1999-12-07 05:32:34 +03:00
|
|
|
// Number of test entries to be placed in the cache
|
|
|
|
// FIXME - temporary
|
|
|
|
#define NUM_CACHE_ENTRIES 25
|
|
|
|
|
|
|
|
// Cache content stream length will have random length between zero and
|
|
|
|
// MAX_CONTENT_LENGTH bytes
|
|
|
|
#define MAX_CONTENT_LENGTH 20000
|
|
|
|
|
|
|
|
// Limits, converted to KB
|
|
|
|
#define DISK_CACHE_CAPACITY ((MAX_CONTENT_LENGTH * 4) >> 10)
|
|
|
|
#define MEM_CACHE_CAPACITY ((MAX_CONTENT_LENGTH * 3) >> 10)
|
|
|
|
|
|
|
|
// Length of random-data cache entry URI key
|
|
|
|
#define CACHE_KEY_LENGTH 13
|
|
|
|
|
|
|
|
// Length of random-data cache entry secondary key
|
|
|
|
#define CACHE_SECONDARY_KEY_LENGTH 10
|
|
|
|
|
|
|
|
// Length of random-data cache entry meta-data
|
|
|
|
#define CACHE_PROTOCOL_PRIVATE_LENGTH 10
|
|
|
|
|
|
|
|
// Mapping from test case number to RecordID
|
|
|
|
static PRInt32 recordID[NUM_CACHE_ENTRIES];
|
|
|
|
|
|
|
|
static PRInt32
|
|
|
|
mapRecordIdToTestNum(PRInt32 aRecordID)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
for (i = 0; i < NUM_CACHE_ENTRIES; i++) {
|
|
|
|
if (recordID[i] == aRecordID)
|
|
|
|
return i;
|
|
|
|
}
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
// A supply of stream data to either store or compare with
|
|
|
|
class nsITestDataStream {
|
|
|
|
public:
|
|
|
|
virtual ~nsITestDataStream() {};
|
|
|
|
virtual PRUint32 Next() = 0;
|
|
|
|
virtual void Read(char* aBuf, PRUint32 aCount) = 0;
|
|
|
|
virtual void ReadString(char* aBuf, PRUint32 aCount) = 0;
|
|
|
|
|
|
|
|
virtual PRBool Match(char* aBuf, PRUint32 aCount) = 0;
|
|
|
|
virtual PRBool MatchString(char* aBuf, PRUint32 aCount) = 0;
|
|
|
|
virtual void Skip(PRUint32 aCount) = 0;
|
|
|
|
virtual void SkipString(PRUint32 aCount) = 0;
|
|
|
|
};
|
|
|
|
|
|
|
|
// A reproducible stream of random data.
|
|
|
|
class RandomStream : public nsITestDataStream {
|
|
|
|
public:
|
|
|
|
RandomStream(PRUint32 aSeed) {
|
|
|
|
mStartSeed = mState = aSeed;
|
|
|
|
}
|
|
|
|
|
|
|
|
PRUint32 GetStartSeed() {
|
|
|
|
return mStartSeed;
|
|
|
|
}
|
|
|
|
|
|
|
|
PRUint32 Next() {
|
|
|
|
mState = 1103515245 * mState + 12345 ^ (mState >> 16);
|
|
|
|
return mState;
|
|
|
|
}
|
|
|
|
|
|
|
|
PRUint8 NextChar() {
|
|
|
|
PRUint8 c;
|
|
|
|
do {
|
|
|
|
c = Next();
|
|
|
|
} while (!isalnum(c));
|
|
|
|
return c;
|
|
|
|
}
|
|
|
|
|
|
|
|
void Read(char* aBuf, PRUint32 aCount) {
|
|
|
|
PRUint32 i;
|
|
|
|
for (i = 0; i < aCount; i++) {
|
|
|
|
*aBuf++ = Next();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Same as Read(), but using only printable chars and
|
|
|
|
// with a terminating NUL
|
|
|
|
void ReadString(char* aBuf, PRUint32 aCount) {
|
|
|
|
PRUint32 i;
|
|
|
|
for (i = 0; i < aCount; i++) {
|
|
|
|
*aBuf++ = NextChar();
|
|
|
|
}
|
|
|
|
*aBuf = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
PRBool
|
|
|
|
Match(char* aBuf, PRUint32 aCount) {
|
|
|
|
PRUint32 i;
|
|
|
|
for (i = 0; i < aCount; i++) {
|
|
|
|
if (*aBuf++ != (char)(Next() & 0xff))
|
|
|
|
return PR_FALSE;
|
|
|
|
}
|
|
|
|
return PR_TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
PRBool
|
|
|
|
MatchString(char* aBuf, PRUint32 aCount) {
|
|
|
|
PRUint32 i;
|
|
|
|
for (i = 0; i < aCount; i++) {
|
|
|
|
if (*aBuf++ != (char)(NextChar() & 0xff))
|
|
|
|
return PR_FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Check for terminating NUL character
|
|
|
|
if (*aBuf)
|
|
|
|
return PR_FALSE;
|
|
|
|
return PR_TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
Skip(PRUint32 aCount) {
|
|
|
|
while (aCount--)
|
|
|
|
Next();
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
SkipString(PRUint32 aCount) {
|
|
|
|
while (aCount--)
|
|
|
|
NextChar();
|
|
|
|
}
|
|
|
|
|
|
|
|
protected:
|
|
|
|
|
|
|
|
PRUint32 mState;
|
|
|
|
PRUint32 mStartSeed;
|
|
|
|
};
|
|
|
|
|
|
|
|
static int gNumReaders = 0;
|
|
|
|
static PRUint32 gTotalBytesRead = 0;
|
|
|
|
static PRUint32 gTotalBytesWritten = 0;
|
|
|
|
static PRUint32 gTotalDuration = 0;
|
|
|
|
|
|
|
|
class nsReader : public nsIStreamListener {
|
|
|
|
public:
|
|
|
|
NS_DECL_ISUPPORTS
|
|
|
|
|
|
|
|
nsReader()
|
|
|
|
: mStartTime(0), mBytesRead(0)
|
|
|
|
{
|
|
|
|
NS_INIT_REFCNT();
|
|
|
|
gNumReaders++;
|
|
|
|
}
|
|
|
|
|
|
|
|
virtual ~nsReader() {
|
|
|
|
delete mTestDataStream;
|
|
|
|
gNumReaders--;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsresult
|
|
|
|
Init(nsITestDataStream* aRandomStream, PRUint32 aExpectedStreamLength) {
|
|
|
|
mTestDataStream = aRandomStream;
|
|
|
|
mExpectedStreamLength = aExpectedStreamLength;
|
|
|
|
mRefCnt = 1;
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHOD OnStartRequest(nsIChannel* channel,
|
|
|
|
nsISupports* context) {
|
|
|
|
mStartTime = PR_IntervalNow();
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHOD OnDataAvailable(nsIChannel* channel,
|
|
|
|
nsISupports* context,
|
|
|
|
nsIInputStream *aIStream,
|
|
|
|
PRUint32 aSourceOffset,
|
|
|
|
PRUint32 aLength) {
|
|
|
|
char buf[1025];
|
|
|
|
while (aLength > 0) {
|
|
|
|
PRUint32 amt;
|
|
|
|
PRBool match;
|
|
|
|
aIStream->Read(buf, sizeof buf, &amt);
|
|
|
|
if (amt == 0) break;
|
|
|
|
aLength -= amt;
|
|
|
|
mBytesRead += amt;
|
|
|
|
match = mTestDataStream->Match(buf, amt);
|
|
|
|
NS_ASSERTION(match, "Stored data was corrupted on read");
|
|
|
|
}
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHOD OnStopRequest(nsIChannel* channel,
|
|
|
|
nsISupports* context,
|
|
|
|
nsresult aStatus,
|
|
|
|
const PRUnichar* aMsg) {
|
|
|
|
PRIntervalTime endTime;
|
|
|
|
PRIntervalTime duration;
|
|
|
|
|
|
|
|
endTime = PR_IntervalNow();
|
|
|
|
duration = (endTime - mStartTime);
|
|
|
|
|
|
|
|
if (NS_FAILED(aStatus)) printf("channel failed.\n");
|
|
|
|
// printf("read %d bytes\n", mBytesRead);
|
|
|
|
|
|
|
|
//FIXME NS_ASSERTION(mBytesRead == mExpectedStreamLength,
|
|
|
|
// "Stream in cache is wrong length");
|
|
|
|
|
|
|
|
gTotalBytesRead += mBytesRead;
|
|
|
|
gTotalDuration += duration;
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
protected:
|
|
|
|
PRIntervalTime mStartTime;
|
|
|
|
PRUint32 mBytesRead;
|
|
|
|
nsITestDataStream* mTestDataStream;
|
|
|
|
PRUint32 mExpectedStreamLength;
|
|
|
|
};
|
|
|
|
|
|
|
|
NS_IMPL_ISUPPORTS2(nsReader, nsIStreamListener, nsIStreamObserver)
|
|
|
|
|
|
|
|
static nsIEventQueue* eventQueue;
|
|
|
|
|
|
|
|
static NS_DEFINE_CID(kEventQueueServiceCID, NS_EVENTQUEUESERVICE_CID);
|
|
|
|
|
|
|
|
nsresult
|
|
|
|
InitQueue() {
|
|
|
|
nsresult rv;
|
|
|
|
|
|
|
|
NS_WITH_SERVICE(nsIEventQueueService, eventQService, kEventQueueServiceCID, &rv);
|
|
|
|
NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't get event queue service");
|
|
|
|
|
|
|
|
rv = eventQService->CreateThreadEventQueue();
|
|
|
|
NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't create event queue");
|
|
|
|
|
|
|
|
rv = eventQService->GetThreadEventQueue(PR_CurrentThread(), &eventQueue);
|
|
|
|
NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't get event queue for main thread");
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Process events until all streams are OnStopRequest'ed
|
|
|
|
nsresult
|
|
|
|
WaitForEvents() {
|
|
|
|
while (gNumReaders) {
|
|
|
|
eventQueue->ProcessPendingEvents();
|
|
|
|
}
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Read data for a single cache record and compare against testDataStream
|
|
|
|
nsresult
|
|
|
|
TestReadStream(nsICachedNetData *cacheEntry, nsITestDataStream *testDataStream,
|
|
|
|
PRUint32 expectedStreamLength)
|
|
|
|
{
|
|
|
|
nsCOMPtr<nsIChannel> channel;
|
|
|
|
nsresult rv;
|
|
|
|
PRUint32 actualContentLength;
|
|
|
|
|
2000-03-14 07:03:46 +03:00
|
|
|
rv = cacheEntry->NewChannel(0, getter_AddRefs(channel));
|
1999-12-07 05:32:34 +03:00
|
|
|
NS_ASSERTION(NS_SUCCEEDED(rv), " ");
|
|
|
|
|
|
|
|
rv = cacheEntry->GetStoredContentLength(&actualContentLength);
|
|
|
|
NS_ASSERTION(NS_SUCCEEDED(rv), " ");
|
|
|
|
// FIXME NS_ASSERTION(actualContentLength == expectedStreamLength,
|
|
|
|
// "nsICachedNetData::GetContentLength() busted ?");
|
|
|
|
|
|
|
|
nsReader *reader = new nsReader;
|
|
|
|
reader->AddRef();
|
|
|
|
rv = reader->Init(testDataStream, expectedStreamLength);
|
|
|
|
NS_ASSERTION(NS_SUCCEEDED(rv), " ");
|
|
|
|
|
2000-03-29 07:58:50 +04:00
|
|
|
rv = channel->AsyncRead(0, reader);
|
1999-12-07 05:32:34 +03:00
|
|
|
NS_ASSERTION(NS_SUCCEEDED(rv), " ");
|
|
|
|
reader->Release();
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Convert PRTime to unix-style time_t, i.e. seconds since the epoch
|
|
|
|
static PRUint32
|
|
|
|
convertPRTimeToSeconds(PRTime aTime64)
|
|
|
|
{
|
|
|
|
double fpTime;
|
|
|
|
LL_L2D(fpTime, aTime64);
|
|
|
|
return (PRUint32)(fpTime * 1e-6 + 0.5);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Convert unix-style time_t, i.e. seconds since the epoch, to PRTime
|
|
|
|
static PRTime
|
|
|
|
convertSecondsToPRTime(PRUint32 aSeconds)
|
|
|
|
{
|
|
|
|
PRInt64 t64;
|
|
|
|
LL_L2I(t64, aSeconds);
|
|
|
|
LL_MUL(t64, t64, 1000000);
|
|
|
|
return t64;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Read the test data that was written in FillCache(), checking for
|
|
|
|
// corruption, truncation.
|
|
|
|
nsresult
|
|
|
|
TestRead(nsINetDataCacheManager *aCache, PRUint32 aFlags)
|
|
|
|
{
|
|
|
|
nsresult rv;
|
|
|
|
PRBool inCache;
|
|
|
|
nsCOMPtr<nsICachedNetData> cacheEntry;
|
|
|
|
RandomStream *randomStream;
|
|
|
|
char uriCacheKey[CACHE_KEY_LENGTH];
|
|
|
|
char secondaryCacheKey[CACHE_SECONDARY_KEY_LENGTH];
|
|
|
|
char *storedUriKey;
|
|
|
|
PRUint32 testNum;
|
|
|
|
|
|
|
|
gTotalBytesRead = 0;
|
|
|
|
gTotalDuration = 0;
|
|
|
|
for (testNum = 0; testNum < NUM_CACHE_ENTRIES; testNum++) {
|
|
|
|
randomStream = new RandomStream(testNum);
|
|
|
|
randomStream->ReadString(uriCacheKey, sizeof uriCacheKey - 1);
|
|
|
|
randomStream->Read(secondaryCacheKey, sizeof secondaryCacheKey);
|
|
|
|
|
|
|
|
// Ensure that entry is in the cache
|
|
|
|
rv = aCache->Contains(uriCacheKey,
|
|
|
|
secondaryCacheKey, sizeof secondaryCacheKey,
|
|
|
|
aFlags, &inCache);
|
|
|
|
NS_ASSERTION(NS_SUCCEEDED(rv), " ");
|
|
|
|
NS_ASSERTION(inCache, "nsINetDataCacheManager::Contains error");
|
|
|
|
|
|
|
|
rv = aCache->GetCachedNetData(uriCacheKey,
|
|
|
|
secondaryCacheKey, sizeof secondaryCacheKey,
|
|
|
|
aFlags,
|
|
|
|
getter_AddRefs(cacheEntry));
|
|
|
|
NS_ASSERTION(NS_SUCCEEDED(rv), " ");
|
|
|
|
|
|
|
|
// Test GetUriSpec() method
|
|
|
|
rv = cacheEntry->GetUriSpec(&storedUriKey);
|
|
|
|
NS_ASSERTION(NS_SUCCEEDED(rv) &&
|
|
|
|
!memcmp(storedUriKey, &uriCacheKey[0], sizeof uriCacheKey),
|
|
|
|
"nsICachedNetData::GetKey failed");
|
|
|
|
nsAllocator::Free(storedUriKey);
|
|
|
|
|
|
|
|
// Test GetSecondaryKey() method
|
|
|
|
PRUint32 storedSecondaryKeyLength;
|
|
|
|
char* storedSecondaryKey;
|
|
|
|
rv = cacheEntry->GetSecondaryKey(&storedSecondaryKeyLength, &storedSecondaryKey);
|
|
|
|
NS_ASSERTION(NS_SUCCEEDED(rv) &&
|
|
|
|
!memcmp(storedSecondaryKey, &secondaryCacheKey[0],
|
|
|
|
sizeof secondaryCacheKey),
|
|
|
|
"nsICachedNetData::GetSecondaryKey failed");
|
|
|
|
|
|
|
|
// Compare against stored protocol data
|
|
|
|
char *storedProtocolData;
|
|
|
|
PRUint32 storedProtocolDataLength;
|
|
|
|
rv = cacheEntry->GetAnnotation("test data", &storedProtocolDataLength, &storedProtocolData);
|
|
|
|
NS_ASSERTION(NS_SUCCEEDED(rv) &&
|
|
|
|
storedProtocolDataLength == CACHE_PROTOCOL_PRIVATE_LENGTH,
|
|
|
|
"nsICachedNetData::GetAnnotation() failed");
|
|
|
|
randomStream->Match(storedProtocolData, storedProtocolDataLength);
|
|
|
|
|
|
|
|
// Test GetAllowPartial()
|
|
|
|
PRBool allowPartial;
|
|
|
|
rv = cacheEntry->GetAllowPartial(&allowPartial);
|
|
|
|
NS_ASSERTION(NS_SUCCEEDED(rv) &&
|
|
|
|
(allowPartial == (PRBool)(randomStream->Next() & 1)),
|
|
|
|
"nsICachedNetData::GetAllowPartial() failed");
|
|
|
|
|
|
|
|
// Test GetExpirationTime()
|
|
|
|
PRTime expirationTime;
|
|
|
|
PRTime expectedExpirationTime = convertSecondsToPRTime(randomStream->Next() & 0xffffff);
|
|
|
|
rv = cacheEntry->GetExpirationTime(&expirationTime);
|
|
|
|
|
|
|
|
NS_ASSERTION(NS_SUCCEEDED(rv) && LL_EQ(expirationTime, expectedExpirationTime),
|
|
|
|
"nsICachedNetData::GetExpirationTime() failed");
|
|
|
|
|
|
|
|
PRUint32 expectedStreamLength = randomStream->Next() % MAX_CONTENT_LENGTH;
|
|
|
|
|
|
|
|
TestReadStream(cacheEntry, randomStream, expectedStreamLength);
|
|
|
|
}
|
|
|
|
|
|
|
|
WaitForEvents();
|
|
|
|
|
|
|
|
// Compute rate in MB/s
|
|
|
|
double rate = gTotalBytesRead / PR_IntervalToMilliseconds(gTotalDuration);
|
|
|
|
rate *= NUM_CACHE_ENTRIES;
|
|
|
|
rate *= 1000;
|
|
|
|
rate /= (1024 * 1024);
|
|
|
|
printf("Read %7d bytes at a rate of %5.1f MB per second \n",
|
|
|
|
gTotalBytesRead, rate);
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Create entries in the network data cache, using random data for the
|
|
|
|
// key, the meta-data and the stored content data.
|
|
|
|
nsresult
|
|
|
|
FillCache(nsINetDataCacheManager *aCache, PRUint32 aFlags, PRUint32 aCacheCapacity)
|
|
|
|
{
|
|
|
|
nsresult rv;
|
|
|
|
PRBool inCache;
|
|
|
|
nsCOMPtr<nsICachedNetData> cacheEntry;
|
|
|
|
nsCOMPtr<nsIChannel> channel;
|
|
|
|
nsCOMPtr<nsIOutputStream> outStream;
|
|
|
|
nsCOMPtr<nsINetDataCache> containingCache;
|
|
|
|
char buf[1000];
|
|
|
|
PRUint32 protocolDataLength;
|
|
|
|
char cacheKey[CACHE_KEY_LENGTH];
|
|
|
|
char secondaryCacheKey[CACHE_SECONDARY_KEY_LENGTH];
|
|
|
|
char protocolData[CACHE_PROTOCOL_PRIVATE_LENGTH];
|
|
|
|
PRUint32 testNum;
|
|
|
|
RandomStream *randomStream;
|
|
|
|
|
|
|
|
gTotalBytesWritten = 0;
|
|
|
|
PRIntervalTime startTime = PR_IntervalNow();
|
|
|
|
|
|
|
|
for (testNum = 0; testNum < NUM_CACHE_ENTRIES; testNum++) {
|
|
|
|
randomStream = new RandomStream(testNum);
|
|
|
|
randomStream->ReadString(cacheKey, sizeof cacheKey - 1);
|
|
|
|
randomStream->Read(secondaryCacheKey, sizeof secondaryCacheKey);
|
|
|
|
|
|
|
|
// No entry should be in cache until we add it
|
|
|
|
rv = aCache->Contains(cacheKey,
|
|
|
|
secondaryCacheKey, sizeof secondaryCacheKey,
|
|
|
|
aFlags, &inCache);
|
|
|
|
NS_ASSERTION(NS_SUCCEEDED(rv), " ");
|
|
|
|
NS_ASSERTION(!inCache, "nsINetDataCacheManager::Contains error");
|
|
|
|
|
|
|
|
rv = aCache->GetCachedNetData(cacheKey,
|
|
|
|
secondaryCacheKey, sizeof secondaryCacheKey,
|
|
|
|
aFlags,
|
|
|
|
getter_AddRefs(cacheEntry));
|
|
|
|
NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't access cacheEntry via cache key");
|
|
|
|
|
|
|
|
// Test nsINetDataCacheManager::GetNumEntries()
|
|
|
|
PRUint32 numEntries = (PRUint32)-1;
|
|
|
|
rv = aCache->GetNumEntries(&numEntries);
|
|
|
|
NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't get number of cache entries");
|
|
|
|
NS_ASSERTION(numEntries == testNum + 1, "GetNumEntries failure");
|
|
|
|
|
|
|
|
// Record meta-data should be initially empty
|
|
|
|
char *protocolDatap;
|
|
|
|
rv = cacheEntry->GetAnnotation("test data", &protocolDataLength, &protocolDatap);
|
|
|
|
NS_ASSERTION(NS_SUCCEEDED(rv), " ");
|
|
|
|
if ((protocolDataLength != 0) || (protocolDatap != 0))
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
|
|
|
|
// Store random data as meta-data
|
|
|
|
randomStream->Read(protocolData, sizeof protocolData);
|
|
|
|
cacheEntry->SetAnnotation("test data", sizeof protocolData, protocolData);
|
|
|
|
|
|
|
|
// Store random data as allow-partial flag
|
|
|
|
PRBool allowPartial = randomStream->Next() & 1;
|
|
|
|
rv = cacheEntry->SetAllowPartial(allowPartial);
|
|
|
|
NS_ASSERTION(NS_SUCCEEDED(rv),
|
|
|
|
"nsICachedNetData::SetAllowPartial() failed");
|
|
|
|
|
|
|
|
// Store random data as expiration time
|
|
|
|
PRTime expirationTime = convertSecondsToPRTime(randomStream->Next() & 0xffffff);
|
|
|
|
rv = cacheEntry->SetExpirationTime(expirationTime);
|
|
|
|
NS_ASSERTION(NS_SUCCEEDED(rv),
|
|
|
|
"nsICachedNetData::SetExpirationTime() failed");
|
|
|
|
|
|
|
|
// Cache manager complains if expiration set without setting last-modified time
|
|
|
|
rv = cacheEntry->SetLastModifiedTime(expirationTime);
|
|
|
|
|
2000-03-14 07:03:46 +03:00
|
|
|
rv = cacheEntry->NewChannel(0, getter_AddRefs(channel));
|
1999-12-07 05:32:34 +03:00
|
|
|
NS_ASSERTION(NS_SUCCEEDED(rv), " ");
|
|
|
|
|
|
|
|
rv = cacheEntry->GetCache(getter_AddRefs(containingCache));
|
|
|
|
NS_ASSERTION(NS_SUCCEEDED(rv), " ");
|
|
|
|
|
2000-03-29 07:58:50 +04:00
|
|
|
rv = channel->OpenOutputStream(getter_AddRefs(outStream));
|
1999-12-07 05:32:34 +03:00
|
|
|
NS_ASSERTION(NS_SUCCEEDED(rv), " ");
|
|
|
|
|
|
|
|
int streamLength = randomStream->Next() % MAX_CONTENT_LENGTH;
|
|
|
|
int remaining = streamLength;
|
|
|
|
while (remaining) {
|
|
|
|
PRUint32 numWritten;
|
|
|
|
int amount = PR_MIN(sizeof buf, remaining);
|
|
|
|
randomStream->Read(buf, amount);
|
|
|
|
|
|
|
|
rv = outStream->Write(buf, amount, &numWritten);
|
|
|
|
NS_ASSERTION(NS_SUCCEEDED(rv), " ");
|
|
|
|
NS_ASSERTION(numWritten == (PRUint32)amount, "Write() bug?");
|
|
|
|
|
|
|
|
remaining -= amount;
|
|
|
|
|
|
|
|
PRUint32 storageInUse;
|
|
|
|
rv = containingCache->GetStorageInUse(&storageInUse);
|
|
|
|
NS_ASSERTION(NS_SUCCEEDED(rv) && (storageInUse <= aCacheCapacity),
|
|
|
|
"Cache manager failed to limit cache growth");
|
|
|
|
}
|
|
|
|
outStream->Close();
|
|
|
|
gTotalBytesWritten += streamLength;
|
|
|
|
|
|
|
|
// *Now* there should be an entry in the cache
|
|
|
|
rv = aCache->Contains(cacheKey,
|
|
|
|
secondaryCacheKey, sizeof secondaryCacheKey,
|
|
|
|
aFlags, &inCache);
|
|
|
|
NS_ASSERTION(NS_SUCCEEDED(rv), " ");
|
|
|
|
NS_ASSERTION(inCache, "nsINetDataCacheManager::Contains error");
|
|
|
|
|
|
|
|
delete randomStream;
|
|
|
|
}
|
|
|
|
|
|
|
|
PRIntervalTime endTime = PR_IntervalNow();
|
|
|
|
|
|
|
|
// Compute rate in MB/s
|
|
|
|
double rate = gTotalBytesWritten / PR_IntervalToMilliseconds(endTime - startTime);
|
|
|
|
rate *= 1000;
|
|
|
|
rate /= (1024 * 1024);
|
|
|
|
printf("Wrote %7d bytes at a rate of %5.1f MB per second \n",
|
|
|
|
gTotalBytesWritten, rate);
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsresult NS_AutoregisterComponents()
|
|
|
|
{
|
|
|
|
nsresult rv = nsComponentManager::AutoRegister(nsIComponentManager::NS_Startup,
|
|
|
|
NULL /* default */);
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsresult
|
|
|
|
Test(nsINetDataCacheManager *aCache, PRUint32 aFlags, PRUint32 aCacheCapacity)
|
|
|
|
{
|
|
|
|
nsresult rv;
|
|
|
|
|
|
|
|
rv = aCache->RemoveAll();
|
|
|
|
NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't clear cache");
|
|
|
|
|
|
|
|
PRUint32 numEntries = (PRUint32)-1;
|
|
|
|
rv = aCache->GetNumEntries(&numEntries);
|
|
|
|
NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't get number of cache entries");
|
|
|
|
NS_ASSERTION(numEntries == 0, "Couldn't clear cache");
|
|
|
|
|
|
|
|
rv = FillCache(aCache, aFlags, aCacheCapacity);
|
|
|
|
NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't fill cache with random test data");
|
|
|
|
|
|
|
|
rv = TestRead(aCache, aFlags);
|
|
|
|
NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't read random test data from cache");
|
|
|
|
|
|
|
|
rv = aCache->RemoveAll();
|
|
|
|
NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't clear cache");
|
|
|
|
|
|
|
|
rv = aCache->GetNumEntries(&numEntries);
|
|
|
|
NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't get number of cache entries");
|
|
|
|
NS_ASSERTION(numEntries == 0, "Couldn't clear cache");
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
int
|
|
|
|
main(int argc, char* argv[])
|
|
|
|
{
|
|
|
|
nsresult rv;
|
|
|
|
nsCOMPtr<nsINetDataCacheManager> cache;
|
|
|
|
|
|
|
|
rv = NS_AutoregisterComponents();
|
|
|
|
NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't register XPCOM components");
|
|
|
|
|
|
|
|
rv = nsComponentManager::CreateInstance(NS_NETWORK_CACHE_MANAGER_PROGID,
|
|
|
|
nsnull,
|
|
|
|
NS_GET_IID(nsINetDataCacheManager),
|
|
|
|
getter_AddRefs(cache));
|
|
|
|
NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't create cache manager factory") ;
|
|
|
|
|
|
|
|
cache->SetDiskCacheCapacity(DISK_CACHE_CAPACITY);
|
|
|
|
cache->SetMemCacheCapacity(MEM_CACHE_CAPACITY);
|
|
|
|
|
|
|
|
InitQueue();
|
|
|
|
|
|
|
|
Test(cache, nsINetDataCacheManager::BYPASS_PERSISTENT_CACHE, MEM_CACHE_CAPACITY);
|
|
|
|
Test(cache, nsINetDataCacheManager::BYPASS_MEMORY_CACHE, DISK_CACHE_CAPACITY);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|