void tst_QBrush::gradientStops()
{
QLinearGradient gradient;
gradient.setColorAt(0, Qt::red);
gradient.setColorAt(1, Qt::blue);
QCOMPARE(gradient.stops().size(), 2);
QCOMPARE(gradient.stops().at(0), QGradientStop(0, QColor(Qt::red)));
QCOMPARE(gradient.stops().at(1), QGradientStop(1, QColor(Qt::blue)));
gradient.setColorAt(0, Qt::blue);
gradient.setColorAt(1, Qt::red);
QCOMPARE(gradient.stops().size(), 2);
QCOMPARE(gradient.stops().at(0), QGradientStop(0, QColor(Qt::blue)));
QCOMPARE(gradient.stops().at(1), QGradientStop(1, QColor(Qt::red)));
gradient.setColorAt(0.5, Qt::green);
QCOMPARE(gradient.stops().size(), 3);
QCOMPARE(gradient.stops().at(1), QGradientStop(0.5, QColor(Qt::green)));
// A hack in parseStopNode() in qsvghandler.cpp depends on inserting stops at NaN.
gradient.setStops(QGradientStops() << QGradientStop(qQNaN(), QColor()));
QCOMPARE(gradient.stops().size(), 1);
QVERIFY(qIsNaN(gradient.stops().at(0).first));
QCOMPARE(gradient.stops().at(0).second, QColor());
}
void tst_QNumeric::qNan()
{
#if defined __FAST_MATH__ && (__GNUC__ * 100 + __GNUC_MINOR__ < 404)
QSKIP("Non-conformant fast math mode is enabled, cannot run test");
#endif
double nan = qQNaN();
QVERIFY(!(0 > nan));
QVERIFY(!(0 < nan));
QVERIFY(qIsNaN(nan));
QVERIFY(qIsNaN(nan + 1));
QVERIFY(qIsNaN(-nan));
double inf = qInf();
QVERIFY(inf > 0);
QVERIFY(-inf < 0);
QVERIFY(qIsInf(inf));
QVERIFY(qIsInf(-inf));
QVERIFY(qIsInf(2*inf));
QCOMPARE(1/inf, 0.0);
#ifdef Q_CC_INTEL
QEXPECT_FAIL("", "ICC optimizes zero * anything to zero", Continue);
#endif
QVERIFY(qIsNaN(0*nan));
#ifdef Q_CC_INTEL
QEXPECT_FAIL("", "ICC optimizes zero * anything to zero", Continue);
#endif
QVERIFY(qIsNaN(0*inf));
QVERIFY(qFuzzyCompare(1/inf, 0.0));
}
void tst_QNumeric::qNan()
{
double nan = qQNaN();
#if defined( __INTEL_COMPILER)
QCOMPARE((0 > nan), false);
QCOMPARE((0 < nan), false);
QSKIP("This fails due to a bug in the Intel Compiler", SkipAll);
#else
if (0 > nan)
QFAIL("compiler thinks 0 > nan");
# if defined(Q_CC_DIAB)
QWARN("!(0 < nan) would fail due to a bug in dcc");
# else
if (0 < nan)
QFAIL("compiler thinks 0 < nan");
# endif
#endif
QVERIFY(qIsNaN(nan));
QVERIFY(qIsNaN(nan + 1));
QVERIFY(qIsNaN(-nan));
double inf = qInf();
QVERIFY(inf > 0);
QVERIFY(-inf < 0);
QVERIFY(qIsInf(inf));
QVERIFY(qIsInf(-inf));
QVERIFY(qIsInf(2*inf));
QCOMPARE(1/inf, 0.0);
QVERIFY(qIsNaN(0*nan));
QVERIFY(qIsNaN(0*inf));
QVERIFY(qFuzzyCompare(1/inf, 0.0));
}
void
SamplingItem::copyDataPoint(int index)
{
if (hidden() || index >= my.dataCount)
my.itemData[index] = qQNaN();
else
my.itemData[index] = my.data[index];
}
void
SamplingItem::preserveSample(int index, int oldindex)
{
if (my.dataCount > oldindex)
my.itemData[index] = my.data[index] = my.data[oldindex];
else
my.itemData[index] = my.data[index] = qQNaN();
}
QNmeaPositionInfoSourcePrivate::QNmeaPositionInfoSourcePrivate(QNmeaPositionInfoSource *parent, QNmeaPositionInfoSource::UpdateMode updateMode)
: QObject(parent),
m_updateMode(updateMode),
m_device(0),
m_invokedStart(false),
m_positionError(QGeoPositionInfoSource::UnknownSourceError),
m_userEquivalentRangeError(qQNaN()),
m_source(parent),
m_nmeaReader(0),
m_updateTimer(0),
m_requestTimer(0),
m_horizontalAccuracy(qQNaN()),
m_verticalAccuracy(qQNaN()),
m_noUpdateLastInterval(false),
m_updateTimeoutSent(false),
m_connectedReadyRead(false)
{
}
QTM_BEGIN_NAMESPACE
/*!
\qmlclass BoundingBox QDeclarativeGeoBoundingBox
\brief The QGeoBoundingBox class defines a rectangular geographic area.
\ingroup qml-location
The BoundingBox class defines a rectangular geographic area.
This element is part of the \bold{QtMobility.location 1.1} module.
For behavioral details, please see \l QGeoBoundingBox.
\sa Landmark, Place, Address, {QGeoBoundingBox}
*/
QDeclarativeGeoBoundingBox::QDeclarativeGeoBoundingBox(QObject* parent) :
QObject(parent), m_height(qQNaN()), m_width(qQNaN())
{
}
void
SamplingItem::setPlotUtil(int index, double sum)
{
if (index < 0)
index = my.dataCount - 1;
if (hidden() || sum == 0.0 ||
index >= my.dataCount || qIsNaN(my.data[index]))
my.itemData[index] = qQNaN();
else
my.itemData[index] = 100.0 * my.data[index] / sum;
}
void
SamplingItem::rescaleValues(pmUnits *new_units)
{
pmUnits *old_units = &ChartItem::my.units;
pmAtomValue old_av, new_av;
console->post("Chart::update change units from %s to %s",
pmUnitsStr(old_units), pmUnitsStr(new_units));
for (int i = my.dataCount - 1; i >= 0; i--) {
if (my.data[i] != qQNaN()) {
old_av.d = my.data[i];
pmConvScale(PM_TYPE_DOUBLE, &old_av, old_units, &new_av, new_units);
my.data[i] = new_av.d;
}
if (my.itemData[i] != qQNaN()) {
old_av.d = my.itemData[i];
pmConvScale(PM_TYPE_DOUBLE, &old_av, old_units, &new_av, new_units);
my.itemData[i] = new_av.d;
}
}
}
/*!
Returns the width of this bounding box in degrees.
The return value is undefined if this bounding box is invalid.
*/
double QGeoBoundingBox::width() const
{
if (!isValid())
return qQNaN();
double result = d_ptr->bottomRight.longitude() - d_ptr->topLeft.longitude();
if (result < 0.0)
result += 360.0;
if (result > 360.0)
result -= 360.0;
return result;
}
double
SamplingItem::setDataStack(int index, double sum)
{
if (index < 0)
index = my.dataCount - 1;
if (hidden() || qIsNaN(my.data[index])) {
my.itemData[index] = qQNaN();
} else {
sum += my.data[index];
my.itemData[index] = sum;
}
return sum;
}
void tst_QGeoBoundingCircle::empty_data()
{
QTest::addColumn<QGeoCoordinate>("center");
QTest::addColumn<qreal>("radius");
QTest::addColumn<bool>("empty");
QTest::newRow("default") << QGeoCoordinate() << qreal(-1.0) << true;
QTest::newRow("empty coord") << QGeoCoordinate() << qreal(5.0) << true;
QTest::newRow("NaN coord") << QGeoCoordinate(500, 500) << qreal(5.0) << true;
QTest::newRow("bad radius") << QGeoCoordinate(10, 10) << qreal(-5.0) << true;
QTest::newRow("NaN radius") << QGeoCoordinate(10, 10) << qreal(qQNaN()) << true;
QTest::newRow("zero radius") << QGeoCoordinate(10, 10) << qreal(0.0) << true;
QTest::newRow("good") << QGeoCoordinate(10, 10) << qreal(5.0) << false;
}
QDoubleVector2D QGeoTiledMapGoogle::coordinateToItemPosition(const QGeoCoordinate &coordinate, bool clipToViewport) const
{
QGeoCoordinate coor = coordinate;
//WGS84 to GCJ-02
if("cn" == m_szLocale)
{
//qDebug() << "transformFromWGSToGCJ:";
//qDebug() << "lat:" << coor.latitude() << ";lng:" << coor.longitude();
coor = QCoordTrans::WGSToGCJ(coor);
//qDebug() << "lat:" << coor.latitude() << ";lng:" << coor.longitude();
}
QDoubleVector2D pos = QGeoTiledMap::coordinateToItemPosition(coor, clipToViewport);
if (clipToViewport) {
int w = width();
int h = height();
if ((pos.x() < 0) || (w < pos.x()) || (pos.y() < 0) || (h < pos.y()))
return QDoubleVector2D(qQNaN(), qQNaN());
}
return pos;
}
GcodeViewParse::GcodeViewParse(QObject *parent) :
QObject(parent)
{
absoluteMode = true;
absoluteIJK = false;
currentLine = 0;
debug = true;
m_min = QVector3D(qQNaN(), qQNaN(), qQNaN());
m_max = QVector3D(qQNaN(), qQNaN(), qQNaN());
m_minLength = qQNaN();
}
/*!
Returns the width of this geo rectangle in degrees.
The return value is undefined if this geo rectangle is invalid.
*/
double QGeoRectangle::width() const
{
if (!isValid())
return qQNaN();
Q_D(const QGeoRectangle);
double result = d->bottomRight.longitude() - d->topLeft.longitude();
if (result < 0.0)
result += 360.0;
if (result > 360.0)
result -= 360.0;
return result;
}
bool Ledger::checkCsvRow(QList<QStandardItem*> &row, QString &field, QChar ch)
{
if(field.count("\"")%2 == 0) {
if (field.startsWith( QChar('\"')) && field.endsWith( QChar('\"') ) ) {
field.remove( QRegularExpression("^\"") );
field.remove( QRegularExpression("\"$") );
}
field.replace("\"\"", "\"");
LedgerItem *item = new LedgerItem();
if( row.size()==COL_DATE ){
QDate fieldDate = QDate::fromString(field,Qt::ISODate);
item->setData(QVariant(fieldDate),Qt::EditRole);
item->setData(Qt::AlignCenter,Qt::TextAlignmentRole);
item->setData(*MainWindow::numFont,Qt::FontRole);
} else if( row.size()==COL_DESCRIP ) {
item->setData(QVariant(field),Qt::EditRole);
item->setData(int(Qt::AlignLeft|Qt::AlignVCenter),Qt::TextAlignmentRole);
} else if( row.size()==COL_PRICE ) {
bool numeric;
double fieldNum = field.toDouble(&numeric);
if(numeric && fieldNum!=qQNaN())
item->setData(QVariant(fieldNum),Qt::EditRole);
item->setData(int(Qt::AlignRight|Qt::AlignVCenter),Qt::TextAlignmentRole);
item->setData(*MainWindow::numFont,Qt::FontRole);
} else if( row.size()==COL_CATEG ) {
bool isInt;
int fieldInt = field.toInt(&isInt);
if(isInt)
item->setData(QVariant(fieldInt),Qt::EditRole);
item->setData(int(Qt::AlignLeft|Qt::AlignVCenter),Qt::TextAlignmentRole);
} else
item->setText(field); // Not really necessary
if(row.size()<NCOL)
row.append(static_cast<QStandardItem*>(item));
field.clear();
if (ch != QChar(',')) {
QCoreApplication::processEvents(QEventLoop::AllEvents,1);
if(row.size()!=NCOL) return false;
appendRow(row);
row.clear();
}
} else {
field.append(ch);
}
return true;
}
QPlace QPlaceManagerEngineJsonDb::compatiblePlace(const QPlace &original) const
{
QPlace place;
place.setName(original.name());
QGeoLocation location = original.location();
QGeoCoordinate coord = original.location().coordinate();
coord.setAltitude(qQNaN());
location.setCoordinate(coord);
location.setBoundingBox(QGeoRectangle());
place.setLocation(location);
QList<QPlaceContactDetail> details;
foreach (const QString &contactType, original.contactTypes())
place.setContactDetails(contactType, original.contactDetails(contactType));
place.setVisibility(QLocation::UnspecifiedVisibility);
QStringList attributeTypes = original.extendedAttributeTypes();
foreach (const QString &attributeType, attributeTypes)
place.setExtendedAttribute(attributeType, original.extendedAttribute(attributeType));
QString provider = original.extendedAttribute(QLatin1String("x_provider")).text();
if (!provider.isEmpty()) {
QPlaceAttribute alternativeId;
alternativeId.setText(original.placeId());
place.setExtendedAttribute(QString::fromLatin1("x_id_") + provider,
alternativeId);
if (provider == QLatin1String("nokia") || provider == QLatin1String("nokia_mos")) {
QStringList nokiaCategoryIds;
foreach (const QPlaceCategory &cat, original.categories()) {
if (!cat.categoryId().isEmpty())
nokiaCategoryIds.append(cat.categoryId());
}
if (!nokiaCategoryIds.isEmpty()) {
QPlaceAttribute nokiaCatIds;
nokiaCatIds.setText(nokiaCategoryIds.join(QLatin1String(",")));
place.setExtendedAttribute(QString::fromLatin1("x_nokia_category_ids"), nokiaCatIds);
}
}
void
SamplingItem::updateValues(bool forward,
bool rateConvert, pmUnits *units, int sampleHistory, int,
double, double, double)
{
pmAtomValue scaled, raw;
QmcMetric *metric = ChartItem::my.metric;
double value;
int sz;
if (metric->numValues() < 1 || metric->error(0)) {
value = qQNaN();
} else {
// convert raw value to current chart scale
raw.d = rateConvert ? metric->value(0) : metric->currentValue(0);
pmConvScale(PM_TYPE_DOUBLE, &raw, &ChartItem::my.units, &scaled, units);
value = scaled.d * my.scale;
}
if (my.dataCount < sampleHistory)
sz = qMax(0, (int)(my.dataCount * sizeof(double)));
else
sz = qMax(0, (int)((my.dataCount - 1) * sizeof(double)));
if (forward) {
memmove(&my.data[1], &my.data[0], sz);
memmove(&my.itemData[1], &my.itemData[0], sz);
my.data[0] = value;
} else {
memmove(&my.data[0], &my.data[1], sz);
memmove(&my.itemData[0], &my.itemData[1], sz);
my.data[my.dataCount - 1] = value;
}
if (my.dataCount < sampleHistory)
my.dataCount++;
}
"engine->evaluate(\"'12.4'\")",
"engine->nullValue()",
"engine->undefinedValue()",
"engine->newObject()",
"engine->newArray()",
"engine->newArray(10)",
"engine->newDate(QDateTime())",
"engine->newQMetaObject(&QObject::staticMetaObject)",
"engine->newRegExp(\"foo\", \"gim\")",
"engine->newVariant(QVariant())",
"engine->newVariant(QVariant(123))",
"engine->newVariant(QVariant(false))",
"engine->newQObject(0)",
"engine->newQObject(engine)"};
static qsreal qscriptvalue_castqsreal_valueArray[] = {
0, qQNaN(), 0, 1, 0, 122, 124, 0, 0, 123,
6.369999999999999e-08, -6.369999999999999e-08, 1126240820, 65536, 65537, qQNaN(), qQNaN(), qInf(), qInf(), qQNaN(),
qInf(), qInf(), qQNaN(), qQNaN(), 0, 0, 0, 123, 12.4, qQNaN(),
0, 1, 0, 122, 124, 0, 0, 123, 6.369999999999999e-08, -6.369999999999999e-08,
1126240820, 65536, 65537, qQNaN(), qQNaN(), qInf(), qInf(), qQNaN(), qInf(), qInf(),
qQNaN(), qQNaN(), 0, 0, 0, 123, 12.3, qQNaN(), 0, 1,
0, 122, 124, 0, 0, 123, 6.369999999999999e-08, -6.369999999999999e-08, 1126240820, 65536,
65537, qQNaN(), qQNaN(), qInf(), qInf(), qQNaN(), qInf(), qInf(), qQNaN(), qQNaN(),
0, 0, 0, 123, 1.23, 0, qQNaN(), qQNaN(), qQNaN(), 0,
qQNaN(), qQNaN(), qQNaN(), qQNaN(), qQNaN(), qQNaN(), qQNaN(), qQNaN(), qQNaN(), qQNaN(),
qQNaN(), 0, qQNaN(), 1, 0, 123, qQNaN(), qQNaN(), 22, qQNaN(),
qQNaN(), qQNaN(), qQNaN(), qQNaN(), 0, 1, 0, 122, 124, 0,
0, 123, 6.369999999999999e-08, -6.369999999999999e-08, 1126240820, 65536, 65537, qQNaN(), qInf(), qInf(),
qQNaN(), 0, 0, 123, 12.4, 0, qQNaN(), qQNaN(), 0, qQNaN(),
qQNaN(), qQNaN(), qQNaN(), qQNaN(), 123, 0, 0, qQNaN()};
void tst_QScriptValueGenerated::qscriptvalue_castqsreal_makeData(const char* expr)
QGeoCoordinatePrivate() {
lat = qQNaN();
lng = qQNaN();
alt = qQNaN();
}
/*!
\return the value at a raster position
\param x X value in plot coordinates
\param y Y value in plot coordinates
\sa ResampleMode
*/
double QwtMatrixRasterData::value( double x, double y ) const
{
const QwtInterval xInterval = interval( Qt::XAxis );
const QwtInterval yInterval = interval( Qt::YAxis );
if ( !( xInterval.contains(x) && yInterval.contains(y) ) )
return qQNaN();
double value;
switch( d_data->resampleMode )
{
case BilinearInterpolation:
{
int col1 = qRound( (x - xInterval.minValue() ) / d_data->dx ) - 1;
int row1 = qRound( (y - yInterval.minValue() ) / d_data->dy ) - 1;
int col2 = col1 + 1;
int row2 = row1 + 1;
if ( col1 < 0 )
col1 = col2;
else if ( col2 >= static_cast<int>( d_data->numColumns ) )
col2 = col1;
if ( row1 < 0 )
row1 = row2;
else if ( row2 >= static_cast<int>( d_data->numRows ) )
row2 = row1;
const double v11 = d_data->value( row1, col1 );
const double v21 = d_data->value( row1, col2 );
const double v12 = d_data->value( row2, col1 );
const double v22 = d_data->value( row2, col2 );
const double x2 = xInterval.minValue() +
( col2 + 0.5 ) * d_data->dx;
const double y2 = yInterval.minValue() +
( row2 + 0.5 ) * d_data->dy;
const double rx = ( x2 - x ) / d_data->dx;
const double ry = ( y2 - y ) / d_data->dy;
const double vr1 = rx * v11 + ( 1.0 - rx ) * v21;
const double vr2 = rx * v12 + ( 1.0 - rx ) * v22;
value = ry * vr1 + ( 1.0 - ry ) * vr2;
break;
}
case NearestNeighbour:
default:
{
int row = int( (y - yInterval.minValue() ) / d_data->dy );
int col = int( (x - xInterval.minValue() ) / d_data->dx );
// In case of intervals, where the maximum is included
// we get out of bound for row/col, when the value for the
// maximum is requested. Instead we return the value
// from the last row/col
if ( row >= d_data->numRows )
row = d_data->numRows - 1;
if ( col >= d_data->numColumns )
col = d_data->numColumns - 1;
value = d_data->value( row, col );
}
}
return value;
}
qreal Accelerometer::x() const {
if (QAccelerometerReading *reading = this->reading()) return reading->x();
return qQNaN();
}
QcMapResolution::QcMapResolution(double resolution)
: m_resolution(qQNaN())
{
set_resolution(resolution);
}
//-----------------------------------------------------------------------------
qtDoubleSpinBoxDelegatePrivate::qtDoubleSpinBoxDelegatePrivate()
: precision(-1), minimum(qQNaN()), maximum(qQNaN()),
dataRole(Qt::EditRole)
{
}
inline void setInvalid()
{
m_dts = m_pts = qQNaN();
}
void tst_QScriptValueGenerated::initScriptValues()
{
m_values.clear();
if (engine)
delete engine;
engine = new QScriptEngine;
DEFINE_TEST_VALUE(QScriptValue());
DEFINE_TEST_VALUE(QScriptValue(QScriptValue::UndefinedValue));
DEFINE_TEST_VALUE(QScriptValue(QScriptValue::NullValue));
DEFINE_TEST_VALUE(QScriptValue(true));
DEFINE_TEST_VALUE(QScriptValue(false));
DEFINE_TEST_VALUE(QScriptValue(int(122)));
DEFINE_TEST_VALUE(QScriptValue(uint(124)));
DEFINE_TEST_VALUE(QScriptValue(0));
DEFINE_TEST_VALUE(QScriptValue(0.0));
DEFINE_TEST_VALUE(QScriptValue(123.0));
DEFINE_TEST_VALUE(QScriptValue(6.37e-8));
DEFINE_TEST_VALUE(QScriptValue(-6.37e-8));
DEFINE_TEST_VALUE(QScriptValue(0x43211234));
DEFINE_TEST_VALUE(QScriptValue(0x10000));
DEFINE_TEST_VALUE(QScriptValue(0x10001));
DEFINE_TEST_VALUE(QScriptValue(qSNaN()));
DEFINE_TEST_VALUE(QScriptValue(qQNaN()));
DEFINE_TEST_VALUE(QScriptValue(qInf()));
DEFINE_TEST_VALUE(QScriptValue(-qInf()));
DEFINE_TEST_VALUE(QScriptValue("NaN"));
DEFINE_TEST_VALUE(QScriptValue("Infinity"));
DEFINE_TEST_VALUE(QScriptValue("-Infinity"));
DEFINE_TEST_VALUE(QScriptValue("ciao"));
DEFINE_TEST_VALUE(QScriptValue(QString::fromLatin1("ciao")));
DEFINE_TEST_VALUE(QScriptValue(QString("")));
DEFINE_TEST_VALUE(QScriptValue(QString()));
DEFINE_TEST_VALUE(QScriptValue(QString("0")));
DEFINE_TEST_VALUE(QScriptValue(QString("123")));
DEFINE_TEST_VALUE(QScriptValue(QString("12.4")));
DEFINE_TEST_VALUE(QScriptValue(0, QScriptValue::UndefinedValue));
DEFINE_TEST_VALUE(QScriptValue(0, QScriptValue::NullValue));
DEFINE_TEST_VALUE(QScriptValue(0, true));
DEFINE_TEST_VALUE(QScriptValue(0, false));
DEFINE_TEST_VALUE(QScriptValue(0, int(122)));
DEFINE_TEST_VALUE(QScriptValue(0, uint(124)));
DEFINE_TEST_VALUE(QScriptValue(0, 0));
DEFINE_TEST_VALUE(QScriptValue(0, 0.0));
DEFINE_TEST_VALUE(QScriptValue(0, 123.0));
DEFINE_TEST_VALUE(QScriptValue(0, 6.37e-8));
DEFINE_TEST_VALUE(QScriptValue(0, -6.37e-8));
DEFINE_TEST_VALUE(QScriptValue(0, 0x43211234));
DEFINE_TEST_VALUE(QScriptValue(0, 0x10000));
DEFINE_TEST_VALUE(QScriptValue(0, 0x10001));
DEFINE_TEST_VALUE(QScriptValue(0, qSNaN()));
DEFINE_TEST_VALUE(QScriptValue(0, qQNaN()));
DEFINE_TEST_VALUE(QScriptValue(0, qInf()));
DEFINE_TEST_VALUE(QScriptValue(0, -qInf()));
DEFINE_TEST_VALUE(QScriptValue(0, "NaN"));
DEFINE_TEST_VALUE(QScriptValue(0, "Infinity"));
DEFINE_TEST_VALUE(QScriptValue(0, "-Infinity"));
DEFINE_TEST_VALUE(QScriptValue(0, "ciao"));
DEFINE_TEST_VALUE(QScriptValue(0, QString::fromLatin1("ciao")));
DEFINE_TEST_VALUE(QScriptValue(0, QString("")));
DEFINE_TEST_VALUE(QScriptValue(0, QString()));
DEFINE_TEST_VALUE(QScriptValue(0, QString("0")));
DEFINE_TEST_VALUE(QScriptValue(0, QString("123")));
DEFINE_TEST_VALUE(QScriptValue(0, QString("12.3")));
DEFINE_TEST_VALUE(QScriptValue(engine, QScriptValue::UndefinedValue));
DEFINE_TEST_VALUE(QScriptValue(engine, QScriptValue::NullValue));
DEFINE_TEST_VALUE(QScriptValue(engine, true));
DEFINE_TEST_VALUE(QScriptValue(engine, false));
DEFINE_TEST_VALUE(QScriptValue(engine, int(122)));
DEFINE_TEST_VALUE(QScriptValue(engine, uint(124)));
DEFINE_TEST_VALUE(QScriptValue(engine, 0));
DEFINE_TEST_VALUE(QScriptValue(engine, 0.0));
DEFINE_TEST_VALUE(QScriptValue(engine, 123.0));
DEFINE_TEST_VALUE(QScriptValue(engine, 6.37e-8));
DEFINE_TEST_VALUE(QScriptValue(engine, -6.37e-8));
DEFINE_TEST_VALUE(QScriptValue(engine, 0x43211234));
DEFINE_TEST_VALUE(QScriptValue(engine, 0x10000));
DEFINE_TEST_VALUE(QScriptValue(engine, 0x10001));
DEFINE_TEST_VALUE(QScriptValue(engine, qSNaN()));
DEFINE_TEST_VALUE(QScriptValue(engine, qQNaN()));
DEFINE_TEST_VALUE(QScriptValue(engine, qInf()));
DEFINE_TEST_VALUE(QScriptValue(engine, -qInf()));
DEFINE_TEST_VALUE(QScriptValue(engine, "NaN"));
DEFINE_TEST_VALUE(QScriptValue(engine, "Infinity"));
DEFINE_TEST_VALUE(QScriptValue(engine, "-Infinity"));
DEFINE_TEST_VALUE(QScriptValue(engine, "ciao"));
DEFINE_TEST_VALUE(QScriptValue(engine, QString::fromLatin1("ciao")));
DEFINE_TEST_VALUE(QScriptValue(engine, QString("")));
DEFINE_TEST_VALUE(QScriptValue(engine, QString()));
DEFINE_TEST_VALUE(QScriptValue(engine, QString("0")));
DEFINE_TEST_VALUE(QScriptValue(engine, QString("123")));
DEFINE_TEST_VALUE(QScriptValue(engine, QString("1.23")));
DEFINE_TEST_VALUE(engine->evaluate("[]"));
DEFINE_TEST_VALUE(engine->evaluate("{}"));
DEFINE_TEST_VALUE(engine->evaluate("Object.prototype"));
DEFINE_TEST_VALUE(engine->evaluate("Date.prototype"));
DEFINE_TEST_VALUE(engine->evaluate("Array.prototype"));
DEFINE_TEST_VALUE(engine->evaluate("Function.prototype"));
DEFINE_TEST_VALUE(engine->evaluate("Error.prototype"));
DEFINE_TEST_VALUE(engine->evaluate("Object"));
DEFINE_TEST_VALUE(engine->evaluate("Array"));
DEFINE_TEST_VALUE(engine->evaluate("Number"));
DEFINE_TEST_VALUE(engine->evaluate("Function"));
DEFINE_TEST_VALUE(engine->evaluate("(function() { return 1; })"));
DEFINE_TEST_VALUE(engine->evaluate("(function() { return 'ciao'; })"));
DEFINE_TEST_VALUE(engine->evaluate("(function() { throw new Error('foo'); })"));
DEFINE_TEST_VALUE(engine->evaluate("/foo/"));
DEFINE_TEST_VALUE(engine->evaluate("new Object()"));
DEFINE_TEST_VALUE(engine->evaluate("new Array()"));
DEFINE_TEST_VALUE(engine->evaluate("new Error()"));
DEFINE_TEST_VALUE(engine->evaluate("new Boolean(true)"));
DEFINE_TEST_VALUE(engine->evaluate("new Boolean(false)"));
DEFINE_TEST_VALUE(engine->evaluate("new Number(123)"));
DEFINE_TEST_VALUE(engine->evaluate("new RegExp('foo', 'gim')"));
DEFINE_TEST_VALUE(engine->evaluate("new String('ciao')"));
DEFINE_TEST_VALUE(engine->evaluate("a = new Object(); a.foo = 22; a.foo"));
DEFINE_TEST_VALUE(engine->evaluate("Undefined"));
DEFINE_TEST_VALUE(engine->evaluate("Null"));
DEFINE_TEST_VALUE(engine->evaluate("True"));
DEFINE_TEST_VALUE(engine->evaluate("False"));
DEFINE_TEST_VALUE(engine->evaluate("undefined"));
DEFINE_TEST_VALUE(engine->evaluate("null"));
DEFINE_TEST_VALUE(engine->evaluate("true"));
DEFINE_TEST_VALUE(engine->evaluate("false"));
DEFINE_TEST_VALUE(engine->evaluate("122"));
DEFINE_TEST_VALUE(engine->evaluate("124"));
DEFINE_TEST_VALUE(engine->evaluate("0"));
DEFINE_TEST_VALUE(engine->evaluate("0.0"));
DEFINE_TEST_VALUE(engine->evaluate("123.0"));
DEFINE_TEST_VALUE(engine->evaluate("6.37e-8"));
DEFINE_TEST_VALUE(engine->evaluate("-6.37e-8"));
DEFINE_TEST_VALUE(engine->evaluate("0x43211234"));
DEFINE_TEST_VALUE(engine->evaluate("0x10000"));
DEFINE_TEST_VALUE(engine->evaluate("0x10001"));
DEFINE_TEST_VALUE(engine->evaluate("NaN"));
DEFINE_TEST_VALUE(engine->evaluate("Infinity"));
DEFINE_TEST_VALUE(engine->evaluate("-Infinity"));
DEFINE_TEST_VALUE(engine->evaluate("'ciao'"));
DEFINE_TEST_VALUE(engine->evaluate("''"));
DEFINE_TEST_VALUE(engine->evaluate("'0'"));
DEFINE_TEST_VALUE(engine->evaluate("'123'"));
DEFINE_TEST_VALUE(engine->evaluate("'12.4'"));
DEFINE_TEST_VALUE(engine->nullValue());
DEFINE_TEST_VALUE(engine->undefinedValue());
DEFINE_TEST_VALUE(engine->newObject());
DEFINE_TEST_VALUE(engine->newArray());
DEFINE_TEST_VALUE(engine->newArray(10));
DEFINE_TEST_VALUE(engine->newDate(QDateTime()));
DEFINE_TEST_VALUE(engine->newQMetaObject(&QObject::staticMetaObject));
DEFINE_TEST_VALUE(engine->newRegExp("foo", "gim"));
DEFINE_TEST_VALUE(engine->newVariant(QVariant()));
DEFINE_TEST_VALUE(engine->newVariant(QVariant(123)));
DEFINE_TEST_VALUE(engine->newVariant(QVariant(false)));
DEFINE_TEST_VALUE(engine->newQObject(0));
DEFINE_TEST_VALUE(engine->newQObject(engine));
}
WeatherData::WeatherData()
: stationLat(qQNaN())
, stationLon(qQNaN())
, temperature_F(qQNaN())
, temperature_C(qQNaN())
, humidity(qQNaN())
, windSpeed(qQNaN())
, windGust(qQNaN())
, pressure(qQNaN())
, dewpoint_F(qQNaN())
, dewpoint_C(qQNaN())
, heatindex_F(qQNaN())
, heatindex_C(qQNaN())
, windchill_F(qQNaN())
, windchill_C(qQNaN())
, visibility(qQNaN())
{
}
void
SamplingItem::punchoutSample(int index)
{
my.data[index] = my.itemData[index] = qQNaN();
}
float temperature() { return qQNaN(); }
qreal Positioning::longitude() const {
QReadLocker locker(&this->t_readWriteLock);
return this->t_geoInfo.isValid() ? this->t_geoInfo.coordinate().longitude() : qQNaN();
}
