if (versionsOfPatch.any { !it.contains("-") }) {
                                add(versionsOfPatch.first { !it.contains("-") })
                                break
                            }
                            if (versionsOfPatch.any { it.contains("-RC") }) {
                                add(versionsOfPatch.firstOrNull { it.contains("-RC") })

        // When
        String result = trans2GetDfsReferral.toString();

        // Then
        assertNotNull(result);
        assertTrue(result.contains("Trans2GetDfsReferral"));
        assertTrue(result.contains("maxReferralLevel=0x3"));
        assertTrue(result.contains("filename=" + filename));
    }

    @Test
    @DisplayName("toString should handle null path")
    void testToStringWithNullPath() {

 * limitations under the License.
 */
package okhttp.android.test.sni

import android.os.Build
import android.util.Log
import assertk.assertThat
import assertk.assertions.contains
import assertk.assertions.isEqualTo
import java.security.cert.X509Certificate
import javax.net.ssl.SNIHostName
import javax.net.ssl.SNIServerName
import javax.net.ssl.SSLSocket
import javax.net.ssl.SSLSocketFactory

  }

  /**
   * Delegates to {@link Collection#contains}. Returns {@code false} if the {@code contains} method
   * throws a {@code ClassCastException} or {@code NullPointerException}.
   */
  static boolean safeContains(Collection<?> collection, @Nullable Object object) {
    checkNotNull(collection);
    try {
      return collection.contains(object);
    } catch (ClassCastException | NullPointerException e) {

        logStream.flush();

        String output = testOutput.toString();
        assertTrue(output.contains("test"));
        assertTrue(output.contains("123"));
        assertTrue(output.contains("true"));
        assertTrue(output.contains("line"));
        assertTrue(output.contains("formatted 42"));
    }

    @Test
    void testDefaultLevel() {
        // Test that default level is 1

    assertTrue(permutationSet.contains(newArrayList(1, 2, 3)));
    assertTrue(permutationSet.contains(newArrayList(2, 3, 1)));
    assertFalse(permutationSet.contains(newArrayList(1, 2)));
    assertFalse(permutationSet.contains(newArrayList(1, 1, 2, 3)));
    assertFalse(permutationSet.contains(newArrayList(1, 2, 3, 4)));
    assertFalse(permutationSet.contains(null));
  }

    assertTrue(table.contains("foo", 1));
    assertTrue(table.contains("bar", 1));
    assertTrue(table.contains("foo", 3));
    assertFalse(table.contains("foo", 2));
    assertFalse(table.contains("bar", 3));
    assertFalse(table.contains("cat", 1));
    assertFalse(table.contains("foo", null));
    assertFalse(table.contains(null, 1));
    assertFalse(table.contains(null, null));
  }

          || (node.equals(target) && predecessorsOrEmpty(node).contains(source));
    } else {
      Set<N> adjacent = graph.adjacentNodes(node);
      Object nodeU = endpointPair.nodeU();
      Object nodeV = endpointPair.nodeV();

      return (node.equals(nodeV) && adjacent.contains(nodeU))
          || (node.equals(nodeU) && adjacent.contains(nodeV));
    }
  }

  /**

      return
    }

    try {
      testHttpUrl(testData)
      if (KNOWN_FAILURES.contains(testData.toString())) {
        System.err.println("Expected failure but was success: $testData")
      }
    } catch (e: Throwable) {
      if (KNOWN_FAILURES.contains(testData.toString())) {
        System.err.println("Ignoring known failure: $testData")
        e.printStackTrace()
      } else {

     *
     * @param array
     *            the array
     * @param value
     *            the value to search for
     * @return {@literal true} if the array contains the specified value
     */
    public static boolean contains(final double[] array, final double value) {
        return indexOf(array, value) > -1;
    }

    /**