chromium/src/third_party/blink/renderer/platform/text/bidi_resolver_test.cc - manifest_repos/chromium_src - Git at Google

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
  * copyright notice, this list of conditions and the following disclaimer
  * in the documentation and/or other materials provided with the
  * distribution.
  *     * Neither the name of Google Inc. nor the names of its
  * contributors may be used to endorse or promote products derived from
  * this software without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */

 #include "third_party/blink/renderer/platform/text/bidi_resolver.h"

 #include <fstream>

 #include "base/stl_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/blink/renderer/platform/text/bidi_test_harness.h"
 #include "third_party/blink/renderer/platform/text/text_run_iterator.h"
 #include "third_party/blink/renderer/platform/wtf/allocator/allocator.h"

 namespace blink {

 TEST(BidiResolver, Basic) {
   bool has_strong_directionality;
   String value("foo");
   TextRun run(value);
   BidiResolver<TextRunIterator, BidiCharacterRun> bidi_resolver;
   bidi_resolver.SetStatus(
       BidiStatus(run.Direction(), run.DirectionalOverride()));
   bidi_resolver.SetPositionIgnoringNestedIsolates(TextRunIterator(&run, 0));
   TextDirection direction = bidi_resolver.DetermineParagraphDirectionality(
       &has_strong_directionality);
   EXPECT_TRUE(has_strong_directionality);
   EXPECT_EQ(TextDirection::kLtr, direction);
 }

 TextDirection DetermineParagraphDirectionality(
     const TextRun& text_run,
     bool* has_strong_directionality = nullptr) {
   BidiResolver<TextRunIterator, BidiCharacterRun> resolver;
   resolver.SetStatus(BidiStatus(TextDirection::kLtr, false));
   resolver.SetPositionIgnoringNestedIsolates(TextRunIterator(&text_run, 0));
   return resolver.DetermineParagraphDirectionality(has_strong_directionality);
 }

 struct TestData {
   UChar text[3];
   size_t length;
   TextDirection expected_direction;
   bool expected_strong;
 };

 void TestDirectionality(const TestData& entry) {
   bool has_strong_directionality;
   String data(entry.text, entry.length);
   TextRun run(data);
   TextDirection direction =
       DetermineParagraphDirectionality(run, &has_strong_directionality);
   EXPECT_EQ(entry.expected_strong, has_strong_directionality);
   EXPECT_EQ(entry.expected_direction, direction);
 }

 TEST(BidiResolver, ParagraphDirectionSurrogates) {
   const TestData kTestData[] = {
       // Test strong RTL, non-BMP. (U+10858 Imperial
       // Aramaic number one, strong RTL)
       {{0xD802, 0xDC58}, 2, TextDirection::kRtl, true},

       // Test strong LTR, non-BMP. (U+1D15F Musical
       // symbol quarter note, strong LTR)
       {{0xD834, 0xDD5F}, 2, TextDirection::kLtr, true},

       // Test broken surrogate: valid leading, invalid
       // trail. (Lead of U+10858, space)
       {{0xD802, ' '}, 2, TextDirection::kLtr, false},

       // Test broken surrogate: invalid leading. (Trail
       // of U+10858, U+05D0 Hebrew Alef)
       {{0xDC58, 0x05D0}, 2, TextDirection::kRtl, true},

       // Test broken surrogate: valid leading, invalid
       // trail/valid lead, valid trail.
       {{0xD802, 0xD802, 0xDC58}, 3, TextDirection::kRtl, true},

       // Test broken surrogate: valid leading, no trail
       // (string too short). (Lead of U+10858)
       {{0xD802, 0xDC58}, 1, TextDirection::kLtr, false},

       // Test broken surrogate: trail appearing before
       // lead. (U+10858 units reversed)
       {{0xDC58, 0xD802}, 2, TextDirection::kLtr, false}};
   for (size_t i = 0; i < base::size(kTestData); ++i)
     TestDirectionality(kTestData[i]);
 }

 class BidiTestRunner {
   STACK_ALLOCATED();

  public:
   BidiTestRunner()
       : tests_run_(0),
         tests_skipped_(0),
         ignored_char_failures_(0),
         level_failures_(0),
         order_failures_(0) {}

   void SkipTestsWith(UChar codepoint) {
     skipped_code_points_.insert(codepoint);
   }

   void RunTest(const std::basic_string<UChar>& input,
                const Vector<int>& reorder,
                const Vector<int>& levels,
                bidi_test::ParagraphDirection,
                const std::string& line,
                size_t line_number);

   size_t tests_run_;
   size_t tests_skipped_;
   HashSet<UChar> skipped_code_points_;
   size_t ignored_char_failures_;
   size_t level_failures_;
   size_t order_failures_;
 };

 // Blink's UBA does not filter out control characters, etc. Maybe it should?
 // Instead it depends on later layers of Blink to simply ignore them.
 // This function helps us emulate that to be compatible with BidiTest.txt
 // expectations.
 static bool IsNonRenderedCodePoint(UChar c) {
   // The tests also expect us to ignore soft-hyphen.
   if (c == 0xAD)
     return true;
   // Control characters are not rendered:
   return c >= 0x202A && c <= 0x202E;
   // But it seems to expect LRI, etc. to be rendered!?
 }

 std::string DiffString(const Vector<int>& actual, const Vector<int>& expected) {
   std::ostringstream diff;
   diff << "actual: ";
   // This is the magical way to print a vector to a stream, clear, right?
   std::copy(actual.begin(), actual.end(),
             std::ostream_iterator<int>(diff, " "));
   diff << " expected: ";
   std::copy(expected.begin(), expected.end(),
             std::ostream_iterator<int>(diff, " "));
   return diff.str();
 }

 void BidiTestRunner::RunTest(const std::basic_string<UChar>& input,
                              const Vector<int>& expected_order,
                              const Vector<int>& expected_levels,
                              bidi_test::ParagraphDirection paragraph_direction,
                              const std::string& line,
                              size_t line_number) {
   if (!skipped_code_points_.IsEmpty()) {
     for (size_t i = 0; i < input.size(); i++) {
       if (skipped_code_points_.Contains(input[i])) {
         tests_skipped_++;
         return;
       }
     }
   }

   tests_run_++;

   TextRun text_run(input.data(), input.size());
   switch (paragraph_direction) {
     case bidi_test::kDirectionAutoLTR:
       text_run.SetDirection(DetermineParagraphDirectionality(text_run));
       break;
     case bidi_test::kDirectionLTR:
       text_run.SetDirection(TextDirection::kLtr);
       break;
     case bidi_test::kDirectionRTL:
       text_run.SetDirection(TextDirection::kRtl);
       break;
     default:
       break;
   }
   BidiResolver<TextRunIterator, BidiCharacterRun> resolver;
   resolver.SetStatus(
       BidiStatus(text_run.Direction(), text_run.DirectionalOverride()));
   resolver.SetPositionIgnoringNestedIsolates(TextRunIterator(&text_run, 0));

   BidiRunList<BidiCharacterRun>& runs = resolver.Runs();
   resolver.CreateBidiRunsForLine(TextRunIterator(&text_run, text_run.length()));

   std::ostringstream error_context;
   error_context << ", line " << line_number << " \"" << line << "\"";
   error_context << " context: "
                 << bidi_test::NameFromParagraphDirection(paragraph_direction);

   Vector<int> actual_order;
   Vector<int> actual_levels;
   actual_levels.Fill(-1, input.size());
   BidiCharacterRun* run = runs.FirstRun();
   while (run) {
     // Blink's UBA just makes runs, the actual ordering of the display of
     // characters is handled later in our pipeline, so we fake it here:
     bool reversed = run->Reversed(false);
     DCHECK_GE(run->Stop(), run->Start());
     size_t length = run->Stop() - run->Start();
     for (size_t i = 0; i < length; i++) {
       int input_index = reversed ? run->Stop() - i - 1 : run->Start() + i;
       if (!IsNonRenderedCodePoint(input[input_index]))
         actual_order.push_back(input_index);
       // BidiTest.txt gives expected level data in the order of the original
       // input.
       actual_levels[input_index] = run->Level();
     }
     run = run->Next();
   }

   if (expected_order.size() != actual_order.size()) {
     ignored_char_failures_++;
     EXPECT_EQ(expected_order.size(), actual_order.size())
         << error_context.str();
   } else if (expected_order != actual_order) {
     order_failures_++;
     printf("ORDER %s%s\n", DiffString(actual_order, expected_order).c_str(),
            error_context.str().c_str());
   }

   if (expected_levels.size() != actual_levels.size()) {
     ignored_char_failures_++;
     EXPECT_EQ(expected_levels.size(), actual_levels.size())
         << error_context.str();
   } else {
     for (size_t i = 0; i < expected_levels.size(); i++) {
       // level == -1 means the level should be ignored.
       if (expected_levels[i] == actual_levels[i] || expected_levels[i] == -1)
         continue;

       printf("LEVELS %s%s\n",
              DiffString(actual_levels, expected_levels).c_str(),
              error_context.str().c_str());
       level_failures_++;
       break;
     }
   }
   runs.DeleteRuns();
 }

 TEST(BidiResolver, DISABLED_BidiTest_txt) {
   BidiTestRunner runner;
   // Blink's Unicode Bidi Algorithm (UBA) doesn't yet support the
   // new isolate directives from Unicode 6.3:
   // http://www.unicode.org/reports/tr9/#Explicit_Directional_Isolates
   runner.SkipTestsWith(0x2066);  // LRI
   runner.SkipTestsWith(0x2067);  // RLI
   runner.SkipTestsWith(0x2068);  // FSI
   runner.SkipTestsWith(0x2069);  // PDI

   std::string bidi_test_path = "BidiTest.txt";
   std::ifstream bidi_test_file(bidi_test_path.c_str());
   EXPECT_TRUE(bidi_test_file.is_open());
   bidi_test::Harness<BidiTestRunner> harness(runner);
   harness.Parse(bidi_test_file);
   bidi_test_file.close();

   if (runner.tests_skipped_)
     LOG(WARNING) << "WARNING: Skipped " << runner.tests_skipped_ << " tests.";
   LOG(INFO) << "Ran " << runner.tests_run_
             << " tests: " << runner.level_failures_ << " level failures "
             << runner.order_failures_ << " order failures.";

   // The unittest harness only pays attention to GTest output, so we verify
   // that the tests behaved as expected:
   EXPECT_EQ(352098u, runner.tests_run_);
   EXPECT_EQ(418143u, runner.tests_skipped_);
   EXPECT_EQ(0u, runner.ignored_char_failures_);
   EXPECT_EQ(44882u, runner.level_failures_);
   EXPECT_EQ(19151u, runner.order_failures_);
 }

 TEST(BidiResolver, DISABLED_BidiCharacterTest_txt) {
   BidiTestRunner runner;
   // Blink's Unicode Bidi Algorithm (UBA) doesn't yet support the
   // new isolate directives from Unicode 6.3:
   // http://www.unicode.org/reports/tr9/#Explicit_Directional_Isolates
   runner.SkipTestsWith(0x2066);  // LRI
   runner.SkipTestsWith(0x2067);  // RLI
   runner.SkipTestsWith(0x2068);  // FSI
   runner.SkipTestsWith(0x2069);  // PDI

   std::string bidi_test_path = "BidiCharacterTest.txt";
   std::ifstream bidi_test_file(bidi_test_path.c_str());
   EXPECT_TRUE(bidi_test_file.is_open());
   bidi_test::CharacterHarness<BidiTestRunner> harness(runner);
   harness.Parse(bidi_test_file);
   bidi_test_file.close();

   if (runner.tests_skipped_)
     LOG(WARNING) << "WARNING: Skipped " << runner.tests_skipped_ << " tests.";
   LOG(INFO) << "Ran " << runner.tests_run_
             << " tests: " << runner.level_failures_ << " level failures "
             << runner.order_failures_ << " order failures.";

   EXPECT_EQ(91660u, runner.tests_run_);
   EXPECT_EQ(39u, runner.tests_skipped_);
   EXPECT_EQ(0u, runner.ignored_char_failures_);
   EXPECT_EQ(14533u, runner.level_failures_);
   EXPECT_EQ(14533u, runner.order_failures_);
 }

 }  // namespace blink
	/*
	* Copyright (C) 2013 Google Inc. All rights reserved.
	*
	* Redistribution and use in source and binary forms, with or without
	* modification, are permitted provided that the following conditions are
	* met:
	*
	* * Redistributions of source code must retain the above copyright
	* notice, this list of conditions and the following disclaimer.
	* * Redistributions in binary form must reproduce the above
	* copyright notice, this list of conditions and the following disclaimer
	* in the documentation and/or other materials provided with the
	* distribution.
	* * Neither the name of Google Inc. nor the names of its
	* contributors may be used to endorse or promote products derived from
	* this software without specific prior written permission.
	*
	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
	* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
	* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
	* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
	* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
	* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
	* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	*/

	#include "third_party/blink/renderer/platform/text/bidi_resolver.h"

	#include <fstream>

	#include "base/stl_util.h"
	#include "testing/gtest/include/gtest/gtest.h"
	#include "third_party/blink/renderer/platform/text/bidi_test_harness.h"
	#include "third_party/blink/renderer/platform/text/text_run_iterator.h"
	#include "third_party/blink/renderer/platform/wtf/allocator/allocator.h"

	namespace blink {

	TEST(BidiResolver, Basic) {
	bool has_strong_directionality;
	String value("foo");
	TextRun run(value);
	BidiResolver<TextRunIterator, BidiCharacterRun> bidi_resolver;
	bidi_resolver.SetStatus(
	BidiStatus(run.Direction(), run.DirectionalOverride()));
	bidi_resolver.SetPositionIgnoringNestedIsolates(TextRunIterator(&run, 0));
	TextDirection direction = bidi_resolver.DetermineParagraphDirectionality(
	&has_strong_directionality);
	EXPECT_TRUE(has_strong_directionality);
	EXPECT_EQ(TextDirection::kLtr, direction);
	}

	TextDirection DetermineParagraphDirectionality(
	const TextRun& text_run,
	bool* has_strong_directionality = nullptr) {
	BidiResolver<TextRunIterator, BidiCharacterRun> resolver;
	resolver.SetStatus(BidiStatus(TextDirection::kLtr, false));
	resolver.SetPositionIgnoringNestedIsolates(TextRunIterator(&text_run, 0));
	return resolver.DetermineParagraphDirectionality(has_strong_directionality);
	}

	struct TestData {
	UChar text[3];
	size_t length;
	TextDirection expected_direction;
	bool expected_strong;
	};

	void TestDirectionality(const TestData& entry) {
	bool has_strong_directionality;
	String data(entry.text, entry.length);
	TextRun run(data);
	TextDirection direction =
	DetermineParagraphDirectionality(run, &has_strong_directionality);
	EXPECT_EQ(entry.expected_strong, has_strong_directionality);
	EXPECT_EQ(entry.expected_direction, direction);
	}

	TEST(BidiResolver, ParagraphDirectionSurrogates) {
	const TestData kTestData[] = {
	// Test strong RTL, non-BMP. (U+10858 Imperial
	// Aramaic number one, strong RTL)
	{{0xD802, 0xDC58}, 2, TextDirection::kRtl, true},

	// Test strong LTR, non-BMP. (U+1D15F Musical
	// symbol quarter note, strong LTR)
	{{0xD834, 0xDD5F}, 2, TextDirection::kLtr, true},

	// Test broken surrogate: valid leading, invalid
	// trail. (Lead of U+10858, space)
	{{0xD802, ' '}, 2, TextDirection::kLtr, false},

	// Test broken surrogate: invalid leading. (Trail
	// of U+10858, U+05D0 Hebrew Alef)
	{{0xDC58, 0x05D0}, 2, TextDirection::kRtl, true},

	// Test broken surrogate: valid leading, invalid
	// trail/valid lead, valid trail.
	{{0xD802, 0xD802, 0xDC58}, 3, TextDirection::kRtl, true},

	// Test broken surrogate: valid leading, no trail
	// (string too short). (Lead of U+10858)
	{{0xD802, 0xDC58}, 1, TextDirection::kLtr, false},

	// Test broken surrogate: trail appearing before
	// lead. (U+10858 units reversed)
	{{0xDC58, 0xD802}, 2, TextDirection::kLtr, false}};
	for (size_t i = 0; i < base::size(kTestData); ++i)
	TestDirectionality(kTestData[i]);
	}

	class BidiTestRunner {
	STACK_ALLOCATED();

	public:
	BidiTestRunner()
	: tests_run_(0),
	tests_skipped_(0),
	ignored_char_failures_(0),
	level_failures_(0),
	order_failures_(0) {}

	void SkipTestsWith(UChar codepoint) {
	skipped_code_points_.insert(codepoint);
	}

	void RunTest(const std::basic_string<UChar>& input,
	const Vector<int>& reorder,
	const Vector<int>& levels,
	bidi_test::ParagraphDirection,
	const std::string& line,
	size_t line_number);

	size_t tests_run_;
	size_t tests_skipped_;
	HashSet<UChar> skipped_code_points_;
	size_t ignored_char_failures_;
	size_t level_failures_;
	size_t order_failures_;
	};

	// Blink's UBA does not filter out control characters, etc. Maybe it should?
	// Instead it depends on later layers of Blink to simply ignore them.
	// This function helps us emulate that to be compatible with BidiTest.txt
	// expectations.
	static bool IsNonRenderedCodePoint(UChar c) {
	// The tests also expect us to ignore soft-hyphen.
	if (c == 0xAD)
	return true;
	// Control characters are not rendered:
	return c >= 0x202A && c <= 0x202E;
	// But it seems to expect LRI, etc. to be rendered!?
	}

	std::string DiffString(const Vector<int>& actual, const Vector<int>& expected) {
	std::ostringstream diff;
	diff << "actual: ";
	// This is the magical way to print a vector to a stream, clear, right?
	std::copy(actual.begin(), actual.end(),
	std::ostream_iterator<int>(diff, " "));
	diff << " expected: ";
	std::copy(expected.begin(), expected.end(),
	std::ostream_iterator<int>(diff, " "));
	return diff.str();
	}

	void BidiTestRunner::RunTest(const std::basic_string<UChar>& input,
	const Vector<int>& expected_order,
	const Vector<int>& expected_levels,
	bidi_test::ParagraphDirection paragraph_direction,
	const std::string& line,
	size_t line_number) {
	if (!skipped_code_points_.IsEmpty()) {
	for (size_t i = 0; i < input.size(); i++) {
	if (skipped_code_points_.Contains(input[i])) {
	tests_skipped_++;
	return;
	}
	}
	}

	tests_run_++;

	TextRun text_run(input.data(), input.size());
	switch (paragraph_direction) {
	case bidi_test::kDirectionAutoLTR:
	text_run.SetDirection(DetermineParagraphDirectionality(text_run));
	break;
	case bidi_test::kDirectionLTR:
	text_run.SetDirection(TextDirection::kLtr);
	break;
	case bidi_test::kDirectionRTL:
	text_run.SetDirection(TextDirection::kRtl);
	break;
	default:
	break;
	}
	BidiResolver<TextRunIterator, BidiCharacterRun> resolver;
	resolver.SetStatus(
	BidiStatus(text_run.Direction(), text_run.DirectionalOverride()));
	resolver.SetPositionIgnoringNestedIsolates(TextRunIterator(&text_run, 0));

	BidiRunList<BidiCharacterRun>& runs = resolver.Runs();
	resolver.CreateBidiRunsForLine(TextRunIterator(&text_run, text_run.length()));

	std::ostringstream error_context;
	error_context << ", line " << line_number << " \"" << line << "\"";
	error_context << " context: "
	<< bidi_test::NameFromParagraphDirection(paragraph_direction);

	Vector<int> actual_order;
	Vector<int> actual_levels;
	actual_levels.Fill(-1, input.size());
	BidiCharacterRun* run = runs.FirstRun();
	while (run) {
	// Blink's UBA just makes runs, the actual ordering of the display of
	// characters is handled later in our pipeline, so we fake it here:
	bool reversed = run->Reversed(false);
	DCHECK_GE(run->Stop(), run->Start());
	size_t length = run->Stop() - run->Start();
	for (size_t i = 0; i < length; i++) {
	int input_index = reversed ? run->Stop() - i - 1 : run->Start() + i;
	if (!IsNonRenderedCodePoint(input[input_index]))
	actual_order.push_back(input_index);
	// BidiTest.txt gives expected level data in the order of the original
	// input.
	actual_levels[input_index] = run->Level();
	}
	run = run->Next();
	}

	if (expected_order.size() != actual_order.size()) {
	ignored_char_failures_++;
	EXPECT_EQ(expected_order.size(), actual_order.size())
	<< error_context.str();
	} else if (expected_order != actual_order) {
	order_failures_++;
	printf("ORDER %s%s\n", DiffString(actual_order, expected_order).c_str(),
	error_context.str().c_str());
	}

	if (expected_levels.size() != actual_levels.size()) {
	ignored_char_failures_++;
	EXPECT_EQ(expected_levels.size(), actual_levels.size())
	<< error_context.str();
	} else {
	for (size_t i = 0; i < expected_levels.size(); i++) {
	// level == -1 means the level should be ignored.
	if (expected_levels[i] == actual_levels[i] \|\| expected_levels[i] == -1)
	continue;

	printf("LEVELS %s%s\n",
	DiffString(actual_levels, expected_levels).c_str(),
	error_context.str().c_str());
	level_failures_++;
	break;
	}
	}
	runs.DeleteRuns();
	}

	TEST(BidiResolver, DISABLED_BidiTest_txt) {
	BidiTestRunner runner;
	// Blink's Unicode Bidi Algorithm (UBA) doesn't yet support the
	// new isolate directives from Unicode 6.3:
	// http://www.unicode.org/reports/tr9/#Explicit_Directional_Isolates
	runner.SkipTestsWith(0x2066); // LRI
	runner.SkipTestsWith(0x2067); // RLI
	runner.SkipTestsWith(0x2068); // FSI
	runner.SkipTestsWith(0x2069); // PDI

	std::string bidi_test_path = "BidiTest.txt";
	std::ifstream bidi_test_file(bidi_test_path.c_str());
	EXPECT_TRUE(bidi_test_file.is_open());
	bidi_test::Harness<BidiTestRunner> harness(runner);
	harness.Parse(bidi_test_file);
	bidi_test_file.close();

	if (runner.tests_skipped_)
	LOG(WARNING) << "WARNING: Skipped " << runner.tests_skipped_ << " tests.";
	LOG(INFO) << "Ran " << runner.tests_run_
	<< " tests: " << runner.level_failures_ << " level failures "
	<< runner.order_failures_ << " order failures.";

	// The unittest harness only pays attention to GTest output, so we verify
	// that the tests behaved as expected:
	EXPECT_EQ(352098u, runner.tests_run_);
	EXPECT_EQ(418143u, runner.tests_skipped_);
	EXPECT_EQ(0u, runner.ignored_char_failures_);
	EXPECT_EQ(44882u, runner.level_failures_);
	EXPECT_EQ(19151u, runner.order_failures_);
	}

	TEST(BidiResolver, DISABLED_BidiCharacterTest_txt) {
	BidiTestRunner runner;
	// Blink's Unicode Bidi Algorithm (UBA) doesn't yet support the
	// new isolate directives from Unicode 6.3:
	// http://www.unicode.org/reports/tr9/#Explicit_Directional_Isolates
	runner.SkipTestsWith(0x2066); // LRI
	runner.SkipTestsWith(0x2067); // RLI
	runner.SkipTestsWith(0x2068); // FSI
	runner.SkipTestsWith(0x2069); // PDI

	std::string bidi_test_path = "BidiCharacterTest.txt";
	std::ifstream bidi_test_file(bidi_test_path.c_str());
	EXPECT_TRUE(bidi_test_file.is_open());
	bidi_test::CharacterHarness<BidiTestRunner> harness(runner);
	harness.Parse(bidi_test_file);
	bidi_test_file.close();

	if (runner.tests_skipped_)
	LOG(WARNING) << "WARNING: Skipped " << runner.tests_skipped_ << " tests.";
	LOG(INFO) << "Ran " << runner.tests_run_
	<< " tests: " << runner.level_failures_ << " level failures "
	<< runner.order_failures_ << " order failures.";

	EXPECT_EQ(91660u, runner.tests_run_);
	EXPECT_EQ(39u, runner.tests_skipped_);
	EXPECT_EQ(0u, runner.ignored_char_failures_);
	EXPECT_EQ(14533u, runner.level_failures_);
	EXPECT_EQ(14533u, runner.order_failures_);
	}

	} // namespace blink