System.err.println("Ignoring unsupported scheme ${testData.scheme}")
      return
    }

    if (!testData.base!!.startsWith("https:") &&
      !testData.base!!.startsWith("http:") &&
      testData.base != "about:blank"
    ) {
      System.err.println("Ignoring unsupported base ${testData.base}")
      return
    }

    try {

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package okhttp3.internal.connection

/**
 * A RoutePlanner that will always establish a new connection, ignoring any connection pooling
 */
class ForceConnectRoutePlanner(
  private val delegate: RealRoutePlanner,
) : RoutePlanner by delegate {
  override fun plan(): RoutePlanner.Plan = delegate.planConnect() // not delegate.plan()

    }

    /**
     * Returns whether two strings are equal ignoring case. If both are null, returns <code>true</code>.
     *
     * @param target1
     *            the first string
     * @param target2
     *            the second string
     * @return {@literal true} if the strings are equal ignoring case
     */

  when {
    this.isNullOrEmpty() -> emptyList()
    this.size == 1 -> Collections.singletonList(this[0])
    else -> this.clone().asList().unmodifiable()
  }

/** Closes this, ignoring any checked exceptions. */
internal fun Socket.closeQuietly() {
  try {
    close()
  } catch (e: AssertionError) {
    throw e
  } catch (rethrown: RuntimeException) {

            LOGGER.info(
                    "System property '" + Constants.MAVEN_LOGGER_DEFAULT_LOG_LEVEL + "' is already set to '" + current
                            + "' - ignoring system property and get log level from -X/-e/-q options, log level will be set to "
                            + value);
        }
    }

    @Override
    public void activate() {

                    if (reactorBuildStatus.isHalted()) {
                        break;
                    }
                } catch (Exception e) {
                    break; // Why are we just ignoring this exception? Are exceptions are being used for flow control
                }
            }
        }
    }

        final String id = scheduledJob.getId();
        final String target = scheduledJob.getTarget();
        if (!ComponentUtil.getFessConfig().isSchedulerTarget(target)) {
            logger.info("Ignoring job: name={}, id={}, target={}", scheduledJob.getName(), id, scheduledJob.getTarget());
            return;
        }

        final JobHelper jobHelper = ComponentUtil.getJobHelper();

import org.codehaus.plexus.logging.LoggerManager;
import org.slf4j.ILoggerFactory;
import org.slf4j.LoggerFactory;

/**
 * Use an SLF4J {@link ILoggerFactory} as a backing for a Plexus
 * {@link LoggerManager},
 * ignoring Plexus logger API parts that are not classical and probably not really used.
 *
 * @since 3.1
 */
public class Slf4jLoggerManager implements LoggerManager {

    private final ILoggerFactory loggerFactory;

                    string(v2_reader_->key()) /* full var's name */,
                    TensorSlice(slice_proto)))
                .second);
    }
  }

  // Second pass: adds the entries, ignoring the filtered keys.
  std::unique_ptr<TensorSliceReader::VarToShapeMap> var_to_shape_map(
      new TensorSliceReader::VarToShapeMap);
  std::unique_ptr<TensorSliceReader::VarToDataTypeMap> var_to_data_type_map(

      dummy ^= JOINER_ON_CHARACTER.join(components).length();
    }
    return dummy;
  }

  /**
   * Mimics what the {@link Joiner} class does internally when no extra options like ignoring {@code
   * null} values are used.
   */
  @Benchmark
  int joinerInlined(int reps) {
    int dummy = 0;
    for (int i = 0; i < reps; i++) {
      StringBuilder sb = new StringBuilder();