void tst_QDBusType::isValidBasicType_data()
{
addColumns();
addBasicTypes(Valid);
addVariant(Invalid);
addInvalidSingleLetterTypes();
}
UciEngine::UciEngine(QObject* parent)
: ChessEngine(parent),
m_sendOpponentsName(false)
{
addVariant("standard");
setName("UciEngine");
}
void Evaluate::addArray(QVariantList &list) {
m_buffer.append("[");
for (int i = 0; i < list.length(); i++) {
if (i > 0)
m_buffer.append(",");
addVariant(list[i]);
}
m_buffer.append("]");
}
void JsonSerializer::addArray(const QVariantList &list) {
m_buffer.append("[");
for (int i = 0; i < list.length(); i++) {
if (i > 0)
m_buffer.append(",");
addVariant(list[i]);
}
m_buffer.append("]");
}
UciEngine::UciEngine(QObject* parent)
: ChessEngine(parent),
m_sendOpponentsName(false),
m_canPonder(false),
m_ponderState(NotPondering),
m_ignoreThinking(false),
m_rePing(false)
{
addVariant("standard");
setName("UciEngine");
}
void Evaluate::addMap(QVariantMap &map) {
m_buffer.append("{");
QMapIterator<QString, QVariant> iterator(map);
while (iterator.hasNext()) {
iterator.next();
QString key = iterator.key();
QVariant value = iterator.value();
addString(key);
m_buffer.append(":");
addVariant(value);
if (iterator.hasNext())
m_buffer.append(",");
}
m_buffer.append("}");
}
static void addSingleSignatures()
{
addBasicTypes(Valid);
addVariant(Valid);
QTest::newRow("struct-1") << "(y)" << true;
QTest::newRow("struct-2") << "(yy)" << true;
QTest::newRow("struct-3") << "(yyv)" << true;
QTest::newRow("struct-nested-1") << "((y))" << true;
QTest::newRow("struct-nested-2") << "((yy))" << true;
QTest::newRow("struct-nested-3") << "(y(y))" << true;
QTest::newRow("struct-nested-4") << "((y)y)" << true;
QTest::newRow("struct-nested-5") << "(y(y)y)" << true;
QTest::newRow("struct-nested-6") << "((y)(y))" << true;
QTest::newRow("array-1") << "as" << true;
QTest::newRow("struct-array-1") << "(as)" << true;
QTest::newRow("struct-array-2") << "(yas)" << true;
QTest::newRow("struct-array-3") << "(asy)" << true;
QTest::newRow("struct-array-4") << "(yasy)" << true;
QTest::newRow("dict-1") << "a{sy}" << true;
QTest::newRow("dict-2") << "a{sv}" << true;
QTest::newRow("dict-struct-1") << "a{s(y)}" << true;
QTest::newRow("dict-struct-2") << "a{s(yyyy)}" << true;
QTest::newRow("dict-struct-array") << "a{s(ay)}" << true;
QTest::newRow("dict-array") << "a{sas}" << true;
QTest::newRow("dict-array-struct") << "a{sa(y)}" << true;
addInvalidSingleLetterTypes();
QTest::newRow("naked-dict-empty") << "{}" << false;
QTest::newRow("naked-dict-missing-value") << "{i}" << false;
QTest::newRow("dict-empty") << "a{}" << false;
QTest::newRow("dict-missing-value") << "a{i}" << false;
QTest::newRow("dict-non-basic-key") << "a{vi}" << false;
QTest::newRow("dict-struct-key") << "a{(y)y}" << false;
QTest::newRow("dict-missing-close") << "a{sv" << false;
QTest::newRow("dict-mismatched-close") << "a{sv)" << false;
QTest::newRow("dict-missing-value-close") << "a{s" << false;
QTest::newRow("empty-struct") << "()" << false;
QTest::newRow("struct-missing-close") << "(s" << false;
QTest::newRow("struct-nested-missing-close-1") << "((s)" << false;
QTest::newRow("struct-nested-missing-close-2") << "((s" << false;
QTest::newRow("struct-ending-array-no-element") << "(a)" << false;
}
XboardEngine::XboardEngine(QObject* parent)
: ChessEngine(parent),
m_forceMode(false),
m_drawOnNextMove(false),
m_ftName(false),
m_ftPing(false),
m_ftSetboard(false),
m_ftTime(true),
m_ftUsermove(false),
m_ftReuse(true),
m_ftNps(false),
m_gotResult(false),
m_lastPing(0),
m_notation(Chess::Board::LongAlgebraic),
m_initTimer(new QTimer(this))
{
m_initTimer->setSingleShot(true);
m_initTimer->setInterval(8000);
connect(m_initTimer, SIGNAL(timeout()), this, SLOT(initialize()));
addVariant("standard");
setName("XboardEngine");
}
void addVariant(int pid, int varLocInRef, char *p)
{
if (debug == 2) printf("addVariant %d %d %s\n", pid, varLocInRef, p);
if (pid >= numT) fatal("addVariant Pid=%d >= number of threads %d\n", pid, numT);
char s1[100];
if (p[0] == '+' || (strlen(p) == 1 && p[0] != 'D')) {
s1[0] = refseq[pid][varLocInRef];
s1[1]= 0;
if (p[0] == '+') {
p[0] = s1[0];
if (debug) printf("Insertion:%s\t%s\t%c%c%c\n", s1, p, refseq[pid][varLocInRef+1], refseq[pid][varLocInRef+2], refseq[pid][varLocInRef+3]);
}
} else { // ##D
int x = atoi(p);
if (x == 0) x = 1;
strncpy(s1, refseq[pid]+varLocInRef, x+1);
s1[x+1] = 0;
p[0] = s1[0];
p[1] = 0;
if (debug) printf("deletion:%s\t%s\n", s1, p);
}
addVariant(pid, varLocInRef, p, s1);
}
void XboardEngine::setFeature(const QString& name, const QString& val)
{
if (name == "ping")
m_ftPing = (val == "1");
else if (name == "setboard")
m_ftSetboard = (val == "1");
else if (name == "san")
{
if (val == "1")
m_notation = Chess::Board::StandardAlgebraic;
else
m_notation = Chess::Board::LongAlgebraic;
}
else if (name == "usermove")
m_ftUsermove = (val == "1");
else if (name == "nps")
m_ftNps = (val == "1");
else if (name == "time")
m_ftTime = (val == "1");
else if (name == "reuse")
m_ftReuse = (val == "1");
else if (name == "myname")
{
if (this->name() == "XboardEngine")
setName(val);
}
else if (name == "variants")
{
clearVariants();
QStringList variants = val.split(',');
foreach (const QString& str, variants)
{
QString variant = variantFromXboard(str.trimmed());
if (!variant.isEmpty())
addVariant(variant);
}
void UciEngine::parseLine(const QString& line)
{
const QStringRef command(firstToken(line));
if (command == "info")
{
parseInfo(command);
}
else if (command == "bestmove")
{
if (state() != Thinking)
{
if (state() == FinishingGame)
pong();
else
qDebug() << "Unexpected move from" << name();
return;
}
QString moveString(nextToken(command).toString());
m_moveStrings += " " + moveString;
Chess::Move move = board()->moveFromString(moveString);
if (!move.isNull())
emitMove(move);
else
forfeit(Chess::Result::IllegalMove, moveString);
}
else if (command == "readyok")
{
pong();
}
else if (command == "uciok")
{
if (state() == Starting)
{
onProtocolStart();
ping();
}
}
else if (command == "id")
{
QStringRef tag(nextToken(command));
if (tag == "name" && name() == "UciEngine")
setName(nextToken(tag, true).toString());
}
else if (command == "registration")
{
if (nextToken(command) == "error")
{
qDebug("Failed to register UCI engine %s", qPrintable(name()));
write("register later");
}
}
else if (command == "option")
{
EngineOption* option = parseOption(command);
QString variant;
if (option == 0 || !option->isValid())
qDebug("Invalid UCI option from %s: %s",
qPrintable(name()), qPrintable(line));
else if (!(variant = variantFromUci(option->name())).isEmpty())
addVariant(variant);
else if (option->name() == "UCI_Opponent")
m_sendOpponentsName = true;
else if (option->name() == "Ponder"
|| (option->name().startsWith("UCI_") &&
option->name() != "UCI_LimitStrength" &&
option->name() != "UCI_Elo"))
{
// TODO: Deal with UCI features
}
else
{
addOption(option);
return;
}
delete option;
}
}
void Evaluate::start() {
QVariant result = page()->currentFrame()->evaluateJavaScript(arguments()[0]);
addVariant(result);
emit finished(new Response(true, m_buffer));
}
void Evaluate::start(QStringList &arguments) {
QVariant result = page()->mainFrame()->evaluateJavaScript(arguments[0]);
addVariant(result);
emit finished(true, m_buffer);
}
QByteArray JsonSerializer::serialize(const QVariant &object) {
addVariant(object);
return m_buffer;
}
