Changeset 8786
- Timestamp:
- Sep 9, 2006, 10:53:07 PM (20 years ago)
- Location:
- trunk/psLib
- Files:
-
- 7 edited
-
src/types/psMetadata.c (modified) (28 diffs)
-
src/types/psMetadata.h (modified) (2 diffs)
-
test/types/Makefile.am (modified) (2 diffs)
-
test/types/execute_tap (modified) (1 diff)
-
test/types/tap_psListIterator.c (modified) (1 diff)
-
test/types/tap_psMetadata_creating.c (modified) (13 diffs)
-
test/types/tap_psMetadata_polynomials.c (modified) (4 diffs)
Legend:
- Unmodified
- Added
- Removed
-
trunk/psLib/src/types/psMetadata.c
r8694 r8786 12 12 * @author Ross Harman, MHPCC 13 13 * 14 * @version $Revision: 1.13 1$ $Name: not supported by cvs2svn $15 * @date $Date: 2006-0 8-30 00:54:51$14 * @version $Revision: 1.132 $ $Name: not supported by cvs2svn $ 15 * @date $Date: 2006-09-10 08:53:07 $ 16 16 * 17 17 * Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii … … 532 532 // the incoming entry is PS_DATA_METADATA_MULTI 533 533 534 //Shouldn't have a second reference to the same MULTI in a single Metadata! 535 if (item == existingEntry) { 536 psError(PS_ERR_BAD_PARAMETER_VALUE, true, 537 "Cannot have 2 references to the same MULTI in a single Metadata!"); 538 return false; 539 } 540 534 541 // force the hash entry to be PS_DATA_METADATA_MULTI 535 542 existingEntry = makeMetaMulti(mdTable,key,existingEntry); … … 559 566 // add to the hash's list of duplicate entries 560 567 if (! psListAdd(existingEntry->data.list, PS_LIST_TAIL, (psPtr)item) ) { 561 psError(PS_ERR_UNKNOWN,false,_("Failed to add metadata item, %s, to metadata collection list."),key); 568 psError(PS_ERR_UNKNOWN, false, 569 _("Failed to add metadata item, %s, to metadata collection list."), 570 key); 562 571 return false; 563 572 } … … 569 578 570 579 // treat as if new (added to list below) 571 if(!psHashAdd(mdTable, key, (psPtr)item)) { 572 psError(PS_ERR_UNKNOWN,false,_("Failed to add metadata item, %s, to items table."),key); 573 return false; 574 } 580 /* The following is unneeded. HashAdd can't return false with non-null inputs. 581 if(!psHashAdd(mdTable, key, (psPtr)item)) { 582 psError(PS_ERR_UNKNOWN,false, 583 _("Failed to add metadata item, %s, to items table."),key); 584 return false; 585 } 586 */ 587 psHashAdd(mdTable, key, (psPtr)item); 575 588 576 589 // Generate warning that item has been replaced … … 583 596 } 584 597 psError(PS_ERR_BAD_PARAMETER_VALUE, true, 585 _("Duplicate metadata item name is not allowed. Use a psMetadataFlags option to allow such action.")); 598 _("Duplicate metadata item name is not allowed. " 599 "Use a psMetadataFlags option to allow such action.")); 586 600 return false; 587 601 } … … 590 604 591 605 // Node doesn't exist - Add new metadata item to metadata collection's hash 592 if(!psHashAdd(mdTable, key, (psPtr)item)) { 593 psError(PS_ERR_UNKNOWN,false,_("Failed to add metadata item, %s, to items table."),key); 594 return false; 595 } 596 606 /* The following is unneeded. HashAdd can't return false with non-null inputs. 607 608 if(!psHashAdd(mdTable, key, (psPtr)item)) { 609 psError(PS_ERR_UNKNOWN,false, 610 _("Failed to add metadata item, %s, to items table."),key); 611 return false; 612 } 613 */ 614 psHashAdd(mdTable, key, (psPtr)item); 597 615 // Create a multi, if required 598 616 if (flags & PS_META_DUPLICATE_OK) { … … 602 620 603 621 if(!psListAdd(mdList, location, (psPtr)item)) { 604 psError(PS_ERR_UNKNOWN,false,_("Failed to add metadata item, %s, to metadata collection list."),key); 622 psError(PS_ERR_UNKNOWN, false, 623 _("Failed to add metadata item, %s, to metadata collection list."), key); 605 624 return false; 606 625 } … … 1403 1422 psPolynomial2D *psPolynomial2DfromMD (psMetadata *folder) 1404 1423 { 1405 1424 PS_ASSERT_PTR_NON_NULL(folder, NULL); 1406 1425 bool status; 1407 1426 char keyword[80]; … … 1410 1429 // XXX add status failures tests 1411 1430 int nXorder = psMetadataLookupS32 (&status, folder, "NORDER_X"); 1431 if (!status) 1432 return NULL; 1412 1433 int nYorder = psMetadataLookupS32 (&status, folder, "NORDER_Y"); 1434 if (!status) 1435 return NULL; 1413 1436 1414 1437 psPolynomial2D *poly = psPolynomial2DAlloc (PS_POLYNOMIAL_ORD, nXorder, nYorder); … … 1418 1441 sprintf (keyword, "VAL_X%02d_Y%02d", nx, ny); 1419 1442 poly->coeff[nx][ny] = psMetadataLookupF64 (&status, folder, keyword); 1420 if (!status) 1421 poly->mask[nx][ny] = 1; 1422 1443 if (!status) { 1444 //XXX: Setting the mask of a corrupted polynomial doesn't make sense. 1445 //The polynomial is garbage if ANY coeff-element is lost!!! 1446 // poly->mask[nx][ny] = 1; 1447 psError(PS_ERR_BAD_PARAMETER_VALUE, false, 1448 "psPolynomial2D in metadata has lost a coefficient somewhere!" 1449 " >>position= [x,y] = %02d, %02d", nx, ny); 1450 psFree(poly); 1451 return NULL; 1452 } 1423 1453 sprintf (keyword, "ERR_X%02d_Y%02d", nx, ny); 1424 1454 poly->coeffErr[nx][ny] = psMetadataLookupF64 (&status, folder, keyword); … … 1434 1464 ...) 1435 1465 { 1466 PS_ASSERT_PTR_NON_NULL(md, false); 1467 PS_ASSERT_PTR_NON_NULL(poly, false); 1468 //XXX: Current implementation only supports ordinary polynomials. 1469 if (poly->type != PS_POLYNOMIAL_ORD) 1470 return false; 1471 //Make sure polynomial isn't 0, completely empty 1472 if (poly->nX == 0 && poly->nY == 0 && poly->coeff[0][0] == 0) 1473 return false; 1436 1474 1437 1475 int Nbyte; … … 1444 1482 va_end (argp); 1445 1483 1446 if ( !Nbyte)1484 if (Nbyte <= 0) 1447 1485 return false; 1448 1486 … … 1459 1497 psMetadataAdd (folder, PS_LIST_TAIL, "NORDER_Y", PS_DATA_S32, "number of y orders", poly->nY); 1460 1498 1499 char namespace[80]; 1500 char namespace_err[80]; 1461 1501 // place polynomial entries on folder 1462 1502 for (int nx = 0; nx < poly->nX + 1; nx++) { 1463 1503 for (int ny = 0; ny < poly->nY + 1; ny++) { 1464 if (poly->mask[nx][ny]) 1465 continue; 1466 psMetadataAdd (folder, PS_LIST_TAIL, "VAL_X%02d_Y%02d", PS_DATA_F64, 1467 "polynomial coefficient", poly->coeff[nx][ny], nx, ny); 1468 psMetadataAdd (folder, PS_LIST_TAIL, "ERR_X%02d_Y%02d", PS_DATA_F64, 1469 "polynomial coefficient error", poly->coeffErr[nx][ny], nx, ny); 1504 if (poly->mask[nx][ny] == 0) { 1505 sprintf(namespace, "VAL_X%02d_Y%02d", nx, ny); 1506 sprintf(namespace_err, "ERR_X%02d_Y%02d", nx, ny); 1507 psMetadataAdd (folder, PS_LIST_TAIL, namespace, PS_DATA_F64, 1508 "polynomial coefficient", poly->coeff[nx][ny]); 1509 psMetadataAdd (folder, PS_LIST_TAIL, namespace_err, PS_DATA_F64, 1510 "polynomial coefficient error", poly->coeffErr[nx][ny]); 1511 } 1470 1512 } 1471 1513 } … … 1478 1520 psPolynomial3D *psPolynomial3DfromMD (psMetadata *folder) 1479 1521 { 1522 PS_ASSERT_PTR_NON_NULL(folder, NULL); 1480 1523 1481 1524 bool status; … … 1485 1528 // XXX add status failures tests 1486 1529 int nXorder = psMetadataLookupS32 (&status, folder, "NORDER_X"); 1530 if (!status) 1531 return NULL; 1487 1532 int nYorder = psMetadataLookupS32 (&status, folder, "NORDER_Y"); 1533 if (!status) 1534 return NULL; 1488 1535 int nZorder = psMetadataLookupS32 (&status, folder, "NORDER_Z"); 1536 if (!status) 1537 return NULL; 1489 1538 1490 1539 psPolynomial3D *poly = psPolynomial3DAlloc (PS_POLYNOMIAL_ORD, nXorder, nYorder, nZorder); … … 1495 1544 sprintf (keyword, "VAL_X%02d_Y%02d_Z%02d", nx, ny, nz); 1496 1545 poly->coeff[nx][ny][nz] = psMetadataLookupF64 (&status, folder, keyword); 1497 if (!status) 1498 poly->mask[nx][ny][nz] = 1; 1499 1546 if (!status) { 1547 //XXX: Setting the mask of a corrupted polynomial doesn't make sense. 1548 //The polynomial is garbage if ANY coeff-element is lost!!! 1549 // poly->mask[nx][ny][nz] = 1; 1550 psError(PS_ERR_BAD_PARAMETER_VALUE, false, 1551 "psPolynomial3D in metadata has lost a coefficient somewhere!" 1552 " >>position= [x,y,z] = %02d, %02d, %02d", nx, ny, nz); 1553 psFree(poly); 1554 return NULL; 1555 } 1500 1556 sprintf (keyword, "ERR_X%02d_Y%02d_Z%02d", nx, ny, nz); 1501 1557 poly->coeffErr[nx][ny][nz] = psMetadataLookupF64 (&status, folder, keyword); … … 1506 1562 } 1507 1563 1508 bool psPolynomial3DtoMD (psMetadata *md, psPolynomial3D *poly, char *format, ...) 1509 { 1564 bool psPolynomial3DtoMD (psMetadata *md, 1565 psPolynomial3D *poly, 1566 char *format, 1567 ...) 1568 { 1569 PS_ASSERT_PTR_NON_NULL(md, false); 1570 PS_ASSERT_PTR_NON_NULL(poly, false); 1571 //XXX: Current implementation only supports ordinary polynomials. 1572 if (poly->type != PS_POLYNOMIAL_ORD) 1573 return false; 1574 //Make sure polynomial isn't 0, completely empty 1575 if (poly->nX == 0 && poly->nY == 0 && poly->nZ == 0 && poly->coeff[0][0][0] == 0) 1576 return false; 1510 1577 1511 1578 int Nbyte; … … 1518 1585 va_end (argp); 1519 1586 1520 if ( !Nbyte)1587 if (Nbyte <= 0) 1521 1588 return false; 1522 1589 … … 1528 1595 1529 1596 psMetadata *folder = psMetadataAlloc (); 1530 psMetadataAdd (md, PS_LIST_TAIL, root, PS_DATA_METADATA, "folder for 3D polynomial", folder);1531 psFree (root);1532 1597 1533 1598 // specify the polynomial orders … … 1536 1601 psMetadataAdd (folder, PS_LIST_TAIL, "NORDER_Z", PS_DATA_S32, "number of z orders", poly->nZ); 1537 1602 1603 char namespace[80]; 1604 char namespace_err[80]; 1538 1605 // place polynomial entries on folder 1539 1606 for (int nx = 0; nx < poly->nX + 1; nx++) { 1540 1607 for (int ny = 0; ny < poly->nY + 1; ny++) { 1541 1608 for (int nz = 0; nz < poly->nZ + 1; nz++) { 1542 if (poly->mask[nx][ny][nz]) 1543 continue; 1544 psMetadataAdd (folder, PS_LIST_TAIL, "VAL_X%02d_Y%02d_Z%02d", PS_DATA_F64, "polynomial coefficient", poly->coeff[nx][ny][nz], nx, ny, nz); 1545 psMetadataAdd (folder, PS_LIST_TAIL, "ERR_X%02d_Y%02d_Z%02d", PS_DATA_F64, "polynomial coeffficient error", poly->coeffErr[nx][ny][nz], nx, ny, nz); 1546 } 1547 } 1548 } 1609 if (poly->mask[nx][ny][nz] == 0) { 1610 sprintf(namespace, "VAL_X%02d_Y%02d_Z%02d", nx, ny, nz); 1611 sprintf(namespace_err, "ERR_X%02d_Y%02d_Z%02d", nx, ny, nz); 1612 psMetadataAdd (folder, PS_LIST_TAIL, namespace, 1613 PS_DATA_F64, "polynomial coefficient", 1614 poly->coeff[nx][ny][nz], nx, ny, nz); 1615 psMetadataAdd (folder, PS_LIST_TAIL, namespace_err, 1616 PS_DATA_F64, "polynomial coeffficient error", 1617 poly->coeffErr[nx][ny][nz], nx, ny, nz); 1618 } 1619 } 1620 } 1621 } 1622 1623 psMetadataAdd (md, PS_LIST_TAIL, root, PS_DATA_METADATA, "folder for 3D polynomial", folder); 1624 psFree(root); 1625 psFree(folder); 1549 1626 return true; 1550 1627 } … … 1553 1630 psPolynomial4D *psPolynomial4DfromMD (psMetadata *folder) 1554 1631 { 1632 PS_ASSERT_PTR_NON_NULL(folder, NULL); 1555 1633 1556 1634 bool status; … … 1560 1638 // XXX add status failures tests 1561 1639 int nXorder = psMetadataLookupS32 (&status, folder, "NORDER_X"); 1640 if (!status) 1641 return NULL; 1562 1642 int nYorder = psMetadataLookupS32 (&status, folder, "NORDER_Y"); 1643 if (!status) 1644 return NULL; 1563 1645 int nZorder = psMetadataLookupS32 (&status, folder, "NORDER_Z"); 1646 if (!status) 1647 return NULL; 1564 1648 int nTorder = psMetadataLookupS32 (&status, folder, "NORDER_T"); 1565 1566 psPolynomial4D *poly = psPolynomial4DAlloc (PS_POLYNOMIAL_ORD, nXorder, nYorder, nZorder, nTorder); 1649 if (!status) 1650 return NULL; 1651 1652 psPolynomial4D *poly = psPolynomial4DAlloc(PS_POLYNOMIAL_ORD, 1653 nXorder, nYorder, nZorder, nTorder); 1567 1654 1568 1655 for (int nx = 0; nx < poly->nX + 1; nx++) { … … 1572 1659 sprintf (keyword, "VAL_X%02d_Y%02d_Z%02d_T%02d", nx, ny, nz, nt); 1573 1660 poly->coeff[nx][ny][nz][nt] = psMetadataLookupF64 (&status, folder, keyword); 1574 if (!status) 1575 poly->mask[nx][ny][nz][nt] = 1; 1661 if (!status) { 1662 //XXX: Setting the mask of a corrupted polynomial doesn't make sense. 1663 //The polynomial is garbage if ANY coeff-element is lost!!! 1664 // poly->mask[nx][ny][nz][nt] = 1; 1665 psError(PS_ERR_BAD_PARAMETER_VALUE, false, 1666 "psPolynomial4D in metadata has lost a coefficient somewhere!" 1667 " >>position= [x,y,z,t] = %02d, %02d, %02d, %02d", nx,ny,nz,nt); 1668 psFree(poly); 1669 return NULL; 1670 } 1576 1671 1577 1672 sprintf (keyword, "ERR_X%02d_Y%02d_Z%02d_T%02d", nx, ny, nz, nt); … … 1584 1679 } 1585 1680 1586 bool psPolynomial4DtoMD (psMetadata *md, psPolynomial4D *poly, char *format, ...) 1587 { 1681 bool psPolynomial4DtoMD (psMetadata *md, 1682 psPolynomial4D *poly, 1683 char *format, 1684 ...) 1685 { 1686 PS_ASSERT_PTR_NON_NULL(md, false); 1687 PS_ASSERT_PTR_NON_NULL(poly, false); 1688 //XXX: Current implementation only supports ordinary polynomials. 1689 if (poly->type != PS_POLYNOMIAL_ORD) 1690 return false; 1691 //Make sure polynomial isn't 0, completely empty 1692 if (poly->nX == 0 && poly->nY == 0 && poly->nZ == 0 && poly->nT == 0 1693 && poly->coeff[0][0][0][0] == 0) 1694 return false; 1695 1588 1696 1589 1697 int Nbyte; … … 1596 1704 va_end (argp); 1597 1705 1598 if ( !Nbyte)1706 if (Nbyte <= 0) 1599 1707 return false; 1600 1708 … … 1606 1714 1607 1715 psMetadata *folder = psMetadataAlloc (); 1608 psMetadataAdd (md, PS_LIST_TAIL, root, PS_DATA_METADATA, "folder for 4D polynomial", folder);1609 psFree (root);1610 1716 1611 1717 // specify the polynomial orders … … 1613 1719 psMetadataAdd (folder, PS_LIST_TAIL, "NORDER_Y", PS_DATA_S32, "number of y orders", poly->nY); 1614 1720 psMetadataAdd (folder, PS_LIST_TAIL, "NORDER_Z", PS_DATA_S32, "number of z orders", poly->nZ); 1615 psMetadataAdd (folder, PS_LIST_TAIL, "NORDER_T", PS_DATA_S32, "number of z orders", poly->nT); 1616 1721 psMetadataAdd (folder, PS_LIST_TAIL, "NORDER_T", PS_DATA_S32, "number of t orders", poly->nT); 1722 1723 char namespace[80]; 1724 char namespace_err[80]; 1617 1725 // place polynomial entries on folder 1618 1726 for (int nx = 0; nx < poly->nX + 1; nx++) { … … 1620 1728 for (int nz = 0; nz < poly->nZ + 1; nz++) { 1621 1729 for (int nt = 0; nt < poly->nT + 1; nt++) { 1622 if (poly->mask[nx][ny][nz][nt]) 1623 continue; 1624 psMetadataAdd (folder, PS_LIST_TAIL, "VAL_X%02d_Y%02d_Z%02d_T%02d", PS_DATA_F64, "polynomial coefficient", poly->coeff[nx][ny][nz][nt], nx, ny, nz, nt); 1625 psMetadataAdd (folder, PS_LIST_TAIL, "ERR_X%02d_Y%02d_Z%02d_T%02d", PS_DATA_F64, "polynomial coeffficient error", poly->coeffErr[nx][ny][nz][nt], nx, ny, nz, nt); 1730 if (poly->mask[nx][ny][nz][nt] == 0) { 1731 sprintf(namespace, "VAL_X%02d_Y%02d_Z%02d_T%02d", nx, ny, nz, nt); 1732 sprintf(namespace_err, "ERR_X%02d_Y%02d_Z%02d_T%02d", nx, ny, nz, nt); 1733 psMetadataAdd (folder, PS_LIST_TAIL, namespace, 1734 PS_DATA_F64, "polynomial coefficient", 1735 poly->coeff[nx][ny][nz][nt], nx, ny, nz, nt); 1736 psMetadataAdd (folder, PS_LIST_TAIL, namespace_err, 1737 PS_DATA_F64, "polynomial coeffficient error", 1738 poly->coeffErr[nx][ny][nz][nt], nx, ny, nz, nt); 1739 } 1626 1740 } 1627 1741 } 1628 1742 } 1629 1743 } 1744 psMetadataAdd (md, PS_LIST_TAIL, root, PS_DATA_METADATA, "folder for 4D polynomial", folder); 1745 psFree(root); 1746 psFree(folder); 1630 1747 return true; 1631 1748 } -
trunk/psLib/src/types/psMetadata.h
r8625 r8786 11 11 * @author Ross Harman, MHPCC 12 12 * 13 * @version $Revision: 1.8 4$ $Name: not supported by cvs2svn $14 * @date $Date: 2006-0 8-26 03:15:15$13 * @version $Revision: 1.85 $ $Name: not supported by cvs2svn $ 14 * @date $Date: 2006-09-10 08:53:07 $ 15 15 * 16 16 * Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii … … 1066 1066 bool psMetadataPrint( 1067 1067 FILE *fd, ///< File Descriptor or NULL 1068 const psMetadata *md, 1068 const psMetadata *md, ///< Metadata collection to print. 1069 1069 int level ///< the level of metadata items. 1070 1070 ); 1071 1071 1072 1073 psPolynomial2D *psPolynomial2DfromMD (psMetadata *folder); 1074 bool psPolynomial2DtoMD (psMetadata *md, psPolynomial2D *poly, char *format, ...); 1075 1076 psPolynomial3D *psPolynomial3DfromMD (psMetadata *folder); 1077 bool psPolynomial3DtoMD (psMetadata *md, psPolynomial3D *poly, char *format, ...); 1078 1079 psPolynomial4D *psPolynomial4DfromMD (psMetadata *folder); 1080 bool psPolynomial4DtoMD (psMetadata *md, psPolynomial4D *poly, char *format, ...); 1072 /** Allocates a new psPolynomial2D structure with information from a psMetadata. 1073 * 1074 * Parses a psMetadata container with psPolynomial2D information. The first two 1075 * elements of the metadata folder specify the order of the x & y variables. (ie, 1076 * NORDER_X, NORDER_Y). The following elements are the values of the coefficients 1077 * and the coefficient errors. (ie, VAL_X00_Y00, ERR_X00_Y00, etc.). If the orders 1078 * or any coefficients are missing or have incorrect syntax, NULL is returned. 1079 * 1080 * @return psPolynomial2D*: Newly allocated psPolynomial2D from metadata. 1081 */ 1082 psPolynomial2D *psPolynomial2DfromMD( 1083 psMetadata *folder ///< folder containing the polynomial info. 1084 ); 1085 1086 /** Stores the information from a psPolynomial2D structure in a psMetadata container. 1087 * 1088 * Creates a psMetadata folder with psPolynomial2D information. The first two 1089 * elements of the metadata folder specify the order of the x & y variables. (ie, 1090 * NORDER_X, NORDER_Y). The following elements are the values of the coefficients 1091 * and the coefficient errors. (ie, VAL_X00_Y00, ERR_X00_Y00, etc.). The input 1092 * polynomial must be of ordinary type and have a valid name format. False is also 1093 * returned if any inputs are NULL. *If a particular mask element is non-zero, that 1094 * polynomial coefficient (and error) are skipped. 1095 * 1096 * @return bool: True if successful, otherwise false. 1097 */ 1098 bool psPolynomial2DtoMD( 1099 psMetadata *md, ///< Metadata container for polynomial storage. 1100 psPolynomial2D *poly, ///< Polynomial information to be stored. 1101 char *format, ///< Name of polynomial folder. 1102 ... ///< Arguments for name formatting. 1103 ); 1104 1105 /** Allocates a new psPolynomial3D structure with information from a psMetadata. 1106 * 1107 * Parses a psMetadata container with psPolynomial3D information. The first three 1108 * elements of the metadata folder specify the order of the x, y, & z variables. (ie, 1109 * NORDER_X, NORDER_Y, NORDER_Z). The following elements are the values of the 1110 * coefficients and the coefficient errors. (ie, VAL_X00_Y00_Z00, ERR_X00_Y00_Z00, 1111 * etc.). If the orders or any coefficients are missing or have incorrect syntax, 1112 * NULL is returned. 1113 * 1114 * @return psPolynomial3D*: Newly allocated psPolynomial3D from metadata. 1115 */ 1116 psPolynomial3D *psPolynomial3DfromMD( 1117 psMetadata *folder ///< folder containing the polynomial info. 1118 ); 1119 1120 /** Stores the information from a psPolynomial3D structure in a psMetadata container. 1121 * 1122 * Creates a psMetadata folder with psPolynomial3D information. The first three 1123 * elements of the metadata folder specify the order of the x, y, & z variables. (ie, 1124 * NORDER_X, NORDER_Y, NORDER_Z). The following elements are the values of the 1125 * coefficients and the coefficient errors. (ie, VAL_X00_Y00_Z00, ERR_X00_Y00_Z00, 1126 * etc.). The input polynomial must be of ordinary type and have a valid name format. 1127 * False is also returned if any inputs are NULL. *If a particular mask element is 1128 * non-zero, that polynomial coefficient (and error) are skipped. 1129 * 1130 * @return bool: True if successful, otherwise false. 1131 */ 1132 bool psPolynomial3DtoMD( 1133 psMetadata *md, ///< Metadata container for polynomial storage. 1134 psPolynomial3D *poly, ///< Polynomial information to be stored. 1135 char *format, ///< Name of polynomial folder. 1136 ... ///< Arguments for name formatting. 1137 ); 1138 1139 /** Allocates a new psPolynomial4D structure with information from a psMetadata. 1140 * 1141 * Parses a psMetadata container with psPolynomial4D information. The first four 1142 * elements of the metadata folder specify the order of the x, y, z, & t variables. 1143 * (ie, NORDER_X, NORDER_Y, NORDER_Z, NORDER_T). The following elements are the 1144 * values of the coefficients and the coefficient errors. (ie, VAL_X00_Y00_Z00_T00, 1145 * ERR_X00_Y00_Z00_T00, etc.). If the orders or any coefficients are missing or 1146 * have incorrect syntax, NULL is returned. 1147 * 1148 * @return psPolynomial4D*: Newly allocated psPolynomial4D from metadata. 1149 */ 1150 psPolynomial4D *psPolynomial4DfromMD( 1151 psMetadata *folder ///< folder containing the polynomial info. 1152 ); 1153 1154 /** Stores the information from a psPolynomial4D structure in a psMetadata container. 1155 * 1156 * Creates a psMetadata folder with psPolynomial4D information. The first four 1157 * elements of the metadata folder specify the order of the x, y, z, & t variables. 1158 * (ie, NORDER_X, NORDER_Y, NORDER_Z, NORDER_T). The following elements are the values 1159 * of the coefficients and the coefficient errors. (ie, VAL_X00_Y00_Z00_T00, 1160 * ERR_X00_Y00_Z00_T00, etc.). The input polynomial must be of ordinary type and have 1161 * a valid name format. False is also returned if any inputs are NULL. *If a particular 1162 * mask element is non-zero, that polynomial coefficient (and error) are skipped. 1163 * 1164 * @return bool: True if successful, otherwise false. 1165 */ 1166 bool psPolynomial4DtoMD( 1167 psMetadata *md, ///< Metadata container for polynomial storage. 1168 psPolynomial4D *poly, ///< Polynomial information to be stored. 1169 char *format, ///< Name of polynomial folder. 1170 ... ///< Arguments for name formatting. 1171 ); 1081 1172 1082 1173 -
trunk/psLib/test/types/Makefile.am
r8775 r8786 26 26 tap_psArray_all 27 27 28 check_PROGRAMS = $(TESTS)29 30 28 check_DATA = \ 31 29 test.config \ … … 44 42 tableU8.dat \ 45 43 mdcfgwrt.verified 44 45 check_PROGRAMS = $(TESTS) 46 46 47 47 EXTRA_DIST = \ -
trunk/psLib/test/types/execute_tap
r8694 r8786 10 10 ./tap_psMetadata_manip 11 11 ./tap_psMetadata_printing 12 ./tap_psMetadata_polynomials -
trunk/psLib/test/types/tap_psListIterator.c
r8731 r8786 71 71 int main (void) 72 72 { 73 plan_tests( 158);73 plan_tests(66); 74 74 75 75 diag("psListIterator tests"); -
trunk/psLib/test/types/tap_psMetadata_creating.c
r8731 r8786 24 24 int main(void) 25 25 { 26 plan_tests( 35);26 plan_tests(42); 27 27 28 28 diag("psMetadata & psMetadataItem Creation Functions"); … … 37 37 void testItemAllocs(void) 38 38 { 39 diag(" >>>Test 1: psMetadataItemAlloc & FreeFxns");39 diag(" >>>Test 1: psMetadataItemAlloc Fxns"); 40 40 psMetadataItem *itemStr = psMetadataItemAllocStr("itemStr", "", "itemStr"); 41 41 psMetadataItem *itemF32 = psMetadataItemAllocF32("itemF32", "", 6.66); … … 262 262 void testMDAlloc_AddItem(void) 263 263 { 264 diag(" >>>Test 2: psMetadataAlloc , psMemCheckMetadata,& psMetadataAdd Fxns");264 diag(" >>>Test 2: psMetadataAlloc & psMetadataAdd Fxns"); 265 265 psMetadata *md = NULL; 266 //Attempt to free a null metadata267 266 md = psMetadataAlloc(); 268 267 psMetadata *md1 = psMetadataAlloc(); … … 271 270 { 272 271 ok( psMemCheckMetadata(md), 273 "psMemCheckMetadata: return true for valid Metadata.");272 "psMemCheckMetadata: return true for valid Metadata."); 274 273 } 275 274 //Make sure MemCheck worked. Try primitive type. Expect false. … … 277 276 int j = 2; 278 277 ok( !psMemCheckMetadata(&j), 279 "psMemCheckMetadata: return false for non-Metadata input.");278 "psMemCheckMetadata: return false for non-Metadata input."); 280 279 } 281 280 //Return false for attempt to add a psMetadataItem with no name. 282 281 { 283 282 ok( !psMetadataAdd(md1, PS_LIST_HEAD, NULL, PS_DATA_S32, "", 1), 284 "psMetadataAdd: return false for adding item with no name.");283 "psMetadataAdd: return false for adding item with no name."); 285 284 } 286 285 psFree(md1); 287 286 md1 = psMetadataAlloc(); 288 287 289 diag(" >>>Test 3: psMetadataAddItem");290 288 //Return false for NULL metadata input 291 289 psMetadataItem *item = psMetadataItemAllocBool("item", "", true); 292 290 { 293 291 ok( !psMetadataAddItem(NULL, item, PS_LIST_HEAD, PS_META_DEFAULT), 294 "psMetadataAddItem: return false for NULL metadata input.");292 "psMetadataAddItem: return false for NULL metadata input."); 295 293 } 296 294 //Return false for metadata with NULL hash … … 299 297 { 300 298 ok( !psMetadataAddItem(md1, item, PS_LIST_HEAD, PS_META_DEFAULT), 301 "psMetadataAddItem: return false for metadata with no hash.");299 "psMetadataAddItem: return false for metadata with no hash."); 302 300 } 303 301 psFree(md1); … … 307 305 { 308 306 ok( !psMetadataAddItem(md2, item, PS_LIST_HEAD, PS_META_DEFAULT), 309 "psMetadataAddItem: return false for metadata with no list.");307 "psMetadataAddItem: return false for metadata with no list."); 310 308 } 311 309 psFree(md2); … … 313 311 { 314 312 ok( !psMetadataAddItem(md, NULL, PS_LIST_HEAD, PS_META_DEFAULT), 315 "psMetadataAddItem: return false for NULL item input.");313 "psMetadataAddItem: return false for NULL item input."); 316 314 } 317 315 //Return false for psMetadataItem with NULL name … … 320 318 { 321 319 ok( !psMetadataAddItem(md, item, PS_LIST_HEAD, PS_META_DEFAULT), 322 "psMetadataAddItem: return false for item with no name.");320 "psMetadataAddItem: return false for item with no name."); 323 321 } 324 322 psFree(item); 325 323 326 //item type=PS_DATA_METADATA_MULTI327 // psMetadataAddS32(md, PS_LIST_TAIL, "S32", PS_META_DUPLICATE_OK, "", 1);328 324 psMetadata *itemMD = psMetadataAlloc(); 329 325 psMetadataAddS32(itemMD, PS_LIST_HEAD, "s", PS_META_DUPLICATE_OK, "", 2); 330 // psMetadataItem *item2 = psMetadataItemAlloc("multi", PS_DATA_METADATA_MULTI, "", itemMD);331 326 psMetadataItem *item2 = psMetadataItemAllocS32("s", "", 2); 332 327 … … 334 329 { 335 330 ok( psMetadataAddItem(md, item2, PS_LIST_TAIL, PS_META_DUPLICATE_OK), 336 "psMetadataAddItem: return true for addition of PS_DATA_METADATA_MULTI."); 337 } 338 // printf("\n >>Memory leakage coming from above test for METADATA_MULTI\n\n"); 331 "psMetadataAddItem: return true for addition of PS_DATA_METADATA_MULTI."); 332 } 339 333 psFree(item2); 340 334 psFree(itemMD); … … 343 337 psMetadataAddS32(md, PS_LIST_HEAD, "S32", 0, "", 1); 344 338 item2 = psMetadataItemAllocS32("S32", "", 1); 339 //FLAG = PS_META_REPLACE 340 { 341 ok( psMetadataAddItem(md, item2, PS_LIST_TAIL, PS_META_REPLACE), 342 "psMetadataAddItem: return true for PS_META_REPLACE flag."); 343 } 345 344 //FLAG = PS_META_DUPLICATE_OK 346 345 { 347 346 ok( psMetadataAddItem(md, item2, PS_LIST_TAIL, PS_META_DUPLICATE_OK), 348 "psMetadataAddItem: return true for PS_META_DUPLICATE_OK flag."); 349 } 350 //FLAG = PS_META_REPLACE 351 { 352 ok( psMetadataAddItem(md, item2, PS_LIST_TAIL, PS_META_REPLACE), 353 "psMetadataAddItem: return true for PS_META_REPLACE flag."); 354 } 347 "psMetadataAddItem: return true for PS_META_DUPLICATE_OK flag."); 348 } 349 /* SEE BELOW. TEST CASE REDONE b/c item2 in md was already a MULTI 355 350 //FLAG = PS_META_NO_REPLACE 356 351 { 357 352 ok( psMetadataAddItem(md, item2, PS_LIST_TAIL, PS_META_NO_REPLACE), 358 "psMetadataAddItem: return true for PS_META_NO_REPLACE flag."); 359 } 353 "psMetadataAddItem: return true for PS_META_NO_REPLACE flag."); 354 } 355 */ 360 356 //FLAG = PS_META_DEFAULT 361 357 { 362 358 ok( psMetadataAddItem(md, item2, PS_LIST_TAIL, PS_META_DEFAULT), 363 "psMetadataAddItem: return false for PS_META_DEFAULT flag."); 364 } 359 "psMetadataAddItem: return false for PS_META_DEFAULT flag."); 360 } 361 362 //Return false for attempting to add an element twice with flag NO_REPLACE 363 { 364 psMetadata *norep = psMetadataAlloc(); 365 psMetadataAddS32(norep, PS_LIST_HEAD, "S32", 0, "", 1); 366 psMetadataItem *item666 = psMetadataItemAllocS32("S32", "", 1); 367 ok( psMetadataAddItem(norep, item666, PS_LIST_TAIL, PS_META_NO_REPLACE), 368 "psMetadataAddItem: return true for PS_META_NO_REPLACE flag."); 369 psFree(item666); 370 psFree(norep); 371 } 372 //Return false for bad list location 373 { 374 psMetadata *emptymeta = psMetadataAlloc(); 375 psMetadataItem *item666 = psMetadataItemAllocS32("S32", "", 1); 376 ok( !psMetadataAddItem(emptymeta, item666, -100, PS_META_NO_REPLACE), 377 "psMetadataAddItem: return false for invalid list location."); 378 psFree(item666); 379 psFree(emptymeta); 380 } 381 //Return false for trying to add to MULTI with broken list element. 382 { 383 psMetadata *broken_list = psMetadataAlloc(); 384 psMetadataAddS32(broken_list, PS_LIST_HEAD, "S32", 0, "", 1); 385 psMetadataAddS32(broken_list, PS_LIST_TAIL, "S32", PS_META_DUPLICATE_OK, "", 1); 386 psMetadataItem *brokenptr = psMetadataLookup(broken_list, "S32"); 387 if (brokenptr->type != PS_DATA_METADATA_MULTI) 388 printf("\nError, Error\n"); 389 else 390 { 391 psFree(brokenptr->data.list); 392 brokenptr->data.list = NULL; 393 } 394 psMetadataItem *item666 = psMetadataItemAllocS32("S32", "", 1); 395 ok( !psMetadataAddItem(broken_list, item666, PS_LIST_TAIL, PS_META_DUPLICATE_OK), 396 "psMetadataAddItem: return false for MULTI with NULL list."); 397 psFree(item666); 398 psFree(broken_list); 399 } 400 401 //Attempt to add a MULTI 402 psFree(item2); 403 item2 = NULL; 404 psMetadata *xxx = psMetadataAlloc(); 405 psMetadataAddS32(xxx, PS_LIST_TAIL, "new S32", 0, "", 1); 406 item2 = psMetadataItemAllocS32("new S32", "", 1); 407 psMetadataAddItem(xxx, item2, PS_LIST_TAIL, PS_META_DUPLICATE_OK); 408 psFree(item2); 409 item2 = psMetadataLookup(xxx, "new S32"); 410 { 411 ok( psMetadataAddItem(md, item2, PS_LIST_TAIL, PS_META_DUPLICATE_OK), 412 "psMetadataAddItem: return true for new MULTI item"); 413 } 414 //Attempt to add a 2nd reference of a MULTI to the originating metadata container 415 { 416 ok( !psMetadataAddItem(xxx, item2, PS_LIST_TAIL, PS_META_NO_REPLACE), 417 "psMetadataAddItem: return false for attempt to add 2nd reference" 418 " of a MULTI"); 419 } 420 psFree(xxx); 365 421 366 422 //No existing entries or duplicates found 367 psFree(item2);368 423 item2 = psMetadataItemAllocS32("new", "", 2); 369 424 { 370 425 ok( psMetadataAddItem(md, item2, PS_LIST_TAIL, PS_META_DUPLICATE_OK), 371 "psMetadataAddItem: return true for new item.");426 "psMetadataAddItem: return true for new item."); 372 427 } 373 428 … … 382 437 void testIterAlloc(void) 383 438 { 384 diag(" >>>Test 4: psMetadataIteratorAlloc");439 diag(" >>>Test 3: psMetadataIteratorAlloc"); 385 440 psMetadata *md = psMetadataAlloc(); 386 441 psMetadata *md2 = NULL; … … 412 467 "psMetadataIteratorAlloc: return valid iterator for valid inputs, regex=NULL."); 413 468 } 414 469 //Return NULL for attempt to allocate an iterator with unfound regex. 470 psFree(iter); 471 iter = NULL; 472 { 473 iter = psMetadataIteratorAlloc(md, PS_LIST_HEAD, "IPP.machines.sky"); 474 ok( iter == NULL, 475 "psMetadataIteratorAlloc: return NULL for not-found regex input"); 476 } 477 //Return NULL for invalid regex input. 478 { 479 iter = psMetadataIteratorAlloc(md, PS_LIST_HEAD, "IPP.machines.sky\\"); 480 ok( iter == NULL, 481 "psMetadataIteratorAlloc: return NULL for invalid regex input"); 482 } 483 //Return properly allocated iterator for valid non-null regex input. 484 { 485 iter = psMetadataIteratorAlloc(md, PS_LIST_HEAD, "S32_"); 486 ok( iter != NULL, 487 "psMetadataIteratorAlloc: return valid iterator for valid regex input"); 488 } 415 489 416 490 //Check for Memory leaks -
trunk/psLib/test/types/tap_psMetadata_polynomials.c
r8731 r8786 22 22 int main(void) 23 23 { 24 plan_tests( 1);24 plan_tests(58); 25 25 26 26 diag("psPolynomial(2D, 3D, & 4D)(to/from)MD tests"); … … 37 37 diag(" >>>Test 1: psPolynomial2DtoMD & psPolynomial2DfromMD functions"); 38 38 psMetadata *md = psMetadataAlloc(); 39 psMetadata *out = NULL;40 39 psPolynomial2D *p2d = psPolynomial2DAlloc(PS_POLYNOMIAL_ORD, 1, 1); 41 psPolynomial2D *polly = NULL;42 43 40 p2d->coeff[0][0] = 1.1; 44 41 p2d->coeff[0][1] = 2.2; 45 p2d->coeff[1][0] = 2.1; 46 p2d->coeff[1][1] = 1.2; 47 48 if (!psPolynomial2DtoMD(md, p2d, "polyMD") ) 49 printf("\nnot true\n"); 50 else 51 psMetadataPrint(NULL, md, 2); 52 53 54 55 //Return true for valid case 56 { 57 // ok( psPolynomial2DtoMD(md, p2d, "%f", ...); 58 } 59 60 61 42 p2d->coeff[1][0] = 3.3; 43 p2d->coeff[1][1] = 4.4; 44 p2d->coeffErr[0][0] = 0.1; 45 p2d->coeffErr[0][1] = 0.2; 46 p2d->coeffErr[1][0] = 0.3; 47 p2d->coeffErr[1][1] = 0.4; 48 49 //psPolynomial2DtoMD 50 //Return a valid metadata containing a polynomial-metadata structure 51 { 52 ok( psPolynomial2DtoMD(md, p2d, "polyMD"), 53 "psPolynomial2DtoMD: return true for valid inputs."); 54 psMetadata *polyMDtemp = psMetadataLookupMD(NULL, md, "polyMD"); 55 skip_start( polyMDtemp == NULL , 1, 56 "Skipping 1 tests because psPolynomial2DtoMD has errors"); 57 psMetadataItem *polyItem = psMetadataGet(polyMDtemp, 0); 58 skip_start( polyItem == NULL, 2, 59 "Skipping 2 tests because psPolynomial2DtoMD has errors in order elements"); 60 ok( !strncmp(polyItem->name, "NORDER_X", 10) && polyItem->data.S32 == 1, 61 "psPolynomial2DtoMD: return correct number of x orders."); 62 polyItem = psMetadataGet(polyMDtemp, 1); 63 ok( !strncmp(polyItem->name, "NORDER_Y", 10) && polyItem->data.S32 == 1, 64 "psPolynomial2DtoMD: return correct number of y orders."); 65 skip_end(); 66 polyItem = psMetadataGet(polyMDtemp, 2); 67 skip_start( polyItem == NULL, 2, 68 "Skipping 2 tests because psPolynomial2DtoMD has errors in coeff elements"); 69 ok( !strncmp(polyItem->name, "VAL_X00_Y00", 14) && 70 abs(polyItem->data.F64-1.1) < DBL_EPSILON, 71 "psPolynomial2DtoMD: return correct first element."); 72 polyItem = psMetadataGet(polyMDtemp, PS_LIST_TAIL); 73 ok( !strncmp(polyItem->name, "ERR_X01_Y01", 14) && 74 abs(polyItem->data.F64-0.4) < DBL_EPSILON, 75 "psPolynomial2DtoMD: return correct last element."); 76 skip_end(); 77 skip_end(); 78 } 79 80 //Return false for no-name polynomial 81 { 82 ok( !psPolynomial2DtoMD(md, p2d, ""), 83 "psPolynomial2DtoMD: return false for no-name."); 84 } 85 //Return false for NULL-name polynomial 86 { 87 ok( !psPolynomial2DtoMD(md, p2d, NULL), 88 "psPolynomial2DtoMD: return false for NULL name input."); 89 } 90 //Return false for NULL metadata input 91 { 92 ok( !psPolynomial2DtoMD(NULL, p2d, "polyMD"), 93 "psPolynomial2DtoMD: return false for NULL metadata input."); 94 } 95 //Return false for NULL polynomial input 96 { 97 ok( !psPolynomial2DtoMD(md, NULL, "polyMD"), 98 "psPolynomial2DtoMD: return false for NULL polynomial input."); 99 } 100 //Return false for empty polynomial 101 { 102 psPolynomial2D *emptyPoly = psPolynomial2DAlloc(PS_POLYNOMIAL_ORD, 0, 0); 103 ok( !psPolynomial2DtoMD(md, emptyPoly, "polyMD"), 104 "psPolynomial2DtoMD: return false for empty polynomial input."); 105 psFree(emptyPoly); 106 } 107 //Return true for polynomial with 1 element, a constant 108 { 109 psPolynomial2D *constPoly = psPolynomial2DAlloc(PS_POLYNOMIAL_ORD, 0, 0); 110 constPoly->coeff[0][0] = 6.66; 111 ok( psPolynomial2DtoMD(md, constPoly, "polyMD"), 112 "psPolynomial2DtoMD: return true for constant polynomial (1 element != 0)."); 113 psFree(constPoly); 114 } 115 //Return false for non-ordinary polynomial 116 { 117 psPolynomial2D *p2d2 = psPolynomial2DAlloc(PS_POLYNOMIAL_CHEB, 1, 1); 118 p2d2->coeff[0][0] = 1.1; 119 ok( !psPolynomial2DtoMD(md, p2d2, "polyMD"), 120 "psPolynomial2DtoMD: return false for chebyshev polynomial"); 121 psFree(p2d2); 122 } 123 124 //psPolynomial2DfromMD Tests 125 //Return NULL for NULL metadata input. 126 { 127 psPolynomial2D *emptyPoly2D = NULL; 128 emptyPoly2D = psPolynomial2DfromMD(NULL); 129 ok( emptyPoly2D == NULL, 130 "psPolynomial2DfromMD: return NULL for NULL metadata input."); 131 } 132 //Get a polynomial from Metadata. 133 psPolynomial2D *outPoly = NULL; 134 psMetadata *polyMDtemp = psMetadataLookupMD(NULL, md, "polyMD"); 135 outPoly = psPolynomial2DfromMD(polyMDtemp); 136 { 137 skip_start( outPoly == NULL, 1, 138 "Skipping 1 tests because psPolynomial2DfromMD has errors."); 139 ok( outPoly->type == PS_POLYNOMIAL_ORD && outPoly->nX == 1 && 140 outPoly->nY == 1 && abs(outPoly->coeff[0][0] - 1.1) < DBL_EPSILON, 141 "psPolynomial2DfromMD: return correct polynomial from metadata"); 142 skip_end(); 143 } 144 //Set poly->mask[1][1] = 1 for missing [1][1] element in metadata 145 psMetadataRemoveIndex(polyMDtemp, PS_LIST_TAIL-1); 146 psFree(outPoly); 147 outPoly = NULL; 148 outPoly = psPolynomial2DfromMD(polyMDtemp); 149 { 150 // ok( outPoly->mask[1][1] == 1, 151 // "psPolynomial2DfromMD: return mask[1][1] == 1 for metadata-polynomial", 152 // " with missing element"); 153 ok( outPoly == NULL, 154 "psPolynomial2DfromMD: return NULL for polynomial with missing coeff"); 155 } 156 //Return NULL for polynomial in metadata with no y-order 157 psMetadataRemoveKey(polyMDtemp, "NORDER_Y"); 158 outPoly = psPolynomial2DfromMD(polyMDtemp); 159 { 160 ok( outPoly == NULL, 161 "psPolynomial2DfromMD: return NULL for metadata-polynomial with no y-order"); 162 } 163 //Return NULL for polynomial in metadata with no x-order 164 psMetadataRemoveKey(polyMDtemp, "NORDER_X"); 165 outPoly = psPolynomial2DfromMD(polyMDtemp); 166 { 167 ok( outPoly == NULL, 168 "psPolynomial2DfromMD: return NULL for metadata-polynomial with no x-order"); 169 } 62 170 63 171 //Check for Memory leaks 64 172 { 173 psFree(outPoly); 65 174 psFree(p2d); 66 psFree(polly);67 psFree(out);68 175 psFree(md); 69 176 checkMem(); … … 75 182 diag(" >>>Test 2: psPolynomial3DtoMD & psPolynomial3DfromMD functions"); 76 183 psMetadata *md = psMetadataAlloc(); 77 psMetadata *out = NULL; 78 79 80 184 psPolynomial3D *p3d = psPolynomial3DAlloc(PS_POLYNOMIAL_ORD, 1, 1, 1); 185 p3d->coeff[0][0][0] = 1.1; 186 p3d->coeff[1][0][0] = 2.2; 187 p3d->coeff[0][1][0] = 3.3; 188 p3d->coeff[0][0][1] = 4.4; 189 p3d->coeff[1][1][0] = 5.5; 190 p3d->coeff[1][0][1] = 6.6; 191 p3d->coeff[0][1][1] = 7.7; 192 p3d->coeff[1][1][1] = 8.8; 193 p3d->coeffErr[0][0][0] = 0.1; 194 p3d->coeffErr[1][0][0] = 0.2; 195 p3d->coeffErr[0][1][0] = 0.3; 196 p3d->coeffErr[0][0][1] = 0.4; 197 p3d->coeffErr[1][1][0] = 0.5; 198 p3d->coeffErr[1][0][1] = 0.6; 199 p3d->coeffErr[0][1][1] = 0.7; 200 p3d->coeffErr[1][1][1] = 0.8; 201 202 //psPolynomial3DtoMD 203 //Return a valid metadata containing a polynomial-metadata structure 204 { 205 ok( psPolynomial3DtoMD(md, p3d, "polyMD"), 206 "psPolynomial3DtoMD: return true for valid inputs."); 207 psMetadata *polyMDtemp = psMetadataLookupMD(NULL, md, "polyMD"); 208 skip_start( polyMDtemp == NULL , 1, 209 "Skipping 1 tests because psPolynomial3DtoMD has errors"); 210 psMetadataItem *polyItem = psMetadataGet(polyMDtemp, 0); 211 skip_start( polyItem == NULL, 2, 212 "Skipping 3 tests because psPolynomial3DtoMD has errors in order elements"); 213 ok( !strncmp(polyItem->name, "NORDER_X", 10) && polyItem->data.S32 == 1, 214 "psPolynomial3DtoMD: return correct number of x orders."); 215 polyItem = psMetadataGet(polyMDtemp, 1); 216 ok( !strncmp(polyItem->name, "NORDER_Y", 10) && polyItem->data.S32 == 1, 217 "psPolynomial3DtoMD: return correct number of y orders."); 218 polyItem = psMetadataGet(polyMDtemp, 2); 219 ok( !strncmp(polyItem->name, "NORDER_Z", 10) && polyItem->data.S32 == 1, 220 "psPolynomial3DtoMD: return correct number of z orders."); 221 skip_end(); 222 polyItem = psMetadataGet(polyMDtemp, 3); 223 skip_start( polyItem == NULL, 2, 224 "Skipping 2 tests because psPolynomial3DtoMD has errors in coeff elements"); 225 ok( !strncmp(polyItem->name, "VAL_X00_Y00_Z00", 14) && 226 abs(polyItem->data.F64-1.1) < DBL_EPSILON, 227 "psPolynomial3DtoMD: return correct first element."); 228 polyItem = psMetadataGet(polyMDtemp, PS_LIST_TAIL); 229 ok( !strncmp(polyItem->name, "ERR_X01_Y01_Z01", 14) && 230 abs(polyItem->data.F64-0.8) < DBL_EPSILON, 231 "psPolynomial3DtoMD: return correct last element."); 232 skip_end(); 233 skip_end(); 234 } 235 //Return false for no-name polynomial 236 { 237 ok( !psPolynomial3DtoMD(md, p3d, ""), 238 "psPolynomial3DtoMD: return false for no-name."); 239 } 240 //Return false for NULL-name polynomial 241 { 242 ok( !psPolynomial3DtoMD(md, p3d, NULL), 243 "psPolynomial3DtoMD: return false for NULL name input."); 244 } 245 //Return false for NULL metadata input 246 { 247 ok( !psPolynomial3DtoMD(NULL, p3d, "polyMD"), 248 "psPolynomial3DtoMD: return false for NULL metadata input."); 249 } 250 //Return false for NULL polynomial input 251 { 252 ok( !psPolynomial3DtoMD(md, NULL, "polyMD"), 253 "psPolynomial3DtoMD: return false for NULL polynomial input."); 254 } 255 //Return false for empty polynomial 256 { 257 psPolynomial3D *emptyPoly = psPolynomial3DAlloc(PS_POLYNOMIAL_ORD, 0, 0, 0); 258 ok( !psPolynomial3DtoMD(md, emptyPoly, "polyMD"), 259 "psPolynomial3DtoMD: return false for empty polynomial input."); 260 psFree(emptyPoly); 261 } 262 //Return true for polynomial with 1 element, a constant 263 { 264 psPolynomial3D *constPoly = psPolynomial3DAlloc(PS_POLYNOMIAL_ORD, 0, 0, 0); 265 constPoly->coeff[0][0][0] = 6.66; 266 ok( psPolynomial3DtoMD(md, constPoly, "polyMD"), 267 "psPolynomial3DtoMD: return true for constant polynomial (1 element != 0)."); 268 psFree(constPoly); 269 } 270 //Return false for non-ordinary polynomial 271 { 272 psPolynomial3D *p3d2 = psPolynomial3DAlloc(PS_POLYNOMIAL_CHEB, 1, 1, 1); 273 p3d2->coeff[0][0][0] = 1.1; 274 ok( !psPolynomial3DtoMD(md, p3d2, "polyMD"), 275 "psPolynomial3DtoMD: return false for chebyshev polynomial"); 276 psFree(p3d2); 277 } 278 279 //psPolynomial3DfromMD Tests 280 //Return NULL for NULL metadata input. 281 { 282 psPolynomial3D *emptyPoly2D = NULL; 283 emptyPoly2D = psPolynomial3DfromMD(NULL); 284 ok( emptyPoly2D == NULL, 285 "psPolynomial3DfromMD: return NULL for NULL metadata input."); 286 } 287 //Get a polynomial from Metadata. 288 psPolynomial3D *outPoly = NULL; 289 psMetadata *polyMDtemp = psMetadataLookupMD(NULL, md, "polyMD"); 290 outPoly = psPolynomial3DfromMD(polyMDtemp); 291 { 292 skip_start( outPoly == NULL, 1, 293 "Skipping 1 tests because psPolynomial3DfromMD has errors."); 294 ok( outPoly->type == PS_POLYNOMIAL_ORD && outPoly->nX == 1 && 295 outPoly->nY == 1 && outPoly->nZ == 1 && 296 abs(outPoly->coeff[0][0][0] - 1.1) < DBL_EPSILON, 297 "psPolynomial3DfromMD: return correct polynomial from metadata"); 298 skip_end(); 299 } 300 //Return NULL for polynomial with missing coefficient 301 psMetadataRemoveIndex(polyMDtemp, PS_LIST_TAIL-1); 302 psFree(outPoly); 303 outPoly = NULL; 304 outPoly = psPolynomial3DfromMD(polyMDtemp); 305 { 306 // ok( outPoly->mask[1][1][1] == 1, 307 // "psPolynomial3DfromMD: return mask[1][1][1] == 1 for metadata-polynomial" 308 // " with missing element"); 309 ok( outPoly == NULL, 310 "psPolynomial3DfromMD: return NULL for polynomial with missing coeff"); 311 } 312 //Return NULL for polynomial in metadata with no z-order 313 psMetadataRemoveKey(polyMDtemp, "NORDER_Z"); 314 outPoly = psPolynomial3DfromMD(polyMDtemp); 315 { 316 ok( outPoly == NULL, 317 "psPolynomial3DfromMD: return NULL for metadata-polynomial with no z-order"); 318 } 319 //Return NULL for polynomial in metadata with no y-order 320 psMetadataRemoveKey(polyMDtemp, "NORDER_Y"); 321 outPoly = psPolynomial3DfromMD(polyMDtemp); 322 { 323 ok( outPoly == NULL, 324 "psPolynomial3DfromMD: return NULL for metadata-polynomial with no y-order"); 325 } 326 //Return NULL for polynomial in metadata with no x-order 327 psMetadataRemoveKey(polyMDtemp, "NORDER_X"); 328 outPoly = psPolynomial3DfromMD(polyMDtemp); 329 { 330 ok( outPoly == NULL, 331 "psPolynomial3DfromMD: return NULL for metadata-polynomial with no x-order"); 332 } 81 333 82 334 //Check for Memory leaks 83 335 { 84 psFree(out); 336 psFree(outPoly); 337 psFree(p3d); 85 338 psFree(md); 86 339 checkMem(); … … 92 345 diag(" >>>Test 3: psPolynomial4DtoMD & psPolynomial4DfromMD functions"); 93 346 psMetadata *md = psMetadataAlloc(); 94 psMetadata *out = NULL; 95 96 97 347 psPolynomial4D *p4d = psPolynomial4DAlloc(PS_POLYNOMIAL_ORD, 1, 1, 1, 1); 348 p4d->coeff[0][0][0][0] = 1.1; 349 p4d->coeff[0][0][0][1] = 2.2; 350 p4d->coeff[0][0][1][0] = 3.3; 351 p4d->coeff[0][1][0][0] = 4.4; 352 p4d->coeff[1][0][0][0] = 5.5; 353 354 p4d->coeff[0][0][1][1] = 6.6; 355 p4d->coeff[0][1][0][1] = 7.7; 356 p4d->coeff[1][0][0][1] = 8.8; 357 p4d->coeff[0][1][1][0] = 9.9; 358 p4d->coeff[1][0][1][0] = 10.10; 359 p4d->coeff[1][1][0][0] = 11.11; 360 361 p4d->coeff[0][1][1][1] = 12.12; 362 p4d->coeff[1][0][1][1] = 13.13; 363 p4d->coeff[1][1][0][1] = 14.14; 364 p4d->coeff[1][1][1][0] = 15.15; 365 366 p4d->coeff[1][1][1][1] = 16.16; 367 368 p4d->coeffErr[0][0][0][0] = 0.1; 369 p4d->coeffErr[0][0][0][1] = 0.2; 370 p4d->coeffErr[0][0][1][0] = 0.3; 371 p4d->coeffErr[0][1][0][0] = 0.4; 372 p4d->coeffErr[1][0][0][0] = 0.5; 373 374 p4d->coeffErr[0][0][1][1] = 0.6; 375 p4d->coeffErr[0][1][0][1] = 0.7; 376 p4d->coeffErr[1][0][0][1] = 0.8; 377 p4d->coeffErr[0][1][1][0] = 0.9; 378 p4d->coeffErr[1][0][1][0] = 0.10; 379 p4d->coeffErr[1][1][0][0] = 0.11; 380 381 p4d->coeffErr[0][1][1][1] = 0.12; 382 p4d->coeffErr[1][0][1][1] = 0.13; 383 p4d->coeffErr[1][1][0][1] = 0.14; 384 p4d->coeffErr[1][1][1][0] = 0.15; 385 386 p4d->coeffErr[1][1][1][1] = 0.16; 387 388 //psPolynomial4DtoMD 389 //Return a valid metadata containing a polynomial-metadata structure 390 { 391 ok( psPolynomial4DtoMD(md, p4d, "polyMD"), 392 "psPolynomial4DtoMD: return true for valid inputs."); 393 psMetadata *polyMDtemp = psMetadataLookupMD(NULL, md, "polyMD"); 394 skip_start( polyMDtemp == NULL , 1, 395 "Skipping 1 tests because psPolynomial4DtoMD has errors"); 396 psMetadataItem *polyItem = psMetadataGet(polyMDtemp, 0); 397 skip_start( polyItem == NULL, 2, 398 "Skipping 4 tests because psPolynomial4DtoMD has errors in order elements"); 399 ok( !strncmp(polyItem->name, "NORDER_X", 10) && polyItem->data.S32 == 1, 400 "psPolynomial4DtoMD: return correct number of x orders."); 401 polyItem = psMetadataGet(polyMDtemp, 1); 402 ok( !strncmp(polyItem->name, "NORDER_Y", 10) && polyItem->data.S32 == 1, 403 "psPolynomial4DtoMD: return correct number of y orders."); 404 polyItem = psMetadataGet(polyMDtemp, 2); 405 ok( !strncmp(polyItem->name, "NORDER_Z", 10) && polyItem->data.S32 == 1, 406 "psPolynomial4DtoMD: return correct number of z orders."); 407 polyItem = psMetadataGet(polyMDtemp, 3); 408 ok( !strncmp(polyItem->name, "NORDER_T", 10) && polyItem->data.S32 == 1, 409 "psPolynomial4DtoMD: return correct number of t orders."); 410 skip_end(); 411 polyItem = psMetadataGet(polyMDtemp, 4); 412 skip_start( polyItem == NULL, 2, 413 "Skipping 2 tests because psPolynomial4DtoMD has errors in coeff elements"); 414 ok( !strncmp(polyItem->name, "VAL_X00_Y00_Z00_T00", 14) && 415 abs(polyItem->data.F64-1.1) < DBL_EPSILON, 416 "psPolynomial4DtoMD: return correct first element."); 417 polyItem = psMetadataGet(polyMDtemp, PS_LIST_TAIL); 418 ok( !strncmp(polyItem->name, "ERR_X01_Y01_Z01_T01", 14) && 419 abs(polyItem->data.F64-0.16) < DBL_EPSILON, 420 "psPolynomial4DtoMD: return correct last element."); 421 skip_end(); 422 skip_end(); 423 } 424 //Return false for no-name polynomial 425 { 426 ok( !psPolynomial4DtoMD(md, p4d, ""), 427 "psPolynomial4DtoMD: return false for no-name."); 428 } 429 //Return false for NULL-name polynomial 430 { 431 ok( !psPolynomial4DtoMD(md, p4d, NULL), 432 "psPolynomial4DtoMD: return false for NULL name input."); 433 } 434 //Return false for NULL metadata input 435 { 436 ok( !psPolynomial4DtoMD(NULL, p4d, "polyMD"), 437 "psPolynomial4DtoMD: return false for NULL metadata input."); 438 } 439 //Return false for NULL polynomial input 440 { 441 ok( !psPolynomial4DtoMD(md, NULL, "polyMD"), 442 "psPolynomial4DtoMD: return false for NULL polynomial input."); 443 } 444 //Return false for empty polynomial 445 { 446 psPolynomial4D *emptyPoly = psPolynomial4DAlloc(PS_POLYNOMIAL_ORD, 0, 0, 0, 0); 447 ok( !psPolynomial4DtoMD(md, emptyPoly, "polyMD"), 448 "psPolynomial4DtoMD: return false for empty polynomial input."); 449 psFree(emptyPoly); 450 } 451 //Return true for polynomial with 1 element, a constant 452 { 453 psPolynomial4D *constPoly = psPolynomial4DAlloc(PS_POLYNOMIAL_ORD, 0, 0, 0, 0); 454 constPoly->coeff[0][0][0][0] = 6.66; 455 ok( psPolynomial4DtoMD(md, constPoly, "polyMD"), 456 "psPolynomial4DtoMD: return true for constant polynomial (1 element != 0)."); 457 psFree(constPoly); 458 } 459 //Return false for non-ordinary polynomial 460 { 461 psPolynomial4D *p4d2 = psPolynomial4DAlloc(PS_POLYNOMIAL_CHEB, 1, 1, 1, 1); 462 p4d2->coeff[0][0][0][0] = 1.1; 463 ok( !psPolynomial4DtoMD(md, p4d2, "polyMD"), 464 "psPolynomial4DtoMD: return false for chebyshev polynomial"); 465 psFree(p4d2); 466 } 467 468 //psPolynomial4DfromMD Tests 469 //Return NULL for NULL metadata input. 470 { 471 psPolynomial4D *emptyPoly2D = NULL; 472 emptyPoly2D = psPolynomial4DfromMD(NULL); 473 ok( emptyPoly2D == NULL, 474 "psPolynomial4DfromMD: return NULL for NULL metadata input."); 475 } 476 //Get a polynomial from Metadata. 477 psPolynomial4D *outPoly = NULL; 478 psMetadata *polyMDtemp = psMetadataLookupMD(NULL, md, "polyMD"); 479 outPoly = psPolynomial4DfromMD(polyMDtemp); 480 { 481 skip_start( outPoly == NULL, 1, 482 "Skipping 1 tests because psPolynomial4DfromMD has errors."); 483 ok( outPoly->type == PS_POLYNOMIAL_ORD && outPoly->nX == 1 && 484 outPoly->nY == 1 && outPoly->nZ == 1 && outPoly->nT == 1 && 485 abs(outPoly->coeff[0][0][0][0] - 1.1) < DBL_EPSILON, 486 "psPolynomial4DfromMD: return correct polynomial from metadata"); 487 skip_end(); 488 } 489 //Return NULL for polynomial with missing coefficient 490 psMetadataRemoveIndex(polyMDtemp, PS_LIST_TAIL-1); 491 psFree(outPoly); 492 outPoly = NULL; 493 outPoly = psPolynomial4DfromMD(polyMDtemp); 494 { 495 // ok( outPoly->mask[1][1][1] == 1, 496 // "psPolynomial4DfromMD: return mask[1][1][1] == 1 for metadata-polynomial" 497 // " with missing element"); 498 ok( outPoly == NULL, 499 "psPolynomial4DfromMD: return NULL for polynomial with missing coeff"); 500 } 501 //Return NULL for polynomial in metadata with no t-order 502 psMetadataRemoveKey(polyMDtemp, "NORDER_T"); 503 outPoly = psPolynomial4DfromMD(polyMDtemp); 504 { 505 ok( outPoly == NULL, 506 "psPolynomial4DfromMD: return NULL for metadata-polynomial with no t-order"); 507 } 508 //Return NULL for polynomial in metadata with no z-order 509 psMetadataRemoveKey(polyMDtemp, "NORDER_Z"); 510 outPoly = psPolynomial4DfromMD(polyMDtemp); 511 { 512 ok( outPoly == NULL, 513 "psPolynomial4DfromMD: return NULL for metadata-polynomial with no z-order"); 514 } 515 //Return NULL for polynomial in metadata with no y-order 516 psMetadataRemoveKey(polyMDtemp, "NORDER_Y"); 517 outPoly = psPolynomial4DfromMD(polyMDtemp); 518 { 519 ok( outPoly == NULL, 520 "psPolynomial4DfromMD: return NULL for metadata-polynomial with no y-order"); 521 } 522 //Return NULL for polynomial in metadata with no x-order 523 psMetadataRemoveKey(polyMDtemp, "NORDER_X"); 524 outPoly = psPolynomial4DfromMD(polyMDtemp); 525 { 526 ok( outPoly == NULL, 527 "psPolynomial4DfromMD: return NULL for metadata-polynomial with no x-order"); 528 } 98 529 99 530 //Check for Memory leaks 100 531 { 101 psFree(out); 532 psFree(outPoly); 533 psFree(p4d); 102 534 psFree(md); 103 535 checkMem();
Note:
See TracChangeset
for help on using the changeset viewer.
