public void testAccept() {
    File dir = new File("foo");
    FilenameFilter filter = new PatternFilenameFilter("a+");
    assertTrue(filter.accept(dir, "a"));
    assertTrue(filter.accept(dir, "aaaa"));
    assertFalse(filter.accept(dir, "b"));

    // Show that dir is ignored
    assertTrue(filter.accept(null, "a"));
  }

  public void testNulls() throws Exception {
    NullPointerTester tester = new NullPointerTester();

    def changes = new ErrorHandlingChangeContainer(task, delegate)

    def "accept error reports task path"() {
        when:
        changes.accept(Mock(ChangeVisitor))
        then:
        def ex = thrown GradleException
        ex.message == "Cannot determine changes for task ':test'"
        ex.cause.message == "Error!"
        1 * delegate.accept(_) >> { throw new RuntimeException("Error!") }
    }

        acceptor?.stop()
    }

    def "acceptor stop blocks until accept action has completed"() {
        Action action = Mock()

        given:
        1 * action.execute(_) >> {
            instant.connected
            thread.block()
            instant.actionFinished
        }

        when:
        def acceptor = incomingConnector.accept(action, false)

        }
        return true;
    }

    @Override
    public boolean accept(String candidate) {
        for (VersionSelector selector : selectors) {
            if (selector.accept(candidate)) {
                return true;
            }
        }
        return false;
    }

    @Override
    public boolean accept(Version candidate) {
        for (VersionSelector selector : selectors) {

abstract class AbstractStringVersionSelectorTest extends Specification {
    abstract VersionSelector getSelector(String selector);

    def accept(String s1, String s2) {
        return getSelector(s1).accept(s2)
    }

    def accept(String s1, ComponentMetadata cmd) {
        return getSelector(s1).accept(cmd)
    }

    def isDynamic(String s1) {
        return getSelector(s1).isDynamic()
    }

  public void testAccept() {
    File dir = new File("foo");
    FilenameFilter filter = new PatternFilenameFilter("a+");
    assertTrue(filter.accept(dir, "a"));
    assertTrue(filter.accept(dir, "aaaa"));
    assertFalse(filter.accept(dir, "b"));

    // Show that dir is ignored
    assertTrue(filter.accept(null, "a"));
  }

  public void testNulls() throws Exception {
    NullPointerTester tester = new NullPointerTester();

-		     : __builtin_strspn (s, accept))))))		      \
-      : __builtin_strspn (s, accept)); })
-#  else
-#   define strspn(s, accept) \
-  __extension__								      \
-  ({ char __a0, __a1, __a2;						      \
-     (__builtin_constant_p (accept) && __string2_1bptr_p (accept)	      \
-      ? ((__a0 = ((const char *) (accept))[0], __a0 == '\0')		      \
-	 ? ((void) (s), (size_t) 0)					      \

| KUBE-NODE-PORT-UDP             | nodeport type service UDP port           | masquerade for packets to nodePort(UDP)  |
| KUBE-NODE-PORT-LOCAL-UDP       | nodeport type service UDP port with `externalTrafficPolicy=local` | accept packages to nodeport service with `externalTrafficPolicy=local` |

                    expression.returnKeyword.accept(this)
                    expression.labeledExpression?.accept(this)
                    analyseForTest(expression) {
                        val target = expression.getReturnTargetSymbol()
                        append("/* " + target?.getNameWithPositionString() + " */")
                    }
                    expression.returnedExpression?.accept(this)
                }

				"Accept": {""},
			},
			health:  probe.Success,
			notBody: "Accept:",
		},
		{
			handler: headerEchoHandler,
			reqHeaders: http.Header{
				"User-Agent": {"foo/1.0"},
				"Accept":     {""},
			},
			health:  probe.Success,
			notBody: "Accept:",
		},
		{
			handler:    headerEchoHandler,
			reqHeaders: http.Header{},
			health:     probe.Success,
			accBody:    "Accept: */*",
		},