if err != nil {
			return fmt.Errorf("Failed to create API Server client, error: %w", err)
		}
		eventBroadcaster := events.NewBroadcaster(&events.EventSinkImpl{Interface: client.EventsV1()})
		recorder := eventBroadcaster.NewRecorder(legacyscheme.Scheme, "kube-proxy")

		hollowProxy := kubemarkproxy.NewHollowProxy(
			config.NodeName,
			client,
			client.CoreV1(),
			eventBroadcaster,

	serviceCIDRInformer networkinginformers.ServiceCIDRInformer,
	ipAddressInformer networkinginformers.IPAddressInformer) *RepairIPAddress {
	eventBroadcaster := events.NewBroadcaster(&events.EventSinkImpl{Interface: client.EventsV1()})
	recorder := eventBroadcaster.NewRecorder(legacyscheme.Scheme, "ipallocator-repair-controller")

	r := &RepairIPAddress{
		interval:          interval,
		client:            client,

		}
		config.NodePortAddresses = nodePortAddresses
	}

	s.Broadcaster = events.NewBroadcaster(&events.EventSinkImpl{Interface: s.Client.EventsV1()})
	s.Recorder = s.Broadcaster.NewRecorder(proxyconfigscheme.Scheme, "kube-proxy")

	s.NodeRef = &v1.ObjectReference{
		Kind:      "Node",
		Name:      s.Hostname,
		UID:       types.UID(s.Hostname),

	err := w.Add(watchFile1)
	g.Expect(err).NotTo(HaveOccurred())
	err = w.Add(watchFile2)
	g.Expect(err).NotTo(HaveOccurred())

	// Validate events and errors channel are fulfilled.
	events1 := w.Events(watchFile1)
	g.Expect(events1).NotTo(BeNil())
	events2 := w.Events(watchFile2)
	g.Expect(events2).NotTo(BeNil())

	errors1 := w.Errors(watchFile1)
	g.Expect(errors1).NotTo(BeNil())
	errors2 := w.Errors(watchFile2)

        def events = toolchainEvents(task)
        def events1 = filterByJavaVersion(events, jdkMetadata1)
        def events2 = filterByJavaVersion(events, jdkMetadata2)
        then:
        executedAndNotSkipped(task)
        events.size() > 0
        events.size() == events1.size() + events2.size() // no events from other toolchains
        assertToolchainUsages(events1, jdkMetadata1, "JavaLauncher")

        then:
        1 * fooListener1.foo("param")
        0 * _
    }

    def listenersReceiveMessagesInSameOrderRegardlessOfGeneratingThread() {
        given:
        def events1 = events("a", 20)
        def events2 = events("b", 20)
        def events3 = events("c", 20)
        def received1 = new CopyOnWriteArrayList<String>()
        def received2 = new CopyOnWriteArrayList<String>()