void ColumnString::render (
std::vector <std::string>& lines,
const std::string& value,
int width,
Color& color)
{
if (_style == "default" || _style == "left")
{
std::vector <std::string> raw;
wrapText (raw, value, width, _hyphenate);
for (auto& i : raw)
lines.push_back (color.colorize (leftJustify (i, width)));
}
else if (_style == "right")
{
std::vector <std::string> raw;
wrapText (raw, value, width, _hyphenate);
for (auto& i : raw)
lines.push_back (color.colorize (rightJustify (i, width)));
}
else if (_style == "left_fixed")
{
lines.push_back (leftJustify (value, width));
}
else if (_style == "right_fixed")
{
lines.push_back (rightJustify (value, width));
}
}
P2AbstractText::P2AbstractText( QString text )
: P2BasicWidget()
{
this->text = wrapText( text );
update2();
}
void ClickLabel::setTextWrapping(bool textWrapping) {
bool wrappingEnabled = !mTextWrapping && textWrapping;
mTextWrapping = textWrapping;
if (wrappingEnabled) {
wrapText();
}
}
void ColumnUDA::render (
std::vector <std::string>& lines,
Task& task,
int width,
Color& color)
{
if (task.has (_name))
{
if (_style == "default")
{
std::string value = task.get (_name);
if (_type == "date")
{
// Determine the output date format, which uses a hierarchy of definitions.
// rc.report.<report>.dateformat
// rc.dateformat.report
// rc.dateformat.
std::string format = context.config.get ("report." + _report + ".dateformat");
if (format == "")
format = context.config.get ("dateformat.report");
if (format == "")
format = context.config.get ("dateformat");
lines.push_back (
color.colorize (
leftJustify (
Date ((time_t) strtol (value.c_str (), NULL, 10))
.toString (format), width)));
}
else if (_type == "duration")
{
lines.push_back (
color.colorize (
rightJustify (
Duration (value).formatISO (),
width)));
}
else if (_type == "string")
{
std::vector <std::string> raw;
wrapText (raw, value, width, _hyphenate);
std::vector <std::string>::iterator i;
for (i = raw.begin (); i != raw.end (); ++i)
lines.push_back (color.colorize (leftJustify (*i, width)));
}
else if (_type == "numeric")
{
lines.push_back (color.colorize (rightJustify (value, width)));
}
}
else if (_style == "indicator")
{
if (task.has (_name))
lines.push_back (
color.colorize (
rightJustify (context.config.get ("uda." + _name + ".indicator"), width)));
}
}
}
void Cutscene::text(std::string s)
{
Cutscene::m_commands.push_back([this, s]()
{
sf::String cs = wrapText(sf::String(s), SCREEN_WIDTH - 50, *yingge::defaultFont, 20);
m_text.setString(cs);
m_text.setFont(*yingge::defaultFont);
m_text.setColor(sf::Color(255, 255, 255, 0));
m_text.setCharacterSize(20);
m_text.setPosition(20, 20);
m_textBackground.setFillColor(sf::Color(100, 100, 100, 0));
m_textBackground.setSize(sf::Vector2f(SCREEN_WIDTH, m_text.getLocalBounds().height + 50));
return true;
});
Cutscene::m_commands.push_back([this]()
{
// Fade in effect.
int curAlpha = (int)m_textBackground.getFillColor().a;
curAlpha += 10;
if (curAlpha < 255)
{
m_text.setColor(sf::Color(255, 255, 255, (sf::Uint8)curAlpha));
m_textBackground.setFillColor(sf::Color(100, 100, 100, (sf::Uint8)curAlpha));
return false;
}
else
{
m_text.setColor(sf::Color(255, 255, 255, 255));
m_textBackground.setFillColor(sf::Color(100, 100, 100, 255));
return true;
}
// Interrupt the fade in if the mouse is clicked.
if (isClicked())
{
m_text.setColor(sf::Color(255, 255, 255, 255));
m_textBackground.setFillColor(sf::Color(0, 0, 0, 255));
return true;
}
});
Cutscene::m_commands.push_back([this]()
{
if (isClicked())
{
m_text = sf::Text();
return true;
}
return false;
});
}
ClickLabel::ClickLabel(const std::string& caption) {
mGuiFont = static_cast<FIFE::GuiFont*> (getFont());
// setAlignment(Graphics::LEFT);
setTextWrapping(false);
setCaption(caption);
setFrameSize(0);
addMouseListener(this);
addKeyListener(this);
addFocusListener(this);
wrapText();
}
void MMFExporter::writeMMFDirections( QString &content, const Recipe &recipe )
{
QStringList lines;
if (recipe.instructions.isEmpty())
lines = QStringList();
else
lines = recipe.instructions.split( '\n', QString::KeepEmptyParts);
for ( QStringList::const_iterator it = lines.constBegin(); it != lines.constEnd(); ++it ) {
content += wrapText( *it, 80 ).join( "\n" ) + '\n';
}
}
void ColumnBg::render (
std::vector <std::string>& lines,
Task& task,
int width,
Color& color)
{
std::string bg = task.get (_name);
std::vector <std::string> raw;
wrapText (raw, bg, width, _hyphenate);
std::vector <std::string>::iterator i;
for (i = raw.begin (); i != raw.end (); ++i)
lines.push_back (color.colorize (leftJustify (*i, width)));
}
/** format a string to output*/
std::string Help::formatOutString(std::string s, size_t columnWidth, int indentLevel, int numLineBreaks, bool stripLineBreaks)
{
//std::cout << s + "<break>\n";
std::string indent = "";
for (int i = -1; i < indentLevel; i++)
{
indent += RevBayesCore::RbUtils::PAD;
}
// -- remove any pre-formatting that may come from the xml-file
s = replaceString(s, "\t", " ");
if (stripLineBreaks)
{
s = replaceString(s, "\n", " ");
}
s = stripConsecutiveSpace(s);
// do nothing if string is empty
if (s.length() <= 0)
{
return "";
}
// remove space at beginning
if (std::isspace(s.at(0)))
{
s.erase(0, 1);
}
//-- apply the formatting style we want
// wrap text
s = wrapText(s, indent, columnWidth);
// apply line breaks at end
for (int i = 0; i < numLineBreaks; i++)
{
s += "\n";
}
//std::cout << s + "<break>\n";
return s;
}
void Cutscene::decide(std::string que, std::vector<std::string> ans)
{
Cutscene::m_commands.push_back([this, que, ans]() {
m_question = sf::Text();
m_question.setFont(*yingge::defaultFont);
m_question.setPosition(180, 20);
m_question.setCharacterSize(30);
m_question.setString(wrapText(que, SCREEN_WIDTH - 220, *yingge::defaultFont, 30));
m_question.setColor(sf::Color(255, 255, 255, 255));
float y = SCREEN_HEIGHT / 2;
m_answers = std::vector<yingge::textButton *>();
for (auto a = ans.begin(); a != ans.end(); a++)
{
yingge::textButton *button = new yingge::textButton();
button->setFont(*yingge::defaultFont);
button->setPosition(180, y);
button->setCharacterSize(30);
button->setString(*a);
button->setColor(sf::Color(255, 255, 255, 255));
y += 30;
m_answers.push_back(button);
}
m_decideBackground.setSize(sf::Vector2f(SCREEN_WIDTH, SCREEN_HEIGHT));
m_decideBackground.setFillColor(sf::Color(0, 74, 127, 255));
return true;
});
Cutscene::m_commands.push_back([this]()
{
for (unsigned int i = 0; i < m_answers.size(); i++)
delete m_answers[i];
return true;
});
Cutscene::m_commands.push_back([this]()
{
return isClicked();
});
}
void CursesRenderer::drawMessage(const std::string & message)
{
std::string text = wrapText(message, this->width() / 2);
std::vector<std::string> msgBuf;
boost::split(msgBuf, text, boost::is_any_of("\n"));
unsigned int width = 0;
for (auto & s : msgBuf)
width = (s.size() > width ? s.size() : width);
width += 2;
int msgHeight = msgBuf.size();
int height = 2 + msgHeight;
startWindow(this->width() / 2 - width / 2,
this->height() / 2 - height / 2, width, height);
style(Colour::White, Colour::Black, Style::Normal);
wborder(win(), 0,0,0,0,0,0,0,0);
mvwaddstr(win(), 1, 1, text.c_str());
endWindow();
}
void ColumnTags::render (
std::vector <std::string>& lines,
Task& task,
int width,
Color& color)
{
if (task.has (_name))
{
std::string tags = task.get (_name);
if (_style == "default" ||
_style == "list")
{
std::vector <std::string> allTags;
split (allTags, tags, ',');
if (allTags.size () > 1)
{
std::sort (allTags.begin (), allTags.end ());
join (tags, " ", allTags);
}
std::vector <std::string> all;
wrapText (all, tags, width, _hyphenate);
for (auto& i : all)
lines.push_back (color.colorize (leftJustify (i, width)));
}
else if (_style == "indicator")
{
lines.push_back (
color.colorize (
rightJustify (context.config.get ("tag.indicator"), width)));
}
else if (_style == "count")
{
std::vector <std::string> all;
split (all, tags, ',');
lines.push_back (
color.colorize (
rightJustify ("[" + format ((int)all.size ()) + "]", width)));
}
}
}
static const std::string reviewStart (
unsigned int width)
{
std::string welcome = "The review process is important for keeping your list "
"accurate, so you are working on the right tasks.\n"
"\n"
"For each task you are shown, look at the metadata. "
"Determine whether the task needs to be changed (enter "
"'e' to edit), or whether it is accurate ('enter' or "
"'r' to mark as reviewed). You may skip a task ('s') "
"but a skipped task is not considered reviewed.\n"
"\n"
"You may stop at any time, and resume later right "
"where you left off. See 'man tasksh' for more details.";
std::vector <std::string> lines;
wrapText (lines, welcome, width, false);
welcome = join ("\n", lines);
return "\n" + welcome + "\n\n";
}
void ClickLabel::draw(Graphics* graphics) {
if (mGuiFont != static_cast<FIFE::GuiFont*> (getFont())) {
mGuiFont = static_cast<FIFE::GuiFont*> (getFont());
wrapText();
adjustSize();
}
int32_t textX = 0;
int32_t textY = 0;
graphics->setColor(getBackgroundColor());
graphics->fillRectangle(Rectangle(1, 1, getDimension().width-1, getHeight() - 1));
if (mGuiFont) {
if( isTextWrapping() ) {
mGuiFont->drawMultiLineString(graphics, mWrappedText, textX, textY);
} else {
mGuiFont->drawMultiLineString(graphics, mCaption, textX, textY);
}
}
}
void
TipButton::drawTipText()
{
cnull << "_tipsFile: [" << _tipsFile << "]" << endl;
FILE* fp = fopen( _tipsFile, "rt" );
assert( fp );
const MAX_TIP_TEXT = 2000;
char* szTipText = (char*)alloca( MAX_TIP_TEXT );
assert( szTipText );
cnull << "_nTipOfTheDay = " << _nTipOfTheDay << endl;
for ( int i = 0; i < _nTipOfTheDay; ++i )
{
cnull << "reading tips #" << i << endl;
fgets( szTipText, MAX_TIP_TEXT, fp );
}
cnull << "reading tip..." << endl;
fgets( szTipText, MAX_TIP_TEXT, fp );
cnull << "tip=" << szTipText << endl;
cnull << "terminate string" << endl;
*( szTipText + strlen( szTipText ) - 1 ) = '\0'; // Remove trailing LF
cnull << "tip=" << szTipText << endl;
cnull << "close file...";
assert( fp );
fclose( fp );
cnull << "closed" << endl;
cnull << "render tip" << endl;
gfx_cblock( Tip[TIP_TEXT].sx+1, Tip[TIP_TEXT].sy+1,
Tip[TIP_TEXT].width-2, Tip[TIP_TEXT].height-2, DKGRAY );
wrapText( szTipText, 4+Tip[TIP_TEXT].sx, 8+Tip[TIP_TEXT].sy,
Tip[TIP_TEXT].width - 8, Tip[TIP_TEXT].height - 16, WHITE, DKGRAY );
}
void ColumnTags::render (
std::vector <std::string>& lines,
Task& task,
int width,
Color& color)
{
std::string tags = task.get (_name);
if (tags != "")
{
if (_style == "indicator")
{
lines.push_back (
color.colorize (
rightJustify (context.config.get ("tag.indicator"), width)));
}
else if (_style == "count")
{
std::vector <std::string> all;
split (all, tags, ',');
lines.push_back (
color.colorize (
rightJustify ("[" + format ((int)all.size ()) + "]", width)));
}
else if (_style == "default" ||
_style == "list")
{
std::replace (tags.begin (), tags.end (), ',', ' ');
std::vector <std::string> all;
wrapText (all, tags, width, _hyphenate);
std::vector <std::string>::iterator i;
for (i = all.begin (); i != all.end (); ++i)
lines.push_back (color.colorize (leftJustify (*i, width)));
}
}
}
/**
* Draw the text on screen
*/
void GuiText::draw(CVideo *pVideo)
{
if(!text)
return;
if(!isVisible())
return;
color[3] = getAlpha();
blurGlowColor[3] = blurAlpha * getAlpha();
int newSize = size * getScale();
if(newSize != currentSize)
{
currentSize = newSize;
if(text)
textWidth = font->getWidth(text, currentSize);
}
if(maxWidth > 0 && maxWidth <= textWidth)
{
if(wrapMode == DOTTED) // text dotted
{
if(textDyn.size() == 0)
makeDottedText();
if(textDynWidth.size() != textDyn.size())
{
textDynWidth.resize(textDyn.size());
for(u32 i = 0; i < textDynWidth.size(); i++)
textDynWidth[i] = font->getWidth(textDyn[i], currentSize);
}
if(textDyn.size() > 0)
font->drawText(pVideo, getCenterX(), getCenterY(), getDepth(), textDyn[textDyn.size()-1], currentSize, color, alignment, textDynWidth[textDyn.size()-1], defaultBlur, blurGlowIntensity, blurGlowColor);
}
else if(wrapMode == SCROLL_HORIZONTAL)
{
scrollText(pVideo->getFrameCount());
if(textDyn.size() > 0)
font->drawText(pVideo, getCenterX(), getCenterY(), getDepth(), textDyn[textDyn.size()-1], currentSize, color, alignment, maxWidth, defaultBlur, blurGlowIntensity, blurGlowColor);
}
else if(wrapMode == WRAP)
{
int lineheight = currentSize + 6;
int yoffset = 0;
int voffset = 0;
if(textDyn.size() == 0)
wrapText();
if(textDynWidth.size() != textDyn.size())
{
textDynWidth.resize(textDyn.size());
for(u32 i = 0; i < textDynWidth.size(); i++)
textDynWidth[i] = font->getWidth(textDyn[i], currentSize);
}
if(alignment & ALIGN_MIDDLE)
voffset = (lineheight * (textDyn.size()-1)) >> 1;
for(u32 i = 0; i < textDyn.size(); i++)
{
font->drawText(pVideo, getCenterX(), getCenterY() + voffset + yoffset, getDepth(), textDyn[i], currentSize, color, alignment, textDynWidth[i], defaultBlur, blurGlowIntensity, blurGlowColor);
yoffset -= lineheight;
}
}
}
void ClickLabel::setWidth(int32_t width) {
Widget::setWidth(width);
wrapText();
}
void ClickLabel::setCaption(const std::string& caption) {
mCaption = caption;
mGuiFont = static_cast<FIFE::GuiFont*> (getFont());
wrapText();
}
QString makeUsage(const QString &prgName)
{
QString text;
QTextStream stream(&text, QIODevice::WriteOnly);
QString indentation = QString(USAGE_INDENTATION, ' ');
stream << QObject::tr("Usage:") << '\n';
stream << indentation << prgName << QLatin1String(" [options] [(<filename> | <url>)...]") << '\n';
stream << QObject::tr("Options:") << '\n';
#ifndef Q_OS_WIN
stream << SHOW_VERSION_OPTION.usage() << wrapText(QObject::tr("Display program version and exit")) << '\n';
#endif
stream << SHOW_HELP_OPTION.usage() << wrapText(QObject::tr("Display this help message and exit")) << '\n';
stream << WEBUI_PORT_OPTION.usage(QObject::tr("port"))
<< wrapText(QObject::tr("Change the Web UI port"))
<< '\n';
#ifndef DISABLE_GUI
stream << NO_SPLASH_OPTION.usage() << wrapText(QObject::tr("Disable splash screen")) << '\n';
#else
stream << DAEMON_OPTION.usage() << wrapText(QObject::tr("Run in daemon-mode (background)")) << '\n';
#endif
//: Use appropriate short form or abbreviation of "directory"
stream << PROFILE_OPTION.usage(QObject::tr("dir"))
<< wrapText(QObject::tr("Store configuration files in <dir>")) << '\n';
stream << CONFIGURATION_OPTION.usage(QObject::tr("name"))
<< wrapText(QObject::tr("Store configuration files in directories qBittorrent_<name>")) << '\n';
stream << RELATIVE_FASTRESUME.usage()
<< wrapText(QObject::tr("Hack into libtorrent fastresume files and make file paths relative "
"to the profile directory")) << '\n';
stream << PORTABLE_OPTION.usage()
<< wrapText(QObject::tr("Shortcut for %1", "Shortcut for --profile=<exe dir>/profile --relative-fastresume")
.arg(QLatin1String("--profile=<exe dir>/profile --relative-fastresume"))) << '\n';
stream << Option::padUsageText(QObject::tr("files or URLs"))
<< wrapText(QObject::tr("Download the torrents passed by the user")) << '\n'
<< '\n';
stream << wrapText(QObject::tr("Options when adding new torrents:"), 0) << '\n';
stream << SAVE_PATH_OPTION.usage(QObject::tr("path")) << wrapText(QObject::tr("Torrent save path")) << '\n';
stream << PAUSED_OPTION.usage() << wrapText(QObject::tr("Add torrents as started or paused")) << '\n';
stream << SKIP_HASH_CHECK_OPTION.usage() << wrapText(QObject::tr("Skip hash check")) << '\n';
stream << CATEGORY_OPTION.usage(QObject::tr("name"))
<< wrapText(QObject::tr("Assign torrents to category. If the category doesn't exist, it will be "
"created.")) << '\n';
stream << SEQUENTIAL_OPTION.usage() << wrapText(QObject::tr("Download files in sequential order")) << '\n';
stream << FIRST_AND_LAST_OPTION.usage()
<< wrapText(QObject::tr("Download first and last pieces first")) << '\n';
stream << SKIP_DIALOG_OPTION.usage()
<< wrapText(QObject::tr("Specify whether the \"Add New Torrent\" dialog opens when adding a "
"torrent.")) << '\n';
stream << '\n';
stream << wrapText(QObject::tr("Option values may be supplied via environment variables. For option named "
"'parameter-name', environment variable name is 'QBT_PARAMETER_NAME' (in upper "
"case, '-' replaced with '_'). To pass flag values, set the variable to '1' or "
"'TRUE'. For example, to disable the splash screen: "), 0) << "\n"
<< QLatin1String("QBT_NO_SPLASH=1 ") << prgName << '\n'
<< wrapText(QObject::tr("Command line parameters take precedence over environment variables"), 0) << '\n';
stream << flush;
return text;
}
void ColumnDescription::render (
std::vector <std::string>& lines,
Task& task,
int width,
Color& color)
{
std::string description = task.get (_name);
// This is a description
// <date> <anno>
// ...
if (_style == "default" ||
_style == "combined")
{
std::map <std::string, std::string> annos;
task.getAnnotations (annos);
if (annos.size ())
{
std::map <std::string, std::string>::iterator i;
for (i = annos.begin (); i != annos.end (); i++)
{
Date dt (strtol (i->first.substr (11).c_str (), NULL, 10));
description += "\n" + std::string (_indent, ' ') + dt.toString (_dateformat) + " " + i->second;
}
}
std::vector <std::string> raw;
wrapText (raw, description, width, _hyphenate);
std::vector <std::string>::iterator i;
for (i = raw.begin (); i != raw.end (); ++i)
lines.push_back (color.colorize (leftJustify (*i, width)));
}
// This is a description
else if (_style == "desc")
{
std::vector <std::string> raw;
wrapText (raw, description, width, _hyphenate);
std::vector <std::string>::iterator i;
for (i = raw.begin (); i != raw.end (); ++i)
lines.push_back (color.colorize (leftJustify (*i, width)));
}
// This is a description <date> <anno> ...
else if (_style == "oneline")
{
std::map <std::string, std::string> annos;
task.getAnnotations (annos);
if (annos.size ())
{
std::map <std::string, std::string>::iterator i;
for (i = annos.begin (); i != annos.end (); i++)
{
Date dt (atoi (i->first.substr (11).c_str ()));
description += " " + dt.toString (_dateformat) + " " + i->second;
}
}
std::vector <std::string> raw;
wrapText (raw, description, width, _hyphenate);
std::vector <std::string>::iterator i;
for (i = raw.begin (); i != raw.end (); ++i)
lines.push_back (color.colorize (leftJustify (*i, width)));
}
// This is a des...
else if (_style == "truncated")
{
int len = utf8_width (description);
if (len > width)
lines.push_back (color.colorize (description.substr (0, width - 3) + "..."));
else
lines.push_back (color.colorize (leftJustify (description, width)));
}
// This is a description [2]
else if (_style == "count")
{
std::map <std::string, std::string> annos;
task.getAnnotations (annos);
if (annos.size ())
description += " [" + format ((int) annos.size ()) + "]";
std::vector <std::string> raw;
wrapText (raw, description, width, _hyphenate);
std::vector <std::string>::iterator i;
for (i = raw.begin (); i != raw.end (); ++i)
lines.push_back (color.colorize (leftJustify (*i, width)));
}
}
void ColumnDescription::render (
std::vector <std::string>& lines,
Task& task,
int width,
Color& color)
{
std::string description = task.get (_name);
// This is a description
// <date> <anno>
// ...
if (_style == "default" ||
_style == "combined")
{
std::map <std::string, std::string> annos;
task.getAnnotations (annos);
if (annos.size ())
{
for (auto& i : annos)
{
ISO8601d dt (strtol (i.first.substr (11).c_str (), NULL, 10));
description += "\n" + std::string (_indent, ' ') + dt.toString (_dateformat) + " " + i.second;
}
}
std::vector <std::string> raw;
wrapText (raw, description, width, _hyphenate);
for (auto& i : raw)
lines.push_back (color.colorize (leftJustify (i, width)));
}
// This is a description
else if (_style == "desc")
{
std::vector <std::string> raw;
wrapText (raw, description, width, _hyphenate);
for (auto& i : raw)
lines.push_back (color.colorize (leftJustify (i, width)));
}
// This is a description <date> <anno> ...
else if (_style == "oneline")
{
std::map <std::string, std::string> annos;
task.getAnnotations (annos);
if (annos.size ())
{
for (auto& i : annos)
{
ISO8601d dt (strtol (i.first.substr (11).c_str (), NULL, 10));
description += " " + dt.toString (_dateformat) + " " + i.second;
}
}
std::vector <std::string> raw;
wrapText (raw, description, width, _hyphenate);
for (auto& i : raw)
lines.push_back (color.colorize (leftJustify (i, width)));
}
// This is a des...
else if (_style == "truncated")
{
int len = utf8_width (description);
if (len > width)
lines.push_back (color.colorize (description.substr (0, width - 3) + "..."));
else
lines.push_back (color.colorize (leftJustify (description, width)));
}
// This is a description [2]
else if (_style == "count")
{
std::map <std::string, std::string> annos;
task.getAnnotations (annos);
if (annos.size ())
description += " [" + format ((int) annos.size ()) + "]";
std::vector <std::string> raw;
wrapText (raw, description, width, _hyphenate);
for (auto& i : raw)
lines.push_back (color.colorize (leftJustify (i, width)));
}
// This is a des... [2]
else if (_style == "truncated_count")
{
std::map <std::string, std::string> annos;
task.getAnnotations (annos);
int len = utf8_width (description);
std::string annos_count;
int len_annos = 0;
if (annos.size ())
{
annos_count = " [" + format ((int) annos.size ()) + "]";
len_annos = utf8_width (annos_count);
len += len_annos;
}
if (len > width)
lines.push_back (color.colorize (description.substr (0, width - len_annos - 3) + "..." + annos_count));
else
lines.push_back (color.colorize (leftJustify (description + annos_count, width)));
}
}
int main (int argc, char** argv)
{
UnitTest t (264);
// void wrapText (std::vector <std::string>& lines, const std::string& text, const int width, bool hyphenate)
std::string text = "This is a test of the line wrapping code.";
std::vector <std::string> lines;
wrapText (lines, text, 10, true);
t.is (lines.size (), (size_t) 5, "wrapText 'This is a test of the line wrapping code.' -> total 5 lines");
t.is (lines[0], "This is a", "wrapText line 0 -> 'This is a'");
t.is (lines[1], "test of", "wrapText line 1 -> 'test of'");
t.is (lines[2], "the line", "wrapText line 2 -> 'the line'");
t.is (lines[3], "wrapping", "wrapText line 3 -> 'wrapping'");
t.is (lines[4], "code.", "wrapText line 4 -> 'code.'");
text = "This ☺ is a test of utf8 line extraction.";
lines.clear ();
wrapText (lines, text, 7, true);
t.is (lines.size (), (size_t) 7, "wrapText 'This ☺ is a test of utf8 line extraction.' -> total 7 lines");
t.is (lines[0], "This ☺", "wrapText line 0 -> 'This ☺'");
t.is (lines[1], "is a", "wrapText line 1 -> 'is a'");
t.is (lines[2], "test of", "wrapText line 2 -> 'test of'");
t.is (lines[3], "utf8", "wrapText line 3 -> 'utf8'");
t.is (lines[4], "line", "wrapText line 4 -> 'line'");
t.is (lines[5], "extrac-", "wrapText line 5 -> 'extrac-'");
t.is (lines[6], "tion.", "wrapText line 6 -> 'tion.'");
text = "one two three\n four";
lines.clear ();
wrapText (lines, text, 13, true);
t.is (lines.size (), (size_t) 2, "wrapText 'one two three\\n four' -> 2 lines");
t.is (lines[0], "one two three", "wrapText line 0 -> 'one two three'");
t.is (lines[1], " four", "wrapText line 1 -> ' four'");
// void extractLine (std::string& text, std::string& line, int length, bool hyphenate, unsigned int& offset)
text = "This ☺ is a test of utf8 line extraction.";
unsigned int offset = 0;
std::string line;
extractLine (line, text, 7, true, offset);
t.is (line, "This ☺", "extractLine 7 'This ☺ is a test of utf8 line extraction.' -> 'This ☺'");
// void extractLine (std::string& text, std::string& line, int length, bool hyphenate, unsigned int& offset)
text = "line 1\nlengthy second line that exceeds width";
offset = 0;
extractLine (line, text, 10, true, offset);
t.is (line, "line 1", "extractLine 10 'line 1\\nlengthy second line that exceeds width' -> 'line 1'");
extractLine (line, text, 10, true, offset);
t.is (line, "lengthy", "extractLine 10 'lengthy second line that exceeds width' -> 'lengthy'");
extractLine (line, text, 10, true, offset);
t.is (line, "second", "extractLine 10 'second line that exceeds width' -> 'second'");
extractLine (line, text, 10, true, offset);
t.is (line, "line that", "extractLine 10 'line that exceeds width' -> 'line that'");
extractLine (line, text, 10, true, offset);
t.is (line, "exceeds", "extractLine 10 'exceeds width' -> 'exceeds'");
extractLine (line, text, 10, true, offset);
t.is (line, "width", "extractLine 10 'width' -> 'width'");
t.notok (extractLine (line, text, 10, true, offset), "extractLine 10 '' -> ''");
// void split (std::vector<std::string>& results, const std::string& input, const char delimiter)
std::vector <std::string> items;
std::string unsplit = "";
split (items, unsplit, '-');
t.is (items.size (), (size_t) 0, "split '' '-' -> 0 items");
unsplit = "a";
split (items, unsplit, '-');
t.is (items.size (), (size_t) 1, "split 'a' '-' -> 1 item");
t.is (items[0], "a", "split 'a' '-' -> 'a'");
split (items, unsplit, '-');
t.is (items.size (), (size_t) 1, "split 'a' '-' -> 1 item");
t.is (items[0], "a", "split 'a' '-' -> 'a'");
unsplit = "-";
split (items, unsplit, '-');
t.is (items.size (), (size_t) 2, "split '-' '-' -> '' ''");
t.is (items[0], "", "split '-' '-' -> [0] ''");
t.is (items[1], "", "split '-' '-' -> [1] ''");
split_minimal (items, unsplit, '-');
t.is (items.size (), (size_t) 0, "split '-' '-' ->");
unsplit = "-a-bc-def";
split (items, unsplit, '-');
t.is (items.size (), (size_t) 4, "split '-a-bc-def' '-' -> '' 'a' 'bc' 'def'");
t.is (items[0], "", "split '-a-bc-def' '-' -> [0] ''");
t.is (items[1], "a", "split '-a-bc-def' '-' -> [1] 'a'");
t.is (items[2], "bc", "split '-a-bc-def' '-' -> [2] 'bc'");
t.is (items[3], "def", "split '-a-bc-def' '-' -> [3] 'def'");
split_minimal (items, unsplit, '-');
t.is (items.size (), (size_t) 3, "split '-a-bc-def' '-' -> 'a' 'bc' 'def'");
t.is (items[0], "a", "split '-a-bc-def' '-' -> [1] 'a'");
t.is (items[1], "bc", "split '-a-bc-def' '-' -> [2] 'bc'");
t.is (items[2], "def", "split '-a-bc-def' '-' -> [3] 'def'");
// void split (std::vector<std::string>& results, const std::string& input, const std::string& delimiter)
unsplit = "";
split (items, unsplit, "--");
t.is (items.size (), (size_t) 0, "split '' '--' -> 0 items");
unsplit = "a";
split (items, unsplit, "--");
t.is (items.size (), (size_t) 1, "split 'a' '--' -> 1 item");
t.is (items[0], "a", "split 'a' '-' -> 'a'");
unsplit = "--";
split (items, unsplit, "--");
t.is (items.size (), (size_t) 2, "split '-' '--' -> '' ''");
t.is (items[0], "", "split '-' '-' -> [0] ''");
t.is (items[1], "", "split '-' '-' -> [1] ''");
unsplit = "--a--bc--def";
split (items, unsplit, "--");
t.is (items.size (), (size_t) 4, "split '-a-bc-def' '--' -> '' 'a' 'bc' 'def'");
t.is (items[0], "", "split '-a-bc-def' '--' -> [0] ''");
t.is (items[1], "a", "split '-a-bc-def' '--' -> [1] 'a'");
t.is (items[2], "bc", "split '-a-bc-def' '--' -> [2] 'bc'");
t.is (items[3], "def", "split '-a-bc-def' '--' -> [3] 'def'");
unsplit = "one\ntwo\nthree";
split (items, unsplit, "\n");
t.is (items.size (), (size_t) 3, "split 'one\\ntwo\\nthree' -> 'one', 'two', 'three'");
t.is (items[0], "one", "split 'one\\ntwo\\nthree' -> [0] 'one'");
t.is (items[1], "two", "split 'one\\ntwo\\nthree' -> [1] 'two'");
t.is (items[2], "three", "split 'one\\ntwo\\nthree' -> [2] 'three'");
// void splitq (std::vector<std::string>&, const std::string&, const char);
unsplit = "one 'two' '' 'three four' \"five six seven\" eight'nine ten'";
splitq (items, unsplit, ' ');
t.is (items.size () , (size_t) 6, "splitq 'one \\'two\\' \\'\\' \\'three four\\' \"five six seven\" eight'nine ten'");
t.is (items[0], "one", "splitq 'one \\'two\\' \\'\\' \\'three four\\' \"five six seven\" eight'nine ten' -> [0] 'one'");
t.is (items[1], "two", "splitq 'one \\'two\\' \\'\\' \\'three four\\' \"five six seven\" eight'nine ten' -> [1] 'two'");
t.is (items[2], "", "splitq 'one \\'two\\' \\'\\' \\'three four\\' \"five six seven\" eight'nine ten' -> [2] ''");
t.is (items[3], "three four", "splitq 'one \\'two\\' \\'\\' \\'three four\\' \"five six seven\" eight'nine ten' -> [3] 'three four'");
t.is (items[4], "five six seven", "splitq 'one \\'two\\' \\'\\' \\'three four\\' \"five six seven\" eight'nine ten' -> [4] 'five six seven'");
t.is (items[5], "eight'nine ten'", "splitq 'one \\'two\\' \\'\\' \\'three four\\' \"five six seven\" eight'nine ten' -> [4] 'eight\\'nine ten\\''");
// void join (std::string& result, const std::string& separator, const std::vector<std::string>& items)
std::vector <std::string> unjoined;
std::string joined;
join (joined, "", unjoined);
t.is (joined.length (), (size_t) 0, "join -> length 0");
t.is (joined, "", "join -> ''");
unjoined.push_back ("");
unjoined.push_back ("a");
unjoined.push_back ("bc");
unjoined.push_back ("def");
join (joined, "", unjoined);
t.is (joined.length (), (size_t) 6, "join '' 'a' 'bc' 'def' -> length 6");
t.is (joined, "abcdef", "join '' 'a' 'bc' 'def' -> 'abcdef'");
join (joined, "-", unjoined);
t.is (joined.length (), (size_t) 9, "join '' - 'a' - 'bc' - 'def' -> length 9");
t.is (joined, "-a-bc-def", "join '' - 'a' - 'bc' - 'def' -> '-a-bc-def'");
// void join (std::string& result, const std::string& separator, const std::vector<int>& items)
std::vector <int> unjoined2;
join (joined, "", unjoined2);
t.is (joined.length (), (size_t) 0, "join -> length 0");
t.is (joined, "", "join -> ''");
unjoined2.push_back (0);
unjoined2.push_back (1);
unjoined2.push_back (2);
join (joined, "", unjoined2);
t.is (joined.length (), (size_t) 3, "join 0 1 2 -> length 3");
t.is (joined, "012", "join 0 1 2 -> '012'");
join (joined, "-", unjoined2);
t.is (joined.length (), (size_t) 5, "join 0 1 2 -> length 5");
t.is (joined, "0-1-2", "join 0 1 2 -> '0-1-2'");
// std::string trimLeft (const std::string& in, const std::string& t /*= " "*/)
t.is (trimLeft (""), "", "trimLeft '' -> ''");
t.is (trimLeft (" "), "", "trimLeft ' ' -> ''");
t.is (trimLeft ("", " \t"), "", "trimLeft '' -> ''");
t.is (trimLeft ("xxx"), "xxx", "trimLeft 'xxx' -> 'xxx'");
t.is (trimLeft ("xxx", " \t"), "xxx", "trimLeft 'xxx' -> 'xxx'");
t.is (trimLeft (" \t xxx \t "), "\t xxx \t ", "trimLeft ' \\t xxx \\t ' -> '\\t xxx \\t '");
t.is (trimLeft (" \t xxx \t ", " \t"), "xxx \t ", "trimLeft ' \\t xxx \\t ' -> 'xxx \\t '");
// std::string trimRight (const std::string& in, const std::string& t /*= " "*/)
t.is (trimRight (""), "", "trimRight '' -> ''");
t.is (trimRight (" "), "", "trimRight ' ' -> ''");
t.is (trimRight ("", " \t"), "", "trimRight '' -> ''");
t.is (trimRight ("xxx"), "xxx", "trimRight 'xxx' -> 'xxx'");
t.is (trimRight ("xxx", " \t"), "xxx", "trimRight 'xxx' -> 'xxx'");
t.is (trimRight (" \t xxx \t "), " \t xxx \t", "trimRight ' \\t xxx \\t ' -> ' \\t xxx \\t'");
t.is (trimRight (" \t xxx \t ", " \t"), " \t xxx", "trimRight ' \\t xxx \\t ' -> ' \\t xxx'");
// std::string trim (const std::string& in, const std::string& t /*= " "*/)
t.is (trim (""), "", "trim '' -> ''");
t.is (trim (" "), "", "trim ' ' -> ''");
t.is (trim ("", " \t"), "", "trim '' -> ''");
t.is (trim ("xxx"), "xxx", "trim 'xxx' -> 'xxx'");
t.is (trim ("xxx", " \t"), "xxx", "trim 'xxx' -> 'xxx'");
t.is (trim (" \t xxx \t "), "\t xxx \t", "trim ' \\t xxx \\t ' -> '\\t xxx \\t'");
t.is (trim (" \t xxx \t ", " \t"), "xxx", "trim ' \\t xxx \\t ' -> 'xxx'");
// std::string unquoteText (const std::string& text)
t.is (unquoteText (""), "", "unquoteText '' -> ''");
t.is (unquoteText ("x"), "x", "unquoteText 'x' -> 'x'");
t.is (unquoteText ("'x"), "'x", "unquoteText ''x' -> ''x'");
t.is (unquoteText ("x'"), "x'", "unquoteText 'x'' -> 'x''");
t.is (unquoteText ("\"x"), "\"x", "unquoteText '\"x' -> '\"x'");
t.is (unquoteText ("x\""), "x\"", "unquoteText 'x\"' -> 'x\"'");
t.is (unquoteText ("''"), "", "unquoteText '''' -> ''");
t.is (unquoteText ("'''"), "'", "unquoteText ''''' -> '''");
t.is (unquoteText ("\"\""), "", "unquoteText '\"\"' -> ''");
t.is (unquoteText ("\"\"\""), "\"", "unquoteText '\"\"\"' -> '\"'");
t.is (unquoteText ("''''"), "''", "unquoteText '''''' -> ''''");
t.is (unquoteText ("\"\"\"\""), "\"\"", "unquoteText '\"\"\"\"' -> '\"\"'");
t.is (unquoteText ("'\"\"'"), "\"\"", "unquoteText '''\"\"' -> '\"\"'");
t.is (unquoteText ("\"''\""), "''", "unquoteText '\"''\"' -> ''''");
t.is (unquoteText ("'x'"), "x", "unquoteText ''x'' -> 'x'");
t.is (unquoteText ("\"x\""), "x", "unquoteText '\"x\"' -> 'x'");
// int longestWord (const std::string&)
t.is (longestWord (" "), 0, "longestWord ( ) --> 0");
t.is (longestWord ("this is a test"), 4, "longestWord (this is a test) --> 4");
t.is (longestWord ("this is a better test"), 6, "longestWord (this is a better test) --> 6");
t.is (longestWord ("house Çirçös clown"), 6, "longestWord (Çirçös) --> 6");
// int longestLine (const std::string&)
t.is (longestLine ("one two three four"), 18, "longestLine (one two three four) --> 18");
t.is (longestLine ("one\ntwo three four"), 14, "longestLine (one\\ntwo three four) --> 14");
t.is (longestLine ("one\ntwo\nthree\nfour"), 5, "longestLine (one\\ntwo\\nthree\\nfour) --> 5");
// std::string commify (const std::string& data)
t.is (commify (""), "", "commify '' -> ''");
t.is (commify ("1"), "1", "commify '1' -> '1'");
t.is (commify ("12"), "12", "commify '12' -> '12'");
t.is (commify ("123"), "123", "commify '123' -> '123'");
t.is (commify ("1234"), "1,234", "commify '1234' -> '1,234'");
t.is (commify ("12345"), "12,345", "commify '12345' -> '12,345'");
t.is (commify ("123456"), "123,456", "commify '123456' -> '123,456'");
t.is (commify ("1234567"), "1,234,567", "commify '1234567' -> '1,234,567'");
t.is (commify ("12345678"), "12,345,678", "commify '12345678' -> '12,345,678'");
t.is (commify ("123456789"), "123,456,789", "commify '123456789' -> '123,456,789'");
t.is (commify ("1234567890"), "1,234,567,890", "commify '1234567890' -> '1,234,567,890'");
t.is (commify ("pre"), "pre", "commify 'pre' -> 'pre'");
t.is (commify ("pre1234"), "pre1,234", "commify 'pre1234' -> 'pre1,234'");
t.is (commify ("1234post"), "1,234post", "commify '1234post' -> '1,234post'");
t.is (commify ("pre1234post"), "pre1,234post", "commify 'pre1234post' -> 'pre1,234post'");
// std::string lowerCase (const std::string& input)
t.is (lowerCase (""), "", "lowerCase '' -> ''");
t.is (lowerCase ("pre01_:POST"), "pre01_:post", "lowerCase 'pre01_:POST' -> 'pre01_:post'");
// std::string upperCase (const std::string& input)
t.is (upperCase (""), "", "upperCase '' -> ''");
t.is (upperCase ("pre01_:POST"), "PRE01_:POST", "upperCase 'pre01_:POST' -> 'PRE01_:POST'");
// bool nontrivial (const std::string&);
t.notok (nontrivial (""), "nontrivial '' -> false");
t.notok (nontrivial (" "), "nontrivial ' ' -> false");
t.notok (nontrivial ("\t\t"), "nontrivial '\\t\\t' -> false");
t.notok (nontrivial (" \t \t"), "nontrivial ' \\t \\t' -> false");
t.ok (nontrivial ("a"), "nontrivial 'a' -> true");
t.ok (nontrivial (" a"), "nontrivial ' a' -> true");
t.ok (nontrivial ("a "), "nontrivial 'a ' -> true");
t.ok (nontrivial (" \t\ta"), "nontrivial ' \\t\\ta' -> true");
t.ok (nontrivial ("a\t\t "), "nontrivial 'a\\t\\t ' -> true");
// bool digitsOnly (const std::string&);
t.ok (digitsOnly (""), "digitsOnly '' -> true");
t.ok (digitsOnly ("0"), "digitsOnly '0' -> true");
t.ok (digitsOnly ("123"), "digitsOnly '123' -> true");
t.notok (digitsOnly ("12fa"), "digitsOnly '12fa' -> false");
// bool noSpaces (const std::string&);
t.ok (noSpaces (""), "noSpaces '' -> true");
t.ok (noSpaces ("a"), "noSpaces 'a' -> true");
t.ok (noSpaces ("abc"), "noSpaces 'abc' -> true");
t.notok (noSpaces (" "), "noSpaces ' ' -> false");
t.notok (noSpaces ("ab cd"), "noSpaces 'ab cd' -> false");
// bool noVerticalSpace (const std::string&);
t.ok (noVerticalSpace (""), "noVerticalSpace '' -> true");
t.ok (noVerticalSpace ("a"), "noVerticalSpace 'a' -> true");
t.ok (noVerticalSpace ("abc"), "noVerticalSpace 'abc' -> true");
t.notok (noVerticalSpace ("a\nb"), "noVerticalSpace 'a\\nb' -> false");
t.notok (noVerticalSpace ("a\rb"), "noVerticalSpace 'a\\rb' -> false");
t.notok (noVerticalSpace ("a\fb"), "noVerticalSpace 'a\\fb' -> false");
text = "Hello, world.";
// 0123456789012
// s e s e
// bool isWordStart (const std::string&, std::string::size_type);
t.notok (isWordStart ("", 0), "isWordStart (\"\", 0) -> false");
t.ok (isWordStart ("foo", 0), "isWordStart (\"foo\", 0) -> true");
t.ok (isWordStart (text, 0), "isWordStart (\"Hello, world.\", 0) -> true");
t.notok (isWordStart (text, 1), "isWordStart (\"Hello, world.\", 1) -> false");
t.notok (isWordStart (text, 2), "isWordStart (\"Hello, world.\", 2) -> false");
t.notok (isWordStart (text, 3), "isWordStart (\"Hello, world.\", 3) -> false");
t.notok (isWordStart (text, 4), "isWordStart (\"Hello, world.\", 4) -> false");
t.notok (isWordStart (text, 5), "isWordStart (\"Hello, world.\", 5) -> false");
t.notok (isWordStart (text, 6), "isWordStart (\"Hello, world.\", 6) -> false");
t.ok (isWordStart (text, 7), "isWordStart (\"Hello, world.\", 7) -> true");
t.notok (isWordStart (text, 8), "isWordStart (\"Hello, world.\", 8) -> false");
t.notok (isWordStart (text, 9), "isWordStart (\"Hello, world.\", 9) -> false");
t.notok (isWordStart (text, 10), "isWordStart (\"Hello, world.\", 10) -> false");
t.notok (isWordStart (text, 11), "isWordStart (\"Hello, world.\", 11) -> false");
t.notok (isWordStart (text, 12), "isWordStart (\"Hello, world.\", 12) -> false");
// bool isWordEnd (const std::string&, std::string::size_type);
t.notok (isWordEnd ("", 0), "isWordEnd (\"\", 0) -> false");
t.ok (isWordEnd ("foo", 2), "isWordEnd (\"foo\", 2) -> true");
t.notok (isWordEnd (text, 0), "isWordEnd (\"Hello, world.\", 0) -> false");
t.notok (isWordEnd (text, 1), "isWordEnd (\"Hello, world.\", 1) -> false");
t.notok (isWordEnd (text, 2), "isWordEnd (\"Hello, world.\", 2) -> false");
t.notok (isWordEnd (text, 3), "isWordEnd (\"Hello, world.\", 3) -> false");
t.ok (isWordEnd (text, 4), "isWordEnd (\"Hello, world.\", 4) -> true");
t.notok (isWordEnd (text, 5), "isWordEnd (\"Hello, world.\", 5) -> false");
t.notok (isWordEnd (text, 6), "isWordEnd (\"Hello, world.\", 6) -> false");
t.notok (isWordEnd (text, 7), "isWordEnd (\"Hello, world.\", 7) -> false");
t.notok (isWordEnd (text, 8), "isWordEnd (\"Hello, world.\", 8) -> false");
t.notok (isWordEnd (text, 9), "isWordEnd (\"Hello, world.\", 9) -> false");
t.notok (isWordEnd (text, 10), "isWordEnd (\"Hello, world.\", 10) -> false");
t.ok (isWordEnd (text, 11), "isWordEnd (\"Hello, world.\", 11) -> true");
t.notok (isWordEnd (text, 12), "isWordEnd (\"Hello, world.\", 12) -> false");
// bool compare (const std::string&, const std::string&, bool caseless = false);
// Make sure degenerate cases are handled.
t.ok (compare ("", ""), "'' == ''");
t.notok (compare ("foo", ""), "foo != ''");
t.notok (compare ("", "foo"), "'' != foo");
// Make sure the default is case-sensitive.
t.ok (compare ("foo", "foo"), "foo == foo");
t.notok (compare ("foo", "FOO"), "foo != foo");
// Test case-sensitive.
t.notok (compare ("foo", "xx", true), "foo != xx");
t.ok (compare ("foo", "foo", true), "foo == foo");
t.notok (compare ("foo", "FOO", true), "foo != FOO");
t.notok (compare ("FOO", "foo", true), "FOO != foo");
t.ok (compare ("FOO", "FOO", true), "FOO == FOO");
// Test case-insensitive.
t.notok (compare ("foo", "xx", false), "foo != foo (caseless)");
t.ok (compare ("foo", "foo", false), "foo == foo (caseless)");
t.ok (compare ("foo", "FOO", false), "foo == FOO (caseless)");
t.ok (compare ("FOO", "foo", false), "FOO == foo (caseless)");
t.ok (compare ("FOO", "FOO", false), "FOO == FOO (caseless)");
// std::string::size_type find (const std::string&, const std::string&, bool caseless = false);
// Make sure degenerate cases are handled.
t.is ((int) find ("foo", ""), (int) 0, "foo !contains ''");
t.is ((int) find ("", "foo"), (int) std::string::npos, "'' !contains foo");
// Make sure the default is case-sensitive.
t.is ((int) find ("foo", "fo"), 0, "foo contains fo");
t.is ((int) find ("foo", "FO"), (int) std::string::npos, "foo !contains fo");
// Test case-sensitive.
t.is ((int) find ("foo", "xx", true), (int) std::string::npos, "foo !contains xx");
t.is ((int) find ("foo", "oo", true), 1, "foo contains oo");
t.is ((int) find ("foo", "fo", true), 0, "foo contains fo");
t.is ((int) find ("foo", "FO", true), (int) std::string::npos, "foo !contains fo");
t.is ((int) find ("FOO", "fo", true), (int) std::string::npos, "foo !contains fo");
t.is ((int) find ("FOO", "FO", true), 0, "foo contains fo");
// Test case-insensitive.
t.is ((int) find ("foo", "xx", false), (int) std::string::npos, "foo !contains xx (caseless)");
t.is ((int) find ("foo", "oo", false), 1, "foo contains oo (caseless)");
t.is ((int) find ("foo", "fo", false), 0, "foo contains fo (caseless)");
t.is ((int) find ("foo", "FO", false), 0, "foo contains FO (caseless)");
t.is ((int) find ("FOO", "fo", false), 0, "FOO contains fo (caseless)");
t.is ((int) find ("FOO", "FO", false), 0, "FOO contains FO (caseless)");
// Test start offset.
t.is ((int) find ("one two three", "e", 3, true), (int) 11, "offset obeyed");
t.is ((int) find ("one two three", "e", 11, true), (int) 11, "offset obeyed");
// int strippedLength (const std::string&);
t.is (strippedLength (std::string ("")), 0, "strippedLength -> 0");
t.is (strippedLength (std::string ("abc")), 3, "strippedLength abc -> 3");
t.is (strippedLength (std::string ("one\033[5;38;255mtwo\033[0mthree")), 11, "strippedLength one^[[5;38;255mtwo^[[0mthree -> 11");
t.is (strippedLength (std::string ("\033[0m")), 0, "strippedLength ^[[0m -> 0");
t.is (strippedLength (std::string ("\033[1m\033[0m")), 0, "strippedLength ^[[1m^[[0m -> 0");
// std::string format (char);
t.is (format ('A'), "A", "format ('A') -> A");
// std::string format (int);
t.is (format (0), "0", "format (0) -> 0");
t.is (format (-1), "-1", "format (-1) -> -1");
// std::string formatHex (int);
t.is (formatHex (0), "0", "formatHex (0) -> 0");
t.is (formatHex (10), "a", "formatHex (10) -> a");
t.is (formatHex (123), "7b", "formatHex (123) -> 7b");
// std::string format (float, int, int);
t.is (format (1.23456789, 8, 1), " 1", "format (1.23456789, 8, 1) -> _______1");
t.is (format (1.23456789, 8, 2), " 1.2", "format (1.23456789, 8, 2) -> _____1.2");
t.is (format (1.23456789, 8, 3), " 1.23", "format (1.23456789, 8, 3) -> ____1.23");
t.is (format (1.23456789, 8, 4), " 1.235", "format (1.23456789, 8, 4) -> ___1.235");
t.is (format (1.23456789, 8, 5), " 1.2346", "format (1.23456789, 8, 5) -> __1.2346");
t.is (format (1.23456789, 8, 6), " 1.23457", "format (1.23456789, 8, 6) -> 1.23457");
t.is (format (1.23456789, 8, 7), "1.234568", "format (1.23456789, 8, 7) -> 1.234568");
t.is (format (1.23456789, 8, 8), "1.2345679", "format (1.23456789, 8, 8) -> 1.2345679");
t.is (format (2444238.56789, 12, 11), "2444238.5679", "format (2444238.56789, 12, 11) -> 2444238.5679");
// std::string format (double, int, int);
// std::string leftJustify (const std::string&, const int);
t.is (leftJustify (123, 3), "123", "leftJustify 123,3 -> '123'");
t.is (leftJustify (123, 4), "123 ", "leftJustify 123,4 -> '123 '");
t.is (leftJustify (123, 5), "123 ", "leftJustify 123,5 -> '123 '");
// std::string leftJustify (const std::string&, const int);
t.is (leftJustify ("foo", 3), "foo", "leftJustify foo,3 -> 'foo'");
t.is (leftJustify ("foo", 4), "foo ", "leftJustify foo,4 -> 'foo '");
t.is (leftJustify ("foo", 5), "foo ", "leftJustify foo,5 -> 'foo '");
t.is (leftJustify ("föo", 5), "föo ", "leftJustify föo,5 -> 'föo '");
// std::string rightJustify (const std::string&, const int);
t.is (rightJustify (123, 3), "123", "rightJustify 123,3 -> '123'");
t.is (rightJustify (123, 4), " 123", "rightJustify 123,4 -> ' 123'");
t.is (rightJustify (123, 5), " 123", "rightJustify 123,5 -> ' 123'");
// std::string rightJustify (const std::string&, const int);
t.is (rightJustify ("foo", 3), "foo", "rightJustify foo,3 -> 'foo'");
t.is (rightJustify ("foo", 4), " foo", "rightJustify foo,4 -> ' foo'");
t.is (rightJustify ("foo", 5), " foo", "rightJustify foo,5 -> ' foo'");
t.is (rightJustify ("föo", 5), " föo", "rightJustify föo,5 -> ' föo'");
// int utf8_length (const std::string&);
t.is ((int) utf8_length ("Çirçös"), 6, "utf8_length (Çirçös) == 6");
t.is ((int) utf8_length ("ツネナラム"), 5, "utf8_length (ツネナラム) == 5");
t.is ((int) utf8_length ("Zwölf Boxkämpfer"), 16, "utf8_length (Zwölf Boxkämpfer) == 16");
return 0;
}
