IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 10681 for trunk/ippdb/tests


Ignore:
Timestamp:
Dec 12, 2006, 5:52:50 PM (20 years ago)
Author:
jhoblitt
Message:

VERSION 0.0.65

Location:
trunk/ippdb/tests
Files:
11 edited

Legend:

Unmodified
Added
Removed

  • trunk/ippdb/tests/alloc.c

    r10328 r10681  
    14071407    }
    14081408
     1409    {
     1410        p4RunRow        *object;
     1411
     1412        object = p4RunRowAlloc(-32, "a string", "a string", "a string", "a string", "a string", 64.64, 64.64, "a string", "a string"    );
     1413
     1414        if (!object) {
     1415            exit(EXIT_FAILURE);
     1416        }
     1417
     1418        if (!object->p4_id == -32) {
     1419            psFree(object);
     1420            exit(EXIT_FAILURE);
     1421        }
     1422        if (strncmp(object->survey_mode, "a string", MAX_STRING_LENGTH)) {
     1423            psFree(object);
     1424            exit(EXIT_FAILURE);
     1425        }
     1426        if (strncmp(object->state, "a string", MAX_STRING_LENGTH)) {
     1427            psFree(object);
     1428            exit(EXIT_FAILURE);
     1429        }
     1430        if (strncmp(object->filter, "a string", MAX_STRING_LENGTH)) {
     1431            psFree(object);
     1432            exit(EXIT_FAILURE);
     1433        }
     1434        if (strncmp(object->skycell_id, "a string", MAX_STRING_LENGTH)) {
     1435            psFree(object);
     1436            exit(EXIT_FAILURE);
     1437        }
     1438        if (strncmp(object->tess_id, "a string", MAX_STRING_LENGTH)) {
     1439            psFree(object);
     1440            exit(EXIT_FAILURE);
     1441        }
     1442        if (!object->ra == 64.64) {
     1443            psFree(object);
     1444            exit(EXIT_FAILURE);
     1445        }
     1446        if (!object->decl == 64.64) {
     1447            psFree(object);
     1448            exit(EXIT_FAILURE);
     1449        }
     1450        if (strncmp(object->input_ss, "a string", MAX_STRING_LENGTH)) {
     1451            psFree(object);
     1452            exit(EXIT_FAILURE);
     1453        }
     1454        if (strncmp(object->output_ss, "a string", MAX_STRING_LENGTH)) {
     1455            psFree(object);
     1456            exit(EXIT_FAILURE);
     1457        }
     1458
     1459        psFree(object);
     1460    }
     1461
     1462    {
     1463        p4InputImfileRow *object;
     1464
     1465        object = p4InputImfileRowAlloc(-32, "a string", -32, "a string"    );
     1466
     1467        if (!object) {
     1468            exit(EXIT_FAILURE);
     1469        }
     1470
     1471        if (!object->p4_id == -32) {
     1472            psFree(object);
     1473            exit(EXIT_FAILURE);
     1474        }
     1475        if (strncmp(object->exp_tag, "a string", MAX_STRING_LENGTH)) {
     1476            psFree(object);
     1477            exit(EXIT_FAILURE);
     1478        }
     1479        if (!object->p3_version == -32) {
     1480            psFree(object);
     1481            exit(EXIT_FAILURE);
     1482        }
     1483        if (strncmp(object->class_id, "a string", MAX_STRING_LENGTH)) {
     1484            psFree(object);
     1485            exit(EXIT_FAILURE);
     1486        }
     1487
     1488        psFree(object);
     1489    }
     1490
     1491    {
     1492        p4PWarpedImfileRow *object;
     1493
     1494        object = p4PWarpedImfileRowAlloc(-32, "a string", -32, "a string", "a string", "a string", "a string"    );
     1495
     1496        if (!object) {
     1497            exit(EXIT_FAILURE);
     1498        }
     1499
     1500        if (!object->p4_id == -32) {
     1501            psFree(object);
     1502            exit(EXIT_FAILURE);
     1503        }
     1504        if (strncmp(object->exp_tag, "a string", MAX_STRING_LENGTH)) {
     1505            psFree(object);
     1506            exit(EXIT_FAILURE);
     1507        }
     1508        if (!object->p3_version == -32) {
     1509            psFree(object);
     1510            exit(EXIT_FAILURE);
     1511        }
     1512        if (strncmp(object->class_id, "a string", MAX_STRING_LENGTH)) {
     1513            psFree(object);
     1514            exit(EXIT_FAILURE);
     1515        }
     1516        if (strncmp(object->uri, "a string", MAX_STRING_LENGTH)) {
     1517            psFree(object);
     1518            exit(EXIT_FAILURE);
     1519        }
     1520        if (strncmp(object->b1_uri, "a string", MAX_STRING_LENGTH)) {
     1521            psFree(object);
     1522            exit(EXIT_FAILURE);
     1523        }
     1524        if (strncmp(object->b2_uri, "a string", MAX_STRING_LENGTH)) {
     1525            psFree(object);
     1526            exit(EXIT_FAILURE);
     1527        }
     1528
     1529        psFree(object);
     1530    }
     1531
     1532    {
     1533        p4PStackedImfileRow *object;
     1534
     1535        object = p4PStackedImfileRowAlloc(-32, "a string", "a string", "a string", "a string"    );
     1536
     1537        if (!object) {
     1538            exit(EXIT_FAILURE);
     1539        }
     1540
     1541        if (!object->p4_id == -32) {
     1542            psFree(object);
     1543            exit(EXIT_FAILURE);
     1544        }
     1545        if (strncmp(object->class_id, "a string", MAX_STRING_LENGTH)) {
     1546            psFree(object);
     1547            exit(EXIT_FAILURE);
     1548        }
     1549        if (strncmp(object->uri, "a string", MAX_STRING_LENGTH)) {
     1550            psFree(object);
     1551            exit(EXIT_FAILURE);
     1552        }
     1553        if (strncmp(object->b1_uri, "a string", MAX_STRING_LENGTH)) {
     1554            psFree(object);
     1555            exit(EXIT_FAILURE);
     1556        }
     1557        if (strncmp(object->b2_uri, "a string", MAX_STRING_LENGTH)) {
     1558            psFree(object);
     1559            exit(EXIT_FAILURE);
     1560        }
     1561
     1562        psFree(object);
     1563    }
     1564
     1565    {
     1566        p4PDiffImfileRow *object;
     1567
     1568        object = p4PDiffImfileRowAlloc(-32, "a string", -32, "a string", "a string", "a string", "a string"    );
     1569
     1570        if (!object) {
     1571            exit(EXIT_FAILURE);
     1572        }
     1573
     1574        if (!object->p4_id == -32) {
     1575            psFree(object);
     1576            exit(EXIT_FAILURE);
     1577        }
     1578        if (strncmp(object->exp_tag, "a string", MAX_STRING_LENGTH)) {
     1579            psFree(object);
     1580            exit(EXIT_FAILURE);
     1581        }
     1582        if (!object->p3_version == -32) {
     1583            psFree(object);
     1584            exit(EXIT_FAILURE);
     1585        }
     1586        if (strncmp(object->class_id, "a string", MAX_STRING_LENGTH)) {
     1587            psFree(object);
     1588            exit(EXIT_FAILURE);
     1589        }
     1590        if (strncmp(object->uri, "a string", MAX_STRING_LENGTH)) {
     1591            psFree(object);
     1592            exit(EXIT_FAILURE);
     1593        }
     1594        if (strncmp(object->b1_uri, "a string", MAX_STRING_LENGTH)) {
     1595            psFree(object);
     1596            exit(EXIT_FAILURE);
     1597        }
     1598        if (strncmp(object->b2_uri, "a string", MAX_STRING_LENGTH)) {
     1599            psFree(object);
     1600            exit(EXIT_FAILURE);
     1601        }
     1602
     1603        psFree(object);
     1604    }
     1605
     1606    {
     1607        p4PMagicMaskImfileRow *object;
     1608
     1609        object = p4PMagicMaskImfileRowAlloc(-32, "a string", -32, "a string", "a string"    );
     1610
     1611        if (!object) {
     1612            exit(EXIT_FAILURE);
     1613        }
     1614
     1615        if (!object->p4_id == -32) {
     1616            psFree(object);
     1617            exit(EXIT_FAILURE);
     1618        }
     1619        if (strncmp(object->exp_tag, "a string", MAX_STRING_LENGTH)) {
     1620            psFree(object);
     1621            exit(EXIT_FAILURE);
     1622        }
     1623        if (!object->p3_version == -32) {
     1624            psFree(object);
     1625            exit(EXIT_FAILURE);
     1626        }
     1627        if (strncmp(object->class_id, "a string", MAX_STRING_LENGTH)) {
     1628            psFree(object);
     1629            exit(EXIT_FAILURE);
     1630        }
     1631        if (strncmp(object->uri, "a string", MAX_STRING_LENGTH)) {
     1632            psFree(object);
     1633            exit(EXIT_FAILURE);
     1634        }
     1635
     1636        psFree(object);
     1637    }
     1638
    14091639    exit(EXIT_SUCCESS);
    14101640}

  • trunk/ippdb/tests/createtable.c

    r10238 r10681  
    485485    }
    486486
     487    {
     488        psDB            *dbh;
     489
     490        dbh = psDBInit("localhost", "test", NULL, "test");
     491        if (!dbh) {
     492            exit(EXIT_FAILURE);
     493        }
     494
     495        if(!p4RunCreateTable(dbh)) {
     496            exit(EXIT_FAILURE);
     497        }
     498
     499        psDBCleanup(dbh);
     500    }
     501
     502    {
     503        psDB            *dbh;
     504
     505        dbh = psDBInit("localhost", "test", NULL, "test");
     506        if (!dbh) {
     507            exit(EXIT_FAILURE);
     508        }
     509
     510        if(!p4InputImfileCreateTable(dbh)) {
     511            exit(EXIT_FAILURE);
     512        }
     513
     514        psDBCleanup(dbh);
     515    }
     516
     517    {
     518        psDB            *dbh;
     519
     520        dbh = psDBInit("localhost", "test", NULL, "test");
     521        if (!dbh) {
     522            exit(EXIT_FAILURE);
     523        }
     524
     525        if(!p4PWarpedImfileCreateTable(dbh)) {
     526            exit(EXIT_FAILURE);
     527        }
     528
     529        psDBCleanup(dbh);
     530    }
     531
     532    {
     533        psDB            *dbh;
     534
     535        dbh = psDBInit("localhost", "test", NULL, "test");
     536        if (!dbh) {
     537            exit(EXIT_FAILURE);
     538        }
     539
     540        if(!p4PStackedImfileCreateTable(dbh)) {
     541            exit(EXIT_FAILURE);
     542        }
     543
     544        psDBCleanup(dbh);
     545    }
     546
     547    {
     548        psDB            *dbh;
     549
     550        dbh = psDBInit("localhost", "test", NULL, "test");
     551        if (!dbh) {
     552            exit(EXIT_FAILURE);
     553        }
     554
     555        if(!p4PDiffImfileCreateTable(dbh)) {
     556            exit(EXIT_FAILURE);
     557        }
     558
     559        psDBCleanup(dbh);
     560    }
     561
     562    {
     563        psDB            *dbh;
     564
     565        dbh = psDBInit("localhost", "test", NULL, "test");
     566        if (!dbh) {
     567            exit(EXIT_FAILURE);
     568        }
     569
     570        if(!p4PMagicMaskImfileCreateTable(dbh)) {
     571            exit(EXIT_FAILURE);
     572        }
     573
     574        psDBCleanup(dbh);
     575    }
     576
    487577    exit(EXIT_SUCCESS);
    488578}

  • trunk/ippdb/tests/dbcleanup.c

    r10238 r10681  
    4343    p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS detResidExp");
    4444    p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS detRunSummary");
     45    p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p4Run");
     46    p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p4InputImfile");
     47    p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p4PWarpedImfile");
     48    p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p4PStackedImfile");
     49    p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p4PDiffImfile");
     50    p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p4PMagicMaskImfile");
    4551
    4652    psDBCleanup(dbh);

  • trunk/ippdb/tests/dbsetup.c

    r10238 r10681  
    109109    detRunSummaryCreateTable(dbh);
    110110
     111    p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p4Run");
     112    p4RunCreateTable(dbh);
     113
     114    p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p4InputImfile");
     115    p4InputImfileCreateTable(dbh);
     116
     117    p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p4PWarpedImfile");
     118    p4PWarpedImfileCreateTable(dbh);
     119
     120    p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p4PStackedImfile");
     121    p4PStackedImfileCreateTable(dbh);
     122
     123    p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p4PDiffImfile");
     124    p4PDiffImfileCreateTable(dbh);
     125
     126    p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p4PMagicMaskImfile");
     127    p4PMagicMaskImfileCreateTable(dbh);
     128
    111129    psDBCleanup(dbh);
    112130

  • trunk/ippdb/tests/droptable.c

    r10238 r10681  
    485485    }
    486486
     487    {
     488        psDB            *dbh;
     489
     490        dbh = psDBInit("localhost", "test", NULL, "test");
     491        if (!dbh) {
     492            exit(EXIT_FAILURE);
     493        }
     494
     495        if (!p4RunDropTable(dbh)) {
     496            exit(EXIT_FAILURE);
     497        }
     498
     499        psDBCleanup(dbh);
     500    }
     501
     502    {
     503        psDB            *dbh;
     504
     505        dbh = psDBInit("localhost", "test", NULL, "test");
     506        if (!dbh) {
     507            exit(EXIT_FAILURE);
     508        }
     509
     510        if (!p4InputImfileDropTable(dbh)) {
     511            exit(EXIT_FAILURE);
     512        }
     513
     514        psDBCleanup(dbh);
     515    }
     516
     517    {
     518        psDB            *dbh;
     519
     520        dbh = psDBInit("localhost", "test", NULL, "test");
     521        if (!dbh) {
     522            exit(EXIT_FAILURE);
     523        }
     524
     525        if (!p4PWarpedImfileDropTable(dbh)) {
     526            exit(EXIT_FAILURE);
     527        }
     528
     529        psDBCleanup(dbh);
     530    }
     531
     532    {
     533        psDB            *dbh;
     534
     535        dbh = psDBInit("localhost", "test", NULL, "test");
     536        if (!dbh) {
     537            exit(EXIT_FAILURE);
     538        }
     539
     540        if (!p4PStackedImfileDropTable(dbh)) {
     541            exit(EXIT_FAILURE);
     542        }
     543
     544        psDBCleanup(dbh);
     545    }
     546
     547    {
     548        psDB            *dbh;
     549
     550        dbh = psDBInit("localhost", "test", NULL, "test");
     551        if (!dbh) {
     552            exit(EXIT_FAILURE);
     553        }
     554
     555        if (!p4PDiffImfileDropTable(dbh)) {
     556            exit(EXIT_FAILURE);
     557        }
     558
     559        psDBCleanup(dbh);
     560    }
     561
     562    {
     563        psDB            *dbh;
     564
     565        dbh = psDBInit("localhost", "test", NULL, "test");
     566        if (!dbh) {
     567            exit(EXIT_FAILURE);
     568        }
     569
     570        if (!p4PMagicMaskImfileDropTable(dbh)) {
     571            exit(EXIT_FAILURE);
     572        }
     573
     574        psDBCleanup(dbh);
     575    }
     576
    487577    exit(EXIT_SUCCESS);
    488578}

  • trunk/ippdb/tests/insert.c

    r10328 r10681  
    485485    }
    486486
     487    {
     488        psDB            *dbh;
     489
     490        dbh = psDBInit("localhost", "test", NULL, "test");
     491        if (!dbh) {
     492            exit(EXIT_FAILURE);
     493        }
     494
     495        if (!p4RunInsert(dbh, -32, "a string", "a string", "a string", "a string", "a string", 64.64, 64.64, "a string", "a string")) {
     496            exit(EXIT_FAILURE);
     497        }
     498
     499        psDBCleanup(dbh);
     500    }
     501
     502    {
     503        psDB            *dbh;
     504
     505        dbh = psDBInit("localhost", "test", NULL, "test");
     506        if (!dbh) {
     507            exit(EXIT_FAILURE);
     508        }
     509
     510        if (!p4InputImfileInsert(dbh, -32, "a string", -32, "a string")) {
     511            exit(EXIT_FAILURE);
     512        }
     513
     514        psDBCleanup(dbh);
     515    }
     516
     517    {
     518        psDB            *dbh;
     519
     520        dbh = psDBInit("localhost", "test", NULL, "test");
     521        if (!dbh) {
     522            exit(EXIT_FAILURE);
     523        }
     524
     525        if (!p4PWarpedImfileInsert(dbh, -32, "a string", -32, "a string", "a string", "a string", "a string")) {
     526            exit(EXIT_FAILURE);
     527        }
     528
     529        psDBCleanup(dbh);
     530    }
     531
     532    {
     533        psDB            *dbh;
     534
     535        dbh = psDBInit("localhost", "test", NULL, "test");
     536        if (!dbh) {
     537            exit(EXIT_FAILURE);
     538        }
     539
     540        if (!p4PStackedImfileInsert(dbh, -32, "a string", "a string", "a string", "a string")) {
     541            exit(EXIT_FAILURE);
     542        }
     543
     544        psDBCleanup(dbh);
     545    }
     546
     547    {
     548        psDB            *dbh;
     549
     550        dbh = psDBInit("localhost", "test", NULL, "test");
     551        if (!dbh) {
     552            exit(EXIT_FAILURE);
     553        }
     554
     555        if (!p4PDiffImfileInsert(dbh, -32, "a string", -32, "a string", "a string", "a string", "a string")) {
     556            exit(EXIT_FAILURE);
     557        }
     558
     559        psDBCleanup(dbh);
     560    }
     561
     562    {
     563        psDB            *dbh;
     564
     565        dbh = psDBInit("localhost", "test", NULL, "test");
     566        if (!dbh) {
     567            exit(EXIT_FAILURE);
     568        }
     569
     570        if (!p4PMagicMaskImfileInsert(dbh, -32, "a string", -32, "a string", "a string")) {
     571            exit(EXIT_FAILURE);
     572        }
     573
     574        psDBCleanup(dbh);
     575    }
     576
    487577    exit(EXIT_SUCCESS);
    488578}

  • trunk/ippdb/tests/insertfits.c

    r10238 r10681  
    841841    }
    842842
     843    {
     844        psDB            *dbh;
     845        psFits          *fits;
     846
     847        dbh = psDBInit("localhost", "test", NULL, "test");
     848        if (!dbh) {
     849            exit(EXIT_FAILURE);
     850        }
     851
     852        // open a temp
     853        fits = psFitsOpen(TMP_FILENAME, "r");
     854        if (!fits) {
     855            exit(EXIT_FAILURE);
     856        }
     857
     858        if (!p4RunInsertFits(dbh, fits)) {
     859            exit(EXIT_FAILURE);
     860        }
     861
     862        if (!psFitsClose(fits)) {
     863            exit(EXIT_FAILURE);
     864        }
     865
     866        psDBCleanup(dbh);
     867    }
     868
     869    {
     870        psDB            *dbh;
     871        psFits          *fits;
     872
     873        dbh = psDBInit("localhost", "test", NULL, "test");
     874        if (!dbh) {
     875            exit(EXIT_FAILURE);
     876        }
     877
     878        // open a temp
     879        fits = psFitsOpen(TMP_FILENAME, "r");
     880        if (!fits) {
     881            exit(EXIT_FAILURE);
     882        }
     883
     884        if (!p4InputImfileInsertFits(dbh, fits)) {
     885            exit(EXIT_FAILURE);
     886        }
     887
     888        if (!psFitsClose(fits)) {
     889            exit(EXIT_FAILURE);
     890        }
     891
     892        psDBCleanup(dbh);
     893    }
     894
     895    {
     896        psDB            *dbh;
     897        psFits          *fits;
     898
     899        dbh = psDBInit("localhost", "test", NULL, "test");
     900        if (!dbh) {
     901            exit(EXIT_FAILURE);
     902        }
     903
     904        // open a temp
     905        fits = psFitsOpen(TMP_FILENAME, "r");
     906        if (!fits) {
     907            exit(EXIT_FAILURE);
     908        }
     909
     910        if (!p4PWarpedImfileInsertFits(dbh, fits)) {
     911            exit(EXIT_FAILURE);
     912        }
     913
     914        if (!psFitsClose(fits)) {
     915            exit(EXIT_FAILURE);
     916        }
     917
     918        psDBCleanup(dbh);
     919    }
     920
     921    {
     922        psDB            *dbh;
     923        psFits          *fits;
     924
     925        dbh = psDBInit("localhost", "test", NULL, "test");
     926        if (!dbh) {
     927            exit(EXIT_FAILURE);
     928        }
     929
     930        // open a temp
     931        fits = psFitsOpen(TMP_FILENAME, "r");
     932        if (!fits) {
     933            exit(EXIT_FAILURE);
     934        }
     935
     936        if (!p4PStackedImfileInsertFits(dbh, fits)) {
     937            exit(EXIT_FAILURE);
     938        }
     939
     940        if (!psFitsClose(fits)) {
     941            exit(EXIT_FAILURE);
     942        }
     943
     944        psDBCleanup(dbh);
     945    }
     946
     947    {
     948        psDB            *dbh;
     949        psFits          *fits;
     950
     951        dbh = psDBInit("localhost", "test", NULL, "test");
     952        if (!dbh) {
     953            exit(EXIT_FAILURE);
     954        }
     955
     956        // open a temp
     957        fits = psFitsOpen(TMP_FILENAME, "r");
     958        if (!fits) {
     959            exit(EXIT_FAILURE);
     960        }
     961
     962        if (!p4PDiffImfileInsertFits(dbh, fits)) {
     963            exit(EXIT_FAILURE);
     964        }
     965
     966        if (!psFitsClose(fits)) {
     967            exit(EXIT_FAILURE);
     968        }
     969
     970        psDBCleanup(dbh);
     971    }
     972
     973    {
     974        psDB            *dbh;
     975        psFits          *fits;
     976
     977        dbh = psDBInit("localhost", "test", NULL, "test");
     978        if (!dbh) {
     979            exit(EXIT_FAILURE);
     980        }
     981
     982        // open a temp
     983        fits = psFitsOpen(TMP_FILENAME, "r");
     984        if (!fits) {
     985            exit(EXIT_FAILURE);
     986        }
     987
     988        if (!p4PMagicMaskImfileInsertFits(dbh, fits)) {
     989            exit(EXIT_FAILURE);
     990        }
     991
     992        if (!psFitsClose(fits)) {
     993            exit(EXIT_FAILURE);
     994        }
     995
     996        psDBCleanup(dbh);
     997    }
     998
    843999    exit(EXIT_SUCCESS);
    8441000}

  • trunk/ippdb/tests/insertobject.c

    r10328 r10681  
    709709    }
    710710
     711    {
     712        psDB            *dbh;
     713        p4RunRow        *object;
     714
     715        dbh = psDBInit("localhost", "test", NULL, "test");
     716        if (!dbh) {
     717            exit(EXIT_FAILURE);
     718        }
     719
     720        object = p4RunRowAlloc(-32, "a string", "a string", "a string", "a string", "a string", 64.64, 64.64, "a string", "a string");
     721        if (!object) {
     722            exit(EXIT_FAILURE);
     723        }
     724
     725        if (!p4RunInsertObject(dbh, object)) {
     726            exit(EXIT_FAILURE);
     727        }
     728
     729        psFree(object);
     730        psDBCleanup(dbh);
     731    }
     732
     733    {
     734        psDB            *dbh;
     735        p4InputImfileRow *object;
     736
     737        dbh = psDBInit("localhost", "test", NULL, "test");
     738        if (!dbh) {
     739            exit(EXIT_FAILURE);
     740        }
     741
     742        object = p4InputImfileRowAlloc(-32, "a string", -32, "a string");
     743        if (!object) {
     744            exit(EXIT_FAILURE);
     745        }
     746
     747        if (!p4InputImfileInsertObject(dbh, object)) {
     748            exit(EXIT_FAILURE);
     749        }
     750
     751        psFree(object);
     752        psDBCleanup(dbh);
     753    }
     754
     755    {
     756        psDB            *dbh;
     757        p4PWarpedImfileRow *object;
     758
     759        dbh = psDBInit("localhost", "test", NULL, "test");
     760        if (!dbh) {
     761            exit(EXIT_FAILURE);
     762        }
     763
     764        object = p4PWarpedImfileRowAlloc(-32, "a string", -32, "a string", "a string", "a string", "a string");
     765        if (!object) {
     766            exit(EXIT_FAILURE);
     767        }
     768
     769        if (!p4PWarpedImfileInsertObject(dbh, object)) {
     770            exit(EXIT_FAILURE);
     771        }
     772
     773        psFree(object);
     774        psDBCleanup(dbh);
     775    }
     776
     777    {
     778        psDB            *dbh;
     779        p4PStackedImfileRow *object;
     780
     781        dbh = psDBInit("localhost", "test", NULL, "test");
     782        if (!dbh) {
     783            exit(EXIT_FAILURE);
     784        }
     785
     786        object = p4PStackedImfileRowAlloc(-32, "a string", "a string", "a string", "a string");
     787        if (!object) {
     788            exit(EXIT_FAILURE);
     789        }
     790
     791        if (!p4PStackedImfileInsertObject(dbh, object)) {
     792            exit(EXIT_FAILURE);
     793        }
     794
     795        psFree(object);
     796        psDBCleanup(dbh);
     797    }
     798
     799    {
     800        psDB            *dbh;
     801        p4PDiffImfileRow *object;
     802
     803        dbh = psDBInit("localhost", "test", NULL, "test");
     804        if (!dbh) {
     805            exit(EXIT_FAILURE);
     806        }
     807
     808        object = p4PDiffImfileRowAlloc(-32, "a string", -32, "a string", "a string", "a string", "a string");
     809        if (!object) {
     810            exit(EXIT_FAILURE);
     811        }
     812
     813        if (!p4PDiffImfileInsertObject(dbh, object)) {
     814            exit(EXIT_FAILURE);
     815        }
     816
     817        psFree(object);
     818        psDBCleanup(dbh);
     819    }
     820
     821    {
     822        psDB            *dbh;
     823        p4PMagicMaskImfileRow *object;
     824
     825        dbh = psDBInit("localhost", "test", NULL, "test");
     826        if (!dbh) {
     827            exit(EXIT_FAILURE);
     828        }
     829
     830        object = p4PMagicMaskImfileRowAlloc(-32, "a string", -32, "a string", "a string");
     831        if (!object) {
     832            exit(EXIT_FAILURE);
     833        }
     834
     835        if (!p4PMagicMaskImfileInsertObject(dbh, object)) {
     836            exit(EXIT_FAILURE);
     837        }
     838
     839        psFree(object);
     840        psDBCleanup(dbh);
     841    }
     842
    711843    exit(EXIT_SUCCESS);
    712844}

  • trunk/ippdb/tests/metadatafromobject.c

    r10328 r10681  
    16631663    }
    16641664
     1665    {
     1666        psMetadata      *md;
     1667        p4RunRow        *object;
     1668        bool            status;
     1669
     1670        object = p4RunRowAlloc(-32, "a string", "a string", "a string", "a string", "a string", 64.64, 64.64, "a string", "a string");
     1671        if (!object) {
     1672            exit(EXIT_FAILURE);
     1673        }
     1674
     1675        md = p4RunMetadataFromObject(object);
     1676        if (!md) {
     1677            exit(EXIT_FAILURE);
     1678        }
     1679
     1680        psFree(object);
     1681
     1682        if (!psMetadataLookupS32(&status, md, "p4_id") == -32) {
     1683            psFree(md);
     1684            exit(EXIT_FAILURE);
     1685        }
     1686        if (strncmp(psMetadataLookupPtr(&status, md, "survey_mode"), "a string", MAX_STRING_LENGTH)) {
     1687            psFree(md);
     1688            exit(EXIT_FAILURE);
     1689        }
     1690        if (strncmp(psMetadataLookupPtr(&status, md, "state"), "a string", MAX_STRING_LENGTH)) {
     1691            psFree(md);
     1692            exit(EXIT_FAILURE);
     1693        }
     1694        if (strncmp(psMetadataLookupPtr(&status, md, "filter"), "a string", MAX_STRING_LENGTH)) {
     1695            psFree(md);
     1696            exit(EXIT_FAILURE);
     1697        }
     1698        if (strncmp(psMetadataLookupPtr(&status, md, "skycell_id"), "a string", MAX_STRING_LENGTH)) {
     1699            psFree(md);
     1700            exit(EXIT_FAILURE);
     1701        }
     1702        if (strncmp(psMetadataLookupPtr(&status, md, "tess_id"), "a string", MAX_STRING_LENGTH)) {
     1703            psFree(md);
     1704            exit(EXIT_FAILURE);
     1705        }
     1706        if (!psMetadataLookupF64(&status, md, "ra") == 64.64) {
     1707            psFree(md);
     1708            exit(EXIT_FAILURE);
     1709        }
     1710        if (!psMetadataLookupF64(&status, md, "decl") == 64.64) {
     1711            psFree(md);
     1712            exit(EXIT_FAILURE);
     1713        }
     1714        if (strncmp(psMetadataLookupPtr(&status, md, "input_ss"), "a string", MAX_STRING_LENGTH)) {
     1715            psFree(md);
     1716            exit(EXIT_FAILURE);
     1717        }
     1718        if (strncmp(psMetadataLookupPtr(&status, md, "output_ss"), "a string", MAX_STRING_LENGTH)) {
     1719            psFree(md);
     1720            exit(EXIT_FAILURE);
     1721        }
     1722
     1723        psFree(md);
     1724    }
     1725
     1726    {
     1727        psMetadata      *md;
     1728        p4InputImfileRow *object;
     1729        bool            status;
     1730
     1731        object = p4InputImfileRowAlloc(-32, "a string", -32, "a string");
     1732        if (!object) {
     1733            exit(EXIT_FAILURE);
     1734        }
     1735
     1736        md = p4InputImfileMetadataFromObject(object);
     1737        if (!md) {
     1738            exit(EXIT_FAILURE);
     1739        }
     1740
     1741        psFree(object);
     1742
     1743        if (!psMetadataLookupS32(&status, md, "p4_id") == -32) {
     1744            psFree(md);
     1745            exit(EXIT_FAILURE);
     1746        }
     1747        if (strncmp(psMetadataLookupPtr(&status, md, "exp_tag"), "a string", MAX_STRING_LENGTH)) {
     1748            psFree(md);
     1749            exit(EXIT_FAILURE);
     1750        }
     1751        if (!psMetadataLookupS32(&status, md, "p3_version") == -32) {
     1752            psFree(md);
     1753            exit(EXIT_FAILURE);
     1754        }
     1755        if (strncmp(psMetadataLookupPtr(&status, md, "class_id"), "a string", MAX_STRING_LENGTH)) {
     1756            psFree(md);
     1757            exit(EXIT_FAILURE);
     1758        }
     1759
     1760        psFree(md);
     1761    }
     1762
     1763    {
     1764        psMetadata      *md;
     1765        p4PWarpedImfileRow *object;
     1766        bool            status;
     1767
     1768        object = p4PWarpedImfileRowAlloc(-32, "a string", -32, "a string", "a string", "a string", "a string");
     1769        if (!object) {
     1770            exit(EXIT_FAILURE);
     1771        }
     1772
     1773        md = p4PWarpedImfileMetadataFromObject(object);
     1774        if (!md) {
     1775            exit(EXIT_FAILURE);
     1776        }
     1777
     1778        psFree(object);
     1779
     1780        if (!psMetadataLookupS32(&status, md, "p4_id") == -32) {
     1781            psFree(md);
     1782            exit(EXIT_FAILURE);
     1783        }
     1784        if (strncmp(psMetadataLookupPtr(&status, md, "exp_tag"), "a string", MAX_STRING_LENGTH)) {
     1785            psFree(md);
     1786            exit(EXIT_FAILURE);
     1787        }
     1788        if (!psMetadataLookupS32(&status, md, "p3_version") == -32) {
     1789            psFree(md);
     1790            exit(EXIT_FAILURE);
     1791        }
     1792        if (strncmp(psMetadataLookupPtr(&status, md, "class_id"), "a string", MAX_STRING_LENGTH)) {
     1793            psFree(md);
     1794            exit(EXIT_FAILURE);
     1795        }
     1796        if (strncmp(psMetadataLookupPtr(&status, md, "uri"), "a string", MAX_STRING_LENGTH)) {
     1797            psFree(md);
     1798            exit(EXIT_FAILURE);
     1799        }
     1800        if (strncmp(psMetadataLookupPtr(&status, md, "b1_uri"), "a string", MAX_STRING_LENGTH)) {
     1801            psFree(md);
     1802            exit(EXIT_FAILURE);
     1803        }
     1804        if (strncmp(psMetadataLookupPtr(&status, md, "b2_uri"), "a string", MAX_STRING_LENGTH)) {
     1805            psFree(md);
     1806            exit(EXIT_FAILURE);
     1807        }
     1808
     1809        psFree(md);
     1810    }
     1811
     1812    {
     1813        psMetadata      *md;
     1814        p4PStackedImfileRow *object;
     1815        bool            status;
     1816
     1817        object = p4PStackedImfileRowAlloc(-32, "a string", "a string", "a string", "a string");
     1818        if (!object) {
     1819            exit(EXIT_FAILURE);
     1820        }
     1821
     1822        md = p4PStackedImfileMetadataFromObject(object);
     1823        if (!md) {
     1824            exit(EXIT_FAILURE);
     1825        }
     1826
     1827        psFree(object);
     1828
     1829        if (!psMetadataLookupS32(&status, md, "p4_id") == -32) {
     1830            psFree(md);
     1831            exit(EXIT_FAILURE);
     1832        }
     1833        if (strncmp(psMetadataLookupPtr(&status, md, "class_id"), "a string", MAX_STRING_LENGTH)) {
     1834            psFree(md);
     1835            exit(EXIT_FAILURE);
     1836        }
     1837        if (strncmp(psMetadataLookupPtr(&status, md, "uri"), "a string", MAX_STRING_LENGTH)) {
     1838            psFree(md);
     1839            exit(EXIT_FAILURE);
     1840        }
     1841        if (strncmp(psMetadataLookupPtr(&status, md, "b1_uri"), "a string", MAX_STRING_LENGTH)) {
     1842            psFree(md);
     1843            exit(EXIT_FAILURE);
     1844        }
     1845        if (strncmp(psMetadataLookupPtr(&status, md, "b2_uri"), "a string", MAX_STRING_LENGTH)) {
     1846            psFree(md);
     1847            exit(EXIT_FAILURE);
     1848        }
     1849
     1850        psFree(md);
     1851    }
     1852
     1853    {
     1854        psMetadata      *md;
     1855        p4PDiffImfileRow *object;
     1856        bool            status;
     1857
     1858        object = p4PDiffImfileRowAlloc(-32, "a string", -32, "a string", "a string", "a string", "a string");
     1859        if (!object) {
     1860            exit(EXIT_FAILURE);
     1861        }
     1862
     1863        md = p4PDiffImfileMetadataFromObject(object);
     1864        if (!md) {
     1865            exit(EXIT_FAILURE);
     1866        }
     1867
     1868        psFree(object);
     1869
     1870        if (!psMetadataLookupS32(&status, md, "p4_id") == -32) {
     1871            psFree(md);
     1872            exit(EXIT_FAILURE);
     1873        }
     1874        if (strncmp(psMetadataLookupPtr(&status, md, "exp_tag"), "a string", MAX_STRING_LENGTH)) {
     1875            psFree(md);
     1876            exit(EXIT_FAILURE);
     1877        }
     1878        if (!psMetadataLookupS32(&status, md, "p3_version") == -32) {
     1879            psFree(md);
     1880            exit(EXIT_FAILURE);
     1881        }
     1882        if (strncmp(psMetadataLookupPtr(&status, md, "class_id"), "a string", MAX_STRING_LENGTH)) {
     1883            psFree(md);
     1884            exit(EXIT_FAILURE);
     1885        }
     1886        if (strncmp(psMetadataLookupPtr(&status, md, "uri"), "a string", MAX_STRING_LENGTH)) {
     1887            psFree(md);
     1888            exit(EXIT_FAILURE);
     1889        }
     1890        if (strncmp(psMetadataLookupPtr(&status, md, "b1_uri"), "a string", MAX_STRING_LENGTH)) {
     1891            psFree(md);
     1892            exit(EXIT_FAILURE);
     1893        }
     1894        if (strncmp(psMetadataLookupPtr(&status, md, "b2_uri"), "a string", MAX_STRING_LENGTH)) {
     1895            psFree(md);
     1896            exit(EXIT_FAILURE);
     1897        }
     1898
     1899        psFree(md);
     1900    }
     1901
     1902    {
     1903        psMetadata      *md;
     1904        p4PMagicMaskImfileRow *object;
     1905        bool            status;
     1906
     1907        object = p4PMagicMaskImfileRowAlloc(-32, "a string", -32, "a string", "a string");
     1908        if (!object) {
     1909            exit(EXIT_FAILURE);
     1910        }
     1911
     1912        md = p4PMagicMaskImfileMetadataFromObject(object);
     1913        if (!md) {
     1914            exit(EXIT_FAILURE);
     1915        }
     1916
     1917        psFree(object);
     1918
     1919        if (!psMetadataLookupS32(&status, md, "p4_id") == -32) {
     1920            psFree(md);
     1921            exit(EXIT_FAILURE);
     1922        }
     1923        if (strncmp(psMetadataLookupPtr(&status, md, "exp_tag"), "a string", MAX_STRING_LENGTH)) {
     1924            psFree(md);
     1925            exit(EXIT_FAILURE);
     1926        }
     1927        if (!psMetadataLookupS32(&status, md, "p3_version") == -32) {
     1928            psFree(md);
     1929            exit(EXIT_FAILURE);
     1930        }
     1931        if (strncmp(psMetadataLookupPtr(&status, md, "class_id"), "a string", MAX_STRING_LENGTH)) {
     1932            psFree(md);
     1933            exit(EXIT_FAILURE);
     1934        }
     1935        if (strncmp(psMetadataLookupPtr(&status, md, "uri"), "a string", MAX_STRING_LENGTH)) {
     1936            psFree(md);
     1937            exit(EXIT_FAILURE);
     1938        }
     1939
     1940        psFree(md);
     1941    }
     1942
    16651943    exit(EXIT_SUCCESS);
    16661944}

  • trunk/ippdb/tests/objectfrommetadata.c

    r10328 r10681  
    25502550    }
    25512551
     2552    {
     2553        psMetadata      *md;
     2554        p4RunRow        *object;
     2555
     2556        md = psMetadataAlloc();
     2557        if (!psMetadataAddS32(md, PS_LIST_TAIL, "p4_id", 0, NULL, -32)) {
     2558            psFree(md);
     2559            exit(EXIT_FAILURE);
     2560        }
     2561        if (!psMetadataAddStr(md, PS_LIST_TAIL, "survey_mode", 0, NULL, "a string")) {
     2562            psFree(md);
     2563            exit(EXIT_FAILURE);
     2564        }
     2565        if (!psMetadataAddStr(md, PS_LIST_TAIL, "state", 0, NULL, "a string")) {
     2566            psFree(md);
     2567            exit(EXIT_FAILURE);
     2568        }
     2569        if (!psMetadataAddStr(md, PS_LIST_TAIL, "filter", 0, NULL, "a string")) {
     2570            psFree(md);
     2571            exit(EXIT_FAILURE);
     2572        }
     2573        if (!psMetadataAddStr(md, PS_LIST_TAIL, "skycell_id", 0, NULL, "a string")) {
     2574            psFree(md);
     2575            exit(EXIT_FAILURE);
     2576        }
     2577        if (!psMetadataAddStr(md, PS_LIST_TAIL, "tess_id", 0, NULL, "a string")) {
     2578            psFree(md);
     2579            exit(EXIT_FAILURE);
     2580        }
     2581        if (!psMetadataAddF64(md, PS_LIST_TAIL, "ra", 0, NULL, 64.64)) {
     2582            psFree(md);
     2583            exit(EXIT_FAILURE);
     2584        }
     2585        if (!psMetadataAddF64(md, PS_LIST_TAIL, "decl", 0, NULL, 64.64)) {
     2586            psFree(md);
     2587            exit(EXIT_FAILURE);
     2588        }
     2589        if (!psMetadataAddStr(md, PS_LIST_TAIL, "input_ss", 0, NULL, "a string")) {
     2590            psFree(md);
     2591            exit(EXIT_FAILURE);
     2592        }
     2593        if (!psMetadataAddStr(md, PS_LIST_TAIL, "output_ss", 0, NULL, "a string")) {
     2594            psFree(md);
     2595            exit(EXIT_FAILURE);
     2596        }
     2597
     2598        object = p4RunObjectFromMetadata(md);
     2599        if (!object) {
     2600            psFree(md);
     2601            exit(EXIT_FAILURE);
     2602        }
     2603
     2604        psFree(md);
     2605
     2606        if (!object->p4_id == -32) {
     2607            psFree(object);
     2608            exit(EXIT_FAILURE);
     2609        }
     2610        if (strncmp(object->survey_mode, "a string", MAX_STRING_LENGTH)) {
     2611            psFree(object);
     2612            exit(EXIT_FAILURE);
     2613        }
     2614        if (strncmp(object->state, "a string", MAX_STRING_LENGTH)) {
     2615            psFree(object);
     2616            exit(EXIT_FAILURE);
     2617        }
     2618        if (strncmp(object->filter, "a string", MAX_STRING_LENGTH)) {
     2619            psFree(object);
     2620            exit(EXIT_FAILURE);
     2621        }
     2622        if (strncmp(object->skycell_id, "a string", MAX_STRING_LENGTH)) {
     2623            psFree(object);
     2624            exit(EXIT_FAILURE);
     2625        }
     2626        if (strncmp(object->tess_id, "a string", MAX_STRING_LENGTH)) {
     2627            psFree(object);
     2628            exit(EXIT_FAILURE);
     2629        }
     2630        if (!object->ra == 64.64) {
     2631            psFree(object);
     2632            exit(EXIT_FAILURE);
     2633        }
     2634        if (!object->decl == 64.64) {
     2635            psFree(object);
     2636            exit(EXIT_FAILURE);
     2637        }
     2638        if (strncmp(object->input_ss, "a string", MAX_STRING_LENGTH)) {
     2639            psFree(object);
     2640            exit(EXIT_FAILURE);
     2641        }
     2642        if (strncmp(object->output_ss, "a string", MAX_STRING_LENGTH)) {
     2643            psFree(object);
     2644            exit(EXIT_FAILURE);
     2645        }
     2646
     2647        psFree(object);
     2648    }
     2649
     2650    {
     2651        psMetadata      *md;
     2652        p4InputImfileRow *object;
     2653
     2654        md = psMetadataAlloc();
     2655        if (!psMetadataAddS32(md, PS_LIST_TAIL, "p4_id", 0, NULL, -32)) {
     2656            psFree(md);
     2657            exit(EXIT_FAILURE);
     2658        }
     2659        if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_tag", 0, NULL, "a string")) {
     2660            psFree(md);
     2661            exit(EXIT_FAILURE);
     2662        }
     2663        if (!psMetadataAddS32(md, PS_LIST_TAIL, "p3_version", 0, NULL, -32)) {
     2664            psFree(md);
     2665            exit(EXIT_FAILURE);
     2666        }
     2667        if (!psMetadataAddStr(md, PS_LIST_TAIL, "class_id", 0, NULL, "a string")) {
     2668            psFree(md);
     2669            exit(EXIT_FAILURE);
     2670        }
     2671
     2672        object = p4InputImfileObjectFromMetadata(md);
     2673        if (!object) {
     2674            psFree(md);
     2675            exit(EXIT_FAILURE);
     2676        }
     2677
     2678        psFree(md);
     2679
     2680        if (!object->p4_id == -32) {
     2681            psFree(object);
     2682            exit(EXIT_FAILURE);
     2683        }
     2684        if (strncmp(object->exp_tag, "a string", MAX_STRING_LENGTH)) {
     2685            psFree(object);
     2686            exit(EXIT_FAILURE);
     2687        }
     2688        if (!object->p3_version == -32) {
     2689            psFree(object);
     2690            exit(EXIT_FAILURE);
     2691        }
     2692        if (strncmp(object->class_id, "a string", MAX_STRING_LENGTH)) {
     2693            psFree(object);
     2694            exit(EXIT_FAILURE);
     2695        }
     2696
     2697        psFree(object);
     2698    }
     2699
     2700    {
     2701        psMetadata      *md;
     2702        p4PWarpedImfileRow *object;
     2703
     2704        md = psMetadataAlloc();
     2705        if (!psMetadataAddS32(md, PS_LIST_TAIL, "p4_id", 0, NULL, -32)) {
     2706            psFree(md);
     2707            exit(EXIT_FAILURE);
     2708        }
     2709        if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_tag", 0, NULL, "a string")) {
     2710            psFree(md);
     2711            exit(EXIT_FAILURE);
     2712        }
     2713        if (!psMetadataAddS32(md, PS_LIST_TAIL, "p3_version", 0, NULL, -32)) {
     2714            psFree(md);
     2715            exit(EXIT_FAILURE);
     2716        }
     2717        if (!psMetadataAddStr(md, PS_LIST_TAIL, "class_id", 0, NULL, "a string")) {
     2718            psFree(md);
     2719            exit(EXIT_FAILURE);
     2720        }
     2721        if (!psMetadataAddStr(md, PS_LIST_TAIL, "uri", 0, NULL, "a string")) {
     2722            psFree(md);
     2723            exit(EXIT_FAILURE);
     2724        }
     2725        if (!psMetadataAddStr(md, PS_LIST_TAIL, "b1_uri", 0, NULL, "a string")) {
     2726            psFree(md);
     2727            exit(EXIT_FAILURE);
     2728        }
     2729        if (!psMetadataAddStr(md, PS_LIST_TAIL, "b2_uri", 0, NULL, "a string")) {
     2730            psFree(md);
     2731            exit(EXIT_FAILURE);
     2732        }
     2733
     2734        object = p4PWarpedImfileObjectFromMetadata(md);
     2735        if (!object) {
     2736            psFree(md);
     2737            exit(EXIT_FAILURE);
     2738        }
     2739
     2740        psFree(md);
     2741
     2742        if (!object->p4_id == -32) {
     2743            psFree(object);
     2744            exit(EXIT_FAILURE);
     2745        }
     2746        if (strncmp(object->exp_tag, "a string", MAX_STRING_LENGTH)) {
     2747            psFree(object);
     2748            exit(EXIT_FAILURE);
     2749        }
     2750        if (!object->p3_version == -32) {
     2751            psFree(object);
     2752            exit(EXIT_FAILURE);
     2753        }
     2754        if (strncmp(object->class_id, "a string", MAX_STRING_LENGTH)) {
     2755            psFree(object);
     2756            exit(EXIT_FAILURE);
     2757        }
     2758        if (strncmp(object->uri, "a string", MAX_STRING_LENGTH)) {
     2759            psFree(object);
     2760            exit(EXIT_FAILURE);
     2761        }
     2762        if (strncmp(object->b1_uri, "a string", MAX_STRING_LENGTH)) {
     2763            psFree(object);
     2764            exit(EXIT_FAILURE);
     2765        }
     2766        if (strncmp(object->b2_uri, "a string", MAX_STRING_LENGTH)) {
     2767            psFree(object);
     2768            exit(EXIT_FAILURE);
     2769        }
     2770
     2771        psFree(object);
     2772    }
     2773
     2774    {
     2775        psMetadata      *md;
     2776        p4PStackedImfileRow *object;
     2777
     2778        md = psMetadataAlloc();
     2779        if (!psMetadataAddS32(md, PS_LIST_TAIL, "p4_id", 0, NULL, -32)) {
     2780            psFree(md);
     2781            exit(EXIT_FAILURE);
     2782        }
     2783        if (!psMetadataAddStr(md, PS_LIST_TAIL, "class_id", 0, NULL, "a string")) {
     2784            psFree(md);
     2785            exit(EXIT_FAILURE);
     2786        }
     2787        if (!psMetadataAddStr(md, PS_LIST_TAIL, "uri", 0, NULL, "a string")) {
     2788            psFree(md);
     2789            exit(EXIT_FAILURE);
     2790        }
     2791        if (!psMetadataAddStr(md, PS_LIST_TAIL, "b1_uri", 0, NULL, "a string")) {
     2792            psFree(md);
     2793            exit(EXIT_FAILURE);
     2794        }
     2795        if (!psMetadataAddStr(md, PS_LIST_TAIL, "b2_uri", 0, NULL, "a string")) {
     2796            psFree(md);
     2797            exit(EXIT_FAILURE);
     2798        }
     2799
     2800        object = p4PStackedImfileObjectFromMetadata(md);
     2801        if (!object) {
     2802            psFree(md);
     2803            exit(EXIT_FAILURE);
     2804        }
     2805
     2806        psFree(md);
     2807
     2808        if (!object->p4_id == -32) {
     2809            psFree(object);
     2810            exit(EXIT_FAILURE);
     2811        }
     2812        if (strncmp(object->class_id, "a string", MAX_STRING_LENGTH)) {
     2813            psFree(object);
     2814            exit(EXIT_FAILURE);
     2815        }
     2816        if (strncmp(object->uri, "a string", MAX_STRING_LENGTH)) {
     2817            psFree(object);
     2818            exit(EXIT_FAILURE);
     2819        }
     2820        if (strncmp(object->b1_uri, "a string", MAX_STRING_LENGTH)) {
     2821            psFree(object);
     2822            exit(EXIT_FAILURE);
     2823        }
     2824        if (strncmp(object->b2_uri, "a string", MAX_STRING_LENGTH)) {
     2825            psFree(object);
     2826            exit(EXIT_FAILURE);
     2827        }
     2828
     2829        psFree(object);
     2830    }
     2831
     2832    {
     2833        psMetadata      *md;
     2834        p4PDiffImfileRow *object;
     2835
     2836        md = psMetadataAlloc();
     2837        if (!psMetadataAddS32(md, PS_LIST_TAIL, "p4_id", 0, NULL, -32)) {
     2838            psFree(md);
     2839            exit(EXIT_FAILURE);
     2840        }
     2841        if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_tag", 0, NULL, "a string")) {
     2842            psFree(md);
     2843            exit(EXIT_FAILURE);
     2844        }
     2845        if (!psMetadataAddS32(md, PS_LIST_TAIL, "p3_version", 0, NULL, -32)) {
     2846            psFree(md);
     2847            exit(EXIT_FAILURE);
     2848        }
     2849        if (!psMetadataAddStr(md, PS_LIST_TAIL, "class_id", 0, NULL, "a string")) {
     2850            psFree(md);
     2851            exit(EXIT_FAILURE);
     2852        }
     2853        if (!psMetadataAddStr(md, PS_LIST_TAIL, "uri", 0, NULL, "a string")) {
     2854            psFree(md);
     2855            exit(EXIT_FAILURE);
     2856        }
     2857        if (!psMetadataAddStr(md, PS_LIST_TAIL, "b1_uri", 0, NULL, "a string")) {
     2858            psFree(md);
     2859            exit(EXIT_FAILURE);
     2860        }
     2861        if (!psMetadataAddStr(md, PS_LIST_TAIL, "b2_uri", 0, NULL, "a string")) {
     2862            psFree(md);
     2863            exit(EXIT_FAILURE);
     2864        }
     2865
     2866        object = p4PDiffImfileObjectFromMetadata(md);
     2867        if (!object) {
     2868            psFree(md);
     2869            exit(EXIT_FAILURE);
     2870        }
     2871
     2872        psFree(md);
     2873
     2874        if (!object->p4_id == -32) {
     2875            psFree(object);
     2876            exit(EXIT_FAILURE);
     2877        }
     2878        if (strncmp(object->exp_tag, "a string", MAX_STRING_LENGTH)) {
     2879            psFree(object);
     2880            exit(EXIT_FAILURE);
     2881        }
     2882        if (!object->p3_version == -32) {
     2883            psFree(object);
     2884            exit(EXIT_FAILURE);
     2885        }
     2886        if (strncmp(object->class_id, "a string", MAX_STRING_LENGTH)) {
     2887            psFree(object);
     2888            exit(EXIT_FAILURE);
     2889        }
     2890        if (strncmp(object->uri, "a string", MAX_STRING_LENGTH)) {
     2891            psFree(object);
     2892            exit(EXIT_FAILURE);
     2893        }
     2894        if (strncmp(object->b1_uri, "a string", MAX_STRING_LENGTH)) {
     2895            psFree(object);
     2896            exit(EXIT_FAILURE);
     2897        }
     2898        if (strncmp(object->b2_uri, "a string", MAX_STRING_LENGTH)) {
     2899            psFree(object);
     2900            exit(EXIT_FAILURE);
     2901        }
     2902
     2903        psFree(object);
     2904    }
     2905
     2906    {
     2907        psMetadata      *md;
     2908        p4PMagicMaskImfileRow *object;
     2909
     2910        md = psMetadataAlloc();
     2911        if (!psMetadataAddS32(md, PS_LIST_TAIL, "p4_id", 0, NULL, -32)) {
     2912            psFree(md);
     2913            exit(EXIT_FAILURE);
     2914        }
     2915        if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_tag", 0, NULL, "a string")) {
     2916            psFree(md);
     2917            exit(EXIT_FAILURE);
     2918        }
     2919        if (!psMetadataAddS32(md, PS_LIST_TAIL, "p3_version", 0, NULL, -32)) {
     2920            psFree(md);
     2921            exit(EXIT_FAILURE);
     2922        }
     2923        if (!psMetadataAddStr(md, PS_LIST_TAIL, "class_id", 0, NULL, "a string")) {
     2924            psFree(md);
     2925            exit(EXIT_FAILURE);
     2926        }
     2927        if (!psMetadataAddStr(md, PS_LIST_TAIL, "uri", 0, NULL, "a string")) {
     2928            psFree(md);
     2929            exit(EXIT_FAILURE);
     2930        }
     2931
     2932        object = p4PMagicMaskImfileObjectFromMetadata(md);
     2933        if (!object) {
     2934            psFree(md);
     2935            exit(EXIT_FAILURE);
     2936        }
     2937
     2938        psFree(md);
     2939
     2940        if (!object->p4_id == -32) {
     2941            psFree(object);
     2942            exit(EXIT_FAILURE);
     2943        }
     2944        if (strncmp(object->exp_tag, "a string", MAX_STRING_LENGTH)) {
     2945            psFree(object);
     2946            exit(EXIT_FAILURE);
     2947        }
     2948        if (!object->p3_version == -32) {
     2949            psFree(object);
     2950            exit(EXIT_FAILURE);
     2951        }
     2952        if (strncmp(object->class_id, "a string", MAX_STRING_LENGTH)) {
     2953            psFree(object);
     2954            exit(EXIT_FAILURE);
     2955        }
     2956        if (strncmp(object->uri, "a string", MAX_STRING_LENGTH)) {
     2957            psFree(object);
     2958            exit(EXIT_FAILURE);
     2959        }
     2960
     2961        psFree(object);
     2962    }
     2963
    25522964    exit(EXIT_SUCCESS);
    25532965}

  • trunk/ippdb/tests/selectrowsfits.c

    r10238 r10681  
    711711    }
    712712
     713    {
     714        psDB            *dbh;
     715        psFits          *fits;
     716
     717        dbh = psDBInit("localhost", "test", NULL, "test");
     718        if (!dbh) {
     719            exit(EXIT_FAILURE);
     720        }
     721
     722        fits = psFitsOpen(TMP_FILENAME, "w");
     723        if (!fits) {
     724            exit(EXIT_FAILURE);
     725        }
     726
     727        if (!p4RunSelectRowsFits(dbh, fits, NULL, 1)) {
     728            exit(EXIT_FAILURE);
     729        }
     730
     731        psFree(fits);
     732        psDBCleanup(dbh);
     733    }
     734
     735    {
     736        psDB            *dbh;
     737        psFits          *fits;
     738
     739        dbh = psDBInit("localhost", "test", NULL, "test");
     740        if (!dbh) {
     741            exit(EXIT_FAILURE);
     742        }
     743
     744        fits = psFitsOpen(TMP_FILENAME, "w");
     745        if (!fits) {
     746            exit(EXIT_FAILURE);
     747        }
     748
     749        if (!p4InputImfileSelectRowsFits(dbh, fits, NULL, 1)) {
     750            exit(EXIT_FAILURE);
     751        }
     752
     753        psFree(fits);
     754        psDBCleanup(dbh);
     755    }
     756
     757    {
     758        psDB            *dbh;
     759        psFits          *fits;
     760
     761        dbh = psDBInit("localhost", "test", NULL, "test");
     762        if (!dbh) {
     763            exit(EXIT_FAILURE);
     764        }
     765
     766        fits = psFitsOpen(TMP_FILENAME, "w");
     767        if (!fits) {
     768            exit(EXIT_FAILURE);
     769        }
     770
     771        if (!p4PWarpedImfileSelectRowsFits(dbh, fits, NULL, 1)) {
     772            exit(EXIT_FAILURE);
     773        }
     774
     775        psFree(fits);
     776        psDBCleanup(dbh);
     777    }
     778
     779    {
     780        psDB            *dbh;
     781        psFits          *fits;
     782
     783        dbh = psDBInit("localhost", "test", NULL, "test");
     784        if (!dbh) {
     785            exit(EXIT_FAILURE);
     786        }
     787
     788        fits = psFitsOpen(TMP_FILENAME, "w");
     789        if (!fits) {
     790            exit(EXIT_FAILURE);
     791        }
     792
     793        if (!p4PStackedImfileSelectRowsFits(dbh, fits, NULL, 1)) {
     794            exit(EXIT_FAILURE);
     795        }
     796
     797        psFree(fits);
     798        psDBCleanup(dbh);
     799    }
     800
     801    {
     802        psDB            *dbh;
     803        psFits          *fits;
     804
     805        dbh = psDBInit("localhost", "test", NULL, "test");
     806        if (!dbh) {
     807            exit(EXIT_FAILURE);
     808        }
     809
     810        fits = psFitsOpen(TMP_FILENAME, "w");
     811        if (!fits) {
     812            exit(EXIT_FAILURE);
     813        }
     814
     815        if (!p4PDiffImfileSelectRowsFits(dbh, fits, NULL, 1)) {
     816            exit(EXIT_FAILURE);
     817        }
     818
     819        psFree(fits);
     820        psDBCleanup(dbh);
     821    }
     822
     823    {
     824        psDB            *dbh;
     825        psFits          *fits;
     826
     827        dbh = psDBInit("localhost", "test", NULL, "test");
     828        if (!dbh) {
     829            exit(EXIT_FAILURE);
     830        }
     831
     832        fits = psFitsOpen(TMP_FILENAME, "w");
     833        if (!fits) {
     834            exit(EXIT_FAILURE);
     835        }
     836
     837        if (!p4PMagicMaskImfileSelectRowsFits(dbh, fits, NULL, 1)) {
     838            exit(EXIT_FAILURE);
     839        }
     840
     841        psFree(fits);
     842        psDBCleanup(dbh);
     843    }
     844
    713845    exit(EXIT_SUCCESS);
    714846}
Note: See TracChangeset for help on using the changeset viewer.