log.SetPrefix("pack: ")
	telemetry.Start()
	// need "pack op archive" at least.
	if len(os.Args) < 3 {
		log.Print("not enough arguments")
		fmt.Fprintln(os.Stderr)
		usage()
	}
	setOp(os.Args[1])
	telemetry.Inc("pack/invocations")
	telemetry.Inc("pack/op:" + string(op))
	var ar *Archive
	switch op {
	case 'p':
		ar = openArchive(os.Args[2], os.O_RDONLY, os.Args[3:])
		ar.scan(ar.printContents)
	case 'r':

    def packer = Mock(BuildCacheEntryPacker)
    def originFactory = Mock(OriginMetadataFactory)
    def stringInterner = new StringInterner()
    def buildOperationContext = Mock(BuildOperationContext)
    def buildOperationRunner = Mock(BuildOperationRunner)
    PackOperationExecutor packOperationExecutor = new PackOperationExecutor(buildOperationRunner, packer, originFactory, stringInterner)

		// GetQueuedCompletionStatusEx doesn't use a high resolution timer internally,
		// so we use a separate higher resolution timer associated with a wait completion
		// packet to wake up the poller. Note that the completion packet can be delivered
		// to another thread, and the Go scheduler expects netpoll to only block up to delay,
		// so we still need to use a timeout with GetQueuedCompletionStatusEx.

        !localMissLoadOp.result.hit

        packOp.details.cacheKey == cacheKey

        packOp.result.archiveSize == archiveSize
        packOp.result.archiveEntryCount == 5

        storeOp.details.cacheKey == cacheKey
        storeOp.details.archiveSize == archiveSize
        storeOp.result.stored

        when:
        succeeds("clean", "t")

Michael Matloob <******@****.***> 1715626742 -0400

		"Length: " + printUint16(h.Length) + "}"
}

// pack appends the wire format of the ResourceHeader to oldMsg.
//
// lenOff is the offset in msg where the Length field was packed.
func (h *ResourceHeader) pack(oldMsg []byte, compression map[string]uint16, compressionOff int) (msg []byte, lenOff int, err error) {
	msg = oldMsg
	if msg, err = h.Name.pack(msg, compression, compressionOff); err != nil {

        for (SocketAddress address : addresses) {
            DatagramPacket packet = new DatagramPacket(bytes, bytes.length);
            packet.setSocketAddress(address);
            LOGGER.debug("Confirming lock release to Gradle process at port {} for lock with id {}.", packet.getPort(), lockId);
            try {
                socket.send(packet);
            } catch (IOException e) {
                if (!stopped) {

        TemporaryFileProvider temporaryFileProvider,
        BuildCacheEntryPacker packer
    ) {
        super(
            startParameter,
            buildOperationRunner,
            originMetadataFactory,
            stringInterner
        );
        this.temporaryFileProvider = temporaryFileProvider;
        this.packer = packer;
        this.buildOperationProgressEmitter = buildOperationProgressEmitter;
    }

  // CHECK: %[[PACK2:.*]] = "tf.Pack"

  // CHECK: return %[[SHAPE0]], %[[SHAPE1]], %[[PACK0]], %[[PACK1]], %[[PACK2]]
  func.return %5, %9, %15, %17, %20 : tensor<2xi32>, tensor<3xi32>, tensor<3xi32>, tensor<3xi32>, tensor<*xi32>
}

// CHECK-LABEL: testTileMultiplesAllOnes
func.func @testTileMultiplesAllOnes(%arg0: tensor<2x3xf32>) -> tensor<2x3xf32> {

        communicator.getPort() == -1
    }

    def "can receive lock id and type"() {
        FileLockPacketPayload receivedPayload

        start {
            def packet = communicator.receive()
            receivedPayload = communicator.decode(packet)
        }

        poll {
            assert communicator.getPort() != -1 && receivedPayload == null
        }

        when: