}

  @Test fun proxySelectorReturnsNull() {
    val nullProxySelector: ProxySelector =
      object : ProxySelector() {
        override fun select(uri: URI): List<Proxy>? {
          assertThat(uri.host).isEqualTo(uriHost)
          return null
        }

        override fun connectFailed(
          uri: URI,
          socketAddress: SocketAddress,
          e: IOException,

    }

    /**
     * Close the buffer manager and release all resources
     *
     * @throws Exception if cleanup fails
     */
    @Override
    public void close() throws Exception {
        cleanup();
    }

    /**
     * Get total number of regions allocated
     *
     * @return total allocated regions
     */

    private final BuildPluginManager pluginManager;

    @Inject
    public DefaultLifecycleMappingDelegate(BuildPluginManager pluginManager) {
        this.pluginManager = pluginManager;
    }

    @Override
    public Map<String, List<MojoExecution>> calculateLifecycleMappings(
            MavenSession session, MavenProject project, Lifecycle lifecycle, String lifecyclePhase)

        return modelBuilder;
    }

    private static class StubLifecycleBindingsInjector implements LifecycleBindingsInjector {

        @Override
        public void injectLifecycleBindings(
                Model model, ModelBuildingRequest request, ModelProblemCollector problems) {}
    }

   */
  protected abstract Table<String, Integer, C> create(@Nullable Object... data);

  protected void assertSize(int expectedSize) {
    assertEquals(expectedSize, table.size());
  }

  @Override
  public void setUp() throws Exception {
    super.setUp();
    table = create();
  }

  public void testContains() {
    table = create("foo", 1, 'a', "bar", 1, 'b', "foo", 3, 'c');

     * @param roundEnv environment for information about the current and prior round
     * @return whether or not the set of annotations are claimed by this processor
     */
    @Override
    public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
        logMessage(
                Diagnostic.Kind.NOTE, "Processing " + roundEnv.getRootElements().size() + " classes");

func Main(args []string) {
	// Set the minio app name.
	appName := filepath.Base(args[0])

	if debugNoExit {
		freeze := func(_ int) {
			// Infinite blocking op
			<-make(chan struct{})
		}

		// Override the logger os.Exit()
		logger.ExitFunc = freeze

		defer func() {
			if err := recover(); err != nil {
				fmt.Println("panic:", err)
				fmt.Println("")
				fmt.Println(string(debug.Stack()))
			}

 */
public class UrlFilterServiceImplTest extends PlainTestCase {

    @InjectMocks
    private UrlFilterServiceImpl service;

    @Mock
    private MemoryDataHelper dataHelper;

    @Override
    protected void setUp() throws Exception {
        super.setUp();
        MockitoAnnotations.openMocks(this);
    }

    public void test_addIncludeUrlFilterSingle() {
        // Setup

  enum ExampleFeature implements Feature<Object> {
    FOO,
    IMPLIES_FOO,
    IMPLIES_IMPLIES_FOO,
    BAR,
    IMPLIES_BAR,
    IMPLIES_IMPLIES_FOO_AND_IMPLIES_BAR;

    @Override
    public ImmutableSet<Feature<? super Object>> getImpliedFeatures() {
      switch (this) {
        case IMPLIES_FOO:
          return ImmutableSet.of(FOO);
        case IMPLIES_IMPLIES_FOO:

 that belong to the same group, the project level allows configuration management at
 the project level, and the user level allows users to override settings on
 the site level, group level and project level.

* Site configuration

 At the site level all configuration is achieved by tweaking the various files that