// Test other opCode, resultCode, questionType, recordType branches
        packet.opCode = NameServicePacket.WACK;
        packet.resultCode = NameServicePacket.SRV_ERR;
        packet.questionType = NameServicePacket.NBSTAT;
        packet.recordType = NameServicePacket.NBSTAT;
        expectedString =

            throw new IOException("Connection not established");
        }

        try {
            // In real implementation, this would perform RDMA write:
            // Similar to rdmaRead but with IBV_WR_RDMA_WRITE opcode

            log.debug("DiSNI RDMA write completed, {} bytes", length);

        } catch (Exception e) {
            state = RdmaConnectionState.ERROR;

// Copyright 2022 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// This contains the valid opcode combinations available
// in cmd/internal/obj/ppc64/asm9.go which exist for
// POWER10/ISA 3.1.

#include "../../../../../runtime/textflag.h"

TEXT asmtest(SB), DUPOK|NOSPLIT, $0
	BRD R1, R2                              // 7c220176

    assertFailsWith<ProtocolException> {
      clientReader.processNextFrame()
    }.also { expected ->
      assertThat(expected.message)
        .isEqualTo("Expected continuation opcode. Got: 2")
    }
  }

  @Test fun emptyPingCallsCallback() {
    data.write("8900".decodeHex()) // Empty ping
    clientReader.processNextFrame()
    callback.assertPing(EMPTY)
  }

	SRLI	$64, X5, X6			// ERROR "immediate out of range 0 to 63"
	SRAI	$64, X5, X6			// ERROR "immediate out of range 0 to 63"
	BEQ	X5, X6, $1			// ERROR "instruction with branch-like opcode lacks destination"
	BEQ	X5, X6, 31(X10)			// ERROR "instruction with branch-like opcode lacks destination"
	RORI	$-1, X5, X6			// ERROR "immediate out of range 0 to 63"
	SLLI	$-1, X5, X6			// ERROR "immediate out of range 0 to 63"

			}
		}

		if hexes != "" {
			hexByLine[fmt.Sprintf("%s:%d", input, lineno)] = hexes
		}

		// Canonicalize spacing in printed form.
		// First field is opcode, then tab, then arguments separated by spaces.
		// Canonicalize spaces after commas first.
		// Comma to separate argument gets a space; comma within does not.
		var buf []byte
		nest := 0

//	}
	NOP	F2

//	LNOP imm
//	{
//		outcode(int($1), &$2, 0, &nullgen);
//	}
	NOP	$4

//
// special
//
	SYSCALL
	BREAK
	// overloaded cache opcode:
	BREAK	R1, (R1)

//
// RET
//
//	LRETRN	comma // asm doesn't support the trailing comma.
//	{
//		outcode(int($1), &nullgen, 0, &nullgen);
//	}
	SYSCALL
	BEQ	R1, 2(PC)
	RET

	instructions["B"] = obj.AJMP
	instructions["BL"] = obj.ACALL
	// MCR differs from MRC by the way fields of the word are encoded.
	// (Details in arm.go). Here we add the instruction so parse will find
	// it, but give it an opcode number known only to us.
	instructions["MCR"] = aMCR

	return &Arch{
		LinkArch:       &arm.Linkarm,
		Instructions:   instructions,
		Register:       register,
		RegisterPrefix: registerPrefix,

	}
	readDataInto := func(dst []byte, s ws.State, want ws.OpCode) ([]byte, error) {
		dst = dst[:0]
		for {
			hdr, err := wsReader.NextFrame()
			if err != nil {
				return nil, err
			}
			if hdr.OpCode.IsControl() {
				if err := controlHandler(hdr, &wsReader); err != nil {
					return nil, err
				}
				continue
			}
			if hdr.OpCode&want == 0 {
				if err := wsReader.Discard(); err != nil {

Então, você pode procurar por essa exceção específica dentro da dependência com `except AlgumaExcecao`.

Da mesma forma, você pode utilizar `finally` para garantir que os passos de saída são executados, com ou sem exceções.

{* ../../docs_src/dependencies/tutorial007_py310.py hl[3,5] *}

## Subdependências com `yield` { #sub-dependencies-with-yield }