void TestQgsFields::field()
{
QgsField original;
original.setName( "name" );
original.setType( QVariant::Int );
original.setLength( 5 );
original.setPrecision( 2 );
//test constructors for QgsFields::Field
QgsFields::Field fieldConstructor1( original, QgsFields::OriginJoin, 5 );
QCOMPARE( fieldConstructor1.field, original );
QCOMPARE( fieldConstructor1.origin, QgsFields::OriginJoin );
QCOMPARE( fieldConstructor1.originIndex, 5 );
QgsFields::Field fieldConstructor2;
QCOMPARE( fieldConstructor2.origin, QgsFields::OriginUnknown );
QCOMPARE( fieldConstructor2.originIndex, -1 );
//test equality operators
QgsFields::Field field1( original, QgsFields::OriginJoin, 5 );
QgsFields::Field field2( original, QgsFields::OriginJoin, 5 );
QVERIFY( field1 == field2 );
QgsFields::Field field3( original, QgsFields::OriginEdit, 5 );
QVERIFY( field1 != field3 );
QgsFields::Field field4( original, QgsFields::OriginJoin, 6 );
QVERIFY( field1 != field4 );
}
void tst_QSqlField::setValue()
{
QSqlField field1 ( "test", QVariant::Int );
QSqlField field2 ( "test", QVariant::String );
QSqlField field3 ( "test", QVariant::Bool );
QSqlField field4 ( "test", QVariant::Double );
field1.clear();
QFETCH( int, ival );
QFETCH( QString, sval );
QFETCH( double, dval );
QFETCH( bool, bval );
field1.setValue( ival );
QCOMPARE( field1.value().toInt(), ival );
// setValue should also reset the NULL flag
QVERIFY( !field1.isNull() );
field2.setValue( sval );
QCOMPARE( field2.value().toString(), sval );
field3.setValue( QVariant( bval) );
QVERIFY( field3.value().toBool() == bval );
field4.setValue( dval );
QCOMPARE( field4.value().toDouble(), dval );
field4.setReadOnly( true );
field4.setValue( "Something_that's_not_a_double" );
QCOMPARE( field4.value().toDouble(), dval );
}
void tst_QSqlField::operator_Equal()
{
QSqlField field1( "test", QVariant::String );
QSqlField field2( "test2", QVariant::String );
QSqlField field3( "test", QVariant::Int );
QSqlField field4("test", QVariant::String, QString("ATable"));
QSqlField field5("test2", QVariant::String, QString("ATable"));
QSqlField field6("test", QVariant::String, QString("BTable"));
QVERIFY( !(field1 == field2) );
QVERIFY( !(field1 == field3) );
QVERIFY(field1 != field4);
QVERIFY(field1 != field5);
QVERIFY(field1 != field6);
QVERIFY(field4 != field5);
QVERIFY(field4 != field6);
field2.setName( "test" );
QVERIFY( field1 == field2 );
QVERIFY( field1 == field2 );
field1.setValue( "Harry" );
QVERIFY( !(field1 == field2) );
field2.setValue( "Harry" );
QVERIFY( field1 == field2 );
field1.setReadOnly( true );
QVERIFY( !(field1 == field2) );
field2.setReadOnly( true );
QVERIFY( field1 == field2 );
field4.setTableName("BTable");
QCOMPARE(field4, field6);
field6.setName("test3");
QVERIFY(field4 != field6);
}
void TestQuery::constructor()
{
QcSqlField field1("field1");
QcSqlField field2("field2");
QcSqlField field3("field3");
check_sql(field1 == 1, "field1 = 1");
check_sql(field1 != 1, "field1 != 1");
check_sql(field1 < 1, "field1 < 1");
check_sql(field1 > 1, "field1 > 1");
check_sql(field1 <= 1, "field1 <= 1");
check_sql(field1 >= 1, "field1 >= 1");
// check_sql(not field1 == 1, "(NOT field1 = 1)");
check_sql(Not(field1 == 1), "(NOT field1 = 1)");
check_sql(field1 == 1 and field2 == 2, "(field1 = 1 AND field2 = 2)");
check_sql(field1 == 1 or field2 == 2, "(field1 = 1 OR field2 = 2)");
check_sql((field1 == 1 and field2 == 2) or field3 == 3,
"((field1 = 1 AND field2 = 2) OR field3 = 3)");
QcDatabase database; // Flavour is ANSI
QcDatabaseTable table(&database, "table");
check_sql(table.sql_query(), "");
check_sql(table.sql_query().all(), "SELECT * FROM table;");
check_sql(table.sql_query().add_column(field1).all(), "SELECT field1 FROM table;");
check_sql(table.sql_query().add_column(field1).add_column(field2).all().filter(field1 > 1),
"SELECT field1, field2 FROM table WHERE field1 > 1;");
check_sql(table.sql_query().add_column(field1).add_column(field2).all().filter((field1 > 1 and field1 < 10) or field2 > 2),
"SELECT field1, field2 FROM table WHERE ((field1 > 1 AND field1 < 10) OR field2 > 2);");
check_sql(table.sql_query().order_by(field1).all(),
"SELECT * FROM table ORDER BY field1;");
check_sql(table.sql_query().order_by(field1.desc()).all(),
"SELECT * FROM table ORDER BY field1 DESC;");
// Fixme: ->as
check_sql(table.sql_query().add_column(Min(field1)->as("min_field1")).all(),
"SELECT MIN(field1) AS min_field1 FROM table;");
// Fixme: INSERT INTO table VALUES (?, ...);
check_sql(table.sql_query().add_column(field1).insert(),
"INSERT INTO table (field1) VALUES (?);");
check_sql(table.sql_query().add_column(field1).add_column(field2).insert(),
"INSERT INTO table (field1, field2) VALUES (?, ?);");
check_sql(table.sql_query().add_column(field1).update().filter(field1 > 1),
"UPDATE table SET field1 = ? WHERE field1 > 1;");
check_sql(table.sql_query().add_column(field1).add_column(field2).update().filter(field1 > 1),
"UPDATE table SET field1 = ?, field2 = ? WHERE field1 > 1;");
check_sql(table.sql_query().delete_().filter(field1 > 1),
"DELETE FROM table WHERE field1 > 1;");
check_sql(table.sql_query().add_column(ST_AsBinary(field1)).all(),
"SELECT ST_AsBinary(field1) FROM table;");
check_sql(table.sql_query().add_column(field1).add_column(field2, ST_GeomFromWKB()).insert(),
"INSERT INTO table (field1, field2) VALUES (?, ST_GeomFromWKB(?));");
}
void testit(int* wanted, int Nwanted, int dimquads, int (*compar)(const void *, const void *),
anbool cxdx) {
int i;
solver_t* solver;
index_t index;
starxy_t* starxy;
starxy = field1();
quadlist = bl_new(16, dimquads*sizeof(int));
ninv = 0;
solver = solver_new();
memset(&index, 0, sizeof(index_t));
index.index_scale_lower = 1;
index.index_scale_upper = 10;
index.dimquads = dimquads;
index.cx_less_than_dx = index.meanx_less_than_half = cxdx;
solver->funits_lower = 0.1;
solver->funits_upper = 10;
solver_add_index(solver, &index);
solver_set_field(solver, starxy);
solver_preprocess_field(solver);
printf("Found:\n");
solver_run(solver);
printf("\n");
fflush(NULL);
solver_free_field(solver);
solver_free(solver);
//
bl_sort(quadlist, compar);
qsort(wanted, Nwanted, dimquads*sizeof(int), compar);
printf("\n\n");
printf("Wanted:\n");
for (i=0; i<Nwanted; i++) {
int j;
printf("{");
for (j=0; j<dimquads; j++)
printf("%s%i", (j?",":""), wanted[i*dimquads+j]);
printf("}, ");
}
printf("\n");
printf("N found: %i; N wanted: %i\n", bl_size(quadlist), Nwanted);
printf("N obeying invariants: %i\n", ninv);
assert(bl_size(quadlist) == Nwanted);
for (i=0; i<bl_size(quadlist); i++) {
//int* i1 = bl_access(quadlist, i);
//int* i2 = wanted[i];
//printf("[%i, %i, %i] vs [%i, %i, %i]\n", i1[0],i1[1],i1[2], i2[0],i2[1],i2[2]);
assert(compar(bl_access(quadlist, i), wanted+i*dimquads) == 0);
}
bl_free(quadlist);
}
void tst_QSqlField::type()
{
QSqlField field1( "string", QVariant::String );
QSqlField field2( "string", QVariant::Bool );
QSqlField field3( "string", QVariant::Double );
QVERIFY( field1.type() == QVariant::String );
QVERIFY( field2.type() == QVariant::Bool );
QVERIFY( field3.type() == QVariant::Double );
}
void tst_QSqlField::operator_Assign()
{
QSqlField field1( "test", QVariant::String );
field1.setValue( "Harry" );
field1.setReadOnly( true );
QSqlField field2 = field1;
QVERIFY( field1 == field2 );
QSqlField field3( "test", QVariant::Double );
field3.clear();
field1 = field3;
QVERIFY( field1 == field3 );
}
void TargetsDialog::createTargetFromSelection()
{
if (StelApp::getInstance().getStelObjectMgr().getWasSelected()) {
QList<StelObjectP> selectedObjects = StelApp::getInstance().getStelObjectMgr().getSelectedObject();
QListIterator<StelObjectP> objectIterator(selectedObjects);
StelCore* core = StelApp::getInstance().getCore();
while (objectIterator.hasNext()) {
StelObjectP stelObject = objectIterator.next();
QString type = stelObject->getType();
QString englishName = stelObject->getEnglishName();
if (englishName == "") {
englishName = "No Name";
}
float magnatude = stelObject->getVMagnitude(core);
double angularSize = stelObject->getAngularSize(core);
Vec3d pos;
double ra, dec;
// ra/dec in J2000
pos = stelObject->getJ2000EquatorialPos(core);
StelUtils::rectToSphe(&ra, &dec, pos);
QSqlField field1("name", QVariant::String);
QSqlField field2("right_ascension", QVariant::Double);
QSqlField field3("declination", QVariant::Double);
QSqlField field4("target_type_id", QVariant::Int);
QSqlField field5("magnitude", QVariant::Double);
QSqlField field6("size", QVariant::Double);
field1.setValue(QVariant(englishName));
field2.setValue(QVariant(ra));
field3.setValue(QVariant(dec));
field4.setValue(QVariant(1));
field5.setValue(QVariant(magnatude));
field6.setValue(QVariant(angularSize));
QSqlRecord newRecord = QSqlRecord();
newRecord.append(field1);
newRecord.append(field2);
newRecord.append(field3);
newRecord.append(field4);
newRecord.append(field5);
newRecord.append(field6);
if (tableModel->insertRecord(-1, newRecord)) {
ui->targetsListView->setCurrentIndex(tableModel->index(tableModel->rowCount() - 1, 1));
} else {
qWarning() << "LogBook: could not insert new target. The error is: " << tableModel->lastError();
}
}
} else {
qDebug() << "====> Nothing selected.";
}
}
Farm::Farm(float density): Region(density, "Farm")
{
// Set standard background
for (int x = 0; x < REGIONSIZE; x++)
{
for (int y = 0; y < REGIONSIZE; y++)
{
if (lbRNG::decision(0.05))
{
// Random tree or two
replace(x,y, new Tile("grass-light","tree-light"));
} else {
replace(x,y, new Tile("grass-light"));
if (lbRNG::decision(0.01))
{
getTileAt(x, y)->setMob(new Sheep(getTileAt(x, y)));
}
}
}
}
// Add Barn
Feature barn(5,5);
barn.addAll("floor-wood-light");
barn.addBorder("wall-wood-light");
barn.addDoor("door-wood-open","door-wood-closed", N);
// Add fields
Field field1(8,5);
Field field2(4,9);
field1.generate();
field2.generate();
field1.clearBorder();
field1.addBorder("dirt-light");
field1.addBorder("fence-wood");
field1.addDoor("air","air",N);
field1.addDoor("air","air",S);
// Place down new tiles
replace(3,3,barn.tiles);
replace(2,9,field1.tiles);
replace(10,5,field2.tiles);
INFO("Generated Farm");
}
void tst_QSqlField::operator_Equal()
{
QSqlField field1( "test", QVariant::String );
QSqlField field2( "test2", QVariant::String );
QSqlField field3( "test", QVariant::Int );
QVERIFY( !(field1 == field2) );
QVERIFY( !(field1 == field3) );
field2.setName( "test" );
QVERIFY( field1 == field2 );
QVERIFY( field1 == field2 );
field1.setValue( "Harry" );
QVERIFY( !(field1 == field2) );
field2.setValue( "Harry" );
QVERIFY( field1 == field2 );
field1.setReadOnly( true );
QVERIFY( !(field1 == field2) );
field2.setReadOnly( true );
QVERIFY( field1 == field2 );
}
void BarlowsDataMapper::insertNewBarlow()
{
QSqlField field1("model", QVariant::String);
QSqlField field2("vendor", QVariant::String);
QSqlField field3("factor", QVariant::Double);
field1.setValue(QVariant("Model"));
field2.setValue(QVariant("Vendor"));
field3.setValue(QVariant(1.0));
QSqlRecord newRecord = QSqlRecord();
newRecord.append(field1);
newRecord.append(field2);
newRecord.append(field3);
if (tableModel->insertRecord(-1, newRecord)) {
widget->barlowsListView->setCurrentIndex(tableModel->index(tableModel->rowCount() - 1, 1));
} else {
qWarning() << "LogBook: could not insert new barlow. The error is: " << tableModel->lastError();
}
}
void TargetsDialog::insertNewTarget()
{
QSqlField field1("name", QVariant::String);
QSqlField field3("right_ascension", QVariant::Double);
QSqlField field4("declination", QVariant::Double);
QSqlField field6("target_type_id", QVariant::Int);
field1.setValue(QVariant("name"));
field3.setValue(QVariant(0.0));
field4.setValue(QVariant(0.0));
field6.setValue(QVariant(1));
QSqlRecord newRecord = QSqlRecord();
newRecord.append(field1);
newRecord.append(field3);
newRecord.append(field4);
newRecord.append(field6);
if (tableModel->insertRecord(-1, newRecord)) {
ui->targetsListView->setCurrentIndex(tableModel->index(tableModel->rowCount() - 1, 1));
} else {
qWarning() << "LogBook: could not insert new target. The error is: " << tableModel->lastError();
}
}
void test2() {
int i;
solver_t* solver;
index_t index;
starxy_t* starxy;
int wanted[][3] = { { 0, 1, 3 },
{ 0, 1, 4 },
{ 0, 1, 5 },
{ 0, 2, 3 },
{ 0, 2, 4 },
{ 0, 3, 4 },
{ 0, 5, 4 },
{ 0, 6, 4 },
{ 0, 6, 5 },
{ 1, 2, 3 },
{ 1, 2, 4 },
{ 1, 3, 4 },
{ 1, 5, 4 },
{ 1, 6, 4 },
{ 1, 6, 5 },
{ 2, 4, 3 },
{ 2, 5, 0 },
{ 2, 5, 1 },
{ 2, 5, 3 },
{ 2, 5, 4 },
{ 2, 6, 0 },
{ 2, 6, 1 },
{ 2, 6, 3 },
{ 2, 6, 4 },
{ 2, 6, 5 },
{ 3, 5, 4 },
{ 3, 6, 0 },
{ 3, 6, 1 },
{ 3, 6, 4 },
{ 3, 6, 5 },
{ 4, 6, 5 },
};
starxy = field1();
quadlist = bl_new(16, 3*sizeof(uint));
solver = solver_new();
memset(&index, 0, sizeof(index_t));
index.index_scale_lower = 1;
index.index_scale_upper = 10;
index.dimquads = 3;
solver->funits_lower = 0.1;
solver->funits_upper = 10;
solver_add_index(solver, &index);
solver_set_field(solver, starxy);
solver_preprocess_field(solver);
solver_run(solver);
solver_free_field(solver);
solver_free(solver);
//
assert(bl_size(quadlist) == (sizeof(wanted) / (3*sizeof(uint))));
bl_sort(quadlist, compare_tri);
for (i=0; i<bl_size(quadlist); i++) {
assert(compare_tri(bl_access(quadlist, i), wanted[i]) == 0);
}
bl_free(quadlist);
}
return fvMatrixHolder< Type >( laplacian( ds, field(), name ), Deps( &field ) );
}
template< class Type, class GType >
inline fvMatrixHolder< Type > laplacian( const GeometricFieldHolder< GType, fvPatchField, volMesh >& field1,
GeometricFieldHolder< Type, fvPatchField, volMesh >& field2 )
{
return fvMatrixHolder< Type >( laplacian( field1(), field2() ), Deps( &field1, &field2 ) );
}
template< class Type, class GType >
inline fvMatrixHolder< Type > laplacian( const GeometricFieldHolder< GType, fvPatchField, volMesh >& field1,
GeometricFieldHolder< Type, fvPatchField, volMesh >& field2
const word& name )
{
return fvMatrixHolder< Type >( laplacian( field1(), field2(), name ), Deps( &field1, &field2 ) );
}
template< class Type, class GType >
inline fvMatrixHolder< Type > laplacian( const GeometricFieldHolder< GType, vsPatchField, surfaceMesh >& field1,
GeometricFieldHolder< Type, fvPatchField, volMesh >& field2 )
{
return fvMatrixHolder< Type >( laplacian( field1(), field2() ), Deps( &field1, &field2 ) );
}
template< class Type, class GType >
inline fvMatrixHolder< Type > laplacian( const GeometricFieldHolder< GType, vsPatchField, surfaceMesh >& field1,
GeometricFieldHolder< Type, fvPatchField, volMesh >& field2
const word& name )
{
return fvMatrixHolder< Type >( laplacian( field1(), field2(), name ), Deps( &field1, &field2 ) );
