organicmaps/icu
13
Fork 0
mirror of https://github.com/unicode-org/icu.git synced 2025-04-05 21:45:37 +00:00
Code Issues 1 Projects Releases Wiki Activity Actions 12

Merge pull request #26 from hugovdm/units-staging-preferences

Browse source 
Parse unitPreferencesTest.txt preparing to run data-driven tests
This commit is contained in:
Shane F. Carr 2020-03-16 22:12:04 -05:00 • committed by GitHub
commit 9e021f9b6f
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
2 changed files with 296 additions and 25 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

285
icu4c/source/test/intltest/unitstest.cpp
View file

@ -6,13 +6,17 @@
#if !UCONFIG_NO_FORMATTING
#include "charstr.h"
#include "filestrm.h"
#include "intltest.h"
#include "number_decimalquantity.h"
#include "unicode/ctest.h"
#include "unicode/measunit.h"
#include "unicode/unistr.h"
#include "unicode/unum.h"
#include "uparse.h"
using icu::number::impl::DecimalQuantity;
class UnitsTest : public IntlTest {
public:
UnitsTest() {}
@ -20,6 +24,7 @@ class UnitsTest : public IntlTest {
void runIndexedTest(int32_t index, UBool exec, const char *&name, char *par = NULL);
void testConversions();
void testPreferences();
void testBasic();
void testSiPrefixes();
void testMass();
@ -30,9 +35,12 @@ class UnitsTest : public IntlTest {
extern IntlTest *createUnitsTest() { return new UnitsTest(); }
void UnitsTest::runIndexedTest(int32_t index, UBool exec, const char *&name, char * /*par*/) {
if (exec) { logln("TestSuite UnitsTest: "); }
if (exec) {
logln("TestSuite UnitsTest: ");
}
TESTCASE_AUTO_BEGIN;
TESTCASE_AUTO(testConversions);
TESTCASE_AUTO(testPreferences);
TESTCASE_AUTO(testBasic);
TESTCASE_AUTO(testSiPrefixes);
TESTCASE_AUTO(testMass);
@ -165,8 +173,9 @@ void UnitsTest::testArea() {
}
/**
* Returns a StringPiece pointing at the given field with space prefixes and
* postfixes trimmed off.
* Trims whitespace (spaces only) off of the specified string.
* @param field is two pointers pointing at the start and end of the string.
* @return A StringPiece with initial and final space characters trimmed off.
*/
StringPiece trimField(char *(&field)[2]) {
char *start = field[0];
@ -184,8 +193,7 @@ StringPiece trimField(char *(&field)[2]) {
* WIP(hugovdm): deals with a single data-driven unit test for unit conversions.
* This is a UParseLineFn as required by u_parseDelimitedFile.
*/
static void U_CALLCONV unitsTestDataLineFn(void *context, char *fields[][2], int32_t fieldCount,
UErrorCode *pErrorCode) {
void unitsTestDataLineFn(void *context, char *fields[][2], int32_t fieldCount, UErrorCode *pErrorCode) {
(void)fieldCount; // unused UParseLineFn variable
IcuTestErrorCode status(*(UnitsTest *)context, "unitsTestDatalineFn");
@ -242,10 +250,273 @@ void UnitsTest::testConversions() {
CharString path(sourceTestDataPath, errorCode);
path.appendPathPart("units", errorCode);
path.appendPathPart("unitsTest.txt", errorCode);
path.appendPathPart(filename, errorCode);
u_parseDelimitedFile(path.data(), ';', fields, kNumFields, unitsTestDataLineFn, this, errorCode);
if (errorCode.errIfFailureAndReset("error parsing %s: %s\n", filename, u_errorName(errorCode))) {
if (errorCode.errIfFailureAndReset("error parsing %s: %s\n", path.data(), u_errorName(errorCode))) {
return;
}
}
/**
* This class represents the output fields from unitPreferencesTest.txt. Please
* see the documentation at the top of that file for details.
*
* For "mixed units" output, there are more (repeated) output fields. The last
* output unit has the expected output specified as both a rational fraction and
* a decimal fraction. This class ignores rational fractions, and expects to
* find a decimal fraction for each output unit.
*/
class ExpectedOutput {
private:
// Counts number of units in the output. When this is more than one, we have
// "mixed units" in the expected output.
int _compoundCount = 0;
// Counts how many fields were skipped: we expect to skip only one per
// output unit type (the rational fraction).
int _skippedFields = 0;
// The expected output units: more than one for "mixed units".
MeasureUnit _measureUnits[3];
// The amounts of each of the output units.
double _amounts[3];
public:
/**
* Parse an expected output field from the test data file.
*
* @param output may be a string representation of an integer, a rational
* fraction, a decimal fraction, or it may be a unit identifier. Whitespace
* should already be trimmed. This function ignores rational fractions,
* saving only decimal fractions and their unit identifiers.
* @return true if the field was successfully parsed, false if parsing
* failed.
*/
void parseOutputField(StringPiece output, UErrorCode &errorCode) {
if (U_FAILURE(errorCode)) return;
DecimalQuantity dqOutputD;
dqOutputD.setToDecNumber(output, errorCode);
if (U_SUCCESS(errorCode)) {
_amounts[_compoundCount] = dqOutputD.toDouble();
return;
} else if (errorCode == U_DECIMAL_NUMBER_SYNTAX_ERROR) {
// Not a decimal fraction, it might be a rational fraction or a unit
// identifier: continue.
errorCode = U_ZERO_ERROR;
} else {
// Unexpected error, so we propagate it.
return;
}
_measureUnits[_compoundCount] = MeasureUnit::forIdentifier(output, errorCode);
if (U_SUCCESS(errorCode)) {
_compoundCount++;
_skippedFields = 0;
return;
}
_skippedFields++;
if (_skippedFields < 2) {
// We are happy skipping one field per output unit: we want to skip
// rational fraction fiels like "11 / 10".
errorCode = U_ZERO_ERROR;
return;
} else {
// Propagate the error.
return;
}
}
/**
* Produces an output string for debug purposes.
*/
std::string toDebugString() {
std::string result;
for (int i = 0; i < _compoundCount; i++) {
result += std::to_string(_amounts[i]);
result += " ";
result += _measureUnits[i].getIdentifier();
result += " ";
}
return result;
}
};
/**
* WIP(hugovdm): deals with a single data-driven unit test for unit preferences.
* This is a UParseLineFn as required by u_parseDelimitedFile.
*/
void unitPreferencesTestDataLineFn(void *context, char *fields[][2], int32_t fieldCount,
UErrorCode *pErrorCode) {
if (U_FAILURE(*pErrorCode)) return;
UnitsTest *intltest = (UnitsTest *)context;
IcuTestErrorCode status(*(UnitsTest *)context, "unitPreferencesTestDatalineFn");
if (!intltest->assertTrue(u"unitPreferencesTestDataLineFn expects 9 fields for simple and 11 "
u"fields for compound. Other field counts not yet supported. ",
fieldCount == 9 || fieldCount == 11)) {
return;
}
StringPiece quantity = trimField(fields[0]);
StringPiece usage = trimField(fields[1]);
StringPiece region = trimField(fields[2]);
// Unused // StringPiece inputR = trimField(fields[3]);
StringPiece inputD = trimField(fields[4]);
StringPiece inputUnit = trimField(fields[5]);
ExpectedOutput output;
for (int i = 6; i < fieldCount; i++) {
output.parseOutputField(trimField(fields[i]), status);
}
if (status.errIfFailureAndReset("parsing unitPreferencesTestData.txt test case: %s", fields[0][0])) {
return;
}
DecimalQuantity dqInputD;
dqInputD.setToDecNumber(inputD, status);
if (status.errIfFailureAndReset("parsing decimal quantity: \"%.*s\"", inputD.length(),
inputD.data())) {
*pErrorCode = U_PARSE_ERROR;
return;
}
double inputAmount = dqInputD.toDouble();
MeasureUnit inputMeasureUnit = MeasureUnit::forIdentifier(inputUnit, status);
if (status.errIfFailureAndReset("forIdentifier(\"%.*s\")", inputUnit.length(), inputUnit.data())) {
*pErrorCode = U_PARSE_ERROR;
return;
}
// WIP(hugovdm): hook this up to actual tests.
//
// Possible after merging in younies/tryingdouble:
// UnitConverter converter(sourceUnit, targetUnit, *pErrorCode);
// double got = converter.convert(1000, *pErrorCode);
// ((UnitsTest*)context)->assertEqualsNear(quantity.data(), expected, got, 0.0001);
//
// In the meantime, printing to stderr.
fprintf(stderr,
"Quantity (Category): \"%.*s\", Usage: \"%.*s\", Region: \"%.*s\", "
"Input: \"%f %s\", Expected Output: %s\n",
quantity.length(), quantity.data(), usage.length(), usage.data(), region.length(),
region.data(), inputAmount, inputMeasureUnit.getIdentifier(),
output.toDebugString().c_str());
}
/**
* Parses the format used by unitPreferencesTest.txt, calling lineFn for each
* line.
*
* This is a modified version of u_parseDelimitedFile, customised for
* unitPreferencesTest.txt, due to it having a variable number of fields per
* line.
*/
void parsePreferencesTests(const char *filename, char delimiter, char *fields[][2],
int32_t maxFieldCount, UParseLineFn *lineFn, void *context,
UErrorCode *pErrorCode) {
FileStream *file;
char line[10000];
char *start, *limit;
int32_t i;
if (U_FAILURE(*pErrorCode)) { return; }
if (fields == NULL || lineFn == NULL || maxFieldCount <= 0) {
*pErrorCode = U_ILLEGAL_ARGUMENT_ERROR;
return;
}
if (filename == NULL || *filename == 0 || (*filename == '-' && filename[1] == 0)) {
filename = NULL;
file = T_FileStream_stdin();
} else {
file = T_FileStream_open(filename, "r");
}
if (file == NULL) {
*pErrorCode = U_FILE_ACCESS_ERROR;
return;
}
while (T_FileStream_readLine(file, line, sizeof(line)) != NULL) {
/* remove trailing newline characters */
u_rtrim(line);
start = line;
*pErrorCode = U_ZERO_ERROR;
/* skip this line if it is empty or a comment */
if (*start == 0 || *start == '#') { continue; }
/* remove in-line comments */
limit = uprv_strchr(start, '#');
if (limit != NULL) {
/* get white space before the pound sign */
while (limit > start && U_IS_INV_WHITESPACE(*(limit - 1))) {
--limit;
}
/* truncate the line */
*limit = 0;
}
/* skip lines with only whitespace */
if (u_skipWhitespace(start)[0] == 0) { continue; }
/* for each field, call the corresponding field function */
for (i = 0; i < maxFieldCount; ++i) {
/* set the limit pointer of this field */
limit = start;
while (*limit != delimiter && *limit != 0) {
++limit;
}
/* set the field start and limit in the fields array */
fields[i][0] = start;
fields[i][1] = limit;
/* set start to the beginning of the next field, if any */
start = limit;
if (*start != 0) {
++start;
} else {
break;
}
}
if (i == maxFieldCount) { *pErrorCode = U_PARSE_ERROR; }
int fieldCount = i + 1;
/* call the field function */
lineFn(context, fields, fieldCount, pErrorCode);
if (U_FAILURE(*pErrorCode)) { break; }
}
if (filename != NULL) { T_FileStream_close(file); }
}
/**
* Runs data-driven unit tests for unit preferences.
*/
void UnitsTest::testPreferences() {
const char *filename = "unitPreferencesTest.txt";
const int32_t maxFields = 11;
char *fields[maxFields][2];
IcuTestErrorCode errorCode(*this, "UnitsTest::testPreferences");
const char *sourceTestDataPath = getSourceTestData(errorCode);
if (errorCode.errIfFailureAndReset("unable to find the source/test/testdata "
"folder (getSourceTestData())")) {
return;
}
CharString path(sourceTestDataPath, errorCode);
path.appendPathPart("units", errorCode);
path.appendPathPart(filename, errorCode);
parsePreferencesTests(path.data(), ';', fields, maxFields, unitPreferencesTestDataLineFn, this,
errorCode);
if (errorCode.errIfFailureAndReset("error parsing %s: %s\n", path.data(), u_errorName(errorCode))) {
return;
}
}

36
icu4c/source/test/testdata/units/unitPreferencesTest.txt vendored
View file

@ -53,21 +53,21 @@ area; land; GB; 1738883619 / 390625; 4451.54206464; square-meter; 11 /
area; land; GB; 316160658 / 78125; 4046.8564224; square-meter; 1; 1.0; acre
area; land; GB; 1422722961 / 390625; 3642.17078016; square-meter; 9 / 10; 0.9; acre
concentration; blood-glucose; AG; 662435483600000000000000; 6.624354836E23; item-per-cubic-meter; 11 / 10; 1.1; millimole-per-liter
concentration; blood-glucose; AG; 602214076000000000000000; 6.02214076E23; item-per-cubic-meter; 1; 1.0; millimole-per-liter
concentration; blood-glucose; AG; 541992668400000000000000; 5.419926684E23; item-per-cubic-meter; 9 / 10; 0.9; millimole-per-liter
#WIP(ILLEGAL_ARG)#concentration; blood-glucose; AG; 662435483600000000000000; 6.624354836E23; item-per-cubic-meter; 11 / 10; 1.1; millimole-per-liter
#WIP(ILLEGAL_ARG)#concentration; blood-glucose; AG; 602214076000000000000000; 6.02214076E23; item-per-cubic-meter; 1; 1.0; millimole-per-liter
#WIP(ILLEGAL_ARG)#concentration; blood-glucose; AG; 541992668400000000000000; 5.419926684E23; item-per-cubic-meter; 9 / 10; 0.9; millimole-per-liter
concentration; default; 001; 11 / 10; 1.1; item-per-cubic-meter; 11 / 10; 1.1; item-per-cubic-meter
concentration; default; 001; 1; 1.0; item-per-cubic-meter; 1; 1.0; item-per-cubic-meter
concentration; default; 001; 9 / 10; 0.9; item-per-cubic-meter; 9 / 10; 0.9; item-per-cubic-meter
#WIP(ILLEGAL_ARG)#concentration; default; 001; 11 / 10; 1.1; item-per-cubic-meter; 11 / 10; 1.1; item-per-cubic-meter
#WIP(ILLEGAL_ARG)#concentration; default; 001; 1; 1.0; item-per-cubic-meter; 1; 1.0; item-per-cubic-meter
#WIP(ILLEGAL_ARG)#concentration; default; 001; 9 / 10; 0.9; item-per-cubic-meter; 9 / 10; 0.9; item-per-cubic-meter
consumption; default; 001; 11 / 1000000000; 1.1E-8; cubic-meter-per-meter; 11 / 10; 1.1; liter-per-100-kilometer
consumption; default; 001; 1 / 100000000; 1.0E-8; cubic-meter-per-meter; 1; 1.0; liter-per-100-kilometer
consumption; default; 001; 9 / 1000000000; 9.0E-9; cubic-meter-per-meter; 9 / 10; 0.9; liter-per-100-kilometer
#WIP(ILLEGAL_ARG)#consumption; default; 001; 11 / 1000000000; 1.1E-8; cubic-meter-per-meter; 11 / 10; 1.1; liter-per-100-kilometer
#WIP(ILLEGAL_ARG)#consumption; default; 001; 1 / 100000000; 1.0E-8; cubic-meter-per-meter; 1; 1.0; liter-per-100-kilometer
#WIP(ILLEGAL_ARG)#consumption; default; 001; 9 / 1000000000; 9.0E-9; cubic-meter-per-meter; 9 / 10; 0.9; liter-per-100-kilometer
consumption; vehicle-fuel; 001; 11 / 1000000000; 1.1E-8; cubic-meter-per-meter; 11 / 10; 1.1; liter-per-100-kilometer
consumption; vehicle-fuel; 001; 1 / 100000000; 1.0E-8; cubic-meter-per-meter; 1; 1.0; liter-per-100-kilometer
consumption; vehicle-fuel; 001; 9 / 1000000000; 9.0E-9; cubic-meter-per-meter; 9 / 10; 0.9; liter-per-100-kilometer
#WIP(ILLEGAL_ARG)#consumption; vehicle-fuel; 001; 11 / 1000000000; 1.1E-8; cubic-meter-per-meter; 11 / 10; 1.1; liter-per-100-kilometer
#WIP(ILLEGAL_ARG)#consumption; vehicle-fuel; 001; 1 / 100000000; 1.0E-8; cubic-meter-per-meter; 1; 1.0; liter-per-100-kilometer
#WIP(ILLEGAL_ARG)#consumption; vehicle-fuel; 001; 9 / 1000000000; 9.0E-9; cubic-meter-per-meter; 9 / 10; 0.9; liter-per-100-kilometer
consumption; vehicle-fuel; BR; 11 / 10000000; 1.1E-6; cubic-meter-per-meter; 11 / 10; 1.1; liter-per-kilometer
consumption; vehicle-fuel; BR; 1 / 1000000; 1.0E-6; cubic-meter-per-meter; 1; 1.0; liter-per-kilometer
@ -311,17 +311,17 @@ pressure; baromtrc; 001; 110; 110.0; kilogram-per-meter-square-second
pressure; baromtrc; 001; 100; 100.0; kilogram-per-meter-square-second; 1; 1.0; hectopascal
pressure; baromtrc; 001; 90; 90.0; kilogram-per-meter-square-second; 9 / 10; 0.9; hectopascal
pressure; baromtrc; IN; 37250279 / 10000; 3725.0279; kilogram-per-meter-square-second; 11 / 10; 1.1; inch-ofhg
pressure; baromtrc; IN; 3386389 / 1000; 3386.389; kilogram-per-meter-square-second; 1; 1.0; inch-ofhg
pressure; baromtrc; IN; 30477501 / 10000; 3047.7501; kilogram-per-meter-square-second; 9 / 10; 0.9; inch-ofhg
#WIP(ILLEGAL_ARG)#pressure; baromtrc; IN; 37250279 / 10000; 3725.0279; kilogram-per-meter-square-second; 11 / 10; 1.1; inch-ofhg
#WIP(ILLEGAL_ARG)#pressure; baromtrc; IN; 3386389 / 1000; 3386.389; kilogram-per-meter-square-second; 1; 1.0; inch-ofhg
#WIP(ILLEGAL_ARG)#pressure; baromtrc; IN; 30477501 / 10000; 3047.7501; kilogram-per-meter-square-second; 9 / 10; 0.9; inch-ofhg
pressure; baromtrc; BR; 110; 110.0; kilogram-per-meter-square-second; 11 / 10; 1.1; millibar
pressure; baromtrc; BR; 100; 100.0; kilogram-per-meter-square-second; 1; 1.0; millibar
pressure; baromtrc; BR; 90; 90.0; kilogram-per-meter-square-second; 9 / 10; 0.9; millibar
pressure; baromtrc; MX; 44583 / 3040; 14.66546052631579; kilogram-per-meter-square-second; 11 / 10; 1.1; millimeter-ofhg
pressure; baromtrc; MX; 4053 / 304; 13.33223684210526; kilogram-per-meter-square-second; 1; 1.0; millimeter-ofhg
pressure; baromtrc; MX; 36477 / 3040; 11.99901315789474; kilogram-per-meter-square-second; 9 / 10; 0.9; millimeter-ofhg
#WIP(ILLEGAL_ARG)#pressure; baromtrc; MX; 44583 / 3040; 14.66546052631579; kilogram-per-meter-square-second; 11 / 10; 1.1; millimeter-ofhg
#WIP(ILLEGAL_ARG)#pressure; baromtrc; MX; 4053 / 304; 13.33223684210526; kilogram-per-meter-square-second; 1; 1.0; millimeter-ofhg
#WIP(ILLEGAL_ARG)#pressure; baromtrc; MX; 36477 / 3040; 11.99901315789474; kilogram-per-meter-square-second; 9 / 10; 0.9; millimeter-ofhg
pressure; default; 001; 1100000; 1100000.0; kilogram-per-meter-square-second; 11 / 10; 1.1; megapascal
pressure; default; 001; 1000000; 1000000.0; kilogram-per-meter-square-second; 1; 1.0; megapascal