// We buffer some outbound data and headers and confirm that the END_STREAM flag comes with the
    // headers (and not with the data).

    // Write the mocking script. for the client
    peer.setClient(true)

    // Write the mocking script.
    peer.sendFrame().settings(Settings())
    peer.sendFrame().headers(true, 3, headerEntries("client", "abc"))
    peer.acceptFrame() // ACK

'

includes_Darwin='
#define _DARWIN_C_SOURCE
#define KERNEL
#define _DARWIN_USE_64_BIT_INODE
#include <sys/types.h>
#include <sys/event.h>
#include <sys/ptrace.h>
#include <sys/socket.h>
#include <sys/sockio.h>
#include <sys/sysctl.h>
#include <sys/mman.h>
#include <sys/wait.h>
#include <net/bpf.h>
#include <net/if.h>
#include <net/if_types.h>
#include <net/route.h>
#include <netinet/in.h>
#include <netinet/ip.h>

    runtimeOnly(project(":composite-builds"))
    runtimeOnly(libs.groovy) // for 'Closure'

    testCompileOnly(project(":toolchains-jvm")) {
        because("JavaLauncher is required for mocking Test.")
    }
    testImplementation(project(":file-collections"))
    testImplementation(project(":platform-jvm"))
    testImplementation(testFixtures(project(":core")))
}

strictCompile {

import play.twirl.api.Content;

import static play.test.Helpers.*;
import static org.fest.assertions.Assertions.*;


/**
*
* Simple (JUnit) tests that can call all parts of a play app.
* If you are interested in mocking a whole application, see the wiki for more details.
*
*/
public class ApplicationTest {

    @Test
    public void simpleCheck() {
        int a = 1 + 1;
        assertThat(a).isEqualTo(2);
    }

limitations under the License.
*/

package testing

import "k8s.io/kubernetes/pkg/kubelet/checkpointmanager"

var _ checkpointmanager.Checkpoint = &MockCheckpoint{}

// MockCheckpoint struct is used for mocking checkpoint values in testing
type MockCheckpoint struct {
	Content string
}

// MarshalCheckpoint returns fake content
func (mc *MockCheckpoint) MarshalCheckpoint() ([]byte, error) {
	return []byte(mc.Content), nil

	"time"

	"github.com/containernetworking/cni/pkg/skel"
	cniv1 "github.com/containernetworking/cni/pkg/types/100"

	"istio.io/istio/cni/pkg/nodeagent"
)

// newCNIClient is a unit test override variable for mocking.
var newCNIClient = buildClient

// An udsCore write entries to an UDS server with HTTP Post. Log messages will be encoded into a JSON array.
type CNIEventClient struct {
	client *http.Client
	url    string
}

#include <sys/kern_control.h>
#include <sys/types.h>
#include <sys/event.h>
#include <sys/ptrace.h>
#include <sys/select.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <sys/un.h>
#include <sys/sockio.h>
#include <sys/sys_domain.h>
#include <sys/sysctl.h>
#include <sys/mman.h>
#include <sys/mount.h>
#include <sys/utsname.h>
#include <sys/wait.h>
#include <sys/xattr.h>
#include <sys/vsock.h>

	builder *resource.Builder
}

// Do finds you resources to check
func (b *ResourceFindBuilderWrapper) Do() resource.Visitor {
	return b.builder.Do()
}

// ResourceFinder allows mocking the resource builder
// TODO resource builders needs to become more interfacey
type ResourceFinder interface {
	Do() resource.Visitor
}

// ResourceFinderFunc is a handy way to make a  ResourceFinder

	"bytes"
	"fmt"
	"io"
	"testing"

	"k8s.io/apimachinery/pkg/runtime"
	"k8s.io/apimachinery/pkg/runtime/schema"
)

// nonCacheableTestObject implements json.Marshaler and proto.Marshaler interfaces
// for mocking purpose.
// +k8s:deepcopy-gen=false
type noncacheableTestObject struct {
	gvk schema.GroupVersionKind
}

// MarshalJSON implements json.Marshaler interface.

		// remove the response from the list of predefined responses and add it to request object for mocking.
		fh.responses = fh.responses[1:]
	}

	var err error
	if fh.errs != nil && len(fh.errs) > 0 {
		err = fh.errs[0]
		// remove the error from the list of predefined errors and add it to request object for mocking.
		fh.errs = fh.errs[1:]
	}

	req := &fakeRequest{cmd: cmd, flags: flags, response: response, err: err}