fonts/shaping/stretchy_operator_shaper_test.cc

// Copyright 2020 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "third_party/blink/renderer/platform/fonts/shaping/stretchy_operator_shaper.h"
#include "base/memory/scoped_refptr.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "third_party/blink/renderer/platform/fonts/font.h"
#include "third_party/blink/renderer/platform/fonts/opentype/open_type_types.h"
#include "third_party/blink/renderer/platform/fonts/shaping/shape_result_inline_headers.h"
#include "third_party/blink/renderer/platform/fonts/shaping/shape_result_test_info.h"
#include "third_party/blink/renderer/platform/testing/font_test_helpers.h"
#include "third_party/blink/renderer/platform/testing/unit_test_helpers.h"

namespace blink {

namespace {

const UChar32 kLeftBraceCodePoint = '{';
const UChar32 kOverBraceCodePoint = 0x23DE;
const UChar32 kRightwardsFrontTiltedShadowedWhiteArrowCodePoint = 0x1F8AB;
const UChar32 kNAryWhiteVerticalBarCodePoint = 0x2AFF;
float kSizeError = .1;

ShapeResultTestInfo* TestInfo(const scoped_refptr<ShapeResult>& result) {
  return static_cast<ShapeResultTestInfo*>(result.get());
}

}  // namespace

class StretchyOperatorShaperTest : public testing::Test {
 protected:
  void SetUp() override {
    font_description.SetComputedSize(10.0);
    font = Font(font_description);
  }

  void TearDown() override {}

  Font CreateMathFont(const String& name, float size = 1000) {
    FontDescription::VariantLigatures ligatures;
    return blink::test::CreateTestFont(
        "MathTestFont",
        blink::test::BlinkWebTestsFontsTestDataPath(String("math/") + name),
        size, &ligatures);
  }

