Use SpannedSubject in WebvttCueParserTest

This is a useful test to see if it works well in a real situation.

PiperOrigin-RevId: 285386471

library/core/src/test/java/com/google/android/exoplayer2/text/webvtt/WebvttCueParserTest.java

@@ -15,14 +15,10 @@
  */
 package com.google.android.exoplayer2.text.webvtt;
 
-import static android.graphics.Typeface.BOLD;
-import static android.graphics.Typeface.ITALIC;
+import static com.google.android.exoplayer2.testutil.truth.SpannedSubject.assertThat;
 import static com.google.common.truth.Truth.assertThat;
 
-import android.graphics.Typeface;
 import android.text.Spanned;
-import android.text.style.StyleSpan;
-import android.text.style.UnderlineSpan;
 import androidx.test.ext.junit.runners.AndroidJUnit4;
 import java.util.Collections;
 import org.junit.Test;
@@ -38,29 +34,22 @@ public final class WebvttCueParserTest {
         + "This <u.style1.style2 some stuff>is</u> text with <b.foo><i.bar>html</i></b> tags");
 
     assertThat(text.toString()).isEqualTo("This is text with html tags");
-
-    UnderlineSpan[] underlineSpans = getSpans(text, UnderlineSpan.class);
-    StyleSpan[] styleSpans = getSpans(text, StyleSpan.class);
-    assertThat(underlineSpans).hasLength(1);
-    assertThat(styleSpans).hasLength(2);
-    assertThat(styleSpans[0].getStyle()).isEqualTo(ITALIC);
-    assertThat(styleSpans[1].getStyle()).isEqualTo(BOLD);
-
-    assertThat(text.getSpanStart(underlineSpans[0])).isEqualTo(5);
-    assertThat(text.getSpanEnd(underlineSpans[0])).isEqualTo(7);
-    assertThat(text.getSpanStart(styleSpans[0])).isEqualTo(18);
-    assertThat(text.getSpanStart(styleSpans[1])).isEqualTo(18);
-    assertThat(text.getSpanEnd(styleSpans[0])).isEqualTo(22);
-    assertThat(text.getSpanEnd(styleSpans[1])).isEqualTo(22);
+    assertThat(text)
+        .hasUnderlineSpan("This ".length(), "This is".length(), Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
+    assertThat(text)
+        .hasBoldItalicSpan(
+            "This is text with ".length(),
+            "This is text with html".length(),
+            Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
   }
 
   @Test
   public void testParseStrictValidUnsupportedTagsStrippedOut() throws Exception {
     Spanned text = parseCueText("<v.first.loud Esme>This <unsupported>is</unsupported> text with "
         + "<notsupp><invalid>html</invalid></notsupp> tags");
+
     assertThat(text.toString()).isEqualTo("This is text with html tags");
-    assertThat(getSpans(text, UnderlineSpan.class)).hasLength(0);
-    assertThat(getSpans(text, StyleSpan.class)).hasLength(0);
+    assertThat(text).hasNoSpans();
   }
 
   @Test
@@ -69,80 +58,67 @@ public final class WebvttCueParserTest {
         + "<i>italic</i> inside");
 
     assertThat(text.toString()).isEqualTo("An unclosed u tag with italic inside");
-
-    UnderlineSpan[] underlineSpans = getSpans(text, UnderlineSpan.class);
-    StyleSpan[] styleSpans = getSpans(text, StyleSpan.class);
-    assertThat(underlineSpans).hasLength(1);
-    assertThat(styleSpans).hasLength(1);
-    assertThat(styleSpans[0].getStyle()).isEqualTo(ITALIC);
-
-    assertThat(text.getSpanStart(underlineSpans[0])).isEqualTo(3);
-    assertThat(text.getSpanStart(styleSpans[0])).isEqualTo(23);
-    assertThat(text.getSpanEnd(styleSpans[0])).isEqualTo(29);
-    assertThat(text.getSpanEnd(underlineSpans[0])).isEqualTo(36);
+    assertThat(text)
+        .hasUnderlineSpan(
+            "An ".length(),
+            "An unclosed u tag with italic inside".length(),
+            Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
+    assertThat(text)
+        .hasItalicSpan(
+            "An unclosed u tag with ".length(),
+            "An unclosed u tag with italic".length(),
+            Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
   }
 
   @Test
   public void testParseWellFormedUnclosedEndAtParent() throws Exception {
-    Spanned text = parseCueText("An unclosed u tag with <i><u>underline and italic</i> inside");
-
-    assertThat(text.toString()).isEqualTo("An unclosed u tag with underline and italic inside");
+    Spanned text = parseCueText("An italic tag with unclosed <i><u>underline</i> inside");
 
-    UnderlineSpan[] underlineSpans = getSpans(text, UnderlineSpan.class);
-    StyleSpan[] styleSpans = getSpans(text, StyleSpan.class);
-    assertThat(underlineSpans).hasLength(1);
-    assertThat(styleSpans).hasLength(1);
-
-    assertThat(text.getSpanStart(underlineSpans[0])).isEqualTo(23);
-    assertThat(text.getSpanStart(styleSpans[0])).isEqualTo(23);
-    assertThat(text.getSpanEnd(underlineSpans[0])).isEqualTo(43);
-    assertThat(text.getSpanEnd(styleSpans[0])).isEqualTo(43);
-
-    assertThat(styleSpans[0].getStyle()).isEqualTo(ITALIC);
+    assertThat(text.toString()).isEqualTo("An italic tag with unclosed underline inside");
+    assertThat(text)
+        .hasItalicSpan(
+            "An italic tag with unclosed ".length(),
+            "An italic tag with unclosed underline".length(),
+            Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
+    assertThat(text)
+        .hasUnderlineSpan(
+            "An italic tag with unclosed ".length(),
+            "An italic tag with unclosed underline".length(),
+            Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
   }
 
   @Test
   public void testParseMalformedNestedElements() throws Exception {
-    Spanned text = parseCueText("<b><u>An unclosed u tag with <i>italic</u> inside</i></b>");
-    assertThat(text.toString()).isEqualTo("An unclosed u tag with italic inside");
+    Spanned text = parseCueText("<b><u>Overlapping u <i>and</u> i tags</i></b>");
 
-    UnderlineSpan[] underlineSpans = getSpans(text, UnderlineSpan.class);
-    StyleSpan[] styleSpans = getSpans(text, StyleSpan.class);
-    assertThat(underlineSpans).hasLength(1);
-    assertThat(styleSpans).hasLength(2);
-
-    // all tags applied until matching start tag found
-    assertThat(text.getSpanStart(underlineSpans[0])).isEqualTo(0);
-    assertThat(text.getSpanEnd(underlineSpans[0])).isEqualTo(29);
-    if (styleSpans[0].getStyle() == Typeface.BOLD) {
-      assertThat(text.getSpanStart(styleSpans[0])).isEqualTo(0);
-      assertThat(text.getSpanStart(styleSpans[1])).isEqualTo(23);
-      assertThat(text.getSpanEnd(styleSpans[1])).isEqualTo(29);
-      assertThat(text.getSpanEnd(styleSpans[0])).isEqualTo(36);
-    } else {
-      assertThat(text.getSpanStart(styleSpans[1])).isEqualTo(0);
-      assertThat(text.getSpanStart(styleSpans[0])).isEqualTo(23);
-      assertThat(text.getSpanEnd(styleSpans[0])).isEqualTo(29);
-      assertThat(text.getSpanEnd(styleSpans[1])).isEqualTo(36);
-    }
+    String expectedText = "Overlapping u and i tags";
+    assertThat(text.toString()).isEqualTo(expectedText);
+    assertThat(text).hasBoldSpan(0, expectedText.length(), Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
+    // Text between the <u> tags is underlined.
+    assertThat(text)
+        .hasUnderlineSpan(0, "Overlapping u and".length(), Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
+    // Only text from <i> to <\\u> is italic (unexpected - but simplifies the parsing).
+    assertThat(text)
+        .hasItalicSpan(
+            "Overlapping u ".length(),
+            "Overlapping u and".length(),
+            Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
   }
 
   @Test
   public void testParseCloseNonExistingTag() throws Exception {
-    Spanned text = parseCueText("blah<b>blah</i>blah</b>blah");
-    assertThat(text.toString()).isEqualTo("blahblahblahblah");
+    Spanned text = parseCueText("foo<b>bar</i>baz</b>buzz");
+    assertThat(text.toString()).isEqualTo("foobarbazbuzz");
 
-    StyleSpan[] spans = getSpans(text, StyleSpan.class);
-    assertThat(spans).hasLength(1);
-    assertThat(spans[0].getStyle()).isEqualTo(BOLD);
-    assertThat(text.getSpanStart(spans[0])).isEqualTo(4);
-    assertThat(text.getSpanEnd(spans[0])).isEqualTo(8); // should be 12 when valid
+    // endIndex should be 9 when valid (i.e. "foobarbaz".length()
+    assertThat(text)
+        .hasBoldSpan("foo".length(), "foobar".length(), Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
   }
 
   @Test
   public void testParseEmptyTagName() throws Exception {
-    Spanned text = parseCueText("An unclosed u tag with <>italic inside");
-    assertThat(text.toString()).isEqualTo("An unclosed u tag with italic inside");
+    Spanned text = parseCueText("An empty <>tag");
+    assertThat(text.toString()).isEqualTo("An empty tag");
   }
 
   @Test
@@ -186,14 +162,13 @@ public final class WebvttCueParserTest {
     Spanned text = parseCueText("blah <b>blah</b> blah <b>foo</b>");
 
     assertThat(text.toString()).isEqualTo("blah blah blah foo");
-    StyleSpan[] spans = getSpans(text, StyleSpan.class);
-    assertThat(spans).hasLength(2);
-    assertThat(text.getSpanStart(spans[0])).isEqualTo(5);
-    assertThat(text.getSpanEnd(spans[0])).isEqualTo(9);
-    assertThat(text.getSpanStart(spans[1])).isEqualTo(15);
-    assertThat(text.getSpanEnd(spans[1])).isEqualTo(18);
-    assertThat(spans[0].getStyle()).isEqualTo(BOLD);
-    assertThat(spans[1].getStyle()).isEqualTo(BOLD);
+    assertThat(text)
+        .hasBoldSpan("blah ".length(), "blah blah".length(), Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
+    assertThat(text)
+        .hasBoldSpan(
+            "blah blah blah ".length(),
+            "blah blah blah foo".length(),
+            Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
   }
 
   @Test
@@ -201,8 +176,7 @@ public final class WebvttCueParserTest {
     Spanned text = parseCueText("blah <b/.st1.st2 trailing stuff> blah");
 
     assertThat(text.toString()).isEqualTo("blah  blah");
-    StyleSpan[] spans = getSpans(text, StyleSpan.class);
-    assertThat(spans).hasLength(0);
+    assertThat(text).hasNoSpans();
   }
 
   @Test

testutils/src/main/java/com/google/android/exoplayer2/testutil/truth/SpannedSubject.java

@@ -58,6 +58,16 @@ public final class SpannedSubject extends Subject {
     return assertAbout(spanned()).that(spanned);
   }
 
+  public void hasNoSpans() {
+    Object[] spans = actual.getSpans(0, actual.length(), Object.class);
+    if (spans.length > 0) {
+      failWithoutActual(
+          simpleFact("Expected no spans"),
+          fact("in text", actual),
+          fact("but found", actualSpansString()));
+    }
+  }
+
   /**
    * Checks that the subject has an italic span from {@code startIndex} to {@code endIndex}.
    *

testutils/src/test/java/com/google/android/exoplayer2/testutil/truth/SpannedSubjectTest.java

@@ -36,6 +36,24 @@ import org.junit.runner.RunWith;
 public class SpannedSubjectTest {
 
   @Test
+  public void hasNoSpans_success() {
+    SpannableString spannable = SpannableString.valueOf("test with no spans");
+
+    assertThat(spannable).hasNoSpans();
+  }
+
+  @Test
+  public void hasNoSpans_failure() {
+    SpannableString spannable = SpannableString.valueOf("test with underlined section");
+    spannable.setSpan(new UnderlineSpan(), 5, 10, Spanned.SPAN_INCLUSIVE_EXCLUSIVE);
+
+    AssertionError expected =
+        expectFailure(whenTesting -> whenTesting.that(spannable).hasNoSpans());
+    assertThat(expected).factKeys().contains("Expected no spans");
+    assertThat(expected).factValue("but found").contains("start=" + 5);
+  }
+
+  @Test
   public void italicSpan_success() {
     SpannableString spannable = SpannableString.valueOf("test with italic section");
     int start = "test with ".length();