void tst_QWaveDecoder::readAllAtOnce()
{
QFile stream;
stream.setFileName(testFilePath("isawav_2_8_44100.wav"));
stream.open(QIODevice::ReadOnly);
QVERIFY(stream.isOpen());
QWaveDecoder waveDecoder(&stream);
QSignalSpy validFormatSpy(&waveDecoder, SIGNAL(formatKnown()));
QTRY_COMPARE(validFormatSpy.count(), 1);
QVERIFY(waveDecoder.size() > 0);
QByteArray buffer;
buffer.resize(waveDecoder.size());
qint64 readSize = waveDecoder.read(buffer.data(), waveDecoder.size());
QVERIFY(readSize == waveDecoder.size());
readSize = waveDecoder.read(buffer.data(), 1);
QVERIFY(readSize == 0);
stream.close();
}
int
testProgramPath (const char *path) {
if (!testFilePath(path)) return 0;
#ifdef X_OK
return access(path, X_OK) != -1;
#else /* X_OK */
errno = ENOSYS;
return 0;
#endif /* X_OK */
}
static int
testTextTable (const char *directory, char *name) {
int exists = 0;
char *path;
if ((path = makeTextTablePath(directory, name))) {
logMessage(LOG_DEBUG, "checking for text table: %s", path);
if (testFilePath(path)) exists = 1;
free(path);
}
return exists;
}
void RawAppendTest()
{
CTSVNPath testPath(L"c:/test/");
testPath.AppendRawString(L"/Hello");
ATLASSERT(testPath.GetWinPathString() == L"c:\\test\\Hello");
testPath.AppendRawString(L"\\T2");
ATLASSERT(testPath.GetWinPathString() == L"c:\\test\\Hello\\T2");
CTSVNPath testFilePath(L"C:\\windows\\win.ini");
CTSVNPath testBasePath(L"c:/temp/myfile.txt");
testBasePath.AppendRawString(testFilePath.GetFileExtension());
ATLASSERT(testBasePath.GetWinPathString() == L"c:\\temp\\myfile.txt.ini");
}
void PathAppendTest()
{
CTSVNPath testPath(L"c:/test/");
testPath.AppendPathString(L"/Hello");
ATLASSERT(testPath.GetWinPathString() == L"c:\\test\\Hello");
testPath.AppendPathString(L"T2");
ATLASSERT(testPath.GetWinPathString() == L"c:\\test\\Hello\\T2");
CTSVNPath testFilePath(L"C:\\windows\\win.ini");
CTSVNPath testBasePath(L"c:/temp/myfile.txt");
// You wouldn't want to do this in real life - you'd use append-raw
testBasePath.AppendPathString(testFilePath.GetFileExtension());
ATLASSERT(testBasePath.GetWinPathString() == L"c:\\temp\\myfile.txt\\.ini");
}
/*!
\property QPluginLoader::fileName
\brief the file name of the plugin
To be loadable, the file's suffix must be a valid suffix for a
loadable library in accordance with the platform, e.g. \c .so on
Unix, \c .dylib on Mac OS X, and \c .dll on Windows. The suffix
can be verified with QLibrary::isLibrary().
If the file name does not exist, it will not be set. This property
will then contain an empty string.
By default, this property contains an empty string.
Note: In Symbian the \a fileName must point to plugin stub file.
\sa load()
*/
void QPluginLoader::setFileName(const QString &fileName)
{
#if defined(QT_SHARED)
QLibrary::LoadHints lh;
if (d) {
lh = d->loadHints;
d->release();
d = 0;
did_load = false;
}
#if defined(Q_OS_SYMBIAN)
// In Symbian we actually look for plugin stub, so modify the filename
// to make canonicalFilePath find the file, if .dll is specified.
QFileInfo fi(fileName);
if (fi.suffix() == QLatin1String("dll")) {
QString stubName = fileName;
stubName.chop(3);
stubName += QLatin1String("qtplugin");
fi = QFileInfo(stubName);
}
QString fn = fi.canonicalFilePath();
// If not found directly, check also all the available drives
if (!fn.length()) {
QString stubPath(fi.fileName().length() ? fi.absoluteFilePath() : QString());
if (stubPath.length() > 1) {
if (stubPath.at(1).toAscii() == ':')
stubPath.remove(0,2);
QFileInfoList driveList(QDir::drives());
RFs rfs = qt_s60GetRFs();
foreach(const QFileInfo& drive, driveList) {
QString testFilePath(drive.absolutePath() + stubPath);
testFilePath = QDir::cleanPath(testFilePath);
// Use native Symbian code to check for file existence, because checking
// for file from under non-existent protected dir like E:/private/<uid> using
// QFile::exists causes platform security violations on most apps.
QString nativePath = QDir::toNativeSeparators(testFilePath);
TPtrC ptr(qt_QString2TPtrC(nativePath));
TUint attributes;
TInt err = rfs.Att(ptr, attributes);
if (err == KErrNone) {
fn = testFilePath;
break;
}
}
}
FILE *
openDataFile (const char *path, const char *mode, int optional) {
const char *name = locatePathName(path);
const char *overrideDirectory = getOverrideDirectory();
char *overridePath;
FILE *file;
if (!overrideDirectory) {
overridePath = NULL;
} else if ((overridePath = makePath(overrideDirectory, name))) {
if (testFilePath(overridePath)) {
file = openFile(overridePath, mode, optional);
goto done;
}
}
if (!(file = openFile(path, mode, optional))) {
if ((*mode == 'w') || (*mode == 'a')) {
if (errno == ENOENT) {
char *directory = getPathDirectory(path);
if (directory) {
int exists = ensureDirectory(directory);
free(directory);
if (exists) {
file = openFile(path, mode, optional);
goto done;
}
}
}
if (((errno == EACCES) || (errno == EROFS)) && overridePath) {
if (ensureDirectory(overrideDirectory)) {
file = openFile(overridePath, mode, optional);
goto done;
}
}
}
}
done:
if (overridePath) free(overridePath);
return file;
}
void tst_QWaveDecoder::readPerByte()
{
QFile stream;
stream.setFileName(testFilePath("isawav_2_8_44100.wav"));
stream.open(QIODevice::ReadOnly);
QVERIFY(stream.isOpen());
QWaveDecoder waveDecoder(&stream);
QSignalSpy validFormatSpy(&waveDecoder, SIGNAL(formatKnown()));
QTRY_COMPARE(validFormatSpy.count(), 1);
QVERIFY(waveDecoder.size() > 0);
qint64 readSize = 0;
char buf;
for (int ii = 0; ii < waveDecoder.size(); ++ii)
readSize += waveDecoder.read(&buf, 1);
QVERIFY(readSize == waveDecoder.size());
QVERIFY(waveDecoder.read(&buf,1) == 0);
stream.close();
}
/**
Application invoked as part of CommandLine tests
@SYMPREQ 280 File Handle Support
FunctionDesc Tests Environment slots .
Acquires a Mutex for log file access
Invokes EnvironmentSlotsReaderL() which returns an CApaCommandLine Object
Verifies the values returned by the GET APIs of CApaCommandLine object with those of predefined values
Writes "Pass" to the logfile if verification passes else "Fail" is written.
*/
void testEnvironmentSlotsL()
{
TPtrC appName;
TPtrC docName;
TApaCommand command = EApaCommandOpen;
TBool testResult = PASS;
//Get the Mutex to access the log file
RMutex fileAccess;
fileAccess.OpenGlobal(KTLogFileAccess);
fileAccess.Wait();
/** Invoke EnvironmenstSlotsReaderL() function which would constuct the CApaCommandLine class object
from the environment slots and return the pointer to that object */
//CApaCommandLine* cmdLine = CApaCommandLine::EnvironmentSlotsReaderL();
//Method CApaCommandLine::EnvironmentSlotsReaderL has been implemented in a different fashion
CApaCommandLine* cmdLine;
CApaCommandLine::GetCommandLineFromProcessEnvironment(cmdLine);
CleanupStack::PushL(cmdLine);
appName.Set(KTAppName);
docName.Set(KTDocName);
RFs fSession;
fSession.Connect();
RFile logFile;
TBufC<KMaxFilePath> testFilePath(KFilePath);
//Open the Log file in Write Mode
User::LeaveIfError(logFile.Replace(fSession,testFilePath,EFileWrite));
// Compare the values returned by GET APIs with pre defined values
TESTCOND(appName,cmdLine->ExecutableName());
if(appName != cmdLine->ExecutableName())
{
logFile.Write(KTFail);
logFile.Write(KTApp);
}
TESTCOND(docName,cmdLine->DocumentName());
if(docName != cmdLine->DocumentName())
{
logFile.Write(KTFail);
logFile.Write(KTDoc);
}
TESTCOND(command,cmdLine->Command());
if(command != cmdLine->Command())
{
logFile.Write(KTFail);
logFile.Write(KTCommand);
}
if(testResult == PASS)
{
logFile.Write(KTPass);
}
//Close the file and the file session
logFile.Close();
fSession.Close();
//Signal the Mutex
fileAccess.Signal();
CleanupStack::PopAndDestroy(cmdLine);
}
void tst_QWaveDecoder::file_data()
{
QTest::addColumn<QString>("file");
QTest::addColumn<tst_QWaveDecoder::Corruption>("corruption");
QTest::addColumn<int>("channels");
QTest::addColumn<int>("samplesize");
QTest::addColumn<int>("samplerate");
QTest::addColumn<QAudioFormat::Endian>("byteorder");
QTest::newRow("File is empty") << testFilePath("empty.wav") << tst_QWaveDecoder::NotAWav << -1 << -1 << -1 << QAudioFormat::LittleEndian;
QTest::newRow("File is one byte") << testFilePath("onebyte.wav") << tst_QWaveDecoder::NotAWav << -1 << -1 << -1 << QAudioFormat::LittleEndian;
QTest::newRow("File is not a wav(text)") << testFilePath("notawav.wav") << tst_QWaveDecoder::NotAWav << -1 << -1 << -1 << QAudioFormat::LittleEndian;
QTest::newRow("Wav file has no sample data") << testFilePath("nosampledata.wav") << tst_QWaveDecoder::NoSampleData << -1 << -1 << -1 << QAudioFormat::LittleEndian;
QTest::newRow("corrupt fmt chunk descriptor") << testFilePath("corrupt_fmtdesc_1_16_8000.le.wav") << tst_QWaveDecoder::FormatDescriptor << -1 << -1 << -1 << QAudioFormat::LittleEndian;
QTest::newRow("corrupt fmt string") << testFilePath("corrupt_fmtstring_1_16_8000.le.wav") << tst_QWaveDecoder::FormatString << -1 << -1 << -1 << QAudioFormat::LittleEndian;
QTest::newRow("corrupt data chunk descriptor") << testFilePath("corrupt_datadesc_1_16_8000.le.wav") << tst_QWaveDecoder::DataDescriptor << -1 << -1 << -1 << QAudioFormat::LittleEndian;
QTest::newRow("File isawav_1_8_8000.wav") << testFilePath("isawav_1_8_8000.wav") << tst_QWaveDecoder::None << 1 << 8 << 8000 << QAudioFormat::LittleEndian;
QTest::newRow("File isawav_1_8_44100.wav") << testFilePath("isawav_1_8_44100.wav") << tst_QWaveDecoder::None << 1 << 8 << 44100 << QAudioFormat::LittleEndian;
QTest::newRow("File isawav_2_8_8000.wav") << testFilePath("isawav_2_8_8000.wav") << tst_QWaveDecoder::None << 2 << 8 << 8000 << QAudioFormat::LittleEndian;
QTest::newRow("File isawav_2_8_44100.wav") << testFilePath("isawav_2_8_44100.wav") << tst_QWaveDecoder::None << 2 << 8 << 44100 << QAudioFormat::LittleEndian;
QTest::newRow("File isawav_1_16_8000_le.wav") << testFilePath("isawav_1_16_8000_le.wav") << tst_QWaveDecoder::None << 1 << 16 << 8000 << QAudioFormat::LittleEndian;
QTest::newRow("File isawav_1_16_44100_le.wav") << testFilePath("isawav_1_16_44100_le.wav") << tst_QWaveDecoder::None << 1 << 16 << 44100 << QAudioFormat::LittleEndian;
QTest::newRow("File isawav_2_16_8000_be.wav") << testFilePath("isawav_2_16_8000_be.wav") << tst_QWaveDecoder::None << 2 << 16 << 8000 << QAudioFormat::BigEndian;
QTest::newRow("File isawav_2_16_44100_be.wav") << testFilePath("isawav_2_16_44100_be.wav") << tst_QWaveDecoder::None << 2 << 16 << 44100 << QAudioFormat::BigEndian;
// The next file has extra data in the wave header.
QTest::newRow("File isawav_1_16_44100_le_2.wav") << testFilePath("isawav_1_16_44100_le_2.wav") << tst_QWaveDecoder::None << 1 << 16 << 44100 << QAudioFormat::LittleEndian;
// 32 bit waves are not supported
QTest::newRow("File isawav_1_32_8000_le.wav") << testFilePath("isawav_1_32_8000_le.wav") << tst_QWaveDecoder::FormatDescriptor << 1 << 32 << 8000 << QAudioFormat::LittleEndian;
QTest::newRow("File isawav_1_32_44100_le.wav") << testFilePath("isawav_1_32_44100_le.wav") << tst_QWaveDecoder::FormatDescriptor << 1 << 32 << 44100 << QAudioFormat::LittleEndian;
QTest::newRow("File isawav_2_32_8000_be.wav") << testFilePath("isawav_2_32_8000_be.wav") << tst_QWaveDecoder::FormatDescriptor << 2 << 32 << 8000 << QAudioFormat::BigEndian;
QTest::newRow("File isawav_2_32_44100_be.wav") << testFilePath("isawav_2_32_44100_be.wav") << tst_QWaveDecoder::FormatDescriptor << 2 << 32 << 44100 << QAudioFormat::BigEndian;
}
void VJSLanguageSyntaxTester::_ParseFile( XBOX::VJSParms_callStaticFunction &ioParams, void * )
{
// The caller has passed us the path to the symbol table and the path to the file to be
// parsed. We want to parse that file and then return back to the caller once the
// parsing is complete.
// We are expecting 4 parameters. One for the path to the symbol table,
// one for the path to the test file
if (ioParams.CountParams() < 4) return;
VString symTablePathStr, testFilePathStr, testFileBaseFolderStr, testFileExecContextStr;
if (!ioParams.GetStringParam( 1, symTablePathStr )) return;
if (!ioParams.GetStringParam( 2, testFilePathStr )) return;
if (!ioParams.GetStringParam( 3, testFileBaseFolderStr )) return;
if (!ioParams.GetStringParam( 4, testFileExecContextStr )) return;
VFilePath testFilePath( testFilePathStr, FPS_POSIX);
if ( ! testFilePath.IsValid() )
return;
ESymbolFileBaseFolder baseFolder;
ESymbolFileExecContext execContext;
// Get file base folder
if (testFileBaseFolderStr == CVSTR("project"))
baseFolder = eSymbolFileBaseFolderProject;
else if (testFileBaseFolderStr == CVSTR("jsf"))
baseFolder = eSymbolFileBaseFolderStudio;
else
return;
// Get file execution context
if (testFileExecContextStr == CVSTR("client"))
execContext = eSymbolFileExecContextClient;
else if (testFileExecContextStr == CVSTR("server"))
execContext = eSymbolFileExecContextServer;
else if (testFileExecContextStr == CVSTR("both"))
execContext = eSymbolFileExecContextClientServer;
else
return;
VFilePath symbolTablePath( symTablePathStr, FPS_POSIX);
if ( ! symbolTablePath.IsValid() )
return;
CLanguageSyntaxComponent *languageSyntax = (CLanguageSyntaxComponent *)VComponentManager::RetainComponent( (CType)CLanguageSyntaxComponent::Component_Type );
if (languageSyntax)
{
// First, load up the symbol table as an actual table instead of just a path string
ISymbolTable *symTable = languageSyntax->CreateSymbolTable();
if (symTable)
{
VFile file(symbolTablePath);
if (symTable->OpenSymbolDatabase( file))
{
IDocumentParserManager *parserManager = languageSyntax->CreateDocumentParserManager();
// Limit parser waiter scope as destructor will disconnect parsing signal
{
ParsingWaiter waiter( parserManager);
VString extension;
testFilePath.GetExtension(extension);
if ( extension == CVSTR("waModel") )
{
VLanguageSyntaxTesterCatalog* catalog = new VLanguageSyntaxTesterCatalog( testFilePath );
parserManager->ScheduleTask( (const void *)0xFEEDFACE, catalog, waiter.GetCookie(), symTable, IDocumentParserManager::kPriorityAboveNormal);
catalog->Release();
}
else
{
VSymbolFileInfos fileInfos(testFilePath, baseFolder, execContext);
parserManager->ScheduleTask( (const void *)0xFEEDFACE, /* Just needs to be unique per scheduler, but since this is a static method, there is no this pointer*/
fileInfos, waiter.GetCookie(), symTable, IDocumentParserManager::kPriorityAboveNormal );
}
waiter.Wait();
}
parserManager->Release();
}
symTable->Release();
}
languageSyntax->Release();
}
}
void VJSLanguageSyntaxTester::_GetCompletions( XBOX::VJSParms_callStaticFunction &ioParams, void * )
{
// We are expecting 5 parameters for JavaScript. One for the path to the symbol table, one for the path to the test file (which
// must already be a part of the symbol table), one for the line number within the file, one for the string that
// we are going to be completing at that point and one for the completion mode. If we get only three parameters, then it's a CSS completion test, which is
// fine -- we just modify the parameters we pass into GetSuggestionsForTesting.
VString symTablePathStr, testFilePathStr, completionString, completionModeStr;
sLONG completionLocation;
if (ioParams.CountParams() == 5) {
if (!ioParams.GetStringParam( 1, symTablePathStr )) return;
if (!ioParams.GetStringParam( 2, completionString )) return;
if (!ioParams.GetStringParam( 3, testFilePathStr )) return;
if (!ioParams.GetLongParam( 4, &completionLocation )) return;
if (!ioParams.GetStringParam( 5, completionModeStr )) return;
} else if (ioParams.CountParams() == 3) {
bool curlyBraces;
if (!ioParams.GetStringParam( 1, completionString )) return;
if (!ioParams.GetBoolParam( 2, &curlyBraces )) return;
if (!ioParams.GetStringParam( 3, testFilePathStr )) return;
// We fudge the completion location information when working with CSS files so that it
// denotes whether we're inside of curly braces or not.
completionLocation = curlyBraces ? 1 : 0;
} else {
return;
}
VFilePath symbolTablePath( symTablePathStr, FPS_POSIX);
VFilePath testFilePath( testFilePathStr, FPS_POSIX);
if ( ! symbolTablePath.IsValid() || ! testFilePath.IsValid() )
return;
EJSCompletionTestingMode completionMode;
if (completionModeStr == "text")
completionMode = eText;
else if (completionModeStr == "displayText")
completionMode = eDisplayText;
else
return;
CLanguageSyntaxComponent *languageSyntax = (CLanguageSyntaxComponent *)VComponentManager::RetainComponent( (CType)CLanguageSyntaxComponent::Component_Type );
if (languageSyntax)
{
// First, load up the symbol table as an actual table instead of just a path string
ISymbolTable *symTable = NULL;
if (!symTablePathStr.IsEmpty())
{
symTable = languageSyntax->CreateSymbolTable();
if ( symTable )
{
VFile file(symbolTablePath);
if (symTable->OpenSymbolDatabase( file ))
{
// Now that we have all of the parameters grabbed, we can figure out which language syntax engine
// we want to load up (based on the test file), and ask it to give us completions. We can then take
// those completions and turn them into an array of values to pass back to the caller.
VString extension;
testFilePath.GetExtension( extension );
ISyntaxInterface *syntaxEngine = languageSyntax->GetSyntaxByExtension( extension );
if (syntaxEngine)
{
// Now that we've got the syntax engine, we can ask it for the completions we need
std::vector< VString > suggestions;
syntaxEngine->GetSuggestionsForTesting( completionString, symTable, testFilePath.GetPath() , completionLocation, completionMode, suggestions );
JSResult *results = new JSResult( suggestions );
ioParams.ReturnValue( VJSLanguageSyntaxTesterResults::CreateInstance( ioParams.GetContextRef(), results ) );
results->Release();
}
}
symTable->Release();
}
}
languageSyntax->Release();
}
}