  FontDescription font_description;
  Font font;
};

// See createStretchy() in
// third_party/blink/web_tests/external/wpt/mathml/tools/operator-dictionary.py
TEST_F(StretchyOperatorShaperTest, GlyphVariants) {
  Font math = CreateMathFont("operators.woff");

  StretchyOperatorShaper vertical_shaper(
      kLeftBraceCodePoint, OpenTypeMathStretchData::StretchAxis::Vertical);
  StretchyOperatorShaper horizontal_shaper(
      kOverBraceCodePoint, OpenTypeMathStretchData::StretchAxis::Horizontal);

  auto left_brace = math.PrimaryFont()->GlyphForCharacter(kLeftBraceCodePoint);
  auto over_brace = math.PrimaryFont()->GlyphForCharacter(kOverBraceCodePoint);

  // Calculate glyph indices from the last unicode character in the font.
  // TODO(https://crbug.com/1057596): Find a better way to access these glyph
  // indices.
  auto v0 = math.PrimaryFont()->GlyphForCharacter(
                kRightwardsFrontTiltedShadowedWhiteArrowCodePoint) +
            1;
  auto h0 = v0 + 1;
  auto v1 = h0 + 1;
  auto h1 = v1 + 1;
  auto v2 = h1 + 1;
  auto h2 = v2 + 1;

  // Stretch operators to target sizes (in font units) 125, 250, 375, 500, 625,
  // 750, 875, 1000, 1125, ..., 3750, 3875, 4000.
  //
  // Shaper tries glyphs over_brace/left_brace, h0/v0, h1/v1, h2/v2, h3/v3 of
  // respective sizes 1000, 1000, 2000, 3000 and 4000. It returns the smallest
  // glyph larger than the target size.
  const unsigned size_count = 4;
  const unsigned subdivision = 8;
  for (unsigned i = 0; i < size_count; i++) {
    for (unsigned j = 1; j <= subdivision; j++) {
      // Due to floating-point errors, the actual metrics of the size variants
      // might actually be slightly smaller than expected. Reduce the
      // target_size by kSizeError to ensure that the shaper picks the desired
      // size variant.
      float target_size = i * 1000 + (j * 1000 / subdivision) - kSizeError;

      // Metrics of horizontal size variants.
      {
        StretchyOperatorShaper::Metrics metrics;
        horizontal_shaper.Shape(&math, target_size, &metrics);
        EXPECT_NEAR(metrics.advance, (i + 1) * 1000, kSizeError);
        EXPECT_NEAR(metrics.ascent, 1000, kSizeError);
        EXPECT_FLOAT_EQ(metrics.descent, 0);
      }

      // Metrics of vertical size variants.

      {
        StretchyOperatorShaper::Metrics metrics;
        vertical_shaper.Shape(&math, target_size, &metrics);
        EXPECT_NEAR(metrics.advance, 1000, kSizeError);
        EXPECT_NEAR(metrics.ascent, (i + 1) * 1000, kSizeError);
        EXPECT_FLOAT_EQ(metrics.descent, 0);
      }

      // Shaping of horizontal size variants.
      {
        scoped_refptr<ShapeResult> result =
            horizontal_shaper.Shape(&math, target_size);
        EXPECT_EQ(TestInfo(result)->NumberOfRunsForTesting(), 1u);
        EXPECT_EQ(TestInfo(result)->RunInfoForTesting(0).NumGlyphs(), 1u);
        Glyph expected_variant = i ? h0 + 2 * i : over_brace;
        EXPECT_EQ(TestInfo(result)->GlyphForTesting(0, 0), expected_variant);
        EXPECT_NEAR(TestInfo(result)->AdvanceForTesting(0, 0), (i + 1) * 1000,
                    kSizeError);
      }

      // Shaping of vertical size variants.
      {
        scoped_refptr<ShapeResult> result =
            vertical_shaper.Shape(&math, target_size);
        EXPECT_EQ(TestInfo(result)->NumberOfRunsForTesting(), 1u);
        EXPECT_EQ(TestInfo(result)->RunInfoForTesting(0).NumGlyphs(), 1u);
        Glyph expected_variant = i ? v0 + 2 * i : left_brace;
        EXPECT_EQ(TestInfo(result)->GlyphForTesting(0, 0), expected_variant);
        EXPECT_NEAR(TestInfo(result)->AdvanceForTesting(0, 0), (i + 1) * 1000,
                    kSizeError);
      }
    }
  }

  // Stretch an operator to target sizes (in font units) much larger than 4000.
  //
  // This will force an assembly with the following parts:
  // _____________________________________________________________
  // Part  | MaxStartOverlap | MaxEndOverlap | Advance | Extender |
  // h2/v2 |     0           |    1000       | 3000    |   false  |
  // h1/v1 |    1000         |    1000       | 2000    |   true   |
  //
  // For an assembly made of one non-extender glyph h2/v2 and repetition_count
  // copies of extenders h1/v1, the size is
  // advance(h2/v2) + repetition_count * (advance(h1/v1) - overlap).
  //
  // For repetition_count = k and overlap = 750, the size is X = 1250k + 3000.
  //
  // Since the font min overlap is 500, for repetition_count = k - 1 the size
  // is at most Y = 1500k + 1500.
  //
  // Since the max overlap of parts is 1000, for repetition_count = k + 1 the
  // size is at least Z = 1000k + 4000.
  //
  // { X - 4000 = 1250k - 1000 >= 250 >> kSizeError for k >= 1.
  // { X - Y = 1500 - 250k >= 250 >> kSizeError for k <= 5.
  // Hence setting the target size to 1250k + 3000 will ensure an assembly of
  // k + 1 glyphs and overlap close to 750 for 1 <= k <= 5.
  //
  // Additionally, X - Z = 250k - 1000 = 250 >> kSizeError for k = 5 so this
  // case also verifies that the minimal number of repetitions is actually used.
  //
  for (unsigned repetition_count = 1; repetition_count <= 5;
       repetition_count++) {
    // It is not necessary to decrease the target_size by kSizeError here. The
    // shaper can just increase overlap by kSizeError / repetition_count to
    // reduce the actual size of the assembly.
    float overlap = 750;
    float target_size = 3000 + repetition_count * (2000 - overlap);

    // Metrics of horizontal assembly.
    {
      StretchyOperatorShaper::Metrics metrics;
      horizontal_shaper.Shape(&math, target_size, &metrics);
      EXPECT_NEAR(metrics.advance, target_size, kSizeError);
      EXPECT_NEAR(metrics.ascent, 1000, kSizeError);
      EXPECT_FLOAT_EQ(metrics.descent, 0);
    }

    // Metrics of vertical assembly.
    {
      StretchyOperatorShaper::Metrics metrics;
      vertical_shaper.Shape(&math, target_size, &metrics);
      EXPECT_NEAR(metrics.advance, 1000, kSizeError);
      EXPECT_NEAR(metrics.ascent, target_size, kSizeError);
      EXPECT_FLOAT_EQ(metrics.descent, 0);
    }

    // Shaping of horizontal assembly.
    // From left to right: h2, h1, h1, h1, ...
    {
      scoped_refptr<ShapeResult> result =
          horizontal_shaper.Shape(&math, target_size);

      EXPECT_EQ(TestInfo(result)->NumberOfRunsForTesting(), 1u);
      EXPECT_EQ(TestInfo(result)->RunInfoForTesting(0).NumGlyphs(),
                repetition_count + 1);
      EXPECT_EQ(TestInfo(result)->GlyphForTesting(0, 0), h2);
      EXPECT_NEAR(TestInfo(result)->AdvanceForTesting(0, 0), 3000 - overlap,
                  kSizeError);
      for (unsigned i = 0; i < repetition_count - 1; i++) {
        EXPECT_EQ(TestInfo(result)->GlyphForTesting(0, i + 1), h1);
        EXPECT_NEAR(TestInfo(result)->AdvanceForTesting(0, i + 1),
                    2000 - overlap, kSizeError);
      }
      EXPECT_EQ(TestInfo(result)->GlyphForTesting(0, repetition_count), h1);
      EXPECT_NEAR(TestInfo(result)->AdvanceForTesting(0, repetition_count),
                  2000, kSizeError);
    }

    // Shaping of vertical assembly.
    // From bottom to top: v2, v1, v1, v1, ...
    {
      scoped_refptr<ShapeResult> result =
          vertical_shaper.Shape(&math, target_size);

      EXPECT_EQ(TestInfo(result)->NumberOfRunsForTesting(), 1u);
      EXPECT_EQ(TestInfo(result)->RunInfoForTesting(0).NumGlyphs(),
                repetition_count + 1);
      for (unsigned i = 0; i < repetition_count; i++) {
        EXPECT_EQ(TestInfo(result)->GlyphForTesting(0, i), v1);
        EXPECT_NEAR(TestInfo(result)->AdvanceForTesting(0, i), 2000 - overlap,
                    kSizeError);
      }
      EXPECT_EQ(TestInfo(result)->GlyphForTesting(0, repetition_count), v2);
      EXPECT_NEAR(TestInfo(result)->AdvanceForTesting(0, repetition_count),
                  3000, kSizeError);
    }
  }

  // Stretch an operator to edge target size values.
  //
  // These tests verify that it does not cause any assertion or crashes.
  {
    // Zero.
    float target_size = 0;
    horizontal_shaper.Shape(&math, target_size);
    vertical_shaper.Shape(&math, target_size);

    // Negative.
    target_size = -5500;
    horizontal_shaper.Shape(&math, target_size);
    vertical_shaper.Shape(&math, target_size);

    // Max limit.
    target_size = std::numeric_limits<float>::max();
    horizontal_shaper.Shape(&math, target_size);
    vertical_shaper.Shape(&math, target_size);

    // Min limit.
    target_size = std::numeric_limits<float>::min();
    horizontal_shaper.Shape(&math, target_size);
    vertical_shaper.Shape(&math, target_size);

    // More than the max number of glyphs.
    // The size of an assembly with one non-extender v2/h2 and k - 1 extenders
    // h1/v1 and minimal overlap 500 is Y = 1500k + 1500.
    // So target_size - Y >= 250 >> kSizeError if the assembly does not have
    // more than the max number of glyphs.
    target_size = 1500 * HarfBuzzRunGlyphData::kMaxGlyphs + 1750;
    horizontal_shaper.Shape(&math, target_size);
    vertical_shaper.Shape(&math, target_size);
  }
}

// See third_party/blink/web_tests/external/wpt/mathml/tools/largeop.py
TEST_F(StretchyOperatorShaperTest, MathItalicCorrection) {
  {
    Font math = CreateMathFont(
        "largeop-displayoperatorminheight2000-2AFF-italiccorrection3000.woff");
    StretchyOperatorShaper shaper(
        kNAryWhiteVerticalBarCodePoint,
        OpenTypeMathStretchData::StretchAxis::Vertical);

    // Base size.
    StretchyOperatorShaper::Metrics metrics;
    shaper.Shape(&math, 0, &metrics);
    EXPECT_EQ(metrics.italic_correction, 0);

    // Larger variant.
    float target_size = 2000 - kSizeError;
    shaper.Shape(&math, target_size, &metrics);
    EXPECT_EQ(metrics.italic_correction, 3000);
  }

  {
    Font math = CreateMathFont(
        "largeop-displayoperatorminheight7000-2AFF-italiccorrection5000.woff");
    StretchyOperatorShaper shaper(
        kNAryWhiteVerticalBarCodePoint,
        OpenTypeMathStretchData::StretchAxis::Vertical);

    // Base size.
    StretchyOperatorShaper::Metrics metrics;
    shaper.Shape(&math, 0, &metrics);
    EXPECT_EQ(metrics.italic_correction, 0);

    // Glyph assembly.
    float target_size = 7000;
    shaper.Shape(&math, target_size, &metrics);
    EXPECT_EQ(metrics.italic_correction, 5000);
  }
}

}  // namespace blink