test/text_test.cpp - external/github.com/rive-app/rive-cpp - Git at Google

 #include "rive/text/text.hpp"
 #include "rive/text/text_style.hpp"
 #include "rive/text/text_value_run.hpp"
 #include "rive_file_reader.hpp"
 #include "rive_testing.hpp"
 #include "rive/text/glyph_lookup.hpp"
 #include "rive/text/text_modifier_range.hpp"
 #include "utils/no_op_renderer.hpp"
 #include "rive/text/utf.hpp"
 #include "rive/text/text_modifier_group.hpp"

 TEST_CASE("file with text loads correctly", "[text]")
 {
     auto file = ReadRiveFile("../../test/assets/new_text.riv");
     auto artboard = file->artboard();

     auto textObjects = artboard->find<rive::Text>();
     REQUIRE(textObjects.size() == 5);

     auto styleObjects = artboard->find<rive::TextStyle>();
     REQUIRE(styleObjects.size() == 13);

     auto runObjects = artboard->find<rive::TextValueRun>();
     REQUIRE(runObjects.size() == 22);

     artboard->advance(0.0f);
     rive::NoOpRenderer renderer;
     artboard->draw(&renderer);
 }

 TEST_CASE("can query for all text runs", "[text]")
 {
     auto file = ReadRiveFile("../../test/assets/new_text.riv");
     auto artboard = file->artboard();

     auto textRunCount = artboard->count<rive::TextValueRun>();
     REQUIRE(textRunCount == 22);
 }

 TEST_CASE("can query for a text run at a given index", "[text]")
 {
     auto file = ReadRiveFile("../../test/assets/hello_world.riv");
     auto artboard = file->artboard();

     auto textRun = artboard->objectAt<rive::TextValueRun>(0);
     REQUIRE(textRun->text() == "Hello World!");
 }

 TEST_CASE("simple text loads", "[text]")
 {
     auto file = ReadRiveFile("../../test/assets/hello_world.riv");
     auto artboard = file->artboard();

     auto textObjects = artboard->find<rive::Text>();
     REQUIRE(textObjects.size() == 1);

     auto styleObjects = artboard->find<rive::TextStyle>();
     REQUIRE(styleObjects.size() == 1);

     auto runObjects = artboard->find<rive::TextValueRun>();
     REQUIRE(runObjects.size() == 1);
     REQUIRE(runObjects[0]->text() == "Hello World!");

     rive::NoOpRenderer renderer;

     artboard->advance(0.0f);
     artboard->draw(&renderer);
     {
         REQUIRE(textObjects[0]->shape().size() == 1);
         const rive::Paragraph& paragraph = textObjects[0]->shape()[0];
         REQUIRE(paragraph.runs.size() == 1);
         REQUIRE(paragraph.runs[0].glyphs.size() == 12);
     }

     // Changing to "Just Hello" works.
     runObjects[0]->text("Just Hello");
     artboard->advance(0.0f);
     artboard->draw(&renderer);
     {
         REQUIRE(textObjects[0]->shape().size() == 1);
         const rive::Paragraph& paragraph = textObjects[0]->shape()[0];
         REQUIRE(paragraph.runs.size() == 1);
         REQUIRE(paragraph.runs[0].glyphs.size() == 10);
     }

     // Changing to an empty space " " works.
     runObjects[0]->text(" ");
     artboard->advance(0.0f);
     artboard->draw(&renderer);
     {
         REQUIRE(textObjects[0]->shape().size() == 1);
         const rive::Paragraph& paragraph = textObjects[0]->shape()[0];
         REQUIRE(paragraph.runs.size() == 1);
         REQUIRE(paragraph.runs[0].glyphs.size() == 1);
     }

     // Changing to completely empty works.
     runObjects[0]->text("");
     artboard->advance(0.0f);
     artboard->draw(&renderer);
     {
         REQUIRE(textObjects[0]->shape().size() == 0);
         REQUIRE(textObjects[0]->localBounds().width() == 0.0f);
         REQUIRE(textObjects[0]->localBounds().height() == 0.0f);
     }
 }

 TEST_CASE("ellipsis is shown", "[text]")
 {
     auto file = ReadRiveFile("../../test/assets/ellipsis.riv");
     auto artboard = file->artboard();

     auto textObjects = artboard->find<rive::Text>();
     REQUIRE(textObjects.size() == 1);

     auto styleObjects = artboard->find<rive::TextStyle>();
     REQUIRE(styleObjects.size() == 1);

     auto runObjects = artboard->find<rive::TextValueRun>();
     REQUIRE(runObjects.size() == 1);

     artboard->advance(0.0f);
     auto text = textObjects[0];
     auto lines = text->orderedLines();
     REQUIRE(lines.size() == 1);

     auto orderedLine = lines[0];
     int glyphCount = 0;
     std::vector<rive::GlyphID> glyphIds;
     // for (auto itr = orderedLine.begin(); itr != orderedLine.end(); ++itr)
     for (auto glyphItr : orderedLine)
     {
         auto run = std::get<0>(glyphItr);
         size_t glyphIndex = std::get<1>(glyphItr);
         glyphIds.push_back(run->glyphs[glyphIndex]);
         glyphCount++;
     }
     // Expect 10 glyphs 'one two...'
     REQUIRE(glyphCount == 10);
     // Third to last glyph should be the "." for Inter.
     REQUIRE(glyphIds[7] == 1405);
     // Last three glyphs should be the same '.'
     REQUIRE(glyphIds[7] == glyphIds[8]);
     REQUIRE(glyphIds[8] == glyphIds[9]);

     // now set overflow to visible.
     text->overflow(rive::TextOverflow::visible);
     artboard->advance(0.0f);
     lines = text->orderedLines();

     // 2 lines after we set overflow to visible and advance which updates the
     // ordered lines.
     REQUIRE(lines.size() == 2);

     orderedLine = lines[0];
     glyphCount = 0;
     for (auto itr = orderedLine.begin(); itr != orderedLine.end(); ++itr)
     {
         glyphCount++;
     }
     // Expect 7 glyphs 'one two' as now 'three' is on line 2.
     REQUIRE(glyphCount == 7);

     rive::NoOpRenderer renderer;
     artboard->draw(&renderer);

     rive::GlyphLookup lookup;
     lookup.compute(text->unichars(), text->shape());
     REQUIRE(lookup.count(0) == 1);

     runObjects[0]->text("a -> b");
     artboard->advance(0.0f);
     lookup.compute(text->unichars(), text->shape());
     REQUIRE(lookup.count(0) == 1); // a
     REQUIRE(lookup.count(1) == 1); // space
     REQUIRE(lookup.count(2) == 2); // - ligates > to ->
     REQUIRE(lookup.count(4) == 1); // space
     REQUIRE(lookup.count(5) == 1); // b
 }

 static std::vector<rive::Unichar> toUnicode(const char text[])
 {
     std::vector<rive::Unichar> codePoints;
     const uint8_t* ptr = (const uint8_t*)text;
     while (*ptr)
     {
         codePoints.push_back(rive::UTF::NextUTF8(&ptr));
     }
     return codePoints;
 }

 TEST_CASE("range mapper maps words", "[text]")
 {
     auto codePoints = toUnicode("one two three four");
     rive::RangeMapper rangeMapper;
     rangeMapper.fromWords(codePoints, 0, (uint32_t)codePoints.size());
     REQUIRE(rangeMapper.unitCount() == 4);
 }

 TEST_CASE("run modifier ranges select runs", "[text]")
 {
     auto file = ReadRiveFile("../../test/assets/modifier_to_run.riv");
     auto artboard = file->artboard();

     artboard->advance(0.0f);
     rive::NoOpRenderer renderer;
     artboard->draw(&renderer);

     {
         auto characterSelectedText = artboard->find<rive::Text>("Characters");
         REQUIRE(characterSelectedText != nullptr);
         REQUIRE(characterSelectedText->haveModifiers());
         REQUIRE(characterSelectedText->modifierGroups().size() == 2);
         auto firstModifierGroup = characterSelectedText->modifierGroups()[0];
         REQUIRE(firstModifierGroup->ranges().size() == 1);
         auto firstRange = firstModifierGroup->ranges()[0];
         REQUIRE(firstRange->run() != nullptr);
         for (int i = 0; i < 4; i++)
         {
             REQUIRE(firstModifierGroup->coverage(i) == 0.0f);
         }
         // Run from 4-9 got selected.
         REQUIRE(firstRange->run()->offset() == 4);
         REQUIRE(firstRange->run()->length() == 5);
         for (int i = 4; i < 9; i++)
         {
             REQUIRE(firstModifierGroup->coverage(i) != 0.0f);
         }
         for (int i = 9; i < 26; i++)
         {
             REQUIRE(firstModifierGroup->coverage(i) == 0.0f);
         }
     }
     {
         auto wordSelectedText = artboard->find<rive::Text>("Words");
         REQUIRE(wordSelectedText != nullptr);
         REQUIRE(wordSelectedText->haveModifiers());
         REQUIRE(wordSelectedText->modifierGroups().size() == 1);
         auto firstModifierGroup = wordSelectedText->modifierGroups()[0];
         REQUIRE(firstModifierGroup->ranges().size() == 1);
         auto firstRange = firstModifierGroup->ranges()[0];
         REQUIRE(firstRange->run() != nullptr);
         for (int i = 0; i < 4; i++)
         {
             REQUIRE(firstModifierGroup->coverage(i) == 0.0f);
         }
         // Run from 4-34 got selected.
         REQUIRE(firstRange->run()->offset() == 4);
         auto text = firstRange->run()->text();
         REQUIRE(text.size() == 34);
         for (int i = 4; i < 39; i++)
         {
             if (rive::isWhiteSpace(text[i - 4]))
             {
                 REQUIRE(firstModifierGroup->coverage(i) == 0.0f);
             }
             else
             {
                 REQUIRE(firstModifierGroup->coverage(i) != 0.0f);
             }
         }
         for (int i = 39; i < 50; i++)
         {
             REQUIRE(firstModifierGroup->coverage(i) == 0.0f);
         }
     }
 }

 TEST_CASE("run modifier ranges select runs with varying text size", "[text]")
 {
     auto file = ReadRiveFile("../../test/assets/test_modifier_run.riv");
     auto artboard = file->artboard();

     artboard->advance(0.0f);
     rive::NoOpRenderer renderer;
     artboard->draw(&renderer);

     {
         /*
         Full text is:
         text for first run[UN]line separator[UN]text for second run
         [UN] is the united nations flag
         the first run is 18 characters long
         the second run is 16 characters long
         the second run is 20 characters long
         */
         auto characterSelectedText = artboard->find<rive::Text>("MultiRunText");
         REQUIRE(characterSelectedText != nullptr);
         REQUIRE(characterSelectedText->haveModifiers());
         REQUIRE(characterSelectedText->modifierGroups().size() == 1);
         auto firstModifierGroup = characterSelectedText->modifierGroups()[0];
         REQUIRE(firstModifierGroup->ranges().size() == 1);
         auto firstRange = firstModifierGroup->ranges()[0];
         REQUIRE(firstRange->run() != nullptr);
         for (int i = 0; i < 18; i++)
         {
             REQUIRE(firstModifierGroup->coverage(i) == 0.0f);
         }
         // // Run from 18-33 got selected.
         REQUIRE(firstRange->run()->offset() == 18);
         REQUIRE(firstRange->run()->length() == 16);
         // We confirm that the size and the length of the text are different and they're
         // both correct
         REQUIRE(firstRange->run()->text().size() == 22);
         for (int i = 18; i < 34; i++)
         {
             REQUIRE(firstModifierGroup->coverage(i) != 0.0f);
         }
         for (int i = 34; i < 54; i++)
         {
             REQUIRE(firstModifierGroup->coverage(i) == 0.0f);
         }
     }
 }

 TEST_CASE("double new line type works", "[text]")
 {
     auto file = ReadRiveFile("../../test/assets/double_line.riv");
     auto artboard = file->artboard();

     auto textObjects = artboard->find<rive::Text>();
     REQUIRE(textObjects.size() == 1);

     auto styleObjects = artboard->find<rive::TextStyle>();
     REQUIRE(styleObjects.size() == 1);

     auto runObjects = artboard->find<rive::TextValueRun>();
     REQUIRE(runObjects.size() == 9);

     artboard->advance(0.0f);
     auto text = textObjects[0];
     auto lines = text->orderedLines();
     REQUIRE(lines.size() == 3);
 }
	#include "rive/text/text.hpp"
	#include "rive/text/text_style.hpp"
	#include "rive/text/text_value_run.hpp"
	#include "rive_file_reader.hpp"
	#include "rive_testing.hpp"
	#include "rive/text/glyph_lookup.hpp"
	#include "rive/text/text_modifier_range.hpp"
	#include "utils/no_op_renderer.hpp"
	#include "rive/text/utf.hpp"
	#include "rive/text/text_modifier_group.hpp"

	TEST_CASE("file with text loads correctly", "[text]")
	{
	auto file = ReadRiveFile("../../test/assets/new_text.riv");
	auto artboard = file->artboard();

	auto textObjects = artboard->find<rive::Text>();
	REQUIRE(textObjects.size() == 5);

	auto styleObjects = artboard->find<rive::TextStyle>();
	REQUIRE(styleObjects.size() == 13);

	auto runObjects = artboard->find<rive::TextValueRun>();
	REQUIRE(runObjects.size() == 22);

	artboard->advance(0.0f);
	rive::NoOpRenderer renderer;
	artboard->draw(&renderer);
	}

	TEST_CASE("can query for all text runs", "[text]")
	{
	auto file = ReadRiveFile("../../test/assets/new_text.riv");
	auto artboard = file->artboard();

	auto textRunCount = artboard->count<rive::TextValueRun>();
	REQUIRE(textRunCount == 22);
	}

	TEST_CASE("can query for a text run at a given index", "[text]")
	{
	auto file = ReadRiveFile("../../test/assets/hello_world.riv");
	auto artboard = file->artboard();

	auto textRun = artboard->objectAt<rive::TextValueRun>(0);
	REQUIRE(textRun->text() == "Hello World!");
	}

	TEST_CASE("simple text loads", "[text]")
	{
	auto file = ReadRiveFile("../../test/assets/hello_world.riv");
	auto artboard = file->artboard();

	auto textObjects = artboard->find<rive::Text>();
	REQUIRE(textObjects.size() == 1);

	auto styleObjects = artboard->find<rive::TextStyle>();
	REQUIRE(styleObjects.size() == 1);

	auto runObjects = artboard->find<rive::TextValueRun>();
	REQUIRE(runObjects.size() == 1);
	REQUIRE(runObjects[0]->text() == "Hello World!");

	rive::NoOpRenderer renderer;

	artboard->advance(0.0f);
	artboard->draw(&renderer);
	{
	REQUIRE(textObjects[0]->shape().size() == 1);
	const rive::Paragraph& paragraph = textObjects[0]->shape()[0];
	REQUIRE(paragraph.runs.size() == 1);
	REQUIRE(paragraph.runs[0].glyphs.size() == 12);
	}

	// Changing to "Just Hello" works.
	runObjects[0]->text("Just Hello");
	artboard->advance(0.0f);
	artboard->draw(&renderer);
	{
	REQUIRE(textObjects[0]->shape().size() == 1);
	const rive::Paragraph& paragraph = textObjects[0]->shape()[0];
	REQUIRE(paragraph.runs.size() == 1);
	REQUIRE(paragraph.runs[0].glyphs.size() == 10);
	}

	// Changing to an empty space " " works.
	runObjects[0]->text(" ");
	artboard->advance(0.0f);
	artboard->draw(&renderer);
	{
	REQUIRE(textObjects[0]->shape().size() == 1);
	const rive::Paragraph& paragraph = textObjects[0]->shape()[0];
	REQUIRE(paragraph.runs.size() == 1);
	REQUIRE(paragraph.runs[0].glyphs.size() == 1);
	}

	// Changing to completely empty works.
	runObjects[0]->text("");
	artboard->advance(0.0f);
	artboard->draw(&renderer);
	{
	REQUIRE(textObjects[0]->shape().size() == 0);
	REQUIRE(textObjects[0]->localBounds().width() == 0.0f);
	REQUIRE(textObjects[0]->localBounds().height() == 0.0f);
	}
	}

	TEST_CASE("ellipsis is shown", "[text]")
	{
	auto file = ReadRiveFile("../../test/assets/ellipsis.riv");
	auto artboard = file->artboard();

	auto textObjects = artboard->find<rive::Text>();
	REQUIRE(textObjects.size() == 1);

	auto styleObjects = artboard->find<rive::TextStyle>();
	REQUIRE(styleObjects.size() == 1);

	auto runObjects = artboard->find<rive::TextValueRun>();
	REQUIRE(runObjects.size() == 1);

	artboard->advance(0.0f);
	auto text = textObjects[0];
	auto lines = text->orderedLines();
	REQUIRE(lines.size() == 1);

	auto orderedLine = lines[0];
	int glyphCount = 0;
	std::vector<rive::GlyphID> glyphIds;
	// for (auto itr = orderedLine.begin(); itr != orderedLine.end(); ++itr)
	for (auto glyphItr : orderedLine)
	{
	auto run = std::get<0>(glyphItr);
	size_t glyphIndex = std::get<1>(glyphItr);
	glyphIds.push_back(run->glyphs[glyphIndex]);
	glyphCount++;
	}
	// Expect 10 glyphs 'one two...'
	REQUIRE(glyphCount == 10);
	// Third to last glyph should be the "." for Inter.
	REQUIRE(glyphIds[7] == 1405);
	// Last three glyphs should be the same '.'
	REQUIRE(glyphIds[7] == glyphIds[8]);
	REQUIRE(glyphIds[8] == glyphIds[9]);

	// now set overflow to visible.
	text->overflow(rive::TextOverflow::visible);
	artboard->advance(0.0f);
	lines = text->orderedLines();

	// 2 lines after we set overflow to visible and advance which updates the
	// ordered lines.
	REQUIRE(lines.size() == 2);

	orderedLine = lines[0];
	glyphCount = 0;
	for (auto itr = orderedLine.begin(); itr != orderedLine.end(); ++itr)
	{
	glyphCount++;
	}
	// Expect 7 glyphs 'one two' as now 'three' is on line 2.
	REQUIRE(glyphCount == 7);

	rive::NoOpRenderer renderer;
	artboard->draw(&renderer);

	rive::GlyphLookup lookup;
	lookup.compute(text->unichars(), text->shape());
	REQUIRE(lookup.count(0) == 1);

	runObjects[0]->text("a -> b");
	artboard->advance(0.0f);
	lookup.compute(text->unichars(), text->shape());
	REQUIRE(lookup.count(0) == 1); // a
	REQUIRE(lookup.count(1) == 1); // space
	REQUIRE(lookup.count(2) == 2); // - ligates > to ->
	REQUIRE(lookup.count(4) == 1); // space
	REQUIRE(lookup.count(5) == 1); // b
	}

	static std::vector<rive::Unichar> toUnicode(const char text[])
	{
	std::vector<rive::Unichar> codePoints;
	const uint8_t* ptr = (const uint8_t*)text;
	while (*ptr)
	{
	codePoints.push_back(rive::UTF::NextUTF8(&ptr));
	}
	return codePoints;
	}

	TEST_CASE("range mapper maps words", "[text]")
	{
	auto codePoints = toUnicode("one two three four");
	rive::RangeMapper rangeMapper;
	rangeMapper.fromWords(codePoints, 0, (uint32_t)codePoints.size());
	REQUIRE(rangeMapper.unitCount() == 4);
	}

	TEST_CASE("run modifier ranges select runs", "[text]")
	{
	auto file = ReadRiveFile("../../test/assets/modifier_to_run.riv");
	auto artboard = file->artboard();

	artboard->advance(0.0f);
	rive::NoOpRenderer renderer;
	artboard->draw(&renderer);

	{
	auto characterSelectedText = artboard->find<rive::Text>("Characters");
	REQUIRE(characterSelectedText != nullptr);
	REQUIRE(characterSelectedText->haveModifiers());
	REQUIRE(characterSelectedText->modifierGroups().size() == 2);
	auto firstModifierGroup = characterSelectedText->modifierGroups()[0];
	REQUIRE(firstModifierGroup->ranges().size() == 1);
	auto firstRange = firstModifierGroup->ranges()[0];
	REQUIRE(firstRange->run() != nullptr);
	for (int i = 0; i < 4; i++)
	{
	REQUIRE(firstModifierGroup->coverage(i) == 0.0f);
	}
	// Run from 4-9 got selected.
	REQUIRE(firstRange->run()->offset() == 4);
	REQUIRE(firstRange->run()->length() == 5);
	for (int i = 4; i < 9; i++)
	{
	REQUIRE(firstModifierGroup->coverage(i) != 0.0f);
	}
	for (int i = 9; i < 26; i++)
	{
	REQUIRE(firstModifierGroup->coverage(i) == 0.0f);
	}
	}
	{
	auto wordSelectedText = artboard->find<rive::Text>("Words");
	REQUIRE(wordSelectedText != nullptr);
	REQUIRE(wordSelectedText->haveModifiers());
	REQUIRE(wordSelectedText->modifierGroups().size() == 1);
	auto firstModifierGroup = wordSelectedText->modifierGroups()[0];
	REQUIRE(firstModifierGroup->ranges().size() == 1);
	auto firstRange = firstModifierGroup->ranges()[0];
	REQUIRE(firstRange->run() != nullptr);
	for (int i = 0; i < 4; i++)
	{
	REQUIRE(firstModifierGroup->coverage(i) == 0.0f);
	}
	// Run from 4-34 got selected.
	REQUIRE(firstRange->run()->offset() == 4);
	auto text = firstRange->run()->text();
	REQUIRE(text.size() == 34);
	for (int i = 4; i < 39; i++)
	{
	if (rive::isWhiteSpace(text[i - 4]))
	{
	REQUIRE(firstModifierGroup->coverage(i) == 0.0f);
	}
	else
	{
	REQUIRE(firstModifierGroup->coverage(i) != 0.0f);
	}
	}
	for (int i = 39; i < 50; i++)
	{
	REQUIRE(firstModifierGroup->coverage(i) == 0.0f);
	}
	}
	}

	TEST_CASE("run modifier ranges select runs with varying text size", "[text]")
	{
	auto file = ReadRiveFile("../../test/assets/test_modifier_run.riv");
	auto artboard = file->artboard();

	artboard->advance(0.0f);
	rive::NoOpRenderer renderer;
	artboard->draw(&renderer);

	{
	/*
	Full text is:
	text for first run[UN]line separator[UN]text for second run
	[UN] is the united nations flag
	the first run is 18 characters long
	the second run is 16 characters long
	the second run is 20 characters long
	*/
	auto characterSelectedText = artboard->find<rive::Text>("MultiRunText");
	REQUIRE(characterSelectedText != nullptr);
	REQUIRE(characterSelectedText->haveModifiers());
	REQUIRE(characterSelectedText->modifierGroups().size() == 1);
	auto firstModifierGroup = characterSelectedText->modifierGroups()[0];
	REQUIRE(firstModifierGroup->ranges().size() == 1);
	auto firstRange = firstModifierGroup->ranges()[0];
	REQUIRE(firstRange->run() != nullptr);
	for (int i = 0; i < 18; i++)
	{
	REQUIRE(firstModifierGroup->coverage(i) == 0.0f);
	}
	// // Run from 18-33 got selected.
	REQUIRE(firstRange->run()->offset() == 18);
	REQUIRE(firstRange->run()->length() == 16);
	// We confirm that the size and the length of the text are different and they're
	// both correct
	REQUIRE(firstRange->run()->text().size() == 22);
	for (int i = 18; i < 34; i++)
	{
	REQUIRE(firstModifierGroup->coverage(i) != 0.0f);
	}
	for (int i = 34; i < 54; i++)
	{
	REQUIRE(firstModifierGroup->coverage(i) == 0.0f);
	}
	}
	}

	TEST_CASE("double new line type works", "[text]")
	{
	auto file = ReadRiveFile("../../test/assets/double_line.riv");
	auto artboard = file->artboard();

	auto textObjects = artboard->find<rive::Text>();
	REQUIRE(textObjects.size() == 1);

	auto styleObjects = artboard->find<rive::TextStyle>();
	REQUIRE(styleObjects.size() == 1);

	auto runObjects = artboard->find<rive::TextValueRun>();
	REQUIRE(runObjects.size() == 9);

	artboard->advance(0.0f);
	auto text = textObjects[0];
	auto lines = text->orderedLines();
	REQUIRE(lines.size() == 3);
	}