337 lines
8.6 KiB
C++
337 lines
8.6 KiB
C++
/**
|
|
* @file lltranslate_test.cpp
|
|
* @brief Tests LLTranslate which translates between human languages.
|
|
*
|
|
* $LicenseInfo:firstyear=2009&license=viewergpl$
|
|
*
|
|
* Copyright (c) 2009, Linden Research, Inc.
|
|
*
|
|
* Second Life Viewer Source Code
|
|
* The source code in this file ("Source Code") is provided by Linden Lab
|
|
* to you under the terms of the GNU General Public License, version 2.0
|
|
* ("GPL"), unless you have obtained a separate licensing agreement
|
|
* ("Other License"), formally executed by you and Linden Lab. Terms of
|
|
* the GPL can be found in doc/GPL-license.txt in this distribution, or
|
|
* online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
|
|
*
|
|
* There are special exceptions to the terms and conditions of the GPL as
|
|
* it is applied to this Source Code. View the full text of the exception
|
|
* in the file doc/FLOSS-exception.txt in this software distribution, or
|
|
* online at
|
|
* http://secondlifegrid.net/programs/open_source/licensing/flossexception
|
|
*
|
|
* By copying, modifying or distributing this software, you acknowledge
|
|
* that you have read and understood your obligations described above,
|
|
* and agree to abide by those obligations.
|
|
*
|
|
* ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
|
|
* WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
|
|
* COMPLETENESS OR PERFORMANCE.
|
|
* $/LicenseInfo$
|
|
*/
|
|
#include "../test/lltut.h"
|
|
#include "../lltranslate.h"
|
|
|
|
#include "llerror.h"
|
|
#include "llsdhttpserver.h"
|
|
#include "lliohttpserver.h"
|
|
#include "llhttpclient.h"
|
|
#include "indra_constants.h"
|
|
|
|
namespace tut
|
|
{
|
|
struct TranslateTestData
|
|
{
|
|
public:
|
|
TranslateTestData()
|
|
{
|
|
apr_pool_create(&mPool, NULL);
|
|
mServerPump = new LLPumpIO(mPool);
|
|
mClientPump = new LLPumpIO(mPool);
|
|
|
|
LLHTTPClient::setPump(*mClientPump);
|
|
}
|
|
|
|
~TranslateTestData()
|
|
{
|
|
delete mServerPump;
|
|
delete mClientPump;
|
|
apr_pool_destroy(mPool);
|
|
}
|
|
|
|
void setupTheServer()
|
|
{
|
|
LLHTTPNode& root = LLIOHTTPServer::create(mPool, *mServerPump, 8888);
|
|
|
|
LLHTTPStandardServices::useServices();
|
|
LLHTTPRegistrar::buildAllServices(root);
|
|
}
|
|
|
|
void runThePump(float timeout = 100.0f)
|
|
{
|
|
LLTimer timer;
|
|
timer.setTimerExpirySec(timeout);
|
|
|
|
while(!mSawCompleted && !timer.hasExpired())
|
|
{
|
|
if (mServerPump)
|
|
{
|
|
mServerPump->pump();
|
|
mServerPump->callback();
|
|
}
|
|
if (mClientPump)
|
|
{
|
|
mClientPump->pump();
|
|
mClientPump->callback();
|
|
}
|
|
}
|
|
}
|
|
|
|
void killServer()
|
|
{
|
|
delete mServerPump;
|
|
mServerPump = NULL;
|
|
}
|
|
|
|
private:
|
|
apr_pool_t* mPool;
|
|
LLPumpIO* mServerPump;
|
|
LLPumpIO* mClientPump;
|
|
|
|
protected:
|
|
void ensureStatusOK()
|
|
{
|
|
if (mSawError)
|
|
{
|
|
std::string msg =
|
|
llformat("error() called when not expected, status %d",
|
|
mStatus);
|
|
fail(msg);
|
|
}
|
|
}
|
|
|
|
void ensureStatusError()
|
|
{
|
|
if (!mSawError)
|
|
{
|
|
fail("error() wasn't called");
|
|
}
|
|
}
|
|
|
|
std::string getResult()
|
|
{
|
|
return mResult;
|
|
}
|
|
|
|
protected:
|
|
bool mSawError;
|
|
U32 mStatus;
|
|
std::string mReason;
|
|
bool mSawCompleted;
|
|
std::string mResult;
|
|
bool mResultDeleted;
|
|
|
|
class TranslationTestReceiver: public LLTranslate::TranslationReceiver
|
|
{
|
|
public:
|
|
TranslationTestReceiver(const std::string &fromLang, const std::string &toLang,
|
|
const std::string &mesg, TranslateTestData &translationData)
|
|
: LLTranslate::TranslationReceiver(fromLang, toLang, mesg),
|
|
mClient(translationData)
|
|
{
|
|
}
|
|
|
|
~TranslationTestReceiver()
|
|
{
|
|
mClient.mResultDeleted = true;
|
|
}
|
|
|
|
virtual void error(U32 status, const std::string& reason)
|
|
{
|
|
mClient.mSawError = true;
|
|
mClient.mStatus = status;
|
|
mClient.mReason = reason;
|
|
}
|
|
|
|
static boost::intrusive_ptr<TranslationTestReceiver> build(const std::string &fromLang, const std::string &toLang,
|
|
const std::string &mesg, TranslateTestData &translationData)
|
|
{
|
|
return boost::intrusive_ptr<TranslationTestReceiver>(new TranslationTestReceiver(fromLang, toLang, mesg, translationData));
|
|
}
|
|
|
|
protected:
|
|
void handleResponse(const std::string &translation, const std::string &detectedLanguage)
|
|
{
|
|
std::string fromLang = (detectedLanguage.length() > 0 ? detectedLanguage : m_fromLang);
|
|
LL_INFOS("Translate") << "Translation : " << translation << " (" <<
|
|
fromLang << ")" << LL_ENDL;
|
|
|
|
mClient.mSawCompleted = true;
|
|
mClient.mResult = translation;
|
|
}
|
|
private:
|
|
TranslateTestData& mClient;
|
|
};
|
|
|
|
friend class TranslationTestReceiver;
|
|
|
|
protected:
|
|
LLHTTPClient::ResponderPtr newResult(const std::string &fromLang, const std::string &toLang, const std::string &mesg)
|
|
{
|
|
mSawError = false;
|
|
mStatus = 0;
|
|
mSawCompleted = false;
|
|
mResultDeleted = false;
|
|
|
|
return TranslationTestReceiver::build(fromLang, toLang, mesg, *this);
|
|
}
|
|
};
|
|
|
|
typedef test_group<TranslateTestData> TranslateTestGroup;
|
|
typedef TranslateTestGroup::object TranslateTestObject;
|
|
TranslateTestGroup translateTestGroup("translate");
|
|
|
|
// Test translation requests aren't throwing an error
|
|
template<> template<>
|
|
void TranslateTestObject::test<1>()
|
|
{
|
|
std::string fromLang = "en";
|
|
std::string toLang = "es";
|
|
std::string mesg = "Hello!";
|
|
|
|
setupTheServer();
|
|
LLTranslate::translateMessage(newResult(fromLang, toLang, mesg), fromLang, toLang, mesg);
|
|
runThePump();
|
|
|
|
ensureStatusOK();
|
|
}
|
|
|
|
// Test whether we get a translation back
|
|
template<> template<>
|
|
void TranslateTestObject::test<2>()
|
|
{
|
|
std::string fromLang = "en";
|
|
std::string toLang = "es";
|
|
std::string mesg = "Hello!";
|
|
|
|
setupTheServer();
|
|
LLTranslate::translateMessage(newResult(fromLang, toLang, mesg), fromLang, toLang, mesg);
|
|
runThePump();
|
|
|
|
ensureStatusOK();
|
|
ensure("Translation from English 'Hello!' to Spanish failed, empty string returned",
|
|
getResult().length() > 0);
|
|
}
|
|
|
|
// Test for a correct translation of an ASCII language
|
|
template<> template<>
|
|
void TranslateTestObject::test<3>()
|
|
{
|
|
std::string fromLang = "en";
|
|
std::string toLang = "es";
|
|
std::string mesg = "Hello!";
|
|
|
|
setupTheServer();
|
|
LLTranslate::translateMessage(newResult(fromLang, toLang, mesg), fromLang, toLang, mesg);
|
|
runThePump();
|
|
ensureStatusOK();
|
|
|
|
ensure("Translation from English 'Hello!' to Spanish failed, expected 'Hola'",
|
|
getResult() == "Hola!");
|
|
}
|
|
|
|
// Test sending multiple requests simultaneously
|
|
template<> template<>
|
|
void TranslateTestObject::test<4>()
|
|
{
|
|
setupTheServer();
|
|
char buff[32];
|
|
for (int i = 0; i < 5; i++)
|
|
{
|
|
std::string fromLang = "en";
|
|
std::string toLang = "es";
|
|
sprintf(buff, "Hello %d!", i);
|
|
std::string mesg = buff;
|
|
|
|
LLTranslate::translateMessage(newResult(fromLang, toLang, mesg), fromLang, toLang, mesg);
|
|
runThePump();
|
|
ensureStatusOK();
|
|
}
|
|
}
|
|
|
|
// Test 'translating' symbols that may need escaping
|
|
template<> template<>
|
|
void TranslateTestObject::test<5>()
|
|
{
|
|
std::string fromLang = "en";
|
|
std::string toLang = "en";
|
|
std::string mesg = ".?<>,/=&!@#$%^*()-_+[]{};:'\"\\|~`";
|
|
|
|
setupTheServer();
|
|
|
|
for (unsigned int i = 0; i < mesg.length(); i++)
|
|
{
|
|
char c = mesg.at(i);
|
|
std::stringstream ss;
|
|
std::string s;
|
|
ss << c;
|
|
ss >> s;
|
|
LLTranslate::translateMessage(newResult(fromLang, toLang, s), fromLang, toLang, s);
|
|
runThePump();
|
|
|
|
ensureStatusOK();
|
|
std::string error = "Translation of symbol '" + s + "' failed, returned '" + getResult() + "'";
|
|
ensure(error, getResult().compare(s) == 0);
|
|
}
|
|
}
|
|
|
|
// Test for the correct sending of non ascii languages,
|
|
// this depends on having a User-Agent header in the URL request
|
|
template<> template<>
|
|
void TranslateTestObject::test<6>()
|
|
{
|
|
std::string fromLang = "ja";
|
|
std::string toLang = "en";
|
|
std::string mesg = "木";
|
|
|
|
setupTheServer();
|
|
LLTranslate::translateMessage(newResult(fromLang, toLang, mesg), fromLang, toLang, mesg);
|
|
runThePump();
|
|
|
|
ensureStatusOK();
|
|
ensure("Translation of non-ascii text failed (Japanese->English) .. expected 'Tree'", getResult() == "Tree");
|
|
}
|
|
|
|
// Test for automatic recognition of a non-ASCII language
|
|
template<> template<>
|
|
void TranslateTestObject::test<7>()
|
|
{
|
|
std::string fromLang = "";
|
|
std::string toLang = "en";
|
|
std::string mesg = "木";
|
|
|
|
setupTheServer();
|
|
LLTranslate::translateMessage(newResult(fromLang, toLang, mesg), fromLang, toLang, mesg);
|
|
runThePump();
|
|
|
|
ensureStatusOK();
|
|
ensure("Translation of non-ascii text failed (Automatic->English) .. expected 'Tree'", getResult() == "Tree");
|
|
}
|
|
|
|
// Test for automatic translation to a non-ASCII language
|
|
template<> template<>
|
|
void TranslateTestObject::test<8>()
|
|
{
|
|
std::string fromLang = "";
|
|
std::string toLang = "ja";
|
|
std::string mesg = "Tree";
|
|
|
|
setupTheServer();
|
|
LLTranslate::translateMessage(newResult(fromLang, toLang, mesg), fromLang, toLang, mesg);
|
|
runThePump();
|
|
|
|
ensureStatusOK();
|
|
ensure("Translation to non-ascii text failed (Automatic->Japanese) .. expected '木'", getResult() == "木");
|
|
}
|
|
}
|