var s = http.Server{}
var _ = s.doneChan                  // ERROR "s.doneChan undefined .cannot refer to unexported field or method doneChan.$|unexported field or method|s.doneChan undefined"
var _ = s.DoneChan                  // ERROR "s.DoneChan undefined .type http.Server has no field or method DoneChan.$|undefined field or method"

// struct field and method names are suppressed.

package p

type T struct {
	a, b, c int
	E
}

type E struct{}

func (T) b()  {} // ERROR "field and method named b|redeclares struct field name|field and method with the same name b"
func (*T) E() {} // ERROR "field and method named E|redeclares struct field name|field and method with the same name E"

func _() {
	var x T
	_ = x.a

 * immutable.
 */
class Request internal constructor(builder: Builder) {
  @get:JvmName("url")
  val url: HttpUrl = checkNotNull(builder.url) { "url == null" }

  @get:JvmName("method")
  val method: String = builder.method

  @get:JvmName("headers")
  val headers: Headers = builder.headers.build()

  @get:JvmName("body")
  val body: RequestBody? = builder.body

  @get:JvmName("cacheUrlOverride")

/**
 * Static convenience methods that help a method or constructor check whether it was invoked
 * correctly (that is, whether its <i>preconditions</i> were met).
 *
 * <p>If the precondition is not met, the {@code Preconditions} method throws an unchecked exception
 * of a specified type, which helps the method in which the exception was thrown communicate that

    return Collections.emptySet();
  }

  protected Collection<Method> suppressForCheckedSet() {
    return Collections.emptySet();
  }

  protected Collection<Method> suppressForCheckedSortedSet() {
    return Collections.emptySet();
  }

  protected Collection<Method> suppressForAbstractSet() {
    return Collections.emptySet();
  }

    // we create a test suite containing a test for every AbstractFutureTest test method and we
    // set it as the name of the test.  Then in runTest we can reflectively load and invoke the
    // corresponding method on AbstractFutureTest in the correct classloader.
    TestSuite suite = new TestSuite(AbstractFutureFallbackAtomicHelperTest.class.getName());
    for (Method method : AbstractFutureTest.class.getDeclaredMethods()) {

        )
    }

    static class AddScenarioDefinitionInterceptor implements IMethodInterceptor {
        private final Method method
        private final RunFor runFor

        AddScenarioDefinitionInterceptor(Method method, RunFor runFor) {
            this.method = method
            this.runFor = runFor
        }

        @Override
        void intercept(IMethodInvocation invocation) throws Throwable {

        return request(Method.PUT, path).header("Content-Type", "application/json");
    }

    public CurlRequest delete(final String path) {
        return request(Method.DELETE, path).header("Content-Type", "application/json");
    }

    public CurlRequest request(final Method method, final String path) {
        return request(new FesenRequest(new CurlRequest(method, null), nodeManager, path));
    }

	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockPodManager) EXPECT() *MockPodManagerMockRecorder {
	return m.recorder
}

// GetMirrorPodByPod mocks base method.
func (m *MockPodManager) GetMirrorPodByPod(arg0 *v1.Pod) (*v1.Pod, bool) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetMirrorPodByPod", arg0)
	ret0, _ := ret[0].(*v1.Pod)
	ret1, _ := ret[1].(bool)
	return ret0, ret1

            this.type = type;
            this.dispatch = dispatch;
        }

        @Override
        public Object invoke(Object target, Method method, Object[] parameters) throws Throwable {
            if (method.getName().equals("equals")) {
                Object parameter = parameters[0];
                if (parameter == null || !Proxy.isProxyClass(parameter.getClass())) {