Edge little(Edge l, int i)
{
if (edge_isempty(l) == 4)
return l;
else{
if ((l->weight < i) && (l->weight != 0))
return edge_cons(l->weight, l->targetp, little(l->next, i));
else
return little(l->next, i);
}
}
int main(void)
{
double min=0.0, lower=0.0;
freopen("cowtour.in", "r", stdin);
freopen("cowtour.out", "w", stdout);
scanf("%d", &lim);
for(int i=0; i<lim; i++)
scanf("%d%d\n", &pos[i].x, &pos[i].y);
for(int i=0; i<lim; i++){
char c;
for(int j=0; j<lim; j++){
scanf("%c", &c);
if(c == '1'){
int tx=pos[i].x-pos[j].x;
int ty=pos[i].y-pos[j].y;
dis[i][j] = dis[j][i] = sqrt(tx*tx+ty*ty);
}else
dis[i][j] = dis[j][i] = 0.0;
}
scanf("%c", &c);
}
floyd();
for(int i=0; i<lim; i++){
max[i] = dis[i][0];
for(int j=1; j<lim; j++){
if(i!=j && great(dis[i][j], max[i]))
max[i] = dis[i][j];
}
if(equal(lower, 0.0) || great(max[i], lower))
lower = max[i];
}
for(int i=0; i<lim; i++){
for(int j=i+1; j<lim; j++){
if(equal(dis[i][j], 0.0)){
int tx=pos[i].x-pos[j].x;
int ty=pos[i].y-pos[j].y;
double d=sqrt(tx*tx+ty*ty)+max[i]+max[j];
if(equal(min, 0.0) || little(d, min))
min = d;
}
}
}
if(little(min, lower))
min = lower;
printf("%.6lf\n", min);
return 0;
}
static int
readjolietdesc(Cdimg *cd, Voldesc *v)
{
int i;
static uchar magic[] = { 0x02, 'C', 'D', '0', '0', '1', 0x01, 0x00 };
Cvoldesc cv;
memset(v, 0, sizeof *v);
for(i=16; i<24; i++) {
Creadblock(cd, &cv, i, sizeof cv);
if(memcmp(cv.magic, magic, sizeof magic) != 0)
continue;
if(cv.charset[0] != 0x25 || cv.charset[1] != 0x2F
|| (cv.charset[2] != 0x40 && cv.charset[2] != 0x43 && cv.charset[2] != 0x45))
continue;
break;
}
if(i==24) {
werrstr("could not find Joliet SVD");
return -1;
}
if(little(cv.blocksize, 2) != Blocksize) {
werrstr("block size not %d", Blocksize);
return -1;
}
cd->jolietsvd = i;
parsedesc(v, &cv, jolietstring);
return parsedir(cd, &v->root, cv.rootdir, sizeof cv.rootdir, jolietstring);
}
static void
parsedesc(Voldesc *v, Cvoldesc *cv, char *(*string)(uchar*, int))
{
v->systemid = string(cv->systemid, sizeof cv->systemid);
v->pathsize = little(cv->pathsize, 4);
v->lpathloc = little(cv->lpathloc, 4);
v->mpathloc = little(cv->mpathloc, 4);
v->volumeset = string(cv->volumeset, sizeof cv->volumeset);
v->publisher = string(cv->publisher, sizeof cv->publisher);
v->preparer = string(cv->preparer, sizeof cv->preparer);
v->application = string(cv->application, sizeof cv->application);
v->abstract = string(cv->abstract, sizeof cv->abstract);
v->biblio = string(cv->biblio, sizeof cv->biblio);
v->notice = string(cv->notice, sizeof cv->notice);
}
void floyd(void)
{
int i, j, k;
for(k=0; k<lim; k++){
for(i=0; i<lim; i++){
for(j=0; j<lim; j++){
if(!equal(dis[i][k], 0.0) && !equal(dis[k][j], 0.0) && (little(dis[i][k]+dis[k][j], dis[i][j]) || equal(dis[i][j], 0.0)))
dis[i][j] = dis[i][k]+dis[k][j];
}
}
}
}
Edge sort(Edge l)
{
if (edge_isempty(l) == 4)
return l;
else {if (edge_isempty(l->next) == 4)
return l;
else
{ Edge a = little(l, l->weight);
if (edge_isempty(a) == 4)
return edge_cons(l->weight, l->targetp, sort(l->next));
else{
Edge b = big(l, l->weight);
edge_free(l);
Edge c = append(sort(a), sort(b));
edge_free(a);
return c;
}
}
}
}
/**
* In heuristicLoop(), we only use double or dpe_t or mpfr_t.
*/
int Wrapper::heuristicLoop(int precision) {
int kappa;
if (precision > numeric_limits<double>::digits)
kappa = heuristicLLL<mpz_t, mpfr_t>(b, u, uInv, precision, delta, eta);
else {
#ifdef FPLLL_WITH_DPE
kappa = heuristicLLL<mpz_t, dpe_t>(b, u, uInv, 0, delta, eta);
#else
kappa = heuristicLLL<mpz_t, mpfr_t>(b, u, uInv, precision, delta, eta);
#endif
}
if (kappa == 0)
return 0; // Success
else if (precision < goodPrec && !little(kappa, precision))
return heuristicLoop(increasePrec(precision));
else
return provedLoop(precision);
}
void DealHelp::UpdateDisplay()
{
SDL_FillRect(m_pScreen, NULL, SDL_MapRGB(m_pScreen->format, 153, 153, 255));
nSDL_DrawString(m_pScreen, m_pFont, 15, 20,
"Deal or No Deal is a game.\n\
There are 26 cases each containing\n\
money from a lot ($1,000,000) to\n\
very little ($0.01).\n\
\n\
You want the high value case; however\n\
the banker wants you to take a deal\n\
for the lesser value.\n\
\n\
Your object is to get the highest\n\
amount you can!\n\
\n\
Good luck!\n\
\n\
Also have fun!");
SDL_UpdateRect(m_pScreen, 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT);
}
static int
readisodesc(Cdimg *cd, Voldesc *v)
{
static uchar magic[] = { 0x01, 'C', 'D', '0', '0', '1', 0x01, 0x00 };
Cvoldesc cv;
memset(v, 0, sizeof *v);
Creadblock(cd, &cv, 16, sizeof cv);
if(memcmp(cv.magic, magic, sizeof magic) != 0) {
werrstr("bad pvd magic");
return -1;
}
if(little(cv.blocksize, 2) != Blocksize) {
werrstr("block size not %d", Blocksize);
return -1;
}
cd->iso9660pvd = 16;
parsedesc(v, &cv, isostring);
return parsedir(cd, &v->root, cv.rootdir, sizeof cv.rootdir, isostring);
}
void MainWindow::createActions() /*菜单选项*/
{
/*文件菜单*/
openAction = new QAction(tr("打开"),this);
openAction->setStatusTip(tr("打开新文件"));
connect(openAction,SIGNAL(triggered()),this,SLOT(openFile()));
importAction = new QAction(tr("导入"),this);
importAction->setStatusTip(tr("导入数据"));
connect(importAction,SIGNAL(triggered()),this,SLOT(importFile()));
importAction->setDisabled(true);
sortAction = new QAction(tr("分类数据"),this);
sortAction->setStatusTip(tr("处理分类数据"));
connect(sortAction,SIGNAL(triggered()),this,SLOT(sortFile()));
sortAction->setDisabled(true);
exitAction = new QAction(tr("退出"),this);
exitAction->setStatusTip(tr("退出程序"));
connect(exitAction,SIGNAL(triggered()),this,SLOT(close()));
/*导入菜单*/
ebdicAction = new QAction(tr("显示EBDIC码"),this);
ebdicAction->setStatusTip(tr("显示EBDIC码"));
connect(ebdicAction,SIGNAL(triggered()),this,SLOT(loadEBDIC()));
ebdicAction->setDisabled(true);
reelAction = new QAction(tr("显示卷头"),this);
reelAction->setStatusTip(tr("显示卷头信息"));
connect(reelAction,SIGNAL(triggered()),this,SLOT(loadReel()));
reelAction->setDisabled(true);
traceAction = new QAction(tr("显示道头"),this);
traceAction->setStatusTip(tr("显示选定位置道头信息"));
connect(traceAction,SIGNAL(triggered()),this,SLOT(loadTrace()));
traceAction->setDisabled(true);
dataAction = new QAction(tr("地震数据"),this);
dataAction->setStatusTip(tr("显示选定位置的地震记录"));
connect(dataAction,SIGNAL(triggered()),this,SLOT(loadData()));
dataAction->setDisabled(true);
/*画图菜单*/
waveAction = new QAction(tr("波形显示"),this);
waveAction->setStatusTip(tr("波形显示剖面"));
connect(waveAction,SIGNAL(triggered()),this,SLOT(drawWave()));
waveAction->setDisabled(true);
grayAction = new QAction(tr("灰度显示"),this);
grayAction->setStatusTip(tr("显示灰度图像"));
connect(grayAction,SIGNAL(triggered()),this,SLOT(drawGray()));
grayAction->setDisabled(true);
colorAction = new QAction(tr("彩色显示"),this);
colorAction->setStatusTip(tr("显示彩色图像"));
connect(colorAction,SIGNAL(triggered()),this,SLOT(drawColor()));
colorAction->setDisabled(true);
//操作openGL图像
bigAction = new QAction(tr("放大"),this);
bigAction->setStatusTip(tr("放大图像"));
connect(bigAction,SIGNAL(triggered()),this,SLOT(bigger()));
bigAction->setDisabled(true);
littleAction = new QAction(tr("缩小"),this);
littleAction->setStatusTip(tr("缩小图像"));
connect(littleAction,SIGNAL(triggered()),this,SLOT(little()));
littleAction->setDisabled(true);
moveleftAction = new QAction(tr("左移"),this);
moveleftAction->setStatusTip(tr("左移图像"));
connect(moveleftAction,SIGNAL(triggered()),this,SLOT(moveleft()));
moveleftAction->setDisabled(true);
moverightAction = new QAction(tr("右移"),this);
moverightAction->setStatusTip(tr("图像右移"));
connect(moverightAction,SIGNAL(triggered()),this,SLOT(moveright()));
moverightAction->setDisabled(true);
moveupAction = new QAction(tr("上移"),this);
moveupAction->setStatusTip(tr("上移图像"));
connect(moveupAction,SIGNAL(triggered()),this,SLOT(moveup()));
moveupAction->setDisabled(true);
movedownAction = new QAction(tr("下移"),this);
movedownAction->setStatusTip(tr("下移图像"));
connect(movedownAction,SIGNAL(triggered()),this,SLOT(movedown()));
movedownAction->setDisabled(true);
moveMouseAction = new QAction(tr("移动"),this);
moveMouseAction->setStatusTip(tr("使用鼠标移动图像"));
connect(moveMouseAction,SIGNAL(triggered()),this,SLOT(moveMouse()));
moveMouseAction->setDisabled(true);
rotateMouseAction = new QAction(tr("旋转"),this);
rotateMouseAction->setStatusTip(tr("旋转图像"));
connect(rotateMouseAction,SIGNAL(triggered()),this,SLOT(rotateMouse()));
rotateMouseAction->setDisabled(true);
nextSliceAction = new QAction(tr("下一条剖面"),this);
nextSliceAction->setStatusTip(tr("选择下一条剖面"));
connect(nextSliceAction,SIGNAL(triggered()),this,SLOT(nextSlice()));
nextSliceAction->setDisabled(true);
preSliceAction = new QAction(tr("上一条剖面"),this);
preSliceAction->setStatusTip(tr("选择上一条剖面"));
connect(preSliceAction,SIGNAL(triggered()),this,SLOT(preSlice()));
preSliceAction->setDisabled(true);
drawGridAction = new QAction(tr("关闭网格"),this);
drawGridAction->setStatusTip(tr("打开/关闭剖面图像上的网格"));
connect(drawGridAction,SIGNAL(triggered()),this,SLOT(drawGrid()));
drawGridAction->setDisabled(true);
}
void operator()() const
{
//-------------------------------------------------------
// Data generation : get 4 nearly coplanar points
//-------------------------------------------------------
Point_creator creator;
FT little(1e-10);
FT tiny(1e-25);
Point p1 = creator(little,1,tiny);
Point p2 = creator(1,little,0);
Point p3 = creator(-1*little,1,0);
Point p4 = creator(1,-1*little,0);
Point p5 = creator(0,0,1);
Point p6 = creator(0,1,0);
std::cerr << "Using points: p1[" << p1 << "]\tp2[" << p2
<< "]\tp3[" << p3 << "]\tp4[" << p4 << "]\tp5[" << p5
<< "]\tp6[" << p6 << "]\n";
//-------------------------------------------------------
// Test correctness
//-------------------------------------------------------
typename Gt::Construct_weighted_circumcenter_3 circumcenter =
Gt().construct_weighted_circumcenter_3_object();
Point center = circumcenter(p1,p2);
std::cerr << "\tcircumcenter(p1,p2)=[" << center << "]\n";
center = circumcenter(p1,p3,p6);
std::cerr << "\tcircumcenter(p1,p3,p6)=[" << center << "]\n";
center = circumcenter(p1,p2,p5);
std::cerr << "\tcircumcenter(p1,p3,p5)=[" << center << "]\n";
// Use positive orientation
center = circumcenter(p2,p3,p4,p1);
std::cerr << "\tcircumcenter(p2,p3,p4,p1)=[" << center << "]\n";
center = circumcenter(p1,p3,p2,p5);
std::cerr << "\tcircumcenter(p1,p3,p2,p5)=[" << center << "]\n";
//-------------------------------------------------------
// Test speed
//-------------------------------------------------------
std::cerr << "Test speed: compute loops of: 999*c(p1,p3,p2,p5) "
<< "and 1*c(p2,p3,p4,p1)\n";
CGAL::Timer timer;
timer.start();
int nb_loop = 0;
while ( timer.time() < 0.5 )
{
// Compute 1000 fast queries
for ( int i = 0 ; i < 999 ; ++i)
circumcenter(p1,p3,p2,p5);
// Compute 1 exact query
circumcenter(p2,p3,p4,p1);
++nb_loop;
}
timer.stop();
std::cerr << "\t" << nb_loop*1000/timer.time()
<< " circumcenter computation / second\n";
std::cerr << "Test speed: compute loops of: 999*c(p2,p3,p4,p1) "
<< "and 1*c(p1,p3,p2,p5)\n";
timer.reset();
timer.start();
nb_loop = 0;
while ( timer.time() < 0.5 )
{
// Compute 1 exact queries
for ( int i = 0 ; i < 999 ; ++i)
circumcenter(p2,p3,p4,p1);
// Compute 1 fast query
circumcenter(p1,p3,p2,p5);
++nb_loop;
}
timer.stop();
std::cerr << "\t" << nb_loop*1000/timer.time()
<< " circumcenter computation / second\n";
}
int
parsedir(Cdimg *cd, Direc *d, uchar *buf, int len, char *(*cvtname)(uchar*, int))
{
enum { NAMELEN = 28 };
char name[NAMELEN];
uchar *p;
Cdir *c;
memset(d, 0, sizeof *d);
c = (Cdir*)buf;
if(c->len > len) {
werrstr("buffer too small");
return -1;
}
if(c->namelen == 1 && c->name[0] == '\0')
d->name = atom(".");
else if(c->namelen == 1 && c->name[0] == '\001')
d->name = atom("..");
else if(cvtname)
d->name = cvtname(c->name, c->namelen);
d->block = little(c->dloc, 4);
d->length = little(c->dlen, 4);
if(c->flags & 2)
d->mode |= DMDIR;
/*BUG: do we really need to parse the plan 9 fields? */
/* plan 9 use fields */
if((cd->flags & CDplan9) && cvtname == isostring
&& (c->namelen != 1 || c->name[0] > 1)) {
p = buf+33+c->namelen;
if((p-buf)&1)
p++;
assert(p < buf+c->len);
assert(*p < NAMELEN);
if(*p != 0) {
memmove(name, p+1, *p);
name[*p] = '\0';
d->confname = d->name;
d->name = atom(name);
}
p += *p+1;
assert(*p < NAMELEN);
memmove(name, p+1, *p);
name[*p] = '\0';
d->uid = atom(name);
p += *p+1;
assert(*p < NAMELEN);
memmove(name, p+1, *p);
name[*p] = '\0';
d->gid = atom(name);
p += *p+1;
if((p-buf)&1)
p++;
d->mode = little(p, 4);
}
/* BUG: rock ridge extensions */
return 0;
}
int test(char** argv)
{
verbose = getenv("PEGASUS_TEST_VERBOSE") ? true : false;
String s1 = "Hello World";
String s2 = s1;
String s3(s2);
PEGASUS_TEST_ASSERT(String::equal(s1, s3));
// Test append characters to String
String s4 = "Hello";
s4.append(Char16(0x0000));
s4.append(Char16(0x1234));
s4.append(Char16(0x5678));
s4.append(Char16(0x9cde));
s4.append(Char16(0xffff));
{
#ifdef HAVE_SSTREAM
stringstream os;
#endif
#ifdef HAVE_STRSTREAM
ostrstream os;
#endif
os << s4;
#ifdef HAVE_STRSTREAM
os.put('\0');
#endif
#ifndef PEGASUS_HAS_ICU
const char EXPECTED[] = "Hello\\x0000\\x1234\\x5678\\x9CDE\\xFFFF";
#else
CString cstr = s4.getCString();
const char * EXPECTED = (const char *)cstr;
#endif
#ifdef HAVE_SSTREAM
string os_str = os.str();
const char* tmp = os_str.c_str();
#endif
#ifdef HAVE_STRSTREAM
char *tmp = os.str();
#endif
PEGASUS_TEST_ASSERT(strcmp(EXPECTED, tmp) == 0);
#ifdef PEGASUS_PLATFORM_AIX_RS_IBMCXX
os.freeze(false);
#else
#ifdef HAVE_STRSTREAM
delete tmp;
#endif
#endif
}
{
// Test getCString
const char STR0[] = "one two three four";
String s = STR0;
PEGASUS_TEST_ASSERT(strcmp(s.getCString(), STR0) == 0);
}
{
// Test remove
String s = "abcdefg";
s.remove(3, 3);
PEGASUS_TEST_ASSERT(String::equal(s, "abcg"));
PEGASUS_TEST_ASSERT(s.size() == 4);
s = "abcdefg";
s.remove(3, 4);
PEGASUS_TEST_ASSERT(String::equal(s, "abc"));
PEGASUS_TEST_ASSERT(s.size() == 3);
s = "abcdefg";
s.remove(3);
PEGASUS_TEST_ASSERT(String::equal(s, "abc"));
PEGASUS_TEST_ASSERT(s.size() == 3);
s = "abc";
s.remove(3);
PEGASUS_TEST_ASSERT(String::equal(s, "abc"));
PEGASUS_TEST_ASSERT(s.size() == 3);
s = "abc";
s.remove(0);
PEGASUS_TEST_ASSERT(String::equal(s, ""));
PEGASUS_TEST_ASSERT(s.size() == 0);
s = "abc";
s.remove(0, 1);
PEGASUS_TEST_ASSERT(String::equal(s, "bc"));
PEGASUS_TEST_ASSERT(s.size() == 2);
String t1 = "HELLO";
String t2 = t1;
t2.toLower();
PEGASUS_TEST_ASSERT(String::equal(t1, "HELLO"));
PEGASUS_TEST_ASSERT(String::equal(t2, "hello"));
}
{
// another test of the append method
String t1 = "one";
t1.append(" two");
PEGASUS_TEST_ASSERT(String::equal(t1, "one two"));
t1.append(' ');
t1.append('t');
t1.append('h');
t1.append('r');
t1.append("ee");
PEGASUS_TEST_ASSERT(String::equal(t1,"one two three"));
// used as example in Doc.
String test = "abc";
test.append("def");
PEGASUS_TEST_ASSERT(test == "abcdef");
}
// Test of the different overload operators
{
// Test the == overload operator
String t1 = "one";
String t2 = "one";
PEGASUS_TEST_ASSERT(t1 == "one");
PEGASUS_TEST_ASSERT("one" == t1);
PEGASUS_TEST_ASSERT(t1 == t2);
PEGASUS_TEST_ASSERT(t2 == t1);
PEGASUS_TEST_ASSERT(String("one") == "one");
const char STR0[] = "one two three four";
String s = STR0;
CString tmp = s.getCString();
PEGASUS_TEST_ASSERT(tmp == s);
PEGASUS_TEST_ASSERT(s == tmp);
}
{
// Tests of the + Overload operator
String t1 = "abc";
String t2 = t1 + t1;
PEGASUS_TEST_ASSERT(t2 == "abcabc");
t1 = "abc";
t2 = t1 + "def";
PEGASUS_TEST_ASSERT(t2 == "abcdef");
t1 = "ghi";
PEGASUS_TEST_ASSERT(t1 == "ghi");
// ATTN: the following fails because there
// is no single character overload operator
// KS: Apr 2001
// t2 = t1 + 'k' + 'l' + 'm' + "nop";
t2 = t1 + "k" + "l" + "m" + "nop";
PEGASUS_TEST_ASSERT(t2 == "ghiklmnop");
PEGASUS_TEST_ASSERT(String::equal(t2,"ghiklmnop"));
// add tests for != operator.
t1 = "abc";
PEGASUS_TEST_ASSERT(t1 != "ghi");
PEGASUS_TEST_ASSERT(t1 != t2);
// add tests for other compare operators
// Operater <
t1 = "ab";
t2 = "cde";
PEGASUS_TEST_ASSERT(t1 < t2);
PEGASUS_TEST_ASSERT(t1 <= t2);
PEGASUS_TEST_ASSERT(t2 > t1);
PEGASUS_TEST_ASSERT(t2 >=t1);
PEGASUS_TEST_ASSERT(String::compare(t1,t2) < 0);
PEGASUS_TEST_ASSERT(String::compare(t2,t1) > 0);
PEGASUS_TEST_ASSERT(String::compare(t1, t2, 1) < 0);
PEGASUS_TEST_ASSERT(String::compare(t2, t1, 1) > 0);
PEGASUS_TEST_ASSERT(String::compare(t1, t2, 10) < 0);
PEGASUS_TEST_ASSERT(String::compare(t2, t1, 10) > 0);
PEGASUS_TEST_ASSERT(String::compare(t1, t2, 0) == 0);
t2 = t1;
PEGASUS_TEST_ASSERT(t1 <= t2);
PEGASUS_TEST_ASSERT(t1 >= t2);
PEGASUS_TEST_ASSERT(String::compare(t1, t2) == 0);
PEGASUS_TEST_ASSERT(String::compare(t1, t2, 0) == 0);
PEGASUS_TEST_ASSERT(String::compare(t1, t2, 1) == 0);
PEGASUS_TEST_ASSERT(String::compare(t1, t2, 10) == 0);
// Tests for compare with same length
t1 = "abc";
t2 = "def";
PEGASUS_TEST_ASSERT(t1 < t2);
PEGASUS_TEST_ASSERT(String::compare(t1, t2) < 0);
PEGASUS_TEST_ASSERT(String::compare(t2, t1) > 0);
PEGASUS_TEST_ASSERT(String::compare(t1, t2, 10) < 0);
PEGASUS_TEST_ASSERT(String::compare(t1, t2, 0) == 0);
t1 = "abc";
t2 = "ABC";
PEGASUS_TEST_ASSERT(String::equalNoCase(t1,t2));
PEGASUS_TEST_ASSERT(!String::equal(t1,t2));
PEGASUS_TEST_ASSERT(String::compareNoCase(t1,t2) == 0);
t1.toUpper();
t2.toLower();
PEGASUS_TEST_ASSERT(String::equal(t1, "ABC"));
PEGASUS_TEST_ASSERT(String::equal(t2, "abc"));
t1 = "1000";
t2 = "1001";
PEGASUS_TEST_ASSERT(String::compareNoCase(t1,t2) < 0);
PEGASUS_TEST_ASSERT(String::compare(t1, t2) < 0);
PEGASUS_TEST_ASSERT(String::compare(t1, t2, 3) == 0);
PEGASUS_TEST_ASSERT(String::compare(t1, t2, 4) < 0);
#ifdef PEGASUS_HAS_ICU
//
// Strings used to test non-ascii case mappings
// Tests context sensitve mappings (eg. greek)
// Tests expansion after mapping (eg german)
//
// Lower case german and greek
// --latin small letter sharp s (german) (2 of these to cause
// ICU overflow error inside of String)
// --greek small letter sigma (followed by another letter)
// --latin small a
// --greek small letter sigma (NOT followed by another letter)
const Char16 lowermap[] = {
0xdf,
0xdf,
0x3c3,
'a',
0x3c2,
0x00};
String degkLow(lowermap);
// Needed because the german char does not round trip
// after an uppercase followed by lower case.
// --latin small letters 's' 's' (4 of these due to expansion)
// --greek small letter sigma (followed by another letter)
// --latin small a
// --greek small letter sigma (NOT followed by another letter)
const Char16 lowermap2[] = {
's', 's', 's', 's',
0x3c3,
'a',
0x3c2,
0x00};
String degkLow2(lowermap2);
// Upper case greek and german
// latin cap letter sharp s (german) (4 of these due to expansion)
// greek cap letter sigma (followed by another letter)
// latin cap A
// greek cap letter sigma (NOT followed by another letter)
const Char16 uppermap[] = {
'S', 'S', 'S', 'S',
0x3a3,
'A',
0x3a3,
0x00};
String degkUp(uppermap);
PEGASUS_TEST_ASSERT(String::compareNoCase(degkLow,degkUp) == 0);
// does a binary compare, so lower > upper
PEGASUS_TEST_ASSERT(String::compare(degkLow,degkUp) > 0);
PEGASUS_TEST_ASSERT(String::equalNoCase(degkLow,degkUp));
String mapTest(degkLow);
mapTest.toUpper();
PEGASUS_TEST_ASSERT(String::equal(mapTest, degkUp));
// Note that the German char does not round trip
mapTest.toLower();
PEGASUS_TEST_ASSERT(String::equal(mapTest, degkLow2));
#endif
}
{
// Test of the [] operator
String t1 = "abc";
Char16 c = t1[1];
// note c is Char16
PEGASUS_TEST_ASSERT(c == 'b');
//ATTN: test for outofbounds exception
try
{
c = t1[200];
}
catch (IndexOutOfBoundsException&)
{
PEGASUS_TEST_ASSERT(true);
}
}
{
// Test the find function
String t1 = "abcdef";
String t2 = "cde";
String t3 = "xyz";
String t4 = "abc";
String t5 = "abd";
String t6 = "defg";
PEGASUS_TEST_ASSERT(t1.find('c') == 2);
PEGASUS_TEST_ASSERT(t1.find(t2)==2);
PEGASUS_TEST_ASSERT(t1.find(t3)==PEG_NOT_FOUND);
PEGASUS_TEST_ASSERT(t1.find(t4)==0);
PEGASUS_TEST_ASSERT(t1.find(t5)==PEG_NOT_FOUND);
PEGASUS_TEST_ASSERT(t1.find(t6)==PEG_NOT_FOUND);
PEGASUS_TEST_ASSERT(t1.find("cde")==2);
PEGASUS_TEST_ASSERT(t1.find("def")==3);
PEGASUS_TEST_ASSERT(t1.find("xyz")==PEG_NOT_FOUND);
PEGASUS_TEST_ASSERT(t1.find("a") ==0);
// test for the case where string
// partly occurs and then later
// completely occurs
String s = "this is an apple";
PEGASUS_TEST_ASSERT(s.find("apple")==11);
PEGASUS_TEST_ASSERT(s.find("appld")==PEG_NOT_FOUND);
PEGASUS_TEST_ASSERT(s.find("this")==0);
PEGASUS_TEST_ASSERT(s.find("t")==0);
PEGASUS_TEST_ASSERT(s.find("e")==15);
s = "a";
PEGASUS_TEST_ASSERT(s.find("b")==PEG_NOT_FOUND);
PEGASUS_TEST_ASSERT(s.find("a")==0);
PEGASUS_TEST_ASSERT(s.find(s)==0);
s = "aaaapple";
PEGASUS_TEST_ASSERT(s.find("apple")==3);
// 20020715-RK This method was removed from the String class
//{
// String nameSpace = "a#b#c";
// nameSpace.translate('#', '/');
// PEGASUS_TEST_ASSERT(nameSpace == "a/b/c");
//}
}
{
//
// Test String unicode enablement
//
char utf8chr[] = {
'\xCE', '\x99', '\xCE', '\xBF', '\xCF', '\x8D',
'\xCE', '\xBD', '\xCE', '\xB9', '\xCE', '\xBA',
'\xCE', '\xBF', '\xCE', '\xBD', '\xCF', '\x84',
'\0'
}; // utf8 string with mutliple byte characters
Char16 utf16chr[] = {
0x0399,0x03BF,0x03CD,0x03BD,0x03B9,
0x03BA,0x03BF,0x03BD,0x03C4,0x00
}; // utf16 representation of the utf8 string
String utf16string(utf16chr);
String utf8string(utf8chr);
String utf16merge(utf8string.getChar16Data());
CString temp = utf8string.getCString();
CString temp2 = utf16string.getCString();
PEGASUS_TEST_ASSERT(utf16string == utf8string);
PEGASUS_TEST_ASSERT(utf16string == utf16merge);
PEGASUS_TEST_ASSERT(utf16string == utf16chr);
PEGASUS_TEST_ASSERT(utf8string == utf16chr);
PEGASUS_TEST_ASSERT(memcmp(utf8string.getChar16Data(),
utf16string.getChar16Data(),sizeof(utf16chr)) == 0);
PEGASUS_TEST_ASSERT(strcmp(utf8string.getCString(),utf8chr) == 0);
PEGASUS_TEST_ASSERT(strcmp(utf16string.getCString(),utf8chr) == 0);
PEGASUS_TEST_ASSERT(strcmp(temp,utf8chr) == 0);
PEGASUS_TEST_ASSERT(strcmp(temp2,utf8chr) == 0);
Uint32 count = 0;
Uint32 size = sizeof(utf8chr);
while(count<size)
{
PEGASUS_TEST_ASSERT(isUTF8(&utf8chr[count]) == true);
UTF8_NEXT(utf8chr,count);
}
// utf8 string with mutliple byte characters
char utf8bad[] =
{
'\xFF','\xFF', '\xFF', '\0', '\0', '\0'
};
count = 0;
size = 3;
while(count<size)
{
PEGASUS_TEST_ASSERT(isUTF8(&utf8bad[count]) == false);
UTF8_NEXT(utf8bad,count);
}
Char16 utf16Chars[] =
{
0x6A19, 0x6E96, 0x842C, 0x570B, 0x78BC,
0x042E, 0x043D, 0x0438, 0x043A, 0x043E, 0x0434,
0x110B, 0x1172, 0x1102, 0x1165, 0x110F, 0x1169, 0x11AE,
0x10E3, 0x10DC, 0x10D8, 0x10D9, 0x10DD, 0x10D3, 0x10D8,
0xdbc0, 0xdc01,
0x05D9, 0x05D5, 0x05E0, 0x05D9, 0x05E7, 0x05D0, 0x05B8, 0x05D3,
0x064A, 0x0648, 0x0646, 0x0650, 0x0643, 0x0648, 0x062F,
0x092F, 0x0942, 0x0928, 0x093F, 0x0915, 0x094B, 0x0921,
0x016A, 0x006E, 0x012D, 0x0063, 0x014D, 0x0064, 0x0065, 0x033D,
0x00E0, 0x248B, 0x0061, 0x2173, 0x0062, 0x1EA6, 0xFF21, 0x00AA,
0x0325, 0x2173, 0x249C, 0x0063,
0x02C8, 0x006A, 0x0075, 0x006E, 0x026A, 0x02CC, 0x006B, 0x006F,
0x02D0, 0x0064,
0x30E6, 0x30CB, 0x30B3, 0x30FC, 0x30C9,
0xFF95, 0xFF86, 0xFF7A, 0xFF70, 0xFF84, 0xFF9E,
0xC720, 0xB2C8, 0xCF5B, 0x7D71, 0x4E00, 0x78BC,
0xdbc0, 0xdc01,
0x00};
String ugly(utf16Chars);
PEGASUS_TEST_ASSERT(ugly == utf16Chars);
//
// Test passing bad utf-8 into String
//
// A utf-8 sequence with a byte zeroed out in a bad spot
char utf8bad1[] = {
'\xCE', '\x99', '\xCE', '\xBF', '\xCF', '\x8D',
'\xCE', '\xBD', '\xCE', '\0', '\xCE', '\xBA',
'\xCE', '\xBF', '\xCE', '\xBD', '\xCF', '\x84',
'\0'
}; // utf8 string with mutliple byte characters
// Test String(char *)
try
{
// the first terminator causes invalid utf-8
String tmp(utf8bad1);
PEGASUS_TEST_ASSERT(false);
}
catch (Exception &)
{
// expect an error
}
// Test String(char *, Uint32)
try
{
// bogus utf-8 char in the middle
String tmp(utf8bad1, sizeof(utf8bad1)-1);
PEGASUS_TEST_ASSERT(false);
}
catch (Exception &)
{
// expect an error
}
// Test String(char *, Uint32)
try
{
// good, but the last utf-8 char extends past the last byte
String tmp(utf8chr, sizeof(utf8chr) - 2);
PEGASUS_TEST_ASSERT(false);
}
catch (Exception &)
{
// expect an error
}
// Test String::assign(char *)
String assigntest(utf8chr); // good so far
try
{
// the first terminator causes invalid utf-8
assigntest.assign(utf8bad1); // bad
PEGASUS_TEST_ASSERT(false);
}
catch (Exception &)
{
// expect an error
}
// Test String::assign(char *, Uint32)
try
{
// bogus utf-8 char in the middle
assigntest.assign(utf8bad1, sizeof(utf8bad1) - 1); // bad
PEGASUS_TEST_ASSERT(false);
}
catch (Exception &)
{
// expect an error
}
// Test String::assign(char *, Uint32)
try
{
// good, but the last utf-8 char extends past the end
assigntest.assign(utf8chr, sizeof(utf8chr) - 2); // bad
PEGASUS_TEST_ASSERT(false);
}
catch (Exception &)
{
// expect an error
}
//
// Test passing in good utf-8 with an embedded terminator
//
// A utf-8 sequence with a byte zeroed out in an ok spot
char utf8good1[] = {
'\xCE', '\x99', '\xCE', '\xBF', '\xCF', '\x8D',
'\xCE', '\xBD', 'A', '\0', '\xCE', '\xBA',
'\xCE', '\xBF', '\xCE', '\xBD', '\xCF', '\x84',
'\0'
}; // utf8 string with mutliple byte characters
// Test String(char *)
try
{
// terminator after 5 chars
String tmp(utf8good1);
PEGASUS_TEST_ASSERT (tmp.size() == 5);
}
catch (Exception &)
{
// didn't see that one coming
PEGASUS_TEST_ASSERT(false);
}
// Test String(char *, Uint32)
try
{
// embedded terminator counts as 1 char
String tmp(utf8good1, sizeof(utf8good1) - 1);
PEGASUS_TEST_ASSERT (tmp.size() == 10);
}
catch (Exception &)
{
// didn't see that one coming
PEGASUS_TEST_ASSERT(false);
}
assigntest.clear();
// Test String::assign(char *)
try
{
// terminator after 5 chars
assigntest.assign(utf8good1);
PEGASUS_TEST_ASSERT (assigntest.size() == 5);
}
catch (Exception &)
{
// didn't see that one coming
PEGASUS_TEST_ASSERT(false);
}
assigntest.clear();
// Test String::assign(char *, Uint32)
try
{
// embedded terminator counts as 1 char
assigntest.assign(utf8good1, sizeof(utf8good1) - 1);
PEGASUS_TEST_ASSERT (assigntest.size() == 10);
}
catch (Exception &)
{
// didn't see that one coming
PEGASUS_TEST_ASSERT(false);
}
//
// Casing tests
//
String little("the quick brown fox jumped over the lazy dog");
String big("THE QUICK BROWN FOX JUMPED OVER THE LAZY DOG");
String tmpBig = big;
String tmpLittle = little;
tmpBig.toLower();
PEGASUS_TEST_ASSERT(tmpBig == little);
tmpBig.toUpper();
PEGASUS_TEST_ASSERT(tmpBig == big);
}
#if 0
// The match code has been removed from the String class
// Test the string match functions
{
String abc = "abc";
String ABC = "ABC";
PEGASUS_TEST_ASSERT(String::match(abc, "abc"));
PEGASUS_TEST_ASSERT(String::match(ABC, "ABC"));
PEGASUS_TEST_ASSERT(!String::match(abc, "ABC"));
PEGASUS_TEST_ASSERT(!String::match(ABC, "abc"));
PEGASUS_TEST_ASSERT(String::matchNoCase(abc, "abc"));
PEGASUS_TEST_ASSERT(String::matchNoCase(ABC, "abc"));
PEGASUS_TEST_ASSERT(String::matchNoCase(abc, "ABC"));
PEGASUS_TEST_ASSERT(String::matchNoCase(ABC, "ABc"));
PEGASUS_TEST_ASSERT(String::match(abc, "???"));
PEGASUS_TEST_ASSERT(String::match(ABC, "???"));
PEGASUS_TEST_ASSERT(String::match(abc, "*"));
PEGASUS_TEST_ASSERT(String::match(ABC, "*"));
PEGASUS_TEST_ASSERT(String::match(abc, "?bc"));
PEGASUS_TEST_ASSERT(String::match(abc, "?b?"));
PEGASUS_TEST_ASSERT(String::match(abc, "??c"));
PEGASUS_TEST_ASSERT(String::matchNoCase(ABC, "?bc"));
PEGASUS_TEST_ASSERT(String::matchNoCase(ABC, "?b?"));
PEGASUS_TEST_ASSERT(String::matchNoCase(ABC, "??c"));
PEGASUS_TEST_ASSERT(String::match(abc, "*bc"));
PEGASUS_TEST_ASSERT(String::match(abc, "a*c"));
PEGASUS_TEST_ASSERT(String::match(abc, "ab*"));
PEGASUS_TEST_ASSERT(String::match(abc, "a*"));
// ATTN-RK-P3-20020603: This match code is broken
//PEGASUS_TEST_ASSERT(String::match(abc, "[axy]bc"));
PEGASUS_TEST_ASSERT(!String::match(abc, "[xyz]bc"));
PEGASUS_TEST_ASSERT(!String::match(abc, "def"));
PEGASUS_TEST_ASSERT(!String::match(abc, "[de]bc"));
// ATTN-RK-P3-20020603: This match code is broken
//PEGASUS_TEST_ASSERT(String::match(abc, "a[a-c]c"));
PEGASUS_TEST_ASSERT(!String::match(abc, "a[d-x]c"));
// ATTN-RK-P3-20020603: This match code does not yet handle escape chars
//PEGASUS_TEST_ASSERT(String::match("*test", "\\*test"));
PEGASUS_TEST_ASSERT(String::match("abcdef123", "*[0-9]"));
PEGASUS_TEST_ASSERT(String::match("This is a test", "*is*"));
PEGASUS_TEST_ASSERT(String::matchNoCase("This is a test", "*IS*"));
PEGASUS_TEST_ASSERT(String::match("Hello", "Hello"));
PEGASUS_TEST_ASSERT(String::matchNoCase("HELLO", "hello"));
PEGASUS_TEST_ASSERT(String::match("This is a test", "This is *"));
PEGASUS_TEST_ASSERT(String::match("This is a test", "* is a test"));
PEGASUS_TEST_ASSERT(!String::match("Hello", "Goodbye"));
String tPattern =
"When in the * of human*e??nts it be?ome[sS] [0-9] nec*";
try
{
String x(reinterpret_cast<const char *>(0));
cerr <<
"Error: Exception not thrown on NULL passed to"
" constructor(const char *)"
<< endl;
}
catch ( const NullPointer & )
{
// This is the exception that should be thrown.
}
catch ( ... )
{
cerr <<
"Error: Wrong exception thrown on NULL passed to"
" constructor(const char *)"
<< endl;
}
try
{
String x(reinterpret_cast<const Char16 *>(0));
cerr <<
"Error: Exception not thrown on NULL passed to"
" constructor(const Char16 *)"
<< endl;
}
catch ( const NullPointer & )
{
// This is the exception that should be thrown.
}
catch ( ... )
{
cerr <<
"Error: Wrong exception thrown on NULL passed to"
" constructor(const Char16 *)"
<< endl;
}
try
{
String x;
x.assign(reinterpret_cast<const char *>(0));
cerr <<
"Error: Exception not thrown on NULL passed to"
" assign(const char *)"
<< endl;
}
catch ( const NullPointer & )
{
// This is the exception that should be thrown.
}
catch ( ... )
{
cerr <<
"Error: Wrong exception thrown on NULL passed to"
" assign(const char *)"
<< endl;
}
try
{
String x;
x.assign(reinterpret_cast<const Char16 *>(0));
cerr <<
"Error: Exception not thrown on NULL passed to"
" assign(const Char16 *)"
<< endl;
}
catch ( const NullPointer & )
{
// This is the exception that should be thrown.
}
catch ( ... )
{
cerr <<
"Error: Wrong exception thrown on NULL passed to"
" assign(const Char16 *)"
<< endl;
}
try
{
String x;
x.append(reinterpret_cast<const char *>(0));
cerr <<
"Error: Exception not thrown on NULL passed to"
" append(const char *)"
<< endl;
}
catch ( const NullPointer & )
{
// This is the exception that should be thrown.
}
catch ( ... )
{
cerr <<
"Error: Wrong exception thrown on NULL passed to"
" append(const char *)"
<< endl;
}
try
{
String x;
x.append(reinterpret_cast<const Char16 *>(0));
cerr <<
"Error: Exception not thrown on NULL passed to"
" append(const Char16 *)"
<< endl;
}
catch ( const NullPointer & )
{
// This is the exception that should be thrown.
}
catch ( ... )
{
cerr <<
"Error: Wrong exception thrown on NULL passed"
" to append(const Char16 *)"
<< endl;
}
// ATTN-RK-P3-20020603: This match code is broken
//PEGASUS_TEST_ASSERT(String::match(
// "When in the course of human events it becomes 0 necessary",
// tPattern));
//PEGASUS_TEST_ASSERT(String::match(
// "When in the xyz of human events it becomes 9 necessary",
// tPattern));
//PEGASUS_TEST_ASSERT(String::match(
// "When in the of human events it becomes 3 necessary",
// tPattern));
}
#endif
// string()
{
String s;
PEGASUS_TEST_ASSERT(s.size() == 0);
PEGASUS_TEST_ASSERT(s[0] == '\0');
}
// String(const String& s)
{
const String s("hello");
const String t = s;
PEGASUS_TEST_ASSERT(s.size() == strlen("hello"));
PEGASUS_TEST_ASSERT(s == "hello");
PEGASUS_TEST_ASSERT(t.size() == strlen("hello"));
PEGASUS_TEST_ASSERT(t == "hello");
}
// String(const char*)
{
const String s("hello");
PEGASUS_TEST_ASSERT(s.size() == strlen("hello"));
PEGASUS_TEST_ASSERT(s == "hello");
}
// reserve()
{
String s;
s.reserveCapacity(100);
PEGASUS_TEST_ASSERT(s.size() == 0);
// PEGASUS_TEST_ASSERT(s.getCapacity() >= 100);
String t("hello world");
PEGASUS_TEST_ASSERT(t.size() == strlen("hello world"));
t.reserveCapacity(500);
PEGASUS_TEST_ASSERT(t.size() == strlen("hello world"));
PEGASUS_TEST_ASSERT(t == "hello world");
}
// assign(const String&)
{
String s("this is a test");
String t;
t = s;
PEGASUS_TEST_ASSERT(s.size() == strlen("this is a test"));
PEGASUS_TEST_ASSERT(s == "this is a test");
PEGASUS_TEST_ASSERT(t.size() == strlen("this is a test"));
PEGASUS_TEST_ASSERT(t == "this is a test");
s = t;
PEGASUS_TEST_ASSERT(s.size() == strlen("this is a test"));
PEGASUS_TEST_ASSERT(s == "this is a test");
PEGASUS_TEST_ASSERT(t.size() == strlen("this is a test"));
PEGASUS_TEST_ASSERT(t == "this is a test");
}
// assign(const char*, size_t)
{
const char MESSAGE[] = "x";
const size_t LENGTH = sizeof(MESSAGE) - 1;
String s;
s.assign(MESSAGE, LENGTH);
PEGASUS_TEST_ASSERT(s.size() == LENGTH);
PEGASUS_TEST_ASSERT(s == MESSAGE);
String t("dummy", 5);
t.assign(MESSAGE, LENGTH);
PEGASUS_TEST_ASSERT(t.size() == LENGTH);
PEGASUS_TEST_ASSERT(t == MESSAGE);
}
// assign(const char*)
{
const char MESSAGE[] = "x";
const size_t LENGTH = sizeof(MESSAGE) - 1;
String s;
s.assign(MESSAGE);
PEGASUS_TEST_ASSERT(s.size() == LENGTH);
PEGASUS_TEST_ASSERT(s == MESSAGE);
String t("dummy", 5);
t.assign(MESSAGE);
PEGASUS_TEST_ASSERT(t.size() == LENGTH);
PEGASUS_TEST_ASSERT(t == MESSAGE);
}
// append(const String&)
{
String s;
s.append(String("xxx"));
PEGASUS_TEST_ASSERT(s.size() == 3);
PEGASUS_TEST_ASSERT(s == "xxx");
s.append(String("yyy"));
PEGASUS_TEST_ASSERT(s.size() == 6);
PEGASUS_TEST_ASSERT(s == "xxxyyy");
s.append(String("zzz"));
PEGASUS_TEST_ASSERT(s.size() == 9);
PEGASUS_TEST_ASSERT(s == "xxxyyyzzz");
}
// append(const char*)
{
String s;
s.append("xxx");
PEGASUS_TEST_ASSERT(s.size() == 3);
PEGASUS_TEST_ASSERT(s == "xxx");
s.append("yyy");
PEGASUS_TEST_ASSERT(s.size() == 6);
PEGASUS_TEST_ASSERT(s == "xxxyyy");
s.append("zzz");
PEGASUS_TEST_ASSERT(s.size() == 9);
PEGASUS_TEST_ASSERT(s == "xxxyyyzzz");
}
// append(const char*)
{
String s;
s.append("xxx");
PEGASUS_TEST_ASSERT(s.size() == 3);
PEGASUS_TEST_ASSERT(s == "xxx");
s.append("yyy");
PEGASUS_TEST_ASSERT(s.size() == 6);
PEGASUS_TEST_ASSERT(s == "xxxyyy");
s.append("zzz");
PEGASUS_TEST_ASSERT(s.size() == 9);
PEGASUS_TEST_ASSERT(s == "xxxyyyzzz");
}
// append(char)
{
String s;
for (int i = 'a'; i <= 'z'; i++)
{
Char16 c = i;
s.append(c);
}
PEGASUS_TEST_ASSERT(s.size() == 26);
PEGASUS_TEST_ASSERT(s == "abcdefghijklmnopqrstuvwxyz");
}
// clear()
{
String s("abc");
String t = s;
String u = s;
s.clear();
PEGASUS_TEST_ASSERT(t.size() == 3);
PEGASUS_TEST_ASSERT(t == "abc");
PEGASUS_TEST_ASSERT(t[0] == 'a');
PEGASUS_TEST_ASSERT(u.size() == 3);
PEGASUS_TEST_ASSERT(u == "abc");
PEGASUS_TEST_ASSERT(u[0] == 'a');
PEGASUS_TEST_ASSERT(s.size() == 0);
PEGASUS_TEST_ASSERT(s[0] == '\0');
t.clear();
PEGASUS_TEST_ASSERT(t.size() == 0);
PEGASUS_TEST_ASSERT(t[0] == '\0');
PEGASUS_TEST_ASSERT(t == "");
PEGASUS_TEST_ASSERT(u.size() == 3);
PEGASUS_TEST_ASSERT(u == "abc");
PEGASUS_TEST_ASSERT(u[0] == 'a');
PEGASUS_TEST_ASSERT(s.size() == 0);
PEGASUS_TEST_ASSERT(s == "");
PEGASUS_TEST_ASSERT(s[0] == '\0');
u.clear();
PEGASUS_TEST_ASSERT(t.size() == 0);
PEGASUS_TEST_ASSERT(t == "");
PEGASUS_TEST_ASSERT(t[0] == '\0');
PEGASUS_TEST_ASSERT(u.size() == 0);
PEGASUS_TEST_ASSERT(u == "");
PEGASUS_TEST_ASSERT(u[0] == '\0');
PEGASUS_TEST_ASSERT(s.size() == 0);
PEGASUS_TEST_ASSERT(s == "");
PEGASUS_TEST_ASSERT(s[0] == '\0');
}
// c_str()
{
String s("abc");
String t("abc");
String u("def");
String v;
String w("");
PEGASUS_TEST_ASSERT(s == "abc");
PEGASUS_TEST_ASSERT(t == "abc");
PEGASUS_TEST_ASSERT(u == "def");
PEGASUS_TEST_ASSERT(s == t);
PEGASUS_TEST_ASSERT(s != u);
PEGASUS_TEST_ASSERT(v == "");
PEGASUS_TEST_ASSERT(v[0] == '\0');
PEGASUS_TEST_ASSERT(v[0] == '\0');
PEGASUS_TEST_ASSERT(w.size() == 0);
PEGASUS_TEST_ASSERT(w[0] == '\0');
PEGASUS_TEST_ASSERT(w[0] == '\0');
}
// set(size_t, char)
{
String s("abcdefghijklmnopqrstuvwxyz");
for (int i = 0; i < 26; i++)
s[i] = toupper(s[i]);
PEGASUS_TEST_ASSERT(s == "ABCDEFGHIJKLMNOPQRSTUVWXYZ");
}
// equal(const String&)
{
String t("abc");
String u("abc");
String v("def");
String w("defg");
String x("");
String y("");
PEGASUS_TEST_ASSERT(String::equal(t, t));
PEGASUS_TEST_ASSERT(String::equal(u, u));
PEGASUS_TEST_ASSERT(String::equal(v, v));
PEGASUS_TEST_ASSERT(String::equal(w, w));
PEGASUS_TEST_ASSERT(String::equal(x, x));
PEGASUS_TEST_ASSERT(String::equal(y, y));
PEGASUS_TEST_ASSERT(String::equal(t, u));
PEGASUS_TEST_ASSERT(String::equal(u, t));
PEGASUS_TEST_ASSERT(!String::equal(t, v));
PEGASUS_TEST_ASSERT(!String::equal(t, w));
PEGASUS_TEST_ASSERT(!String::equal(t, x));
PEGASUS_TEST_ASSERT(!String::equal(t, y));
PEGASUS_TEST_ASSERT(!String::equal(v, t));
PEGASUS_TEST_ASSERT(!String::equal(w, t));
PEGASUS_TEST_ASSERT(!String::equal(x, t));
PEGASUS_TEST_ASSERT(!String::equal(y, t));
PEGASUS_TEST_ASSERT(!String::equal(v, w));
PEGASUS_TEST_ASSERT(!String::equal(w, v));
PEGASUS_TEST_ASSERT(String::equal(x, y));
PEGASUS_TEST_ASSERT(String::equal(y, x));
}
// equal(const char*)
{
String t("abc");
String u("abc");
String v("def");
String w("defg");
String x("");
String y("");
PEGASUS_TEST_ASSERT(String::equal(t, "abc"));
PEGASUS_TEST_ASSERT(String::equal(u, "abc"));
PEGASUS_TEST_ASSERT(String::equal(v, "def"));
PEGASUS_TEST_ASSERT(String::equal(w, "defg"));
PEGASUS_TEST_ASSERT(String::equal(x, ""));
PEGASUS_TEST_ASSERT(String::equal(y, ""));
PEGASUS_TEST_ASSERT(String::equal(t, "abc"));
PEGASUS_TEST_ASSERT(String::equal(u, "abc"));
PEGASUS_TEST_ASSERT(!String::equal(t, "def"));
PEGASUS_TEST_ASSERT(!String::equal(t, "defg"));
PEGASUS_TEST_ASSERT(!String::equal(t, ""));
PEGASUS_TEST_ASSERT(!String::equal(t, ""));
PEGASUS_TEST_ASSERT(!String::equal(v, "abc"));
PEGASUS_TEST_ASSERT(!String::equal(w, "abc"));
PEGASUS_TEST_ASSERT(!String::equal(x, "abc"));
PEGASUS_TEST_ASSERT(!String::equal(y, "abc"));
PEGASUS_TEST_ASSERT(!String::equal(v, "defg"));
PEGASUS_TEST_ASSERT(!String::equal(w, "def"));
PEGASUS_TEST_ASSERT(String::equal(x, ""));
PEGASUS_TEST_ASSERT(String::equal(y, ""));
}
// equali()
{
String s("abc");
String t("abC");
String u("ABC");
String v("xyz");
String w("");
String x("");
PEGASUS_TEST_ASSERT(String::equalNoCase(s, t));
PEGASUS_TEST_ASSERT(String::equalNoCase(s, u));
PEGASUS_TEST_ASSERT(!String::equalNoCase(s, v));
PEGASUS_TEST_ASSERT(String::equalNoCase(w, x));
PEGASUS_TEST_ASSERT(!String::equalNoCase(w, s));
PEGASUS_TEST_ASSERT(!String::equalNoCase(w, t));
PEGASUS_TEST_ASSERT(!String::equalNoCase(w, v));
}
{
String t;
const char MESSAGE[] = "hello";
const size_t LENGTH = sizeof(MESSAGE) - 1;
String s = String(MESSAGE);
t = s;
String u = String(t);
PEGASUS_TEST_ASSERT(t.size() == LENGTH);
PEGASUS_TEST_ASSERT(t == MESSAGE);
PEGASUS_TEST_ASSERT(s.size() == LENGTH);
PEGASUS_TEST_ASSERT(s == MESSAGE);
PEGASUS_TEST_ASSERT(u.size() == LENGTH);
PEGASUS_TEST_ASSERT(u == MESSAGE);
PEGASUS_TEST_ASSERT(t[0] == 'h');
PEGASUS_TEST_ASSERT(t[1] == 'e');
PEGASUS_TEST_ASSERT(t[2] == 'l');
PEGASUS_TEST_ASSERT(t[3] == 'l');
PEGASUS_TEST_ASSERT(t[4] == 'o');
PEGASUS_TEST_ASSERT(t[5] == '\0');
t.append(" world");
PEGASUS_TEST_ASSERT(t.size() == strlen("hello world"));
PEGASUS_TEST_ASSERT(t == "hello world");
PEGASUS_TEST_ASSERT(s != "hello world");
PEGASUS_TEST_ASSERT(s == "hello");
PEGASUS_TEST_ASSERT(s.size() == strlen("hello"));
t[0] = 'x';
PEGASUS_TEST_ASSERT(t == "xello world");
}
// remove()
{
String s("abcXYZdefLMNOP");
s.remove(0,0);
PEGASUS_TEST_ASSERT(s.size() == 14);
PEGASUS_TEST_ASSERT(s == "abcXYZdefLMNOP");
s.remove(0, 3);
PEGASUS_TEST_ASSERT(s.size() == 11);
PEGASUS_TEST_ASSERT(s == "XYZdefLMNOP");
s.remove(3, 3);
PEGASUS_TEST_ASSERT(s.size() == 8);
PEGASUS_TEST_ASSERT(s == "XYZLMNOP");
s.remove(7, 1);
PEGASUS_TEST_ASSERT(s.size() == 7);
PEGASUS_TEST_ASSERT(s == "XYZLMNO");
s.remove(0, 1);
PEGASUS_TEST_ASSERT(s.size() == 6);
PEGASUS_TEST_ASSERT(s == "YZLMNO");
s.remove(2, PEG_NOT_FOUND);
PEGASUS_TEST_ASSERT(s.size() == 2);
PEGASUS_TEST_ASSERT(s == "YZ");
s.remove(2, 0);
PEGASUS_TEST_ASSERT(s.size() == 2);
PEGASUS_TEST_ASSERT(s == "YZ");
s.remove(1, 1);
PEGASUS_TEST_ASSERT(s.size() == 1);
PEGASUS_TEST_ASSERT(s == "Y");
s.remove(0, 1);
PEGASUS_TEST_ASSERT(s.size() == 0);
PEGASUS_TEST_ASSERT(s == "");
PEGASUS_TEST_ASSERT(s[0] == '\0');
s.remove(0,0);
PEGASUS_TEST_ASSERT(s.size() == 0);
PEGASUS_TEST_ASSERT(s == "");
PEGASUS_TEST_ASSERT(s[0] == '\0');
}
// subString()
{
String s("one two three");
PEGASUS_TEST_ASSERT(s.subString(0) == "one two three");
PEGASUS_TEST_ASSERT(s.subString(0, 3) == "one");
PEGASUS_TEST_ASSERT(s.subString(4, 3) == "two");
PEGASUS_TEST_ASSERT(s.subString(8, 5) == "three");
PEGASUS_TEST_ASSERT(s.subString(0, 0) == "");
PEGASUS_TEST_ASSERT(s.subString(13, 0) == "");
}
// Overflow
bool caught_bad_alloc = false;
try
{
String s("junk", Uint32(0xFFFFFFFF));
}
catch(...)
{
caught_bad_alloc = true;
}
PEGASUS_TEST_ASSERT(caught_bad_alloc);
// Added to test funtionality of String(const String& str, Uint32 n)
// for memory overflow.
Boolean caughtBadAlloc = false;
try
{
String s("abc", 0xFFFF0000); //to check for alloc
}
catch(const PEGASUS_STD(bad_alloc)&)
{
caughtBadAlloc = true;
}
// Added to test funtionality of
// void reserveCapacity(Uint32 capacity) for memory overflow.
caughtBadAlloc = false;
try
{
String s;
s.reserveCapacity(0xFFFF0000); //to check for _reserve
}
catch (const PEGASUS_STD(bad_alloc)&)
{
caughtBadAlloc = true;
}
PEGASUS_TEST_ASSERT(caughtBadAlloc);
// Added to test funtionality of
// String& append(const char* str, Uint32 size) for memory overflow.
caughtBadAlloc = false;
try
{
String s;
s.append("xxx", 0xFFFF0000); //to check for _reserve
}
catch (const PEGASUS_STD(bad_alloc)&)
{
caughtBadAlloc = true;
}
PEGASUS_TEST_ASSERT(caughtBadAlloc);
// Added to test funtionality of
// String& append(const Char16* str, Uint32 n) for memory overflow.
caughtBadAlloc = false;
try
{
String s;
s.append((Char16 *)"xxx", 0xFFFF0000); //to check for _reserve
}
catch (const PEGASUS_STD(bad_alloc)&)
{
caughtBadAlloc = true;
}
PEGASUS_TEST_ASSERT(caughtBadAlloc);
// Added to test funtionality of
// String& assign(const char* str, Uint32 n) for memory overflow.
caughtBadAlloc = false;
try
{
String s;
s.assign("xxx", 0xFFFF0000); //to check for alloc
}
catch (const PEGASUS_STD(bad_alloc)&)
{
caughtBadAlloc = true;
}
PEGASUS_TEST_ASSERT(caughtBadAlloc);
// Added to test funtionality of
// String& assign(const Char16* str, Uint32 n) for memory overflow.
caughtBadAlloc = false;
try
{
String s;
s.assign((Char16 *)"xxx", 0xFFFF0000); //to check for alloc
}
catch (const PEGASUS_STD(bad_alloc)&)
{
caughtBadAlloc = true;
}
PEGASUS_TEST_ASSERT(caughtBadAlloc);
// Tests for the dump of a bad strings.
// 40 good chars, bad char, 10 trailing chars.
// Testing the full range of printed data.
caughtBadAlloc = false;
try
{
String s1("1234567890123456789012345678901234567890""\xFF""1234567890");
}
catch ( Exception& ex )
{
caughtBadAlloc = true;
PEGASUS_TEST_ASSERT(
strstr((const char*)ex.getMessage().getCString(),
": 1234567890123456789012345678901234567890"
" 0xFF 0x31 0x32 0x33 0x34 0x35 0x36 0x37 0x38 0x39 0x30")
!= 0);
}
PEGASUS_TEST_ASSERT(caughtBadAlloc);
// 7 good chars, bad char, 7 trailing chars.
// Testing reduced number of chars arround the bad char.
caughtBadAlloc = false;
try
{
String s1("0123456""\xAA""0123456");
}
catch ( Exception& ex )
{
caughtBadAlloc = true;
PEGASUS_TEST_ASSERT(
strstr((const char*)ex.getMessage().getCString(),
": 0123456 0xAA 0x30 0x31 0x32 0x33 0x34 0x35 0x36")
!= 0);
}
PEGASUS_TEST_ASSERT(caughtBadAlloc);
// No good chars, bad char , 20 trailing chars
// Testing no good chars, bad char at beginning,
// more trailing chars available then printed.
caughtBadAlloc = false;
try
{
String s1("\xDD""0123456789012345679");
}
catch ( Exception& ex )
{
caughtBadAlloc = true;
PEGASUS_TEST_ASSERT(
strstr((const char*)ex.getMessage().getCString(),
": 0xDD 0x30 0x31 0x32 0x33 0x34 0x35 0x36 0x37 0x38 0x39")
!= 0);
}
PEGASUS_TEST_ASSERT(caughtBadAlloc);
// 50 good chars ( more the printed ), bad char as last char,
// no trailing chars.
caughtBadAlloc = false;
try
{
String s1("AAAAAAAAAA0123456789012345678901234567890123456789""\xBB");
}
catch ( Exception& ex )
{
caughtBadAlloc = true;
PEGASUS_TEST_ASSERT(
strstr((const char*)ex.getMessage().getCString(),
": 0123456789012345678901234567890123456789 0xBB")
!= 0);
}
PEGASUS_TEST_ASSERT(caughtBadAlloc);
// no good chars, bad char as the only char, no trailing chars.
caughtBadAlloc = false;
try
{
String s1("\x80");
}
catch ( Exception& ex )
{
caughtBadAlloc = true;
PEGASUS_TEST_ASSERT(
strstr((const char*)ex.getMessage().getCString(),": 0x80") != 0);
}
PEGASUS_TEST_ASSERT(caughtBadAlloc);
cout << argv[0] << " +++++ passed all tests" << endl;
char* p = (char*)operator new(88888);
operator delete(p);
return 0;
}
/**
* Wrapper.lll() calls
* - heuristicLLL()
* - fastLLL()
* - provedLLL()
*/
bool Wrapper::lll() {
if (b.getRows() == 0 || b.getCols() == 0)
return RED_SUCCESS;
#ifdef FPLLL_WITH_ZLONG
bool heuristicWithLong = maxExponent < numeric_limits<long>::digits - 2
&& u.empty() && uInv.empty();
bool provedWithLong = 2 * maxExponent < numeric_limits<long>::digits - 2
&& u.empty() && uInv.empty();
#else
bool heuristicWithLong = false, provedWithLong = false;
#endif
int kappa;
/* small matrix */
if (heuristicWithLong) {
#ifdef FPLLL_WITH_ZLONG
setUseLong(true);
/* try heuristicLLL <long, double> */
heuristicLLL<long, double>(bLong, uLong, uInvLong, 0, delta, eta);
#endif
}
/* large matrix */
else {
/* try fastLLL<mpz_t, double> */
kappa = fastLLL<double>(delta, eta);
bool lllFailure = (kappa != 0);
int lastPrec;
/* try fastLLL<mpz_t, long double> */
#ifdef FPLLL_WITH_LONG_DOUBLE
if (lllFailure) {
kappa = fastLLL<long double>(delta, eta);
lllFailure = kappa != 0;
}
lastPrec = numeric_limits<long double>::digits;
#else
lastPrec = numeric_limits<double>::digits;
#endif
/* try fastLLL<mpz_t, dd_real> */
#ifdef FPLLL_WITH_QD
if (lllFailure) {
kappa = fastLLL<dd_real>(delta, eta);
lllFailure = kappa != 0;
}
lastPrec = PREC_DD;
#else
#ifdef FPLLL_WITH_LONG_DOUBLE
lastPrec = numeric_limits<long double>::digits;
#else
lastPrec = numeric_limits<double>::digits;
#endif
#endif
/* loop */
if (lllFailure) {
int precD = numeric_limits<double>::digits;
if (little(kappa, lastPrec))
kappa = provedLoop(precD);
else
kappa = heuristicLoop(increasePrec(precD));
}
}
setUseLong(provedWithLong);
/* final LLL */
kappa = lastLLL();
setUseLong(false);
return kappa == 0;
}
