private static Stream<Arguments> provideNamesForWriteTest() {
        return Stream.of(Arguments.of("SERVER", 0x20, "CLIENT", 0x00), Arguments.of("WORKSTATION", 0x00, "USER", 0x03),
                Arguments.of("DOMAIN", 0x1B, "BROWSER", 0x1D), Arguments.of("A", 0x20, "B", 0x00),
                Arguments.of("VERYLONGNAMETEST", 0x20, "ANOTHERLONGNAME", 0x00));
    }

    @Test

    }

    static NbtAddress lookupServerOrWorkgroup(final String name, final InetAddress svr) throws UnknownHostException {
        final Sem sem = new Sem(2);
        final int type = NbtAddress.isWINS(svr) ? 0x1b : 0x1d;

        final QueryThread q1x = new QueryThread(sem, name, type, null, svr);
        final QueryThread q20 = new QueryThread(sem, name, 0x20, null, svr);
        q1x.setDaemon(true);
        q20.setDaemon(true);

	err = en.Append(0xb1, 0x52, 0x65, 0x73, 0x75, 0x6d, 0x65, 0x49, 0x74, 0x65, 0x6d, 0x73, 0x48, 0x65, 0x61, 0x6c, 0x65, 0x64)
	if err != nil {
		return
	}
	err = en.WriteUint64(z.ResumeItemsHealed)
	if err != nil {
		err = msgp.WrapError(err, "ResumeItemsHealed")
		return
	}
	// write "ResumeItemsFailed"
	err = en.Append(0xb1, 0x52, 0x65, 0x73, 0x75, 0x6d, 0x65, 0x49, 0x74, 0x65, 0x6d, 0x73, 0x46, 0x61, 0x69, 0x6c, 0x65, 0x64)

                    break;
                case RESOLVER_WINS:
                case RESOLVER_BCAST:
                    if (element == RESOLVER_WINS && name.name != NbtAddress.MASTER_BROWSER_NAME && name.hexCode != 0x1d) {
                        request.addr = NbtAddress.getWINSAddress();
                        request.isBroadcast = false;
                    } else {
                        request.addr = baddr;

        void testRpcPtShutdown() {
            assertEquals(0x11, DcerpcConstants.RPC_PT_SHUTDOWN, "RPC_PT_SHUTDOWN should be 0x11");
        }

        @Test
        @DisplayName("RPC_PT_CANCEL should have correct value")
        void testRpcPtCancel() {
            assertEquals(0x12, DcerpcConstants.RPC_PT_CANCEL, "RPC_PT_CANCEL should be 0x12");
        }

        @Test

    /**
     * Acknowledgment packet type
     */
    int RPC_PT_ACK = 0x13;
    /**
     * Reject packet type
     */
    int RPC_PT_REJECT = 0x14;
    /**
     * Connection-oriented cancel packet type
     */
    int RPC_PT_CO_CANCEL = 0x15;
    /**
     * Orphaned packet type
     */
    int RPC_PT_ORPHANED = 0x16;

    // RPC_C_PF_ flags (packet flags)
    /**

                }
                if (addr.getAddress() instanceof NbtAddress) {
                    final int code = ((NbtAddress) addr.getAddress()).getNameType();
                    if (code == 0x1d || code == 0x1b) {
                        type = TYPE_WORKGROUP;
                        return type;
                    }
                }
                type = TYPE_SERVER;
            }
        }

        ndrBuffer.readOctetArray(destData, 1, 3); // Read 0x10, 0x11, 0x12 into destData[1-3]

        assertEquals(3, ndrBuffer.getIndex());
        assertEquals(0x00, destData[0]);
        assertEquals(0x10, destData[1]);
        assertEquals(0x11, destData[2]);
        assertEquals(0x12, destData[3]);
        assertEquals(0x00, destData[4]);
    }

    @Test

        byte[] testMac = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06 };
        System.arraycopy(testMac, 0, src, macOffset, 6);

        // Statistics
        byte[] stats = { 0x10, 0x11, 0x12, 0x13, 0x14, 0x15 };
        System.arraycopy(stats, 0, src, macOffset + 6, 6);

        int result = response.readRDataWireFormat(src, srcIndex);
        assertEquals(dataLength, result);

        .isTrue();
  }

  public void testToByteArray() {
    assertByteArrayEquals(
        new byte[] {0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19},
        Longs.toByteArray(0x1213141516171819L));
    assertByteArrayEquals(
        new byte[] {
          (byte) 0xFF, (byte) 0xEE, (byte) 0xDD, (byte) 0xCC,
          (byte) 0xBB, (byte) 0xAA, (byte) 0x99, (byte) 0x88
        },