IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 11679 for trunk/ippdb/tests


Ignore:
Timestamp:
Feb 6, 2007, 3:46:45 PM (19 years ago)
Author:
jhoblitt
Message:

VERSION 1.1.1

Location:
trunk/ippdb/tests
Files:
11 edited

Legend:

Unmodified
Added
Removed

  • trunk/ippdb/tests/alloc.c

    r11193 r11679  
    1717        }
    1818
     19        if (!object->counter == 64) {
    1920            psFree(object);
    2021            exit(EXIT_FAILURE);
    … …  
    399400            exit(EXIT_FAILURE);
    400401        }
     402        if (!object->fault == -16) {
    401403            psFree(object);
    402404            exit(EXIT_FAILURE);
    … …  
    490492            exit(EXIT_FAILURE);
    491493        }
     494        if (!object->fault == -16) {
    492495            psFree(object);
    493496            exit(EXIT_FAILURE);
    … …  
    691694            exit(EXIT_FAILURE);
    692695        }
     696        if (!object->fault == -16) {
    693697            psFree(object);
    694698            exit(EXIT_FAILURE);
    … …  
    800804            exit(EXIT_FAILURE);
    801805        }
     806        if (!object->fault == -16) {
    802807            psFree(object);
    803808            exit(EXIT_FAILURE);
    … …  
    10021007            exit(EXIT_FAILURE);
    10031008        }
     1009        if (!object->fault == -16) {
    10041010            psFree(object);
    10051011            exit(EXIT_FAILURE);
    … …  
    10501056            exit(EXIT_FAILURE);
    10511057        }
     1058        if (!object->fault == -16) {
    10521059            psFree(object);
    10531060            exit(EXIT_FAILURE);
    … …  
    10981105            exit(EXIT_FAILURE);
    10991106        }
     1107        if (!object->fault == -16) {
    11001108            psFree(object);
    11011109            exit(EXIT_FAILURE);
    … …  
    11301138            exit(EXIT_FAILURE);
    11311139        }
     1140        if (!object->fault == -16) {
    11321141            psFree(object);
    11331142            exit(EXIT_FAILURE);
    … …  
    11821191            exit(EXIT_FAILURE);
    11831192        }
     1193        if (!object->fault == -16) {
    11841194            psFree(object);
    11851195            exit(EXIT_FAILURE);
    … …  
    12301240            exit(EXIT_FAILURE);
    12311241        }
     1242        if (!object->fault == -16) {
    12321243            psFree(object);
    12331244            exit(EXIT_FAILURE);
    … …  
    12901301            exit(EXIT_FAILURE);
    12911302        }
     1303        if (!object->fault == -16) {
    12921304            psFree(object);
    12931305            exit(EXIT_FAILURE);
    … …  
    13461358            exit(EXIT_FAILURE);
    13471359        }
     1360        if (!object->fault == -16) {
    13481361            psFree(object);
    13491362            exit(EXIT_FAILURE);
    … …  
    13861399            exit(EXIT_FAILURE);
    13871400        }
    1388             psFree(object);
    1389             exit(EXIT_FAILURE);
    1390         }
    1391 
    1392         psFree(object);
    1393     }
    1394 
    1395     {
    1396         p4RunRow        *object;
    1397 
    1398         object = p4RunRowAlloc(-32, "a string", "a string", "a string", "a string", "a string", "a string", 64.64, 64.64, "a string", "a string"    );
    1399 
    1400         if (!object) {
    1401             exit(EXIT_FAILURE);
    1402         }
    1403 
    1404         if (!object->p4_id == -32) {
    1405             psFree(object);
    1406             exit(EXIT_FAILURE);
    1407         }
    1408         if (strncmp(object->survey_mode, "a string", MAX_STRING_LENGTH)) {
     1401        if (!object->fault == -16) {
     1402            psFree(object);
     1403            exit(EXIT_FAILURE);
     1404        }
     1405
     1406        psFree(object);
     1407    }
     1408
     1409    {
     1410        p4aRunRow       *object;
     1411
     1412        object = p4aRunRowAlloc(-32, "a string", "a string", true    );
     1413
     1414        if (!object) {
     1415            exit(EXIT_FAILURE);
     1416        }
     1417
     1418        if (!object->p4a_id == -32) {
    14091419            psFree(object);
    14101420            exit(EXIT_FAILURE);
    … …  
    14181428            exit(EXIT_FAILURE);
    14191429        }
    1420         if (strncmp(object->filter, "a string", MAX_STRING_LENGTH)) {
     1430        if (!object->magic == true) {
     1431            psFree(object);
     1432            exit(EXIT_FAILURE);
     1433        }
     1434
     1435        psFree(object);
     1436    }
     1437
     1438    {
     1439        p4aInputExpRow  *object;
     1440
     1441        object = p4aInputExpRowAlloc(-32, "a string", -32    );
     1442
     1443        if (!object) {
     1444            exit(EXIT_FAILURE);
     1445        }
     1446
     1447        if (!object->p4a_id == -32) {
     1448            psFree(object);
     1449            exit(EXIT_FAILURE);
     1450        }
     1451        if (strncmp(object->exp_tag, "a string", MAX_STRING_LENGTH)) {
     1452            psFree(object);
     1453            exit(EXIT_FAILURE);
     1454        }
     1455        if (!object->p3_version == -32) {
     1456            psFree(object);
     1457            exit(EXIT_FAILURE);
     1458        }
     1459
     1460        psFree(object);
     1461    }
     1462
     1463    {
     1464        p4aScfileRow    *object;
     1465
     1466        object = p4aScfileRowAlloc(-32, "a string", "a string", "a string", -32, "a string", 64.64, 64.64    );
     1467
     1468        if (!object) {
     1469            exit(EXIT_FAILURE);
     1470        }
     1471
     1472        if (!object->p4a_id == -32) {
    14211473            psFree(object);
    14221474            exit(EXIT_FAILURE);
    … …  
    14301482            exit(EXIT_FAILURE);
    14311483        }
    1432         if (!object->ra == 64.64) {
    1433             psFree(object);
    1434             exit(EXIT_FAILURE);
    1435         }
    1436         if (!object->decl == 64.64) {
    1437             psFree(object);
    1438             exit(EXIT_FAILURE);
    1439         }
    1440         if (strncmp(object->input_ss, "a string", MAX_STRING_LENGTH)) {
    1441             psFree(object);
    1442             exit(EXIT_FAILURE);
    1443         }
    1444         if (strncmp(object->output_ss, "a string", MAX_STRING_LENGTH)) {
    1445             psFree(object);
    1446             exit(EXIT_FAILURE);
    1447         }
    1448 
    1449         psFree(object);
    1450     }
    1451 
    1452     {
    1453         p4InputImfileRow *object;
    1454 
    1455         object = p4InputImfileRowAlloc(-32, "a string", -32, "a string"    );
    1456 
    1457         if (!object) {
    1458             exit(EXIT_FAILURE);
    1459         }
    1460 
    1461         if (!object->p4_id == -32) {
    1462             psFree(object);
    1463             exit(EXIT_FAILURE);
    1464         }
    14651484        if (strncmp(object->exp_tag, "a string", MAX_STRING_LENGTH)) {
    14661485            psFree(object);
    … …  
    14711490            exit(EXIT_FAILURE);
    14721491        }
     1492        if (strncmp(object->uri, "a string", MAX_STRING_LENGTH)) {
     1493            psFree(object);
     1494            exit(EXIT_FAILURE);
     1495        }
     1496        if (!object->bg == 64.64) {
     1497            psFree(object);
     1498            exit(EXIT_FAILURE);
     1499        }
     1500        if (!object->bg_mean_stdev == 64.64) {
     1501            psFree(object);
     1502            exit(EXIT_FAILURE);
     1503        }
     1504
     1505        psFree(object);
     1506    }
     1507
     1508    {
     1509        p4bRunRow       *object;
     1510
     1511        object = p4bRunRowAlloc(-32, "a string", "a string", true    );
     1512
     1513        if (!object) {
     1514            exit(EXIT_FAILURE);
     1515        }
     1516
     1517        if (!object->p4b_id == -32) {
     1518            psFree(object);
     1519            exit(EXIT_FAILURE);
     1520        }
     1521        if (strncmp(object->state, "a string", MAX_STRING_LENGTH)) {
     1522            psFree(object);
     1523            exit(EXIT_FAILURE);
     1524        }
     1525        if (strncmp(object->workdir, "a string", MAX_STRING_LENGTH)) {
     1526            psFree(object);
     1527            exit(EXIT_FAILURE);
     1528        }
     1529        if (!object->magic == true) {
     1530            psFree(object);
     1531            exit(EXIT_FAILURE);
     1532        }
     1533
     1534        psFree(object);
     1535    }
     1536
     1537    {
     1538        p4bInputScfileRow *object;
     1539
     1540        object = p4bInputScfileRowAlloc(-32, "a string", "a string", "a string", -32, "a string"    );
     1541
     1542        if (!object) {
     1543            exit(EXIT_FAILURE);
     1544        }
     1545
     1546        if (!object->p4b_id == -32) {
     1547            psFree(object);
     1548            exit(EXIT_FAILURE);
     1549        }
     1550        if (strncmp(object->skycell_id, "a string", MAX_STRING_LENGTH)) {
     1551            psFree(object);
     1552            exit(EXIT_FAILURE);
     1553        }
     1554        if (strncmp(object->tess_id, "a string", MAX_STRING_LENGTH)) {
     1555            psFree(object);
     1556            exit(EXIT_FAILURE);
     1557        }
     1558        if (strncmp(object->exp_tag, "a string", MAX_STRING_LENGTH)) {
     1559            psFree(object);
     1560            exit(EXIT_FAILURE);
     1561        }
     1562        if (!object->p3_version == -32) {
     1563            psFree(object);
     1564            exit(EXIT_FAILURE);
     1565        }
     1566        if (strncmp(object->kind, "a string", MAX_STRING_LENGTH)) {
     1567            psFree(object);
     1568            exit(EXIT_FAILURE);
     1569        }
     1570
     1571        psFree(object);
     1572    }
     1573
     1574    {
     1575        p4bDiffScfileRow *object;
     1576
     1577        object = p4bDiffScfileRowAlloc(-32, "a string", "a string", "a string", -32, "a string", 64.64, 64.64    );
     1578
     1579        if (!object) {
     1580            exit(EXIT_FAILURE);
     1581        }
     1582
     1583        if (!object->p4b_id == -32) {
     1584            psFree(object);
     1585            exit(EXIT_FAILURE);
     1586        }
     1587        if (strncmp(object->skycell_id, "a string", MAX_STRING_LENGTH)) {
     1588            psFree(object);
     1589            exit(EXIT_FAILURE);
     1590        }
     1591        if (strncmp(object->tess_id, "a string", MAX_STRING_LENGTH)) {
     1592            psFree(object);
     1593            exit(EXIT_FAILURE);
     1594        }
     1595        if (strncmp(object->exp_tag, "a string", MAX_STRING_LENGTH)) {
     1596            psFree(object);
     1597            exit(EXIT_FAILURE);
     1598        }
     1599        if (!object->p3_version == -32) {
     1600            psFree(object);
     1601            exit(EXIT_FAILURE);
     1602        }
     1603        if (strncmp(object->uri, "a string", MAX_STRING_LENGTH)) {
     1604            psFree(object);
     1605            exit(EXIT_FAILURE);
     1606        }
     1607        if (!object->bg == 64.64) {
     1608            psFree(object);
     1609            exit(EXIT_FAILURE);
     1610        }
     1611        if (!object->bg_mean_stdev == 64.64) {
     1612            psFree(object);
     1613            exit(EXIT_FAILURE);
     1614        }
     1615
     1616        psFree(object);
     1617    }
     1618
     1619    {
     1620        p4cRunRow       *object;
     1621
     1622        object = p4cRunRowAlloc(-32, "a string", "a string", true    );
     1623
     1624        if (!object) {
     1625            exit(EXIT_FAILURE);
     1626        }
     1627
     1628        if (!object->p4c_id == -32) {
     1629            psFree(object);
     1630            exit(EXIT_FAILURE);
     1631        }
     1632        if (strncmp(object->state, "a string", MAX_STRING_LENGTH)) {
     1633            psFree(object);
     1634            exit(EXIT_FAILURE);
     1635        }
     1636        if (strncmp(object->workdir, "a string", MAX_STRING_LENGTH)) {
     1637            psFree(object);
     1638            exit(EXIT_FAILURE);
     1639        }
     1640        if (!object->magic == true) {
     1641            psFree(object);
     1642            exit(EXIT_FAILURE);
     1643        }
     1644
     1645        psFree(object);
     1646    }
     1647
     1648    {
     1649        p4cInputExpRow  *object;
     1650
     1651        object = p4cInputExpRowAlloc(-32, "a string", -32    );
     1652
     1653        if (!object) {
     1654            exit(EXIT_FAILURE);
     1655        }
     1656
     1657        if (!object->p4c_id == -32) {
     1658            psFree(object);
     1659            exit(EXIT_FAILURE);
     1660        }
     1661        if (strncmp(object->exp_tag, "a string", MAX_STRING_LENGTH)) {
     1662            psFree(object);
     1663            exit(EXIT_FAILURE);
     1664        }
     1665        if (!object->p3_version == -32) {
     1666            psFree(object);
     1667            exit(EXIT_FAILURE);
     1668        }
     1669
     1670        psFree(object);
     1671    }
     1672
     1673    {
     1674        p4MagicMaskImfileRow *object;
     1675
     1676        object = p4MagicMaskImfileRowAlloc(-32, "a string", -32, "a string", "a string"    );
     1677
     1678        if (!object) {
     1679            exit(EXIT_FAILURE);
     1680        }
     1681
     1682        if (!object->p4c_id == -32) {
     1683            psFree(object);
     1684            exit(EXIT_FAILURE);
     1685        }
     1686        if (strncmp(object->exp_tag, "a string", MAX_STRING_LENGTH)) {
     1687            psFree(object);
     1688            exit(EXIT_FAILURE);
     1689        }
     1690        if (!object->p3_version == -32) {
     1691            psFree(object);
     1692            exit(EXIT_FAILURE);
     1693        }
    14731694        if (strncmp(object->class_id, "a string", MAX_STRING_LENGTH)) {
    14741695            psFree(object);
    14751696            exit(EXIT_FAILURE);
    14761697        }
    1477 
    1478         psFree(object);
    1479     }
    1480 
    1481     {
    1482         p4WarpedImfileRow *object;
    1483 
    1484         object = p4WarpedImfileRowAlloc(-32, "a string", -32, "a string", "a string", "a string", "a string"    );
    1485 
    1486         if (!object) {
    1487             exit(EXIT_FAILURE);
    1488         }
    1489 
    1490         if (!object->p4_id == -32) {
    1491             psFree(object);
    1492             exit(EXIT_FAILURE);
    1493         }
    1494         if (strncmp(object->exp_tag, "a string", MAX_STRING_LENGTH)) {
    1495             psFree(object);
    1496             exit(EXIT_FAILURE);
    1497         }
    1498         if (!object->p3_version == -32) {
     1698        if (strncmp(object->uri, "a string", MAX_STRING_LENGTH)) {
     1699            psFree(object);
     1700            exit(EXIT_FAILURE);
     1701        }
     1702
     1703        psFree(object);
     1704    }
     1705
     1706    {
     1707        skyCellRow      *object;
     1708
     1709        object = skyCellRowAlloc("a string", "a string", 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64    );
     1710
     1711        if (!object) {
     1712            exit(EXIT_FAILURE);
     1713        }
     1714
     1715        if (strncmp(object->skycell_id, "a string", MAX_STRING_LENGTH)) {
     1716            psFree(object);
     1717            exit(EXIT_FAILURE);
     1718        }
     1719        if (strncmp(object->tess_id, "a string", MAX_STRING_LENGTH)) {
     1720            psFree(object);
     1721            exit(EXIT_FAILURE);
     1722        }
     1723        if (!object->ra1 == 64.64) {
     1724            psFree(object);
     1725            exit(EXIT_FAILURE);
     1726        }
     1727        if (!object->decl1 == 64.64) {
     1728            psFree(object);
     1729            exit(EXIT_FAILURE);
     1730        }
     1731        if (!object->ra2 == 64.64) {
     1732            psFree(object);
     1733            exit(EXIT_FAILURE);
     1734        }
     1735        if (!object->decl2 == 64.64) {
     1736            psFree(object);
     1737            exit(EXIT_FAILURE);
     1738        }
     1739        if (!object->ra3 == 64.64) {
     1740            psFree(object);
     1741            exit(EXIT_FAILURE);
     1742        }
     1743        if (!object->decl3 == 64.64) {
     1744            psFree(object);
     1745            exit(EXIT_FAILURE);
     1746        }
     1747        if (!object->ra4 == 64.64) {
     1748            psFree(object);
     1749            exit(EXIT_FAILURE);
     1750        }
     1751        if (!object->decl4 == 64.64) {
     1752            psFree(object);
     1753            exit(EXIT_FAILURE);
     1754        }
     1755
     1756        psFree(object);
     1757    }
     1758
     1759    {
     1760        skyCellMapRow   *object;
     1761
     1762        object = skyCellMapRowAlloc("a string", "a string", "a string", "a string"    );
     1763
     1764        if (!object) {
     1765            exit(EXIT_FAILURE);
     1766        }
     1767
     1768        if (strncmp(object->skycell_id, "a string", MAX_STRING_LENGTH)) {
     1769            psFree(object);
     1770            exit(EXIT_FAILURE);
     1771        }
     1772        if (strncmp(object->tess_id, "a string", MAX_STRING_LENGTH)) {
     1773            psFree(object);
     1774            exit(EXIT_FAILURE);
     1775        }
     1776        if (strncmp(object->exp_tag, "a string", MAX_STRING_LENGTH)) {
    14991777            psFree(object);
    15001778            exit(EXIT_FAILURE);
    15011779        }
    15021780        if (strncmp(object->class_id, "a string", MAX_STRING_LENGTH)) {
    1503             psFree(object);
    1504             exit(EXIT_FAILURE);
    1505         }
    1506         if (strncmp(object->uri, "a string", MAX_STRING_LENGTH)) {
    1507             psFree(object);
    1508             exit(EXIT_FAILURE);
    1509         }
    1510         if (strncmp(object->b1_uri, "a string", MAX_STRING_LENGTH)) {
    1511             psFree(object);
    1512             exit(EXIT_FAILURE);
    1513         }
    1514         if (strncmp(object->b2_uri, "a string", MAX_STRING_LENGTH)) {
    1515             psFree(object);
    1516             exit(EXIT_FAILURE);
    1517         }
    1518 
    1519         psFree(object);
    1520     }
    1521 
    1522     {
    1523         p4StackedImfileRow *object;
    1524 
    1525         object = p4StackedImfileRowAlloc(-32, "a string", "a string", "a string", "a string"    );
    1526 
    1527         if (!object) {
    1528             exit(EXIT_FAILURE);
    1529         }
    1530 
    1531         if (!object->p4_id == -32) {
    1532             psFree(object);
    1533             exit(EXIT_FAILURE);
    1534         }
    1535         if (strncmp(object->class_id, "a string", MAX_STRING_LENGTH)) {
    1536             psFree(object);
    1537             exit(EXIT_FAILURE);
    1538         }
    1539         if (strncmp(object->uri, "a string", MAX_STRING_LENGTH)) {
    1540             psFree(object);
    1541             exit(EXIT_FAILURE);
    1542         }
    1543         if (strncmp(object->b1_uri, "a string", MAX_STRING_LENGTH)) {
    1544             psFree(object);
    1545             exit(EXIT_FAILURE);
    1546         }
    1547         if (strncmp(object->b2_uri, "a string", MAX_STRING_LENGTH)) {
    1548             psFree(object);
    1549             exit(EXIT_FAILURE);
    1550         }
    1551 
    1552         psFree(object);
    1553     }
    1554 
    1555     {
    1556         p4DiffImfileRow *object;
    1557 
    1558         object = p4DiffImfileRowAlloc(-32, "a string", -32, "a string", "a string", "a string", "a string"    );
    1559 
    1560         if (!object) {
    1561             exit(EXIT_FAILURE);
    1562         }
    1563 
    1564         if (!object->p4_id == -32) {
    1565             psFree(object);
    1566             exit(EXIT_FAILURE);
    1567         }
    1568         if (strncmp(object->exp_tag, "a string", MAX_STRING_LENGTH)) {
    1569             psFree(object);
    1570             exit(EXIT_FAILURE);
    1571         }
    1572         if (!object->p3_version == -32) {
    1573             psFree(object);
    1574             exit(EXIT_FAILURE);
    1575         }
    1576         if (strncmp(object->class_id, "a string", MAX_STRING_LENGTH)) {
    1577             psFree(object);
    1578             exit(EXIT_FAILURE);
    1579         }
    1580         if (strncmp(object->uri, "a string", MAX_STRING_LENGTH)) {
    1581             psFree(object);
    1582             exit(EXIT_FAILURE);
    1583         }
    1584         if (strncmp(object->b1_uri, "a string", MAX_STRING_LENGTH)) {
    1585             psFree(object);
    1586             exit(EXIT_FAILURE);
    1587         }
    1588         if (strncmp(object->b2_uri, "a string", MAX_STRING_LENGTH)) {
    1589             psFree(object);
    1590             exit(EXIT_FAILURE);
    1591         }
    1592 
    1593         psFree(object);
    1594     }
    1595 
    1596     {
    1597         p4MagicMaskImfileRow *object;
    1598 
    1599         object = p4MagicMaskImfileRowAlloc(-32, "a string", -32, "a string", "a string"    );
    1600 
    1601         if (!object) {
    1602             exit(EXIT_FAILURE);
    1603         }
    1604 
    1605         if (!object->p4_id == -32) {
    1606             psFree(object);
    1607             exit(EXIT_FAILURE);
    1608         }
    1609         if (strncmp(object->exp_tag, "a string", MAX_STRING_LENGTH)) {
    1610             psFree(object);
    1611             exit(EXIT_FAILURE);
    1612         }
    1613         if (!object->p3_version == -32) {
    1614             psFree(object);
    1615             exit(EXIT_FAILURE);
    1616         }
    1617         if (strncmp(object->class_id, "a string", MAX_STRING_LENGTH)) {
    1618             psFree(object);
    1619             exit(EXIT_FAILURE);
    1620         }
    1621         if (strncmp(object->uri, "a string", MAX_STRING_LENGTH)) {
    16221781            psFree(object);
    16231782            exit(EXIT_FAILURE);

  • trunk/ippdb/tests/createtable.c

    r11045 r11679  
    478478        }
    479479
    480         if(!p4RunCreateTable(dbh)) {
    481             exit(EXIT_FAILURE);
    482         }
    483 
    484         psDBCleanup(dbh);
    485     }
    486 
    487     {
    488         psDB            *dbh;
    489 
    490         dbh = psDBInit("localhost", "test", NULL, "test");
    491         if (!dbh) {
    492             exit(EXIT_FAILURE);
    493         }
    494 
    495         if(!p4InputImfileCreateTable(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(!p4WarpedImfileCreateTable(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(!p4StackedImfileCreateTable(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(!p4DiffImfileCreateTable(dbh)) {
     480        if(!p4aRunCreateTable(dbh)) {
     481            exit(EXIT_FAILURE);
     482        }
     483
     484        psDBCleanup(dbh);
     485    }
     486
     487    {
     488        psDB            *dbh;
     489
     490        dbh = psDBInit("localhost", "test", NULL, "test");
     491        if (!dbh) {
     492            exit(EXIT_FAILURE);
     493        }
     494
     495        if(!p4aInputExpCreateTable(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(!p4aScfileCreateTable(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(!p4bRunCreateTable(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(!p4bInputScfileCreateTable(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(!p4bDiffScfileCreateTable(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(!p4cRunCreateTable(dbh)) {
     571            exit(EXIT_FAILURE);
     572        }
     573
     574        psDBCleanup(dbh);
     575    }
     576
     577    {
     578        psDB            *dbh;
     579
     580        dbh = psDBInit("localhost", "test", NULL, "test");
     581        if (!dbh) {
     582            exit(EXIT_FAILURE);
     583        }
     584
     585        if(!p4cInputExpCreateTable(dbh)) {
    541586            exit(EXIT_FAILURE);
    542587        }
    … …  
    554599
    555600        if(!p4MagicMaskImfileCreateTable(dbh)) {
     601            exit(EXIT_FAILURE);
     602        }
     603
     604        psDBCleanup(dbh);
     605    }
     606
     607    {
     608        psDB            *dbh;
     609
     610        dbh = psDBInit("localhost", "test", NULL, "test");
     611        if (!dbh) {
     612            exit(EXIT_FAILURE);
     613        }
     614
     615        if(!skyCellCreateTable(dbh)) {
     616            exit(EXIT_FAILURE);
     617        }
     618
     619        psDBCleanup(dbh);
     620    }
     621
     622    {
     623        psDB            *dbh;
     624
     625        dbh = psDBInit("localhost", "test", NULL, "test");
     626        if (!dbh) {
     627            exit(EXIT_FAILURE);
     628        }
     629
     630        if(!skyCellMapCreateTable(dbh)) {
    556631            exit(EXIT_FAILURE);
    557632        }

  • trunk/ippdb/tests/dbcleanup.c

    r11045 r11679  
    66    psDB            *dbh;
    77
    8     dbh = psDBInit("localhost", "test", NULL, "test");
     8    dbh = psDBInit("localhost", "test", NULL, "test", 0);
    99    if (!dbh) {
    1010        exit(EXIT_FAILURE);
    … …  
    4242    p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS detResidExp");
    4343    p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS detRunSummary");
    44     p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p4Run");
    45     p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p4InputImfile");
    46     p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p4WarpedImfile");
    47     p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p4StackedImfile");
    48     p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p4DiffImfile");
     44    p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p4aRun");
     45    p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p4aInputExp");
     46    p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p4aScfile");
     47    p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p4bRun");
     48    p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p4bInputScfile");
     49    p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p4bDiffScfile");
     50    p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p4cRun");
     51    p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p4cInputExp");
    4952    p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p4MagicMaskImfile");
     53    p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS skyCell");
     54    p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS skyCellMap");
    5055
    5156    psDBCleanup(dbh);

  • trunk/ippdb/tests/dbsetup.c

    r11045 r11679  
    77    psDB            *dbh;
    88
    9     dbh = psDBInit("localhost", "test", NULL, "test");
     9    dbh = psDBInit("localhost", "test", NULL, "test", 0);
    1010    if (!dbh) {
    1111        exit(EXIT_FAILURE);
    … …  
    106106    detRunSummaryCreateTable(dbh);
    107107
    108     p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p4Run");
    109     p4RunCreateTable(dbh);
     108    p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p4aRun");
     109    p4aRunCreateTable(dbh);
    110110
    111     p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p4InputImfile");
    112     p4InputImfileCreateTable(dbh);
     111    p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p4aInputExp");
     112    p4aInputExpCreateTable(dbh);
    113113
    114     p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p4WarpedImfile");
    115     p4WarpedImfileCreateTable(dbh);
     114    p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p4aScfile");
     115    p4aScfileCreateTable(dbh);
    116116
    117     p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p4StackedImfile");
    118     p4StackedImfileCreateTable(dbh);
     117    p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p4bRun");
     118    p4bRunCreateTable(dbh);
    119119
    120     p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p4DiffImfile");
    121     p4DiffImfileCreateTable(dbh);
     120    p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p4bInputScfile");
     121    p4bInputScfileCreateTable(dbh);
     122
     123    p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p4bDiffScfile");
     124    p4bDiffScfileCreateTable(dbh);
     125
     126    p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p4cRun");
     127    p4cRunCreateTable(dbh);
     128
     129    p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p4cInputExp");
     130    p4cInputExpCreateTable(dbh);
    122131
    123132    p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p4MagicMaskImfile");
    124133    p4MagicMaskImfileCreateTable(dbh);
     134
     135    p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS skyCell");
     136    skyCellCreateTable(dbh);
     137
     138    p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS skyCellMap");
     139    skyCellMapCreateTable(dbh);
    125140
    126141    psDBCleanup(dbh);

  • trunk/ippdb/tests/droptable.c

    r11045 r11679  
    478478        }
    479479
    480         if (!p4RunDropTable(dbh)) {
    481             exit(EXIT_FAILURE);
    482         }
    483 
    484         psDBCleanup(dbh);
    485     }
    486 
    487     {
    488         psDB            *dbh;
    489 
    490         dbh = psDBInit("localhost", "test", NULL, "test");
    491         if (!dbh) {
    492             exit(EXIT_FAILURE);
    493         }
    494 
    495         if (!p4InputImfileDropTable(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 (!p4WarpedImfileDropTable(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 (!p4StackedImfileDropTable(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 (!p4DiffImfileDropTable(dbh)) {
     480        if (!p4aRunDropTable(dbh)) {
     481            exit(EXIT_FAILURE);
     482        }
     483
     484        psDBCleanup(dbh);
     485    }
     486
     487    {
     488        psDB            *dbh;
     489
     490        dbh = psDBInit("localhost", "test", NULL, "test");
     491        if (!dbh) {
     492            exit(EXIT_FAILURE);
     493        }
     494
     495        if (!p4aInputExpDropTable(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 (!p4aScfileDropTable(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 (!p4bRunDropTable(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 (!p4bInputScfileDropTable(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 (!p4bDiffScfileDropTable(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 (!p4cRunDropTable(dbh)) {
     571            exit(EXIT_FAILURE);
     572        }
     573
     574        psDBCleanup(dbh);
     575    }
     576
     577    {
     578        psDB            *dbh;
     579
     580        dbh = psDBInit("localhost", "test", NULL, "test");
     581        if (!dbh) {
     582            exit(EXIT_FAILURE);
     583        }
     584
     585        if (!p4cInputExpDropTable(dbh)) {
    541586            exit(EXIT_FAILURE);
    542587        }
    … …  
    554599
    555600        if (!p4MagicMaskImfileDropTable(dbh)) {
     601            exit(EXIT_FAILURE);
     602        }
     603
     604        psDBCleanup(dbh);
     605    }
     606
     607    {
     608        psDB            *dbh;
     609
     610        dbh = psDBInit("localhost", "test", NULL, "test");
     611        if (!dbh) {
     612            exit(EXIT_FAILURE);
     613        }
     614
     615        if (!skyCellDropTable(dbh)) {
     616            exit(EXIT_FAILURE);
     617        }
     618
     619        psDBCleanup(dbh);
     620    }
     621
     622    {
     623        psDB            *dbh;
     624
     625        dbh = psDBInit("localhost", "test", NULL, "test");
     626        if (!dbh) {
     627            exit(EXIT_FAILURE);
     628        }
     629
     630        if (!skyCellMapDropTable(dbh)) {
    556631            exit(EXIT_FAILURE);
    557632        }

  • trunk/ippdb/tests/insert.c

    r11193 r11679  
    478478        }
    479479
    480         if (!p4RunInsert(dbh, -32, "a string", "a string", "a string", "a string", "a string", "a string", 64.64, 64.64, "a string", "a string")) {
    481             exit(EXIT_FAILURE);
    482         }
    483 
    484         psDBCleanup(dbh);
    485     }
    486 
    487     {
    488         psDB            *dbh;
    489 
    490         dbh = psDBInit("localhost", "test", NULL, "test");
    491         if (!dbh) {
    492             exit(EXIT_FAILURE);
    493         }
    494 
    495         if (!p4InputImfileInsert(dbh, -32, "a string", -32, "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 (!p4WarpedImfileInsert(dbh, -32, "a string", -32, "a string", "a string", "a string", "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 (!p4StackedImfileInsert(dbh, -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 (!p4DiffImfileInsert(dbh, -32, "a string", -32, "a string", "a string", "a string", "a string")) {
     480        if (!p4aRunInsert(dbh, -32, "a string", "a string", true)) {
     481            exit(EXIT_FAILURE);
     482        }
     483
     484        psDBCleanup(dbh);
     485    }
     486
     487    {
     488        psDB            *dbh;
     489
     490        dbh = psDBInit("localhost", "test", NULL, "test");
     491        if (!dbh) {
     492            exit(EXIT_FAILURE);
     493        }
     494
     495        if (!p4aInputExpInsert(dbh, -32, "a string", -32)) {
     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 (!p4aScfileInsert(dbh, -32, "a string", "a string", "a string", -32, "a string", 64.64, 64.64)) {
     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 (!p4bRunInsert(dbh, -32, "a string", "a string", true)) {
     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 (!p4bInputScfileInsert(dbh, -32, "a string", "a string", "a string", -32, "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 (!p4bDiffScfileInsert(dbh, -32, "a string", "a string", "a string", -32, "a string", 64.64, 64.64)) {
     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 (!p4cRunInsert(dbh, -32, "a string", "a string", true)) {
     571            exit(EXIT_FAILURE);
     572        }
     573
     574        psDBCleanup(dbh);
     575    }
     576
     577    {
     578        psDB            *dbh;
     579
     580        dbh = psDBInit("localhost", "test", NULL, "test");
     581        if (!dbh) {
     582            exit(EXIT_FAILURE);
     583        }
     584
     585        if (!p4cInputExpInsert(dbh, -32, "a string", -32)) {
    541586            exit(EXIT_FAILURE);
    542587        }
    … …  
    554599
    555600        if (!p4MagicMaskImfileInsert(dbh, -32, "a string", -32, "a string", "a string")) {
     601            exit(EXIT_FAILURE);
     602        }
     603
     604        psDBCleanup(dbh);
     605    }
     606
     607    {
     608        psDB            *dbh;
     609
     610        dbh = psDBInit("localhost", "test", NULL, "test");
     611        if (!dbh) {
     612            exit(EXIT_FAILURE);
     613        }
     614
     615        if (!skyCellInsert(dbh, "a string", "a string", 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64)) {
     616            exit(EXIT_FAILURE);
     617        }
     618
     619        psDBCleanup(dbh);
     620    }
     621
     622    {
     623        psDB            *dbh;
     624
     625        dbh = psDBInit("localhost", "test", NULL, "test");
     626        if (!dbh) {
     627            exit(EXIT_FAILURE);
     628        }
     629
     630        if (!skyCellMapInsert(dbh, "a string", "a string", "a string", "a string")) {
    556631            exit(EXIT_FAILURE);
    557632        }

  • trunk/ippdb/tests/insertfits.c

    r11045 r11679  
    830830        }
    831831
    832         if (!p4RunInsertFits(dbh, fits)) {
    833             exit(EXIT_FAILURE);
    834         }
    835 
    836         if (!psFitsClose(fits)) {
    837             exit(EXIT_FAILURE);
    838         }
    839 
    840         psDBCleanup(dbh);
    841     }
    842 
    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 (!p4InputImfileInsertFits(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 (!p4WarpedImfileInsertFits(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 (!p4StackedImfileInsertFits(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 (!p4DiffImfileInsertFits(dbh, fits)) {
     832        if (!p4aRunInsertFits(dbh, fits)) {
     833            exit(EXIT_FAILURE);
     834        }
     835
     836        if (!psFitsClose(fits)) {
     837            exit(EXIT_FAILURE);
     838        }
     839
     840        psDBCleanup(dbh);
     841    }
     842
     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 (!p4aInputExpInsertFits(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 (!p4aScfileInsertFits(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 (!p4bRunInsertFits(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 (!p4bInputScfileInsertFits(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 (!p4bDiffScfileInsertFits(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 (!p4cRunInsertFits(dbh, fits)) {
     989            exit(EXIT_FAILURE);
     990        }
     991
     992        if (!psFitsClose(fits)) {
     993            exit(EXIT_FAILURE);
     994        }
     995
     996        psDBCleanup(dbh);
     997    }
     998
     999    {
     1000        psDB            *dbh;
     1001        psFits          *fits;
     1002
     1003        dbh = psDBInit("localhost", "test", NULL, "test");
     1004        if (!dbh) {
     1005            exit(EXIT_FAILURE);
     1006        }
     1007
     1008        // open a temp
     1009        fits = psFitsOpen(TMP_FILENAME, "r");
     1010        if (!fits) {
     1011            exit(EXIT_FAILURE);
     1012        }
     1013
     1014        if (!p4cInputExpInsertFits(dbh, fits)) {
    9371015            exit(EXIT_FAILURE);
    9381016        }
    … …  
    9611039
    9621040        if (!p4MagicMaskImfileInsertFits(dbh, fits)) {
     1041            exit(EXIT_FAILURE);
     1042        }
     1043
     1044        if (!psFitsClose(fits)) {
     1045            exit(EXIT_FAILURE);
     1046        }
     1047
     1048        psDBCleanup(dbh);
     1049    }
     1050
     1051    {
     1052        psDB            *dbh;
     1053        psFits          *fits;
     1054
     1055        dbh = psDBInit("localhost", "test", NULL, "test");
     1056        if (!dbh) {
     1057            exit(EXIT_FAILURE);
     1058        }
     1059
     1060        // open a temp
     1061        fits = psFitsOpen(TMP_FILENAME, "r");
     1062        if (!fits) {
     1063            exit(EXIT_FAILURE);
     1064        }
     1065
     1066        if (!skyCellInsertFits(dbh, fits)) {
     1067            exit(EXIT_FAILURE);
     1068        }
     1069
     1070        if (!psFitsClose(fits)) {
     1071            exit(EXIT_FAILURE);
     1072        }
     1073
     1074        psDBCleanup(dbh);
     1075    }
     1076
     1077    {
     1078        psDB            *dbh;
     1079        psFits          *fits;
     1080
     1081        dbh = psDBInit("localhost", "test", NULL, "test");
     1082        if (!dbh) {
     1083            exit(EXIT_FAILURE);
     1084        }
     1085
     1086        // open a temp
     1087        fits = psFitsOpen(TMP_FILENAME, "r");
     1088        if (!fits) {
     1089            exit(EXIT_FAILURE);
     1090        }
     1091
     1092        if (!skyCellMapInsertFits(dbh, fits)) {
    9631093            exit(EXIT_FAILURE);
    9641094        }

  • trunk/ippdb/tests/insertobject.c

    r11193 r11679  
    689689    {
    690690        psDB            *dbh;
    691         p4RunRow        *object;
    692 
    693         dbh = psDBInit("localhost", "test", NULL, "test");
    694         if (!dbh) {
    695             exit(EXIT_FAILURE);
    696         }
    697 
    698         object = p4RunRowAlloc(-32, "a string", "a string", "a string", "a string", "a string", "a string", 64.64, 64.64, "a string", "a string");
    699         if (!object) {
    700             exit(EXIT_FAILURE);
    701         }
    702 
    703         if (!p4RunInsertObject(dbh, object)) {
    704             exit(EXIT_FAILURE);
    705         }
    706 
    707         psFree(object);
    708         psDBCleanup(dbh);
    709     }
    710 
    711     {
    712         psDB            *dbh;
    713         p4InputImfileRow *object;
    714 
    715         dbh = psDBInit("localhost", "test", NULL, "test");
    716         if (!dbh) {
    717             exit(EXIT_FAILURE);
    718         }
    719 
    720         object = p4InputImfileRowAlloc(-32, "a string", -32, "a string");
    721         if (!object) {
    722             exit(EXIT_FAILURE);
    723         }
    724 
    725         if (!p4InputImfileInsertObject(dbh, object)) {
    726             exit(EXIT_FAILURE);
    727         }
    728 
    729         psFree(object);
    730         psDBCleanup(dbh);
    731     }
    732 
    733     {
    734         psDB            *dbh;
    735         p4WarpedImfileRow *object;
    736 
    737         dbh = psDBInit("localhost", "test", NULL, "test");
    738         if (!dbh) {
    739             exit(EXIT_FAILURE);
    740         }
    741 
    742         object = p4WarpedImfileRowAlloc(-32, "a string", -32, "a string", "a string", "a string", "a string");
    743         if (!object) {
    744             exit(EXIT_FAILURE);
    745         }
    746 
    747         if (!p4WarpedImfileInsertObject(dbh, object)) {
    748             exit(EXIT_FAILURE);
    749         }
    750 
    751         psFree(object);
    752         psDBCleanup(dbh);
    753     }
    754 
    755     {
    756         psDB            *dbh;
    757         p4StackedImfileRow *object;
    758 
    759         dbh = psDBInit("localhost", "test", NULL, "test");
    760         if (!dbh) {
    761             exit(EXIT_FAILURE);
    762         }
    763 
    764         object = p4StackedImfileRowAlloc(-32, "a string", "a string", "a string", "a string");
    765         if (!object) {
    766             exit(EXIT_FAILURE);
    767         }
    768 
    769         if (!p4StackedImfileInsertObject(dbh, object)) {
    770             exit(EXIT_FAILURE);
    771         }
    772 
    773         psFree(object);
    774         psDBCleanup(dbh);
    775     }
    776 
    777     {
    778         psDB            *dbh;
    779         p4DiffImfileRow *object;
    780 
    781         dbh = psDBInit("localhost", "test", NULL, "test");
    782         if (!dbh) {
    783             exit(EXIT_FAILURE);
    784         }
    785 
    786         object = p4DiffImfileRowAlloc(-32, "a string", -32, "a string", "a string", "a string", "a string");
    787         if (!object) {
    788             exit(EXIT_FAILURE);
    789         }
    790 
    791         if (!p4DiffImfileInsertObject(dbh, object)) {
     691        p4aRunRow       *object;
     692
     693        dbh = psDBInit("localhost", "test", NULL, "test");
     694        if (!dbh) {
     695            exit(EXIT_FAILURE);
     696        }
     697
     698        object = p4aRunRowAlloc(-32, "a string", "a string", true);
     699        if (!object) {
     700            exit(EXIT_FAILURE);
     701        }
     702
     703        if (!p4aRunInsertObject(dbh, object)) {
     704            exit(EXIT_FAILURE);
     705        }
     706
     707        psFree(object);
     708        psDBCleanup(dbh);
     709    }
     710
     711    {
     712        psDB            *dbh;
     713        p4aInputExpRow  *object;
     714
     715        dbh = psDBInit("localhost", "test", NULL, "test");
     716        if (!dbh) {
     717            exit(EXIT_FAILURE);
     718        }
     719
     720        object = p4aInputExpRowAlloc(-32, "a string", -32);
     721        if (!object) {
     722            exit(EXIT_FAILURE);
     723        }
     724
     725        if (!p4aInputExpInsertObject(dbh, object)) {
     726            exit(EXIT_FAILURE);
     727        }
     728
     729        psFree(object);
     730        psDBCleanup(dbh);
     731    }
     732
     733    {
     734        psDB            *dbh;
     735        p4aScfileRow    *object;
     736
     737        dbh = psDBInit("localhost", "test", NULL, "test");
     738        if (!dbh) {
     739            exit(EXIT_FAILURE);
     740        }
     741
     742        object = p4aScfileRowAlloc(-32, "a string", "a string", "a string", -32, "a string", 64.64, 64.64);
     743        if (!object) {
     744            exit(EXIT_FAILURE);
     745        }
     746
     747        if (!p4aScfileInsertObject(dbh, object)) {
     748            exit(EXIT_FAILURE);
     749        }
     750
     751        psFree(object);
     752        psDBCleanup(dbh);
     753    }
     754
     755    {
     756        psDB            *dbh;
     757        p4bRunRow       *object;
     758
     759        dbh = psDBInit("localhost", "test", NULL, "test");
     760        if (!dbh) {
     761            exit(EXIT_FAILURE);
     762        }
     763
     764        object = p4bRunRowAlloc(-32, "a string", "a string", true);
     765        if (!object) {
     766            exit(EXIT_FAILURE);
     767        }
     768
     769        if (!p4bRunInsertObject(dbh, object)) {
     770            exit(EXIT_FAILURE);
     771        }
     772
     773        psFree(object);
     774        psDBCleanup(dbh);
     775    }
     776
     777    {
     778        psDB            *dbh;
     779        p4bInputScfileRow *object;
     780
     781        dbh = psDBInit("localhost", "test", NULL, "test");
     782        if (!dbh) {
     783            exit(EXIT_FAILURE);
     784        }
     785
     786        object = p4bInputScfileRowAlloc(-32, "a string", "a string", "a string", -32, "a string");
     787        if (!object) {
     788            exit(EXIT_FAILURE);
     789        }
     790
     791        if (!p4bInputScfileInsertObject(dbh, object)) {
     792            exit(EXIT_FAILURE);
     793        }
     794
     795        psFree(object);
     796        psDBCleanup(dbh);
     797    }
     798
     799    {
     800        psDB            *dbh;
     801        p4bDiffScfileRow *object;
     802
     803        dbh = psDBInit("localhost", "test", NULL, "test");
     804        if (!dbh) {
     805            exit(EXIT_FAILURE);
     806        }
     807
     808        object = p4bDiffScfileRowAlloc(-32, "a string", "a string", "a string", -32, "a string", 64.64, 64.64);
     809        if (!object) {
     810            exit(EXIT_FAILURE);
     811        }
     812
     813        if (!p4bDiffScfileInsertObject(dbh, object)) {
     814            exit(EXIT_FAILURE);
     815        }
     816
     817        psFree(object);
     818        psDBCleanup(dbh);
     819    }
     820
     821    {
     822        psDB            *dbh;
     823        p4cRunRow       *object;
     824
     825        dbh = psDBInit("localhost", "test", NULL, "test");
     826        if (!dbh) {
     827            exit(EXIT_FAILURE);
     828        }
     829
     830        object = p4cRunRowAlloc(-32, "a string", "a string", true);
     831        if (!object) {
     832            exit(EXIT_FAILURE);
     833        }
     834
     835        if (!p4cRunInsertObject(dbh, object)) {
     836            exit(EXIT_FAILURE);
     837        }
     838
     839        psFree(object);
     840        psDBCleanup(dbh);
     841    }
     842
     843    {
     844        psDB            *dbh;
     845        p4cInputExpRow  *object;
     846
     847        dbh = psDBInit("localhost", "test", NULL, "test");
     848        if (!dbh) {
     849            exit(EXIT_FAILURE);
     850        }
     851
     852        object = p4cInputExpRowAlloc(-32, "a string", -32);
     853        if (!object) {
     854            exit(EXIT_FAILURE);
     855        }
     856
     857        if (!p4cInputExpInsertObject(dbh, object)) {
    792858            exit(EXIT_FAILURE);
    793859        }
    … …  
    812878
    813879        if (!p4MagicMaskImfileInsertObject(dbh, object)) {
     880            exit(EXIT_FAILURE);
     881        }
     882
     883        psFree(object);
     884        psDBCleanup(dbh);
     885    }
     886
     887    {
     888        psDB            *dbh;
     889        skyCellRow      *object;
     890
     891        dbh = psDBInit("localhost", "test", NULL, "test");
     892        if (!dbh) {
     893            exit(EXIT_FAILURE);
     894        }
     895
     896        object = skyCellRowAlloc("a string", "a string", 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64);
     897        if (!object) {
     898            exit(EXIT_FAILURE);
     899        }
     900
     901        if (!skyCellInsertObject(dbh, object)) {
     902            exit(EXIT_FAILURE);
     903        }
     904
     905        psFree(object);
     906        psDBCleanup(dbh);
     907    }
     908
     909    {
     910        psDB            *dbh;
     911        skyCellMapRow   *object;
     912
     913        dbh = psDBInit("localhost", "test", NULL, "test");
     914        if (!dbh) {
     915            exit(EXIT_FAILURE);
     916        }
     917
     918        object = skyCellMapRowAlloc("a string", "a string", "a string", "a string");
     919        if (!object) {
     920            exit(EXIT_FAILURE);
     921        }
     922
     923        if (!skyCellMapInsertObject(dbh, object)) {
    814924            exit(EXIT_FAILURE);
    815925        }

  • trunk/ippdb/tests/metadatafromobject.c

    r11193 r11679  
    16431643    {
    16441644        psMetadata      *md;
    1645         p4RunRow        *object;
    1646         bool            status;
    1647 
    1648         object = p4RunRowAlloc(-32, "a string", "a string", "a string", "a string", "a string", "a string", 64.64, 64.64, "a string", "a string");
    1649         if (!object) {
    1650             exit(EXIT_FAILURE);
    1651         }
    1652 
    1653         md = p4RunMetadataFromObject(object);
    1654         if (!md) {
    1655             exit(EXIT_FAILURE);
    1656         }
    1657 
    1658         psFree(object);
    1659 
    1660         if (!psMetadataLookupS32(&status, md, "p4_id") == -32) {
    1661             psFree(md);
    1662             exit(EXIT_FAILURE);
    1663         }
    1664         if (strncmp(psMetadataLookupPtr(&status, md, "survey_mode"), "a string", MAX_STRING_LENGTH)) {
     1645        p4aRunRow       *object;
     1646        bool            status;
     1647
     1648        object = p4aRunRowAlloc(-32, "a string", "a string", true);
     1649        if (!object) {
     1650            exit(EXIT_FAILURE);
     1651        }
     1652
     1653        md = p4aRunMetadataFromObject(object);
     1654        if (!md) {
     1655            exit(EXIT_FAILURE);
     1656        }
     1657
     1658        psFree(object);
     1659
     1660        if (!psMetadataLookupS32(&status, md, "p4a_id") == -32) {
    16651661            psFree(md);
    16661662            exit(EXIT_FAILURE);
    … …  
    16741670            exit(EXIT_FAILURE);
    16751671        }
    1676         if (strncmp(psMetadataLookupPtr(&status, md, "filter"), "a string", MAX_STRING_LENGTH)) {
     1672        if (!psMetadataLookupBool(&status, md, "magic") == true) {
     1673            psFree(md);
     1674            exit(EXIT_FAILURE);
     1675        }
     1676
     1677        psFree(md);
     1678    }
     1679
     1680    {
     1681        psMetadata      *md;
     1682        p4aInputExpRow  *object;
     1683        bool            status;
     1684
     1685        object = p4aInputExpRowAlloc(-32, "a string", -32);
     1686        if (!object) {
     1687            exit(EXIT_FAILURE);
     1688        }
     1689
     1690        md = p4aInputExpMetadataFromObject(object);
     1691        if (!md) {
     1692            exit(EXIT_FAILURE);
     1693        }
     1694
     1695        psFree(object);
     1696
     1697        if (!psMetadataLookupS32(&status, md, "p4a_id") == -32) {
     1698            psFree(md);
     1699            exit(EXIT_FAILURE);
     1700        }
     1701        if (strncmp(psMetadataLookupPtr(&status, md, "exp_tag"), "a string", MAX_STRING_LENGTH)) {
     1702            psFree(md);
     1703            exit(EXIT_FAILURE);
     1704        }
     1705        if (!psMetadataLookupS32(&status, md, "p3_version") == -32) {
     1706            psFree(md);
     1707            exit(EXIT_FAILURE);
     1708        }
     1709
     1710        psFree(md);
     1711    }
     1712
     1713    {
     1714        psMetadata      *md;
     1715        p4aScfileRow    *object;
     1716        bool            status;
     1717
     1718        object = p4aScfileRowAlloc(-32, "a string", "a string", "a string", -32, "a string", 64.64, 64.64);
     1719        if (!object) {
     1720            exit(EXIT_FAILURE);
     1721        }
     1722
     1723        md = p4aScfileMetadataFromObject(object);
     1724        if (!md) {
     1725            exit(EXIT_FAILURE);
     1726        }
     1727
     1728        psFree(object);
     1729
     1730        if (!psMetadataLookupS32(&status, md, "p4a_id") == -32) {
    16771731            psFree(md);
    16781732            exit(EXIT_FAILURE);
    … …  
    16861740            exit(EXIT_FAILURE);
    16871741        }
    1688         if (!psMetadataLookupF64(&status, md, "ra") == 64.64) {
    1689             psFree(md);
    1690             exit(EXIT_FAILURE);
    1691         }
    1692         if (!psMetadataLookupF64(&status, md, "decl") == 64.64) {
    1693             psFree(md);
    1694             exit(EXIT_FAILURE);
    1695         }
    1696         if (strncmp(psMetadataLookupPtr(&status, md, "input_ss"), "a string", MAX_STRING_LENGTH)) {
    1697             psFree(md);
    1698             exit(EXIT_FAILURE);
    1699         }
    1700         if (strncmp(psMetadataLookupPtr(&status, md, "output_ss"), "a string", MAX_STRING_LENGTH)) {
    1701             psFree(md);
    1702             exit(EXIT_FAILURE);
    1703         }
    1704 
    1705         psFree(md);
    1706     }
    1707 
    1708     {
    1709         psMetadata      *md;
    1710         p4InputImfileRow *object;
    1711         bool            status;
    1712 
    1713         object = p4InputImfileRowAlloc(-32, "a string", -32, "a string");
    1714         if (!object) {
    1715             exit(EXIT_FAILURE);
    1716         }
    1717 
    1718         md = p4InputImfileMetadataFromObject(object);
    1719         if (!md) {
    1720             exit(EXIT_FAILURE);
    1721         }
    1722 
    1723         psFree(object);
    1724 
    1725         if (!psMetadataLookupS32(&status, md, "p4_id") == -32) {
    1726             psFree(md);
    1727             exit(EXIT_FAILURE);
    1728         }
    17291742        if (strncmp(psMetadataLookupPtr(&status, md, "exp_tag"), "a string", MAX_STRING_LENGTH)) {
    17301743            psFree(md);
    … …  
    17351748            exit(EXIT_FAILURE);
    17361749        }
     1750        if (strncmp(psMetadataLookupPtr(&status, md, "uri"), "a string", MAX_STRING_LENGTH)) {
     1751            psFree(md);
     1752            exit(EXIT_FAILURE);
     1753        }
     1754        if (!psMetadataLookupF64(&status, md, "bg") == 64.64) {
     1755            psFree(md);
     1756            exit(EXIT_FAILURE);
     1757        }
     1758        if (!psMetadataLookupF64(&status, md, "bg_mean_stdev") == 64.64) {
     1759            psFree(md);
     1760            exit(EXIT_FAILURE);
     1761        }
     1762
     1763        psFree(md);
     1764    }
     1765
     1766    {
     1767        psMetadata      *md;
     1768        p4bRunRow       *object;
     1769        bool            status;
     1770
     1771        object = p4bRunRowAlloc(-32, "a string", "a string", true);
     1772        if (!object) {
     1773            exit(EXIT_FAILURE);
     1774        }
     1775
     1776        md = p4bRunMetadataFromObject(object);
     1777        if (!md) {
     1778            exit(EXIT_FAILURE);
     1779        }
     1780
     1781        psFree(object);
     1782
     1783        if (!psMetadataLookupS32(&status, md, "p4b_id") == -32) {
     1784            psFree(md);
     1785            exit(EXIT_FAILURE);
     1786        }
     1787        if (strncmp(psMetadataLookupPtr(&status, md, "state"), "a string", MAX_STRING_LENGTH)) {
     1788            psFree(md);
     1789            exit(EXIT_FAILURE);
     1790        }
     1791        if (strncmp(psMetadataLookupPtr(&status, md, "workdir"), "a string", MAX_STRING_LENGTH)) {
     1792            psFree(md);
     1793            exit(EXIT_FAILURE);
     1794        }
     1795        if (!psMetadataLookupBool(&status, md, "magic") == true) {
     1796            psFree(md);
     1797            exit(EXIT_FAILURE);
     1798        }
     1799
     1800        psFree(md);
     1801    }
     1802
     1803    {
     1804        psMetadata      *md;
     1805        p4bInputScfileRow *object;
     1806        bool            status;
     1807
     1808        object = p4bInputScfileRowAlloc(-32, "a string", "a string", "a string", -32, "a string");
     1809        if (!object) {
     1810            exit(EXIT_FAILURE);
     1811        }
     1812
     1813        md = p4bInputScfileMetadataFromObject(object);
     1814        if (!md) {
     1815            exit(EXIT_FAILURE);
     1816        }
     1817
     1818        psFree(object);
     1819
     1820        if (!psMetadataLookupS32(&status, md, "p4b_id") == -32) {
     1821            psFree(md);
     1822            exit(EXIT_FAILURE);
     1823        }
     1824        if (strncmp(psMetadataLookupPtr(&status, md, "skycell_id"), "a string", MAX_STRING_LENGTH)) {
     1825            psFree(md);
     1826            exit(EXIT_FAILURE);
     1827        }
     1828        if (strncmp(psMetadataLookupPtr(&status, md, "tess_id"), "a string", MAX_STRING_LENGTH)) {
     1829            psFree(md);
     1830            exit(EXIT_FAILURE);
     1831        }
     1832        if (strncmp(psMetadataLookupPtr(&status, md, "exp_tag"), "a string", MAX_STRING_LENGTH)) {
     1833            psFree(md);
     1834            exit(EXIT_FAILURE);
     1835        }
     1836        if (!psMetadataLookupS32(&status, md, "p3_version") == -32) {
     1837            psFree(md);
     1838            exit(EXIT_FAILURE);
     1839        }
     1840        if (strncmp(psMetadataLookupPtr(&status, md, "kind"), "a string", MAX_STRING_LENGTH)) {
     1841            psFree(md);
     1842            exit(EXIT_FAILURE);
     1843        }
     1844
     1845        psFree(md);
     1846    }
     1847
     1848    {
     1849        psMetadata      *md;
     1850        p4bDiffScfileRow *object;
     1851        bool            status;
     1852
     1853        object = p4bDiffScfileRowAlloc(-32, "a string", "a string", "a string", -32, "a string", 64.64, 64.64);
     1854        if (!object) {
     1855            exit(EXIT_FAILURE);
     1856        }
     1857
     1858        md = p4bDiffScfileMetadataFromObject(object);
     1859        if (!md) {
     1860            exit(EXIT_FAILURE);
     1861        }
     1862
     1863        psFree(object);
     1864
     1865        if (!psMetadataLookupS32(&status, md, "p4b_id") == -32) {
     1866            psFree(md);
     1867            exit(EXIT_FAILURE);
     1868        }
     1869        if (strncmp(psMetadataLookupPtr(&status, md, "skycell_id"), "a string", MAX_STRING_LENGTH)) {
     1870            psFree(md);
     1871            exit(EXIT_FAILURE);
     1872        }
     1873        if (strncmp(psMetadataLookupPtr(&status, md, "tess_id"), "a string", MAX_STRING_LENGTH)) {
     1874            psFree(md);
     1875            exit(EXIT_FAILURE);
     1876        }
     1877        if (strncmp(psMetadataLookupPtr(&status, md, "exp_tag"), "a string", MAX_STRING_LENGTH)) {
     1878            psFree(md);
     1879            exit(EXIT_FAILURE);
     1880        }
     1881        if (!psMetadataLookupS32(&status, md, "p3_version") == -32) {
     1882            psFree(md);
     1883            exit(EXIT_FAILURE);
     1884        }
     1885        if (strncmp(psMetadataLookupPtr(&status, md, "uri"), "a string", MAX_STRING_LENGTH)) {
     1886            psFree(md);
     1887            exit(EXIT_FAILURE);
     1888        }
     1889        if (!psMetadataLookupF64(&status, md, "bg") == 64.64) {
     1890            psFree(md);
     1891            exit(EXIT_FAILURE);
     1892        }
     1893        if (!psMetadataLookupF64(&status, md, "bg_mean_stdev") == 64.64) {
     1894            psFree(md);
     1895            exit(EXIT_FAILURE);
     1896        }
     1897
     1898        psFree(md);
     1899    }
     1900
     1901    {
     1902        psMetadata      *md;
     1903        p4cRunRow       *object;
     1904        bool            status;
     1905
     1906        object = p4cRunRowAlloc(-32, "a string", "a string", true);
     1907        if (!object) {
     1908            exit(EXIT_FAILURE);
     1909        }
     1910
     1911        md = p4cRunMetadataFromObject(object);
     1912        if (!md) {
     1913            exit(EXIT_FAILURE);
     1914        }
     1915
     1916        psFree(object);
     1917
     1918        if (!psMetadataLookupS32(&status, md, "p4c_id") == -32) {
     1919            psFree(md);
     1920            exit(EXIT_FAILURE);
     1921        }
     1922        if (strncmp(psMetadataLookupPtr(&status, md, "state"), "a string", MAX_STRING_LENGTH)) {
     1923            psFree(md);
     1924            exit(EXIT_FAILURE);
     1925        }
     1926        if (strncmp(psMetadataLookupPtr(&status, md, "workdir"), "a string", MAX_STRING_LENGTH)) {
     1927            psFree(md);
     1928            exit(EXIT_FAILURE);
     1929        }
     1930        if (!psMetadataLookupBool(&status, md, "magic") == true) {
     1931            psFree(md);
     1932            exit(EXIT_FAILURE);
     1933        }
     1934
     1935        psFree(md);
     1936    }
     1937
     1938    {
     1939        psMetadata      *md;
     1940        p4cInputExpRow  *object;
     1941        bool            status;
     1942
     1943        object = p4cInputExpRowAlloc(-32, "a string", -32);
     1944        if (!object) {
     1945            exit(EXIT_FAILURE);
     1946        }
     1947
     1948        md = p4cInputExpMetadataFromObject(object);
     1949        if (!md) {
     1950            exit(EXIT_FAILURE);
     1951        }
     1952
     1953        psFree(object);
     1954
     1955        if (!psMetadataLookupS32(&status, md, "p4c_id") == -32) {
     1956            psFree(md);
     1957            exit(EXIT_FAILURE);
     1958        }
     1959        if (strncmp(psMetadataLookupPtr(&status, md, "exp_tag"), "a string", MAX_STRING_LENGTH)) {
     1960            psFree(md);
     1961            exit(EXIT_FAILURE);
     1962        }
     1963        if (!psMetadataLookupS32(&status, md, "p3_version") == -32) {
     1964            psFree(md);
     1965            exit(EXIT_FAILURE);
     1966        }
     1967
     1968        psFree(md);
     1969    }
     1970
     1971    {
     1972        psMetadata      *md;
     1973        p4MagicMaskImfileRow *object;
     1974        bool            status;
     1975
     1976        object = p4MagicMaskImfileRowAlloc(-32, "a string", -32, "a string", "a string");
     1977        if (!object) {
     1978            exit(EXIT_FAILURE);
     1979        }
     1980
     1981        md = p4MagicMaskImfileMetadataFromObject(object);
     1982        if (!md) {
     1983            exit(EXIT_FAILURE);
     1984        }
     1985
     1986        psFree(object);
     1987
     1988        if (!psMetadataLookupS32(&status, md, "p4c_id") == -32) {
     1989            psFree(md);
     1990            exit(EXIT_FAILURE);
     1991        }
     1992        if (strncmp(psMetadataLookupPtr(&status, md, "exp_tag"), "a string", MAX_STRING_LENGTH)) {
     1993            psFree(md);
     1994            exit(EXIT_FAILURE);
     1995        }
     1996        if (!psMetadataLookupS32(&status, md, "p3_version") == -32) {
     1997            psFree(md);
     1998            exit(EXIT_FAILURE);
     1999        }
    17372000        if (strncmp(psMetadataLookupPtr(&status, md, "class_id"), "a string", MAX_STRING_LENGTH)) {
    17382001            psFree(md);
    17392002            exit(EXIT_FAILURE);
    17402003        }
    1741 
    1742         psFree(md);
    1743     }
    1744 
    1745     {
    1746         psMetadata      *md;
    1747         p4WarpedImfileRow *object;
    1748         bool            status;
    1749 
    1750         object = p4WarpedImfileRowAlloc(-32, "a string", -32, "a string", "a string", "a string", "a string");
    1751         if (!object) {
    1752             exit(EXIT_FAILURE);
    1753         }
    1754 
    1755         md = p4WarpedImfileMetadataFromObject(object);
    1756         if (!md) {
    1757             exit(EXIT_FAILURE);
    1758         }
    1759 
    1760         psFree(object);
    1761 
    1762         if (!psMetadataLookupS32(&status, md, "p4_id") == -32) {
    1763             psFree(md);
    1764             exit(EXIT_FAILURE);
    1765         }
    1766         if (strncmp(psMetadataLookupPtr(&status, md, "exp_tag"), "a string", MAX_STRING_LENGTH)) {
    1767             psFree(md);
    1768             exit(EXIT_FAILURE);
    1769         }
    1770         if (!psMetadataLookupS32(&status, md, "p3_version") == -32) {
     2004        if (strncmp(psMetadataLookupPtr(&status, md, "uri"), "a string", MAX_STRING_LENGTH)) {
     2005            psFree(md);
     2006            exit(EXIT_FAILURE);
     2007        }
     2008
     2009        psFree(md);
     2010    }
     2011
     2012    {
     2013        psMetadata      *md;
     2014        skyCellRow      *object;
     2015        bool            status;
     2016
     2017        object = skyCellRowAlloc("a string", "a string", 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64);
     2018        if (!object) {
     2019            exit(EXIT_FAILURE);
     2020        }
     2021
     2022        md = skyCellMetadataFromObject(object);
     2023        if (!md) {
     2024            exit(EXIT_FAILURE);
     2025        }
     2026
     2027        psFree(object);
     2028
     2029        if (strncmp(psMetadataLookupPtr(&status, md, "skycell_id"), "a string", MAX_STRING_LENGTH)) {
     2030            psFree(md);
     2031            exit(EXIT_FAILURE);
     2032        }
     2033        if (strncmp(psMetadataLookupPtr(&status, md, "tess_id"), "a string", MAX_STRING_LENGTH)) {
     2034            psFree(md);
     2035            exit(EXIT_FAILURE);
     2036        }
     2037        if (!psMetadataLookupF64(&status, md, "ra1") == 64.64) {
     2038            psFree(md);
     2039            exit(EXIT_FAILURE);
     2040        }
     2041        if (!psMetadataLookupF64(&status, md, "decl1") == 64.64) {
     2042            psFree(md);
     2043            exit(EXIT_FAILURE);
     2044        }
     2045        if (!psMetadataLookupF64(&status, md, "ra2") == 64.64) {
     2046            psFree(md);
     2047            exit(EXIT_FAILURE);
     2048        }
     2049        if (!psMetadataLookupF64(&status, md, "decl2") == 64.64) {
     2050            psFree(md);
     2051            exit(EXIT_FAILURE);
     2052        }
     2053        if (!psMetadataLookupF64(&status, md, "ra3") == 64.64) {
     2054            psFree(md);
     2055            exit(EXIT_FAILURE);
     2056        }
     2057        if (!psMetadataLookupF64(&status, md, "decl3") == 64.64) {
     2058            psFree(md);
     2059            exit(EXIT_FAILURE);
     2060        }
     2061        if (!psMetadataLookupF64(&status, md, "ra4") == 64.64) {
     2062            psFree(md);
     2063            exit(EXIT_FAILURE);
     2064        }
     2065        if (!psMetadataLookupF64(&status, md, "decl4") == 64.64) {
     2066            psFree(md);
     2067            exit(EXIT_FAILURE);
     2068        }
     2069
     2070        psFree(md);
     2071    }
     2072
     2073    {
     2074        psMetadata      *md;
     2075        skyCellMapRow   *object;
     2076        bool            status;
     2077
     2078        object = skyCellMapRowAlloc("a string", "a string", "a string", "a string");
     2079        if (!object) {
     2080            exit(EXIT_FAILURE);
     2081        }
     2082
     2083        md = skyCellMapMetadataFromObject(object);
     2084        if (!md) {
     2085            exit(EXIT_FAILURE);
     2086        }
     2087
     2088        psFree(object);
     2089
     2090        if (strncmp(psMetadataLookupPtr(&status, md, "skycell_id"), "a string", MAX_STRING_LENGTH)) {
     2091            psFree(md);
     2092            exit(EXIT_FAILURE);
     2093        }
     2094        if (strncmp(psMetadataLookupPtr(&status, md, "tess_id"), "a string", MAX_STRING_LENGTH)) {
     2095            psFree(md);
     2096            exit(EXIT_FAILURE);
     2097        }
     2098        if (strncmp(psMetadataLookupPtr(&status, md, "exp_tag"), "a string", MAX_STRING_LENGTH)) {
    17712099            psFree(md);
    17722100            exit(EXIT_FAILURE);
    17732101        }
    17742102        if (strncmp(psMetadataLookupPtr(&status, md, "class_id"), "a string", MAX_STRING_LENGTH)) {
    1775             psFree(md);
    1776             exit(EXIT_FAILURE);
    1777         }
    1778         if (strncmp(psMetadataLookupPtr(&status, md, "uri"), "a string", MAX_STRING_LENGTH)) {
    1779             psFree(md);
    1780             exit(EXIT_FAILURE);
    1781         }
    1782         if (strncmp(psMetadataLookupPtr(&status, md, "b1_uri"), "a string", MAX_STRING_LENGTH)) {
    1783             psFree(md);
    1784             exit(EXIT_FAILURE);
    1785         }
    1786         if (strncmp(psMetadataLookupPtr(&status, md, "b2_uri"), "a string", MAX_STRING_LENGTH)) {
    1787             psFree(md);
    1788             exit(EXIT_FAILURE);
    1789         }
    1790 
    1791         psFree(md);
    1792     }
    1793 
    1794     {
    1795         psMetadata      *md;
    1796         p4StackedImfileRow *object;
    1797         bool            status;
    1798 
    1799         object = p4StackedImfileRowAlloc(-32, "a string", "a string", "a string", "a string");
    1800         if (!object) {
    1801             exit(EXIT_FAILURE);
    1802         }
    1803 
    1804         md = p4StackedImfileMetadataFromObject(object);
    1805         if (!md) {
    1806             exit(EXIT_FAILURE);
    1807         }
    1808 
    1809         psFree(object);
    1810 
    1811         if (!psMetadataLookupS32(&status, md, "p4_id") == -32) {
    1812             psFree(md);
    1813             exit(EXIT_FAILURE);
    1814         }
    1815         if (strncmp(psMetadataLookupPtr(&status, md, "class_id"), "a string", MAX_STRING_LENGTH)) {
    1816             psFree(md);
    1817             exit(EXIT_FAILURE);
    1818         }
    1819         if (strncmp(psMetadataLookupPtr(&status, md, "uri"), "a string", MAX_STRING_LENGTH)) {
    1820             psFree(md);
    1821             exit(EXIT_FAILURE);
    1822         }
    1823         if (strncmp(psMetadataLookupPtr(&status, md, "b1_uri"), "a string", MAX_STRING_LENGTH)) {
    1824             psFree(md);
    1825             exit(EXIT_FAILURE);
    1826         }
    1827         if (strncmp(psMetadataLookupPtr(&status, md, "b2_uri"), "a string", MAX_STRING_LENGTH)) {
    1828             psFree(md);
    1829             exit(EXIT_FAILURE);
    1830         }
    1831 
    1832         psFree(md);
    1833     }
    1834 
    1835     {
    1836         psMetadata      *md;
    1837         p4DiffImfileRow *object;
    1838         bool            status;
    1839 
    1840         object = p4DiffImfileRowAlloc(-32, "a string", -32, "a string", "a string", "a string", "a string");
    1841         if (!object) {
    1842             exit(EXIT_FAILURE);
    1843         }
    1844 
    1845         md = p4DiffImfileMetadataFromObject(object);
    1846         if (!md) {
    1847             exit(EXIT_FAILURE);
    1848         }
    1849 
    1850         psFree(object);
    1851 
    1852         if (!psMetadataLookupS32(&status, md, "p4_id") == -32) {
    1853             psFree(md);
    1854             exit(EXIT_FAILURE);
    1855         }
    1856         if (strncmp(psMetadataLookupPtr(&status, md, "exp_tag"), "a string", MAX_STRING_LENGTH)) {
    1857             psFree(md);
    1858             exit(EXIT_FAILURE);
    1859         }
    1860         if (!psMetadataLookupS32(&status, md, "p3_version") == -32) {
    1861             psFree(md);
    1862             exit(EXIT_FAILURE);
    1863         }
    1864         if (strncmp(psMetadataLookupPtr(&status, md, "class_id"), "a string", MAX_STRING_LENGTH)) {
    1865             psFree(md);
    1866             exit(EXIT_FAILURE);
    1867         }
    1868         if (strncmp(psMetadataLookupPtr(&status, md, "uri"), "a string", MAX_STRING_LENGTH)) {
    1869             psFree(md);
    1870             exit(EXIT_FAILURE);
    1871         }
    1872         if (strncmp(psMetadataLookupPtr(&status, md, "b1_uri"), "a string", MAX_STRING_LENGTH)) {
    1873             psFree(md);
    1874             exit(EXIT_FAILURE);
    1875         }
    1876         if (strncmp(psMetadataLookupPtr(&status, md, "b2_uri"), "a string", MAX_STRING_LENGTH)) {
    1877             psFree(md);
    1878             exit(EXIT_FAILURE);
    1879         }
    1880 
    1881         psFree(md);
    1882     }
    1883 
    1884     {
    1885         psMetadata      *md;
    1886         p4MagicMaskImfileRow *object;
    1887         bool            status;
    1888 
    1889         object = p4MagicMaskImfileRowAlloc(-32, "a string", -32, "a string", "a string");
    1890         if (!object) {
    1891             exit(EXIT_FAILURE);
    1892         }
    1893 
    1894         md = p4MagicMaskImfileMetadataFromObject(object);
    1895         if (!md) {
    1896             exit(EXIT_FAILURE);
    1897         }
    1898 
    1899         psFree(object);
    1900 
    1901         if (!psMetadataLookupS32(&status, md, "p4_id") == -32) {
    1902             psFree(md);
    1903             exit(EXIT_FAILURE);
    1904         }
    1905         if (strncmp(psMetadataLookupPtr(&status, md, "exp_tag"), "a string", MAX_STRING_LENGTH)) {
    1906             psFree(md);
    1907             exit(EXIT_FAILURE);
    1908         }
    1909         if (!psMetadataLookupS32(&status, md, "p3_version") == -32) {
    1910             psFree(md);
    1911             exit(EXIT_FAILURE);
    1912         }
    1913         if (strncmp(psMetadataLookupPtr(&status, md, "class_id"), "a string", MAX_STRING_LENGTH)) {
    1914             psFree(md);
    1915             exit(EXIT_FAILURE);
    1916         }
    1917         if (strncmp(psMetadataLookupPtr(&status, md, "uri"), "a string", MAX_STRING_LENGTH)) {
    19182103            psFree(md);
    19192104            exit(EXIT_FAILURE);

  • trunk/ippdb/tests/objectfrommetadata.c

    r11193 r11679  
    25322532    {
    25332533        psMetadata      *md;
    2534         p4RunRow        *object;
    2535 
    2536         md = psMetadataAlloc();
    2537         if (!psMetadataAddS32(md, PS_LIST_TAIL, "p4_id", 0, NULL, -32)) {
    2538             psFree(md);
    2539             exit(EXIT_FAILURE);
    2540         }
    2541         if (!psMetadataAddStr(md, PS_LIST_TAIL, "survey_mode", 0, NULL, "a string")) {
     2534        p4aRunRow       *object;
     2535
     2536        md = psMetadataAlloc();
     2537        if (!psMetadataAddS32(md, PS_LIST_TAIL, "p4a_id", 0, NULL, -32)) {
    25422538            psFree(md);
    25432539            exit(EXIT_FAILURE);
    … …  
    25512547            exit(EXIT_FAILURE);
    25522548        }
    2553         if (!psMetadataAddStr(md, PS_LIST_TAIL, "filter", 0, NULL, "a string")) {
     2549        if (!psMetadataAdd(md, PS_LIST_TAIL, "magic", PS_DATA_BOOL, NULL, true)) {
     2550            psFree(md);
     2551            exit(EXIT_FAILURE);
     2552        }
     2553
     2554        object = p4aRunObjectFromMetadata(md);
     2555        if (!object) {
     2556            psFree(md);
     2557            exit(EXIT_FAILURE);
     2558        }
     2559
     2560        psFree(md);
     2561
     2562        if (!object->p4a_id == -32) {
     2563            psFree(object);
     2564            exit(EXIT_FAILURE);
     2565        }
     2566        if (strncmp(object->state, "a string", MAX_STRING_LENGTH)) {
     2567            psFree(object);
     2568            exit(EXIT_FAILURE);
     2569        }
     2570        if (strncmp(object->workdir, "a string", MAX_STRING_LENGTH)) {
     2571            psFree(object);
     2572            exit(EXIT_FAILURE);
     2573        }
     2574        if (!object->magic == true) {
     2575            psFree(object);
     2576            exit(EXIT_FAILURE);
     2577        }
     2578
     2579        psFree(object);
     2580    }
     2581
     2582    {
     2583        psMetadata      *md;
     2584        p4aInputExpRow  *object;
     2585
     2586        md = psMetadataAlloc();
     2587        if (!psMetadataAddS32(md, PS_LIST_TAIL, "p4a_id", 0, NULL, -32)) {
     2588            psFree(md);
     2589            exit(EXIT_FAILURE);
     2590        }
     2591        if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_tag", 0, NULL, "a string")) {
     2592            psFree(md);
     2593            exit(EXIT_FAILURE);
     2594        }
     2595        if (!psMetadataAddS32(md, PS_LIST_TAIL, "p3_version", 0, NULL, -32)) {
     2596            psFree(md);
     2597            exit(EXIT_FAILURE);
     2598        }
     2599
     2600        object = p4aInputExpObjectFromMetadata(md);
     2601        if (!object) {
     2602            psFree(md);
     2603            exit(EXIT_FAILURE);
     2604        }
     2605
     2606        psFree(md);
     2607
     2608        if (!object->p4a_id == -32) {
     2609            psFree(object);
     2610            exit(EXIT_FAILURE);
     2611        }
     2612        if (strncmp(object->exp_tag, "a string", MAX_STRING_LENGTH)) {
     2613            psFree(object);
     2614            exit(EXIT_FAILURE);
     2615        }
     2616        if (!object->p3_version == -32) {
     2617            psFree(object);
     2618            exit(EXIT_FAILURE);
     2619        }
     2620
     2621        psFree(object);
     2622    }
     2623
     2624    {
     2625        psMetadata      *md;
     2626        p4aScfileRow    *object;
     2627
     2628        md = psMetadataAlloc();
     2629        if (!psMetadataAddS32(md, PS_LIST_TAIL, "p4a_id", 0, NULL, -32)) {
    25542630            psFree(md);
    25552631            exit(EXIT_FAILURE);
    … …  
    25632639            exit(EXIT_FAILURE);
    25642640        }
    2565         if (!psMetadataAddF64(md, PS_LIST_TAIL, "ra", 0, NULL, 64.64)) {
    2566             psFree(md);
    2567             exit(EXIT_FAILURE);
    2568         }
    2569         if (!psMetadataAddF64(md, PS_LIST_TAIL, "decl", 0, NULL, 64.64)) {
    2570             psFree(md);
    2571             exit(EXIT_FAILURE);
    2572         }
    2573         if (!psMetadataAddStr(md, PS_LIST_TAIL, "input_ss", 0, NULL, "a string")) {
    2574             psFree(md);
    2575             exit(EXIT_FAILURE);
    2576         }
    2577         if (!psMetadataAddStr(md, PS_LIST_TAIL, "output_ss", 0, NULL, "a string")) {
    2578             psFree(md);
    2579             exit(EXIT_FAILURE);
    2580         }
    2581 
    2582         object = p4RunObjectFromMetadata(md);
    2583         if (!object) {
    2584             psFree(md);
    2585             exit(EXIT_FAILURE);
    2586         }
    2587 
    2588         psFree(md);
    2589 
    2590         if (!object->p4_id == -32) {
    2591             psFree(object);
    2592             exit(EXIT_FAILURE);
    2593         }
    2594         if (strncmp(object->survey_mode, "a string", MAX_STRING_LENGTH)) {
     2641        if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_tag", 0, NULL, "a string")) {
     2642            psFree(md);
     2643            exit(EXIT_FAILURE);
     2644        }
     2645        if (!psMetadataAddS32(md, PS_LIST_TAIL, "p3_version", 0, NULL, -32)) {
     2646            psFree(md);
     2647            exit(EXIT_FAILURE);
     2648        }
     2649        if (!psMetadataAddStr(md, PS_LIST_TAIL, "uri", 0, NULL, "a string")) {
     2650            psFree(md);
     2651            exit(EXIT_FAILURE);
     2652        }
     2653        if (!psMetadataAddF64(md, PS_LIST_TAIL, "bg", 0, NULL, 64.64)) {
     2654            psFree(md);
     2655            exit(EXIT_FAILURE);
     2656        }
     2657        if (!psMetadataAddF64(md, PS_LIST_TAIL, "bg_mean_stdev", 0, NULL, 64.64)) {
     2658            psFree(md);
     2659            exit(EXIT_FAILURE);
     2660        }
     2661
     2662        object = p4aScfileObjectFromMetadata(md);
     2663        if (!object) {
     2664            psFree(md);
     2665            exit(EXIT_FAILURE);
     2666        }
     2667
     2668        psFree(md);
     2669
     2670        if (!object->p4a_id == -32) {
     2671            psFree(object);
     2672            exit(EXIT_FAILURE);
     2673        }
     2674        if (strncmp(object->skycell_id, "a string", MAX_STRING_LENGTH)) {
     2675            psFree(object);
     2676            exit(EXIT_FAILURE);
     2677        }
     2678        if (strncmp(object->tess_id, "a string", MAX_STRING_LENGTH)) {
     2679            psFree(object);
     2680            exit(EXIT_FAILURE);
     2681        }
     2682        if (strncmp(object->exp_tag, "a string", MAX_STRING_LENGTH)) {
     2683            psFree(object);
     2684            exit(EXIT_FAILURE);
     2685        }
     2686        if (!object->p3_version == -32) {
     2687            psFree(object);
     2688            exit(EXIT_FAILURE);
     2689        }
     2690        if (strncmp(object->uri, "a string", MAX_STRING_LENGTH)) {
     2691            psFree(object);
     2692            exit(EXIT_FAILURE);
     2693        }
     2694        if (!object->bg == 64.64) {
     2695            psFree(object);
     2696            exit(EXIT_FAILURE);
     2697        }
     2698        if (!object->bg_mean_stdev == 64.64) {
     2699            psFree(object);
     2700            exit(EXIT_FAILURE);
     2701        }
     2702
     2703        psFree(object);
     2704    }
     2705
     2706    {
     2707        psMetadata      *md;
     2708        p4bRunRow       *object;
     2709
     2710        md = psMetadataAlloc();
     2711        if (!psMetadataAddS32(md, PS_LIST_TAIL, "p4b_id", 0, NULL, -32)) {
     2712            psFree(md);
     2713            exit(EXIT_FAILURE);
     2714        }
     2715        if (!psMetadataAddStr(md, PS_LIST_TAIL, "state", 0, NULL, "a string")) {
     2716            psFree(md);
     2717            exit(EXIT_FAILURE);
     2718        }
     2719        if (!psMetadataAddStr(md, PS_LIST_TAIL, "workdir", 0, NULL, "a string")) {
     2720            psFree(md);
     2721            exit(EXIT_FAILURE);
     2722        }
     2723        if (!psMetadataAdd(md, PS_LIST_TAIL, "magic", PS_DATA_BOOL, NULL, true)) {
     2724            psFree(md);
     2725            exit(EXIT_FAILURE);
     2726        }
     2727
     2728        object = p4bRunObjectFromMetadata(md);
     2729        if (!object) {
     2730            psFree(md);
     2731            exit(EXIT_FAILURE);
     2732        }
     2733
     2734        psFree(md);
     2735
     2736        if (!object->p4b_id == -32) {
    25952737            psFree(object);
    25962738            exit(EXIT_FAILURE);
    … …  
    26042746            exit(EXIT_FAILURE);
    26052747        }
    2606         if (strncmp(object->filter, "a string", MAX_STRING_LENGTH)) {
     2748        if (!object->magic == true) {
     2749            psFree(object);
     2750            exit(EXIT_FAILURE);
     2751        }
     2752
     2753        psFree(object);
     2754    }
     2755
     2756    {
     2757        psMetadata      *md;
     2758        p4bInputScfileRow *object;
     2759
     2760        md = psMetadataAlloc();
     2761        if (!psMetadataAddS32(md, PS_LIST_TAIL, "p4b_id", 0, NULL, -32)) {
     2762            psFree(md);
     2763            exit(EXIT_FAILURE);
     2764        }
     2765        if (!psMetadataAddStr(md, PS_LIST_TAIL, "skycell_id", 0, NULL, "a string")) {
     2766            psFree(md);
     2767            exit(EXIT_FAILURE);
     2768        }
     2769        if (!psMetadataAddStr(md, PS_LIST_TAIL, "tess_id", 0, NULL, "a string")) {
     2770            psFree(md);
     2771            exit(EXIT_FAILURE);
     2772        }
     2773        if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_tag", 0, NULL, "a string")) {
     2774            psFree(md);
     2775            exit(EXIT_FAILURE);
     2776        }
     2777        if (!psMetadataAddS32(md, PS_LIST_TAIL, "p3_version", 0, NULL, -32)) {
     2778            psFree(md);
     2779            exit(EXIT_FAILURE);
     2780        }
     2781        if (!psMetadataAddStr(md, PS_LIST_TAIL, "kind", 0, NULL, "a string")) {
     2782            psFree(md);
     2783            exit(EXIT_FAILURE);
     2784        }
     2785
     2786        object = p4bInputScfileObjectFromMetadata(md);
     2787        if (!object) {
     2788            psFree(md);
     2789            exit(EXIT_FAILURE);
     2790        }
     2791
     2792        psFree(md);
     2793
     2794        if (!object->p4b_id == -32) {
    26072795            psFree(object);
    26082796            exit(EXIT_FAILURE);
    … …  
    26162804            exit(EXIT_FAILURE);
    26172805        }
    2618         if (!object->ra == 64.64) {
    2619             psFree(object);
    2620             exit(EXIT_FAILURE);
    2621         }
    2622         if (!object->decl == 64.64) {
    2623             psFree(object);
    2624             exit(EXIT_FAILURE);
    2625         }
    2626         if (strncmp(object->input_ss, "a string", MAX_STRING_LENGTH)) {
    2627             psFree(object);
    2628             exit(EXIT_FAILURE);
    2629         }
    2630         if (strncmp(object->output_ss, "a string", MAX_STRING_LENGTH)) {
    2631             psFree(object);
    2632             exit(EXIT_FAILURE);
    2633         }
    2634 
    2635         psFree(object);
    2636     }
    2637 
    2638     {
    2639         psMetadata      *md;
    2640         p4InputImfileRow *object;
    2641 
    2642         md = psMetadataAlloc();
    2643         if (!psMetadataAddS32(md, PS_LIST_TAIL, "p4_id", 0, NULL, -32)) {
     2806        if (strncmp(object->exp_tag, "a string", MAX_STRING_LENGTH)) {
     2807            psFree(object);
     2808            exit(EXIT_FAILURE);
     2809        }
     2810        if (!object->p3_version == -32) {
     2811            psFree(object);
     2812            exit(EXIT_FAILURE);
     2813        }
     2814        if (strncmp(object->kind, "a string", MAX_STRING_LENGTH)) {
     2815            psFree(object);
     2816            exit(EXIT_FAILURE);
     2817        }
     2818
     2819        psFree(object);
     2820    }
     2821
     2822    {
     2823        psMetadata      *md;
     2824        p4bDiffScfileRow *object;
     2825
     2826        md = psMetadataAlloc();
     2827        if (!psMetadataAddS32(md, PS_LIST_TAIL, "p4b_id", 0, NULL, -32)) {
     2828            psFree(md);
     2829            exit(EXIT_FAILURE);
     2830        }
     2831        if (!psMetadataAddStr(md, PS_LIST_TAIL, "skycell_id", 0, NULL, "a string")) {
     2832            psFree(md);
     2833            exit(EXIT_FAILURE);
     2834        }
     2835        if (!psMetadataAddStr(md, PS_LIST_TAIL, "tess_id", 0, NULL, "a string")) {
    26442836            psFree(md);
    26452837            exit(EXIT_FAILURE);
    … …  
    26532845            exit(EXIT_FAILURE);
    26542846        }
     2847        if (!psMetadataAddStr(md, PS_LIST_TAIL, "uri", 0, NULL, "a string")) {
     2848            psFree(md);
     2849            exit(EXIT_FAILURE);
     2850        }
     2851        if (!psMetadataAddF64(md, PS_LIST_TAIL, "bg", 0, NULL, 64.64)) {
     2852            psFree(md);
     2853            exit(EXIT_FAILURE);
     2854        }
     2855        if (!psMetadataAddF64(md, PS_LIST_TAIL, "bg_mean_stdev", 0, NULL, 64.64)) {
     2856            psFree(md);
     2857            exit(EXIT_FAILURE);
     2858        }
     2859
     2860        object = p4bDiffScfileObjectFromMetadata(md);
     2861        if (!object) {
     2862            psFree(md);
     2863            exit(EXIT_FAILURE);
     2864        }
     2865
     2866        psFree(md);
     2867
     2868        if (!object->p4b_id == -32) {
     2869            psFree(object);
     2870            exit(EXIT_FAILURE);
     2871        }
     2872        if (strncmp(object->skycell_id, "a string", MAX_STRING_LENGTH)) {
     2873            psFree(object);
     2874            exit(EXIT_FAILURE);
     2875        }
     2876        if (strncmp(object->tess_id, "a string", MAX_STRING_LENGTH)) {
     2877            psFree(object);
     2878            exit(EXIT_FAILURE);
     2879        }
     2880        if (strncmp(object->exp_tag, "a string", MAX_STRING_LENGTH)) {
     2881            psFree(object);
     2882            exit(EXIT_FAILURE);
     2883        }
     2884        if (!object->p3_version == -32) {
     2885            psFree(object);
     2886            exit(EXIT_FAILURE);
     2887        }
     2888        if (strncmp(object->uri, "a string", MAX_STRING_LENGTH)) {
     2889            psFree(object);
     2890            exit(EXIT_FAILURE);
     2891        }
     2892        if (!object->bg == 64.64) {
     2893            psFree(object);
     2894            exit(EXIT_FAILURE);
     2895        }
     2896        if (!object->bg_mean_stdev == 64.64) {
     2897            psFree(object);
     2898            exit(EXIT_FAILURE);
     2899        }
     2900
     2901        psFree(object);
     2902    }
     2903
     2904    {
     2905        psMetadata      *md;
     2906        p4cRunRow       *object;
     2907
     2908        md = psMetadataAlloc();
     2909        if (!psMetadataAddS32(md, PS_LIST_TAIL, "p4c_id", 0, NULL, -32)) {
     2910            psFree(md);
     2911            exit(EXIT_FAILURE);
     2912        }
     2913        if (!psMetadataAddStr(md, PS_LIST_TAIL, "state", 0, NULL, "a string")) {
     2914            psFree(md);
     2915            exit(EXIT_FAILURE);
     2916        }
     2917        if (!psMetadataAddStr(md, PS_LIST_TAIL, "workdir", 0, NULL, "a string")) {
     2918            psFree(md);
     2919            exit(EXIT_FAILURE);
     2920        }
     2921        if (!psMetadataAdd(md, PS_LIST_TAIL, "magic", PS_DATA_BOOL, NULL, true)) {
     2922            psFree(md);
     2923            exit(EXIT_FAILURE);
     2924        }
     2925
     2926        object = p4cRunObjectFromMetadata(md);
     2927        if (!object) {
     2928            psFree(md);
     2929            exit(EXIT_FAILURE);
     2930        }
     2931
     2932        psFree(md);
     2933
     2934        if (!object->p4c_id == -32) {
     2935            psFree(object);
     2936            exit(EXIT_FAILURE);
     2937        }
     2938        if (strncmp(object->state, "a string", MAX_STRING_LENGTH)) {
     2939            psFree(object);
     2940            exit(EXIT_FAILURE);
     2941        }
     2942        if (strncmp(object->workdir, "a string", MAX_STRING_LENGTH)) {
     2943            psFree(object);
     2944            exit(EXIT_FAILURE);
     2945        }
     2946        if (!object->magic == true) {
     2947            psFree(object);
     2948            exit(EXIT_FAILURE);
     2949        }
     2950
     2951        psFree(object);
     2952    }
     2953
     2954    {
     2955        psMetadata      *md;
     2956        p4cInputExpRow  *object;
     2957
     2958        md = psMetadataAlloc();
     2959        if (!psMetadataAddS32(md, PS_LIST_TAIL, "p4c_id", 0, NULL, -32)) {
     2960            psFree(md);
     2961            exit(EXIT_FAILURE);
     2962        }
     2963        if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_tag", 0, NULL, "a string")) {
     2964            psFree(md);
     2965            exit(EXIT_FAILURE);
     2966        }
     2967        if (!psMetadataAddS32(md, PS_LIST_TAIL, "p3_version", 0, NULL, -32)) {
     2968            psFree(md);
     2969            exit(EXIT_FAILURE);
     2970        }
     2971
     2972        object = p4cInputExpObjectFromMetadata(md);
     2973        if (!object) {
     2974            psFree(md);
     2975            exit(EXIT_FAILURE);
     2976        }
     2977
     2978        psFree(md);
     2979
     2980        if (!object->p4c_id == -32) {
     2981            psFree(object);
     2982            exit(EXIT_FAILURE);
     2983        }
     2984        if (strncmp(object->exp_tag, "a string", MAX_STRING_LENGTH)) {
     2985            psFree(object);
     2986            exit(EXIT_FAILURE);
     2987        }
     2988        if (!object->p3_version == -32) {
     2989            psFree(object);
     2990            exit(EXIT_FAILURE);
     2991        }
     2992
     2993        psFree(object);
     2994    }
     2995
     2996    {
     2997        psMetadata      *md;
     2998        p4MagicMaskImfileRow *object;
     2999
     3000        md = psMetadataAlloc();
     3001        if (!psMetadataAddS32(md, PS_LIST_TAIL, "p4c_id", 0, NULL, -32)) {
     3002            psFree(md);
     3003            exit(EXIT_FAILURE);
     3004        }
     3005        if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_tag", 0, NULL, "a string")) {
     3006            psFree(md);
     3007            exit(EXIT_FAILURE);
     3008        }
     3009        if (!psMetadataAddS32(md, PS_LIST_TAIL, "p3_version", 0, NULL, -32)) {
     3010            psFree(md);
     3011            exit(EXIT_FAILURE);
     3012        }
    26553013        if (!psMetadataAddStr(md, PS_LIST_TAIL, "class_id", 0, NULL, "a string")) {
    26563014            psFree(md);
    26573015            exit(EXIT_FAILURE);
    26583016        }
    2659 
    2660         object = p4InputImfileObjectFromMetadata(md);
    2661         if (!object) {
    2662             psFree(md);
    2663             exit(EXIT_FAILURE);
    2664         }
    2665 
    2666         psFree(md);
    2667 
    2668         if (!object->p4_id == -32) {
     3017        if (!psMetadataAddStr(md, PS_LIST_TAIL, "uri", 0, NULL, "a string")) {
     3018            psFree(md);
     3019            exit(EXIT_FAILURE);
     3020        }
     3021
     3022        object = p4MagicMaskImfileObjectFromMetadata(md);
     3023        if (!object) {
     3024            psFree(md);
     3025            exit(EXIT_FAILURE);
     3026        }
     3027
     3028        psFree(md);
     3029
     3030        if (!object->p4c_id == -32) {
    26693031            psFree(object);
    26703032            exit(EXIT_FAILURE);
    … …  
    26823044            exit(EXIT_FAILURE);
    26833045        }
    2684 
    2685         psFree(object);
    2686     }
    2687 
    2688     {
    2689         psMetadata      *md;
    2690         p4WarpedImfileRow *object;
    2691 
    2692         md = psMetadataAlloc();
    2693         if (!psMetadataAddS32(md, PS_LIST_TAIL, "p4_id", 0, NULL, -32)) {
     3046        if (strncmp(object->uri, "a string", MAX_STRING_LENGTH)) {
     3047            psFree(object);
     3048            exit(EXIT_FAILURE);
     3049        }
     3050
     3051        psFree(object);
     3052    }
     3053
     3054    {
     3055        psMetadata      *md;
     3056        skyCellRow      *object;
     3057
     3058        md = psMetadataAlloc();
     3059        if (!psMetadataAddStr(md, PS_LIST_TAIL, "skycell_id", 0, NULL, "a string")) {
     3060            psFree(md);
     3061            exit(EXIT_FAILURE);
     3062        }
     3063        if (!psMetadataAddStr(md, PS_LIST_TAIL, "tess_id", 0, NULL, "a string")) {
     3064            psFree(md);
     3065            exit(EXIT_FAILURE);
     3066        }
     3067        if (!psMetadataAddF64(md, PS_LIST_TAIL, "ra1", 0, NULL, 64.64)) {
     3068            psFree(md);
     3069            exit(EXIT_FAILURE);
     3070        }
     3071        if (!psMetadataAddF64(md, PS_LIST_TAIL, "decl1", 0, NULL, 64.64)) {
     3072            psFree(md);
     3073            exit(EXIT_FAILURE);
     3074        }
     3075        if (!psMetadataAddF64(md, PS_LIST_TAIL, "ra2", 0, NULL, 64.64)) {
     3076            psFree(md);
     3077            exit(EXIT_FAILURE);
     3078        }
     3079        if (!psMetadataAddF64(md, PS_LIST_TAIL, "decl2", 0, NULL, 64.64)) {
     3080            psFree(md);
     3081            exit(EXIT_FAILURE);
     3082        }
     3083        if (!psMetadataAddF64(md, PS_LIST_TAIL, "ra3", 0, NULL, 64.64)) {
     3084            psFree(md);
     3085            exit(EXIT_FAILURE);
     3086        }
     3087        if (!psMetadataAddF64(md, PS_LIST_TAIL, "decl3", 0, NULL, 64.64)) {
     3088            psFree(md);
     3089            exit(EXIT_FAILURE);
     3090        }
     3091        if (!psMetadataAddF64(md, PS_LIST_TAIL, "ra4", 0, NULL, 64.64)) {
     3092            psFree(md);
     3093            exit(EXIT_FAILURE);
     3094        }
     3095        if (!psMetadataAddF64(md, PS_LIST_TAIL, "decl4", 0, NULL, 64.64)) {
     3096            psFree(md);
     3097            exit(EXIT_FAILURE);
     3098        }
     3099
     3100        object = skyCellObjectFromMetadata(md);
     3101        if (!object) {
     3102            psFree(md);
     3103            exit(EXIT_FAILURE);
     3104        }
     3105
     3106        psFree(md);
     3107
     3108        if (strncmp(object->skycell_id, "a string", MAX_STRING_LENGTH)) {
     3109            psFree(object);
     3110            exit(EXIT_FAILURE);
     3111        }
     3112        if (strncmp(object->tess_id, "a string", MAX_STRING_LENGTH)) {
     3113            psFree(object);
     3114            exit(EXIT_FAILURE);
     3115        }
     3116        if (!object->ra1 == 64.64) {
     3117            psFree(object);
     3118            exit(EXIT_FAILURE);
     3119        }
     3120        if (!object->decl1 == 64.64) {
     3121            psFree(object);
     3122            exit(EXIT_FAILURE);
     3123        }
     3124        if (!object->ra2 == 64.64) {
     3125            psFree(object);
     3126            exit(EXIT_FAILURE);
     3127        }
     3128        if (!object->decl2 == 64.64) {
     3129            psFree(object);
     3130            exit(EXIT_FAILURE);
     3131        }
     3132        if (!object->ra3 == 64.64) {
     3133            psFree(object);
     3134            exit(EXIT_FAILURE);
     3135        }
     3136        if (!object->decl3 == 64.64) {
     3137            psFree(object);
     3138            exit(EXIT_FAILURE);
     3139        }
     3140        if (!object->ra4 == 64.64) {
     3141            psFree(object);
     3142            exit(EXIT_FAILURE);
     3143        }
     3144        if (!object->decl4 == 64.64) {
     3145            psFree(object);
     3146            exit(EXIT_FAILURE);
     3147        }
     3148
     3149        psFree(object);
     3150    }
     3151
     3152    {
     3153        psMetadata      *md;
     3154        skyCellMapRow   *object;
     3155
     3156        md = psMetadataAlloc();
     3157        if (!psMetadataAddStr(md, PS_LIST_TAIL, "skycell_id", 0, NULL, "a string")) {
     3158            psFree(md);
     3159            exit(EXIT_FAILURE);
     3160        }
     3161        if (!psMetadataAddStr(md, PS_LIST_TAIL, "tess_id", 0, NULL, "a string")) {
    26943162            psFree(md);
    26953163            exit(EXIT_FAILURE);
    … …  
    26993167            exit(EXIT_FAILURE);
    27003168        }
    2701         if (!psMetadataAddS32(md, PS_LIST_TAIL, "p3_version", 0, NULL, -32)) {
    2702             psFree(md);
    2703             exit(EXIT_FAILURE);
    2704         }
    27053169        if (!psMetadataAddStr(md, PS_LIST_TAIL, "class_id", 0, NULL, "a string")) {
    27063170            psFree(md);
    27073171            exit(EXIT_FAILURE);
    27083172        }
    2709         if (!psMetadataAddStr(md, PS_LIST_TAIL, "uri", 0, NULL, "a string")) {
    2710             psFree(md);
    2711             exit(EXIT_FAILURE);
    2712         }
    2713         if (!psMetadataAddStr(md, PS_LIST_TAIL, "b1_uri", 0, NULL, "a string")) {
    2714             psFree(md);
    2715             exit(EXIT_FAILURE);
    2716         }
    2717         if (!psMetadataAddStr(md, PS_LIST_TAIL, "b2_uri", 0, NULL, "a string")) {
    2718             psFree(md);
    2719             exit(EXIT_FAILURE);
    2720         }
    2721 
    2722         object = p4WarpedImfileObjectFromMetadata(md);
    2723         if (!object) {
    2724             psFree(md);
    2725             exit(EXIT_FAILURE);
    2726         }
    2727 
    2728         psFree(md);
    2729 
    2730         if (!object->p4_id == -32) {
     3173
     3174        object = skyCellMapObjectFromMetadata(md);
     3175        if (!object) {
     3176            psFree(md);
     3177            exit(EXIT_FAILURE);
     3178        }
     3179
     3180        psFree(md);
     3181
     3182        if (strncmp(object->skycell_id, "a string", MAX_STRING_LENGTH)) {
     3183            psFree(object);
     3184            exit(EXIT_FAILURE);
     3185        }
     3186        if (strncmp(object->tess_id, "a string", MAX_STRING_LENGTH)) {
    27313187            psFree(object);
    27323188            exit(EXIT_FAILURE);
    … …  
    27363192            exit(EXIT_FAILURE);
    27373193        }
    2738         if (!object->p3_version == -32) {
    2739             psFree(object);
    2740             exit(EXIT_FAILURE);
    2741         }
    27423194        if (strncmp(object->class_id, "a string", MAX_STRING_LENGTH)) {
    2743             psFree(object);
    2744             exit(EXIT_FAILURE);
    2745         }
    2746         if (strncmp(object->uri, "a string", MAX_STRING_LENGTH)) {
    2747             psFree(object);
    2748             exit(EXIT_FAILURE);
    2749         }
    2750         if (strncmp(object->b1_uri, "a string", MAX_STRING_LENGTH)) {
    2751             psFree(object);
    2752             exit(EXIT_FAILURE);
    2753         }
    2754         if (strncmp(object->b2_uri, "a string", MAX_STRING_LENGTH)) {
    2755             psFree(object);
    2756             exit(EXIT_FAILURE);
    2757         }
    2758 
    2759         psFree(object);
    2760     }
    2761 
    2762     {
    2763         psMetadata      *md;
    2764         p4StackedImfileRow *object;
    2765 
    2766         md = psMetadataAlloc();
    2767         if (!psMetadataAddS32(md, PS_LIST_TAIL, "p4_id", 0, NULL, -32)) {
    2768             psFree(md);
    2769             exit(EXIT_FAILURE);
    2770         }
    2771         if (!psMetadataAddStr(md, PS_LIST_TAIL, "class_id", 0, NULL, "a string")) {
    2772             psFree(md);
    2773             exit(EXIT_FAILURE);
    2774         }
    2775         if (!psMetadataAddStr(md, PS_LIST_TAIL, "uri", 0, NULL, "a string")) {
    2776             psFree(md);
    2777             exit(EXIT_FAILURE);
    2778         }
    2779         if (!psMetadataAddStr(md, PS_LIST_TAIL, "b1_uri", 0, NULL, "a string")) {
    2780             psFree(md);
    2781             exit(EXIT_FAILURE);
    2782         }
    2783         if (!psMetadataAddStr(md, PS_LIST_TAIL, "b2_uri", 0, NULL, "a string")) {
    2784             psFree(md);
    2785             exit(EXIT_FAILURE);
    2786         }
    2787 
    2788         object = p4StackedImfileObjectFromMetadata(md);
    2789         if (!object) {
    2790             psFree(md);
    2791             exit(EXIT_FAILURE);
    2792         }
    2793 
    2794         psFree(md);
    2795 
    2796         if (!object->p4_id == -32) {
    2797             psFree(object);
    2798             exit(EXIT_FAILURE);
    2799         }
    2800         if (strncmp(object->class_id, "a string", MAX_STRING_LENGTH)) {
    2801             psFree(object);
    2802             exit(EXIT_FAILURE);
    2803         }
    2804         if (strncmp(object->uri, "a string", MAX_STRING_LENGTH)) {
    2805             psFree(object);
    2806             exit(EXIT_FAILURE);
    2807         }
    2808         if (strncmp(object->b1_uri, "a string", MAX_STRING_LENGTH)) {
    2809             psFree(object);
    2810             exit(EXIT_FAILURE);
    2811         }
    2812         if (strncmp(object->b2_uri, "a string", MAX_STRING_LENGTH)) {
    2813             psFree(object);
    2814             exit(EXIT_FAILURE);
    2815         }
    2816 
    2817         psFree(object);
    2818     }
    2819 
    2820     {
    2821         psMetadata      *md;
    2822         p4DiffImfileRow *object;
    2823 
    2824         md = psMetadataAlloc();
    2825         if (!psMetadataAddS32(md, PS_LIST_TAIL, "p4_id", 0, NULL, -32)) {
    2826             psFree(md);
    2827             exit(EXIT_FAILURE);
    2828         }
    2829         if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_tag", 0, NULL, "a string")) {
    2830             psFree(md);
    2831             exit(EXIT_FAILURE);
    2832         }
    2833         if (!psMetadataAddS32(md, PS_LIST_TAIL, "p3_version", 0, NULL, -32)) {
    2834             psFree(md);
    2835             exit(EXIT_FAILURE);
    2836         }
    2837         if (!psMetadataAddStr(md, PS_LIST_TAIL, "class_id", 0, NULL, "a string")) {
    2838             psFree(md);
    2839             exit(EXIT_FAILURE);
    2840         }
    2841         if (!psMetadataAddStr(md, PS_LIST_TAIL, "uri", 0, NULL, "a string")) {
    2842             psFree(md);
    2843             exit(EXIT_FAILURE);
    2844         }
    2845         if (!psMetadataAddStr(md, PS_LIST_TAIL, "b1_uri", 0, NULL, "a string")) {
    2846             psFree(md);
    2847             exit(EXIT_FAILURE);
    2848         }
    2849         if (!psMetadataAddStr(md, PS_LIST_TAIL, "b2_uri", 0, NULL, "a string")) {
    2850             psFree(md);
    2851             exit(EXIT_FAILURE);
    2852         }
    2853 
    2854         object = p4DiffImfileObjectFromMetadata(md);
    2855         if (!object) {
    2856             psFree(md);
    2857             exit(EXIT_FAILURE);
    2858         }
    2859 
    2860         psFree(md);
    2861 
    2862         if (!object->p4_id == -32) {
    2863             psFree(object);
    2864             exit(EXIT_FAILURE);
    2865         }
    2866         if (strncmp(object->exp_tag, "a string", MAX_STRING_LENGTH)) {
    2867             psFree(object);
    2868             exit(EXIT_FAILURE);
    2869         }
    2870         if (!object->p3_version == -32) {
    2871             psFree(object);
    2872             exit(EXIT_FAILURE);
    2873         }
    2874         if (strncmp(object->class_id, "a string", MAX_STRING_LENGTH)) {
    2875             psFree(object);
    2876             exit(EXIT_FAILURE);
    2877         }
    2878         if (strncmp(object->uri, "a string", MAX_STRING_LENGTH)) {
    2879             psFree(object);
    2880             exit(EXIT_FAILURE);
    2881         }
    2882         if (strncmp(object->b1_uri, "a string", MAX_STRING_LENGTH)) {
    2883             psFree(object);
    2884             exit(EXIT_FAILURE);
    2885         }
    2886         if (strncmp(object->b2_uri, "a string", MAX_STRING_LENGTH)) {
    2887             psFree(object);
    2888             exit(EXIT_FAILURE);
    2889         }
    2890 
    2891         psFree(object);
    2892     }
    2893 
    2894     {
    2895         psMetadata      *md;
    2896         p4MagicMaskImfileRow *object;
    2897 
    2898         md = psMetadataAlloc();
    2899         if (!psMetadataAddS32(md, PS_LIST_TAIL, "p4_id", 0, NULL, -32)) {
    2900             psFree(md);
    2901             exit(EXIT_FAILURE);
    2902         }
    2903         if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_tag", 0, NULL, "a string")) {
    2904             psFree(md);
    2905             exit(EXIT_FAILURE);
    2906         }
    2907         if (!psMetadataAddS32(md, PS_LIST_TAIL, "p3_version", 0, NULL, -32)) {
    2908             psFree(md);
    2909             exit(EXIT_FAILURE);
    2910         }
    2911         if (!psMetadataAddStr(md, PS_LIST_TAIL, "class_id", 0, NULL, "a string")) {
    2912             psFree(md);
    2913             exit(EXIT_FAILURE);
    2914         }
    2915         if (!psMetadataAddStr(md, PS_LIST_TAIL, "uri", 0, NULL, "a string")) {
    2916             psFree(md);
    2917             exit(EXIT_FAILURE);
    2918         }
    2919 
    2920         object = p4MagicMaskImfileObjectFromMetadata(md);
    2921         if (!object) {
    2922             psFree(md);
    2923             exit(EXIT_FAILURE);
    2924         }
    2925 
    2926         psFree(md);
    2927 
    2928         if (!object->p4_id == -32) {
    2929             psFree(object);
    2930             exit(EXIT_FAILURE);
    2931         }
    2932         if (strncmp(object->exp_tag, "a string", MAX_STRING_LENGTH)) {
    2933             psFree(object);
    2934             exit(EXIT_FAILURE);
    2935         }
    2936         if (!object->p3_version == -32) {
    2937             psFree(object);
    2938             exit(EXIT_FAILURE);
    2939         }
    2940         if (strncmp(object->class_id, "a string", MAX_STRING_LENGTH)) {
    2941             psFree(object);
    2942             exit(EXIT_FAILURE);
    2943         }
    2944         if (strncmp(object->uri, "a string", MAX_STRING_LENGTH)) {
    29453195            psFree(object);
    29463196            exit(EXIT_FAILURE);

  • trunk/ippdb/tests/selectrowsfits.c

    r11045 r11679  
    703703        }
    704704
    705         if (!p4RunSelectRowsFits(dbh, fits, NULL, 1)) {
    706             exit(EXIT_FAILURE);
    707         }
    708 
    709         psFree(fits);
    710         psDBCleanup(dbh);
    711     }
    712 
    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 (!p4InputImfileSelectRowsFits(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 (!p4WarpedImfileSelectRowsFits(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 (!p4StackedImfileSelectRowsFits(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 (!p4DiffImfileSelectRowsFits(dbh, fits, NULL, 1)) {
     705        if (!p4aRunSelectRowsFits(dbh, fits, NULL, 1)) {
     706            exit(EXIT_FAILURE);
     707        }
     708
     709        psFree(fits);
     710        psDBCleanup(dbh);
     711    }
     712
     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 (!p4aInputExpSelectRowsFits(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 (!p4aScfileSelectRowsFits(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 (!p4bRunSelectRowsFits(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 (!p4bInputScfileSelectRowsFits(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 (!p4bDiffScfileSelectRowsFits(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 (!p4cRunSelectRowsFits(dbh, fits, NULL, 1)) {
     838            exit(EXIT_FAILURE);
     839        }
     840
     841        psFree(fits);
     842        psDBCleanup(dbh);
     843    }
     844
     845    {
     846        psDB            *dbh;
     847        psFits          *fits;
     848
     849        dbh = psDBInit("localhost", "test", NULL, "test");
     850        if (!dbh) {
     851            exit(EXIT_FAILURE);
     852        }
     853
     854        fits = psFitsOpen(TMP_FILENAME, "w");
     855        if (!fits) {
     856            exit(EXIT_FAILURE);
     857        }
     858
     859        if (!p4cInputExpSelectRowsFits(dbh, fits, NULL, 1)) {
    794860            exit(EXIT_FAILURE);
    795861        }
    … …  
    814880
    815881        if (!p4MagicMaskImfileSelectRowsFits(dbh, fits, NULL, 1)) {
     882            exit(EXIT_FAILURE);
     883        }
     884
     885        psFree(fits);
     886        psDBCleanup(dbh);
     887    }
     888
     889    {
     890        psDB            *dbh;
     891        psFits          *fits;
     892
     893        dbh = psDBInit("localhost", "test", NULL, "test");
     894        if (!dbh) {
     895            exit(EXIT_FAILURE);
     896        }
     897
     898        fits = psFitsOpen(TMP_FILENAME, "w");
     899        if (!fits) {
     900            exit(EXIT_FAILURE);
     901        }
     902
     903        if (!skyCellSelectRowsFits(dbh, fits, NULL, 1)) {
     904            exit(EXIT_FAILURE);
     905        }
     906
     907        psFree(fits);
     908        psDBCleanup(dbh);
     909    }
     910
     911    {
     912        psDB            *dbh;
     913        psFits          *fits;
     914
     915        dbh = psDBInit("localhost", "test", NULL, "test");
     916        if (!dbh) {
     917            exit(EXIT_FAILURE);
     918        }
     919
     920        fits = psFitsOpen(TMP_FILENAME, "w");
     921        if (!fits) {
     922            exit(EXIT_FAILURE);
     923        }
     924
     925        if (!skyCellMapSelectRowsFits(dbh, fits, NULL, 1)) {
    816926            exit(EXIT_FAILURE);
    817927        }
Note: See TracChangeset for help on using the changeset viewer.