QString FLManager::formatAssignValue(FLFieldMetaData *fMD, const QVariant &v, const bool upper)
{
if (!fMD)
return "1 = 1";
FLTableMetaData *mtd = fMD->metadata();
QString fieldName(fMD->name());
if (mtd && mtd->isQuery()) {
QString prefixTable(mtd->name());
FLSqlQuery *qry = query(mtd->query());
if (qry) {
QStringList fL(qry->fieldList());
for (QStringList::Iterator it = fL.begin(); it != fL.end(); ++it) {
prefixTable = (*it).section('.', 0, 0);
if ((*it).section('.', 1, 1) == fieldName)
break;
}
qry->deleteLater();
}
fieldName.prepend(prefixTable + ".");
}
return formatAssignValue(fieldName, fMD->type(), v, upper);
}
/**
* This test does round-trip testing (format -> parse -> format -> parse -> etc.) of
* NumberFormat.
*/
void IntlTestNumberFormatAPI::testAPI(/* char* par */)
{
UErrorCode status = U_ZERO_ERROR;
// ======= Test constructors
logln("Testing NumberFormat constructors");
NumberFormat *def = NumberFormat::createInstance(status);
if(U_FAILURE(status)) {
errln("ERROR: Could not create NumberFormat (default)");
}
status = U_ZERO_ERROR;
NumberFormat *fr = NumberFormat::createInstance(Locale::getFrench(), status);
if(U_FAILURE(status)) {
errln("ERROR: Could not create NumberFormat (French)");
}
NumberFormat *cur = NumberFormat::createCurrencyInstance(status);
if(U_FAILURE(status)) {
errln("ERROR: Could not create NumberFormat (currency, default)");
}
status = U_ZERO_ERROR;
NumberFormat *cur_fr = NumberFormat::createCurrencyInstance(Locale::getFrench(), status);
if(U_FAILURE(status)) {
errln("ERROR: Could not create NumberFormat (currency, French)");
}
NumberFormat *per = NumberFormat::createPercentInstance(status);
if(U_FAILURE(status)) {
errln("ERROR: Could not create NumberFormat (percent, default)");
}
status = U_ZERO_ERROR;
NumberFormat *per_fr = NumberFormat::createPercentInstance(Locale::getFrench(), status);
if(U_FAILURE(status)) {
errln("ERROR: Could not create NumberFormat (percent, French)");
}
// ======= Test equality
if (per_fr != NULL && cur_fr != NULL)
{
logln("Testing equality operator");
if( *per_fr == *cur_fr || ! ( *per_fr != *cur_fr) ) {
errln("ERROR: == failed");
}
}
// ======= Test various format() methods
if (cur_fr != NULL)
{
logln("Testing various format() methods");
double d = -10456.0037;
int32_t l = 100000000;
Formattable fD(d);
Formattable fL(l);
UnicodeString res1, res2, res3, res4, res5, res6;
FieldPosition pos1(0), pos2(0), pos3(0), pos4(0);
res1 = cur_fr->format(d, res1);
logln( (UnicodeString) "" + (int32_t) d + " formatted to " + res1);
res2 = cur_fr->format(l, res2);
logln((UnicodeString) "" + (int32_t) l + " formatted to " + res2);
res3 = cur_fr->format(d, res3, pos1);
logln( (UnicodeString) "" + (int32_t) d + " formatted to " + res3);
res4 = cur_fr->format(l, res4, pos2);
logln((UnicodeString) "" + (int32_t) l + " formatted to " + res4);
status = U_ZERO_ERROR;
res5 = cur_fr->format(fD, res5, pos3, status);
if(U_FAILURE(status)) {
errln("ERROR: format(Formattable [double]) failed");
}
logln((UnicodeString) "" + (int32_t) fD.getDouble() + " formatted to " + res5);
status = U_ZERO_ERROR;
res6 = cur_fr->format(fL, res6, pos4, status);
if(U_FAILURE(status)) {
errln("ERROR: format(Formattable [long]) failed");
}
logln((UnicodeString) "" + fL.getLong() + " formatted to " + res6);
}
// ======= Test parse()
if (fr != NULL)
{
logln("Testing parse()");
double d = -10456.0037;
UnicodeString text("-10,456.0037");
Formattable result1, result2, result3;
ParsePosition pos(0), pos01(0);
fr->parseObject(text, result1, pos);
if(result1.getType() != Formattable::kDouble && result1.getDouble() != d) {
errln("ERROR: Roundtrip failed (via parse()) for " + text);
}
logln(text + " parsed into " + (int32_t) result1.getDouble());
fr->parse(text, result2, pos01);
if(result2.getType() != Formattable::kDouble && result2.getDouble() != d) {
errln("ERROR: Roundtrip failed (via parse()) for " + text);
}
logln(text + " parsed into " + (int32_t) result2.getDouble());
status = U_ZERO_ERROR;
fr->parse(text, result3, status);
if(U_FAILURE(status)) {
errln("ERROR: parse() failed");
}
if(result3.getType() != Formattable::kDouble && result3.getDouble() != d) {
errln("ERROR: Roundtrip failed (via parse()) for " + text);
}
logln(text + " parsed into " + (int32_t) result3.getDouble());
}
// ======= Test getters and setters
if (fr != NULL && def != NULL)
{
logln("Testing getters and setters");
int32_t count = 0;
const Locale *locales = NumberFormat::getAvailableLocales(count);
logln((UnicodeString) "Got " + count + " locales" );
for(int32_t i = 0; i < count; i++) {
UnicodeString name(locales[i].getName(),"");
logln(name);
}
fr->setParseIntegerOnly( def->isParseIntegerOnly() );
if(fr->isParseIntegerOnly() != def->isParseIntegerOnly() ) {
errln("ERROR: setParseIntegerOnly() failed");
}
fr->setGroupingUsed( def->isGroupingUsed() );
if(fr->isGroupingUsed() != def->isGroupingUsed() ) {
errln("ERROR: setGroupingUsed() failed");
}
fr->setMaximumIntegerDigits( def->getMaximumIntegerDigits() );
if(fr->getMaximumIntegerDigits() != def->getMaximumIntegerDigits() ) {
errln("ERROR: setMaximumIntegerDigits() failed");
}
fr->setMinimumIntegerDigits( def->getMinimumIntegerDigits() );
if(fr->getMinimumIntegerDigits() != def->getMinimumIntegerDigits() ) {
errln("ERROR: setMinimumIntegerDigits() failed");
}
fr->setMaximumFractionDigits( def->getMaximumFractionDigits() );
if(fr->getMaximumFractionDigits() != def->getMaximumFractionDigits() ) {
errln("ERROR: setMaximumFractionDigits() failed");
}
fr->setMinimumFractionDigits( def->getMinimumFractionDigits() );
if(fr->getMinimumFractionDigits() != def->getMinimumFractionDigits() ) {
errln("ERROR: setMinimumFractionDigits() failed");
}
}
// ======= Test getStaticClassID()
logln("Testing getStaticClassID()");
status = U_ZERO_ERROR;
NumberFormat *test = new DecimalFormat(status);
if(U_FAILURE(status)) {
errln("ERROR: Couldn't create a NumberFormat");
}
if(test->getDynamicClassID() != DecimalFormat::getStaticClassID()) {
errln("ERROR: getDynamicClassID() didn't return the expected value");
}
delete test;
delete def;
delete fr;
delete cur;
delete cur_fr;
delete per;
delete per_fr;
}
/**
* This test checks various generic API methods in DecimalFormat to achieve 100%
* API coverage.
*/
void IntlTestDecimalFormatAPI::testAPI(/*char *par*/)
{
UErrorCode status = U_ZERO_ERROR;
// ======= Test constructors
logln((UnicodeString)"Testing DecimalFormat constructors");
DecimalFormat def(status);
if(U_FAILURE(status)) {
errcheckln(status, "ERROR: Could not create DecimalFormat (default) - %s", u_errorName(status));
return;
}
// bug 10864
status = U_ZERO_ERROR;
DecimalFormat noGrouping("###0.##", status);
if (noGrouping.getGroupingSize() != 0) {
errln("Grouping size should be 0 for no grouping.");
}
// end bug 10864
status = U_ZERO_ERROR;
const UnicodeString pattern("#,##0.# FF");
DecimalFormat pat(pattern, status);
if(U_FAILURE(status)) {
errln((UnicodeString)"ERROR: Could not create DecimalFormat (pattern)");
return;
}
status = U_ZERO_ERROR;
DecimalFormatSymbols *symbols = new DecimalFormatSymbols(Locale::getFrench(), status);
if(U_FAILURE(status)) {
errln((UnicodeString)"ERROR: Could not create DecimalFormatSymbols (French)");
return;
}
status = U_ZERO_ERROR;
DecimalFormat cust1(pattern, symbols, status);
if(U_FAILURE(status)) {
errln((UnicodeString)"ERROR: Could not create DecimalFormat (pattern, symbols*)");
}
status = U_ZERO_ERROR;
DecimalFormat cust2(pattern, *symbols, status);
if(U_FAILURE(status)) {
errln((UnicodeString)"ERROR: Could not create DecimalFormat (pattern, symbols)");
}
DecimalFormat copy(pat);
// ======= Test clone(), assignment, and equality
logln((UnicodeString)"Testing clone(), assignment and equality operators");
if( ! (copy == pat) || copy != pat) {
errln((UnicodeString)"ERROR: Copy constructor or == failed");
}
copy = cust1;
if(copy != cust1) {
errln((UnicodeString)"ERROR: Assignment (or !=) failed");
}
Format *clone = def.clone();
if( ! (*clone == def) ) {
errln((UnicodeString)"ERROR: Clone() failed");
}
delete clone;
// ======= Test various format() methods
logln((UnicodeString)"Testing various format() methods");
double d = -10456.0037;
int32_t l = 100000000;
Formattable fD(d);
Formattable fL(l);
UnicodeString res1, res2, res3, res4;
FieldPosition pos1(0), pos2(0), pos3(0), pos4(0);
res1 = def.format(d, res1, pos1);
logln( (UnicodeString) "" + (int32_t) d + " formatted to " + res1);
res2 = pat.format(l, res2, pos2);
logln((UnicodeString) "" + (int32_t) l + " formatted to " + res2);
status = U_ZERO_ERROR;
res3 = cust1.format(fD, res3, pos3, status);
if(U_FAILURE(status)) {
errln((UnicodeString)"ERROR: format(Formattable [double]) failed");
}
logln((UnicodeString) "" + (int32_t) fD.getDouble() + " formatted to " + res3);
status = U_ZERO_ERROR;
res4 = cust2.format(fL, res4, pos4, status);
if(U_FAILURE(status)) {
errln((UnicodeString)"ERROR: format(Formattable [long]) failed");
}
logln((UnicodeString) "" + fL.getLong() + " formatted to " + res4);
// ======= Test parse()
logln((UnicodeString)"Testing parse()");
UnicodeString text("-10,456.0037");
Formattable result1, result2;
ParsePosition pos(0);
UnicodeString patt("#,##0.#");
status = U_ZERO_ERROR;
pat.applyPattern(patt, status);
if(U_FAILURE(status)) {
errln((UnicodeString)"ERROR: applyPattern() failed");
}
pat.parse(text, result1, pos);
if(result1.getType() != Formattable::kDouble && result1.getDouble() != d) {
errln((UnicodeString)"ERROR: Roundtrip failed (via parse()) for " + text);
}
logln(text + " parsed into " + (int32_t) result1.getDouble());
status = U_ZERO_ERROR;
pat.parse(text, result2, status);
if(U_FAILURE(status)) {
errln((UnicodeString)"ERROR: parse() failed");
}
if(result2.getType() != Formattable::kDouble && result2.getDouble() != d) {
errln((UnicodeString)"ERROR: Roundtrip failed (via parse()) for " + text);
}
logln(text + " parsed into " + (int32_t) result2.getDouble());
// ======= Test getters and setters
logln((UnicodeString)"Testing getters and setters");
const DecimalFormatSymbols *syms = pat.getDecimalFormatSymbols();
DecimalFormatSymbols *newSyms = new DecimalFormatSymbols(*syms);
def.setDecimalFormatSymbols(*newSyms);
def.adoptDecimalFormatSymbols(newSyms); // don't use newSyms after this
if( *(pat.getDecimalFormatSymbols()) != *(def.getDecimalFormatSymbols())) {
errln((UnicodeString)"ERROR: adopt or set DecimalFormatSymbols() failed");
}
UnicodeString posPrefix;
pat.setPositivePrefix("+");
posPrefix = pat.getPositivePrefix(posPrefix);
logln((UnicodeString)"Positive prefix (should be +): " + posPrefix);
if(posPrefix != "+") {
errln((UnicodeString)"ERROR: setPositivePrefix() failed");
}
UnicodeString negPrefix;
pat.setNegativePrefix("-");
negPrefix = pat.getNegativePrefix(negPrefix);
logln((UnicodeString)"Negative prefix (should be -): " + negPrefix);
if(negPrefix != "-") {
errln((UnicodeString)"ERROR: setNegativePrefix() failed");
}
UnicodeString posSuffix;
pat.setPositiveSuffix("_");
posSuffix = pat.getPositiveSuffix(posSuffix);
logln((UnicodeString)"Positive suffix (should be _): " + posSuffix);
if(posSuffix != "_") {
errln((UnicodeString)"ERROR: setPositiveSuffix() failed");
}
UnicodeString negSuffix;
pat.setNegativeSuffix("~");
negSuffix = pat.getNegativeSuffix(negSuffix);
logln((UnicodeString)"Negative suffix (should be ~): " + negSuffix);
if(negSuffix != "~") {
errln((UnicodeString)"ERROR: setNegativeSuffix() failed");
}
int32_t multiplier = 0;
pat.setMultiplier(8);
multiplier = pat.getMultiplier();
logln((UnicodeString)"Multiplier (should be 8): " + multiplier);
if(multiplier != 8) {
errln((UnicodeString)"ERROR: setMultiplier() failed");
}
int32_t groupingSize = 0;
pat.setGroupingSize(2);
groupingSize = pat.getGroupingSize();
logln((UnicodeString)"Grouping size (should be 2): " + (int32_t) groupingSize);
if(groupingSize != 2) {
errln((UnicodeString)"ERROR: setGroupingSize() failed");
}
pat.setDecimalSeparatorAlwaysShown(TRUE);
UBool tf = pat.isDecimalSeparatorAlwaysShown();
logln((UnicodeString)"DecimalSeparatorIsAlwaysShown (should be TRUE) is " + (UnicodeString) (tf ? "TRUE" : "FALSE"));
if(tf != TRUE) {
errln((UnicodeString)"ERROR: setDecimalSeparatorAlwaysShown() failed");
}
// Added by Ken Liu testing set/isExponentSignAlwaysShown
pat.setExponentSignAlwaysShown(TRUE);
UBool esas = pat.isExponentSignAlwaysShown();
logln((UnicodeString)"ExponentSignAlwaysShown (should be TRUE) is " + (UnicodeString) (esas ? "TRUE" : "FALSE"));
if(esas != TRUE) {
errln((UnicodeString)"ERROR: ExponentSignAlwaysShown() failed");
}
// Added by Ken Liu testing set/isScientificNotation
pat.setScientificNotation(TRUE);
UBool sn = pat.isScientificNotation();
logln((UnicodeString)"isScientificNotation (should be TRUE) is " + (UnicodeString) (sn ? "TRUE" : "FALSE"));
if(sn != TRUE) {
errln((UnicodeString)"ERROR: setScientificNotation() failed");
}
// Added by Ken Liu testing set/getMinimumExponentDigits
int8_t MinimumExponentDigits = 0;
pat.setMinimumExponentDigits(2);
MinimumExponentDigits = pat.getMinimumExponentDigits();
logln((UnicodeString)"MinimumExponentDigits (should be 2) is " + (int8_t) MinimumExponentDigits);
if(MinimumExponentDigits != 2) {
errln((UnicodeString)"ERROR: setMinimumExponentDigits() failed");
}
// Added by Ken Liu testing set/getRoundingIncrement
double RoundingIncrement = 0.0;
pat.setRoundingIncrement(2.0);
RoundingIncrement = pat.getRoundingIncrement();
logln((UnicodeString)"RoundingIncrement (should be 2.0) is " + (double) RoundingIncrement);
if(RoundingIncrement != 2.0) {
errln((UnicodeString)"ERROR: setRoundingIncrement() failed");
}
//end of Ken's Adding
UnicodeString funkyPat;
funkyPat = pat.toPattern(funkyPat);
logln((UnicodeString)"Pattern is " + funkyPat);
UnicodeString locPat;
locPat = pat.toLocalizedPattern(locPat);
logln((UnicodeString)"Localized pattern is " + locPat);
// ======= Test applyPattern()
logln((UnicodeString)"Testing applyPattern()");
UnicodeString p1("#,##0.0#;(#,##0.0#)");
logln((UnicodeString)"Applying pattern " + p1);
status = U_ZERO_ERROR;
pat.applyPattern(p1, status);
if(U_FAILURE(status)) {
errln((UnicodeString)"ERROR: applyPattern() failed with " + (int32_t) status);
}
UnicodeString s2;
s2 = pat.toPattern(s2);
logln((UnicodeString)"Extracted pattern is " + s2);
if(s2 != p1) {
errln((UnicodeString)"ERROR: toPattern() result did not match pattern applied");
}
if(pat.getSecondaryGroupingSize() != 0) {
errln("FAIL: Secondary Grouping Size should be 0, not %d\n", pat.getSecondaryGroupingSize());
}
if(pat.getGroupingSize() != 3) {
errln("FAIL: Primary Grouping Size should be 3, not %d\n", pat.getGroupingSize());
}
UnicodeString p2("#,##,##0.0# FF;(#,##,##0.0# FF)");
logln((UnicodeString)"Applying pattern " + p2);
status = U_ZERO_ERROR;
pat.applyLocalizedPattern(p2, status);
if(U_FAILURE(status)) {
errln((UnicodeString)"ERROR: applyPattern() failed with " + (int32_t) status);
}
UnicodeString s3;
s3 = pat.toLocalizedPattern(s3);
logln((UnicodeString)"Extracted pattern is " + s3);
if(s3 != p2) {
errln((UnicodeString)"ERROR: toLocalizedPattern() result did not match pattern applied");
}
status = U_ZERO_ERROR;
UParseError pe;
pat.applyLocalizedPattern(p2, pe, status);
if(U_FAILURE(status)) {
errln((UnicodeString)"ERROR: applyPattern((with ParseError)) failed with " + (int32_t) status);
}
UnicodeString s4;
s4 = pat.toLocalizedPattern(s3);
logln((UnicodeString)"Extracted pattern is " + s4);
if(s4 != p2) {
errln((UnicodeString)"ERROR: toLocalizedPattern(with ParseErr) result did not match pattern applied");
}
if(pat.getSecondaryGroupingSize() != 2) {
errln("FAIL: Secondary Grouping Size should be 2, not %d\n", pat.getSecondaryGroupingSize());
}
if(pat.getGroupingSize() != 3) {
errln("FAIL: Primary Grouping Size should be 3, not %d\n", pat.getGroupingSize());
}
// ======= Test getStaticClassID()
logln((UnicodeString)"Testing getStaticClassID()");
status = U_ZERO_ERROR;
NumberFormat *test = new DecimalFormat(status);
if(U_FAILURE(status)) {
errln((UnicodeString)"ERROR: Couldn't create a DecimalFormat");
}
if(test->getDynamicClassID() != DecimalFormat::getStaticClassID()) {
errln((UnicodeString)"ERROR: getDynamicClassID() didn't return the expected value");
}
delete test;
}
//---------------------------------------------------------
void EulerShock2D::precalc_limiter_data()
//---------------------------------------------------------
{
//---------------------------------------------
// pre-calculate element geometry and constant
// factors for use in this->EulerLimiter2D()
//---------------------------------------------
Lim_AVE = 0.5 * MassMatrix.col_sums();
DMat dropAVE = eye(Np) - outer(ones(Np),Lim_AVE);
Lim_dx = dropAVE*x;
Lim_dy = dropAVE*y;
// Extract coordinates of vertices of elements
IVec v1=EToV(All,1); Lim_xv1=VX(v1); Lim_yv1=VY(v1);
IVec v2=EToV(All,2); Lim_xv2=VX(v2); Lim_yv2=VY(v2);
IVec v3=EToV(All,3); Lim_xv3=VX(v3); Lim_yv3=VY(v3);
const DVec &xv1=Lim_xv1,&xv2=Lim_xv2,&xv3=Lim_xv3;
const DVec &yv1=Lim_yv1,&yv2=Lim_yv2,&yv3=Lim_yv3;
DMat &fnx=Lim_fnx, &fny=Lim_fny, &fL=Lim_fL;
// Compute face unit normals and lengths
fnx.resize(3,K); fny.resize(3,K);
// fnx = (3,K) = [yv2-yv1; yv3-yv2; yv1-yv3];
fnx.set_row(1, yv2-yv1); fnx.set_row(2, yv3-yv2); fnx.set_row(3, yv1-yv3);
// fny = (3,K) = -[xv2-xv1;xv3-xv2;xv1-xv3];
//fny.set_row(1, xv2-xv1); fny.set_row(2, xv3-xv2); fny.set_row(3, xv1-xv3);
fny.set_row(1, xv1-xv2); fny.set_row(2, xv2-xv3); fny.set_row(3, xv3-xv1);
fL = sqrt(sqr(fnx)+sqr(fny)); fnx.div_element(fL); fny.div_element(fL);
//-------------------------------------------------------
// Compute coords of element centers and face weights
//-------------------------------------------------------
// Find neighbors in patch
Lim_E1=EToE(All,1); Lim_E2=EToE(All,2); Lim_E3=EToE(All,3);
// Compute coordinates of element centers
xc0=Lim_AVE*x; xc1=xc0(Lim_E1); xc2=xc0(Lim_E2); xc3=xc0(Lim_E3);
yc0=Lim_AVE*y; yc1=yc0(Lim_E1); yc2=yc0(Lim_E2); yc3=yc0(Lim_E3);
// Compute weights for face gradients
A0=Lim_AVE*J*TWOTHIRD;
A1=A0+A0(Lim_E1); A2=A0+A0(Lim_E2); A3=A0+A0(Lim_E3);
A1_A2_A3 = A1+A2+A3;
// Find boundary faces for each face
Lim_id1=find(BCType.get_col(1),'!',0);
Lim_id2=find(BCType.get_col(2),'!',0);
Lim_id3=find(BCType.get_col(3),'!',0);
// Compute location of centers of reflected ghost elements at boundary faces
if (1) {
DMat FL1=fL(1,Lim_id1), Fnx1=fnx(1,Lim_id1), Fny1=fny(1,Lim_id1);
DVec fL1=FL1, fnx1=Fnx1, fny1=Fny1;
DVec H1 = 2.0*(dd(A0(Lim_id1),fL1));
xc1(Lim_id1) += 2.0*fnx1.dm(H1);
yc1(Lim_id1) += 2.0*fny1.dm(H1);
DMat FL2=fL(2,Lim_id2), Fnx2=fnx(2,Lim_id2), Fny2=fny(2,Lim_id2);
DVec fL2=FL2, fnx2=Fnx2, fny2=Fny2;
DVec H2 = 2.0*(dd(A0(Lim_id2),fL2));
xc2(Lim_id2) += 2.0*fnx2.dm(H2);
yc2(Lim_id2) += 2.0*fny2.dm(H2);
DMat FL3=fL(3,Lim_id3), Fnx3=fnx(3,Lim_id3), Fny3=fny(3,Lim_id3);
DVec fL3=FL3, fnx3=Fnx3, fny3=Fny3;
DVec H3 = 2.0*(dd(A0(Lim_id3),fL3));
xc3(Lim_id3) += 2.0*fnx3.dm(H3);
yc3(Lim_id3) += 2.0*fny3.dm(H3);
}
// Find boundary faces
IVec bct = trans(BCType);
Lim_idI = find(bct, '=', (int)BC_In);
Lim_idO = find(bct, '=', (int)BC_Out);
Lim_idW = find(bct, '=', (int)BC_Wall);
Lim_idC = find(bct, '=', (int)BC_Cyl);
Lim_ctx.resize(3,K); Lim_cty.resize(3,K);
Lim_ctx.set_row(1,xc1); Lim_ctx.set_row(2,xc2); Lim_ctx.set_row(3,xc3);
Lim_cty.set_row(1,yc1); Lim_cty.set_row(2,yc2); Lim_cty.set_row(3,yc3);
// load the set of ids
Lim_ids.resize(6);
Lim_ids(1)=1; Lim_ids(2)=Nfp; Lim_ids(3)=Nfp+1;
Lim_ids(4)=2*Nfp; Lim_ids(5)=3*Nfp; Lim_ids(6)=2*Nfp+1;
limQ = Q;
}
