int positiveValue = 12345;
        NdrLong ndrLongPositive = new NdrLong(positiveValue);
        assertEquals(positiveValue, ndrLongPositive.value, "Constructor should correctly initialize with a positive value.");

        // Test case 2: Negative value
        int negativeValue = -54321;
        NdrLong ndrLongNegative = new NdrLong(negativeValue);

                    }
                }
                if (field == null) {
                    throw new NoSuchFieldException(fieldName);
                }
                field.setAccessible(true);
                field.set(this, value);
            } catch (Exception e) {
                throw new RuntimeException("Failed to set field " + fieldName, e);
            }
        }

        assertFalse(loopback.isUsableForChannel());
    }

    @Test
    void testGetScore() {
        NetworkInterfaceInfo basic = new NetworkInterfaceInfo(testAddress, 1000);
        assertEquals(1000, basic.getScore()); // Base score is link speed

        NetworkInterfaceInfo fast = new NetworkInterfaceInfo(testAddress, 10000);

                }
                bufferIndex += len;
            } else {
                server.oemDomainName = new String();
            }
        } else {
            server.guid = new byte[16];
            System.arraycopy(buffer, bufferIndex, server.guid, 0, 16);
            server.oemDomainName = new String();
            // ignore SPNEGO token for now ...
        }

        return bufferIndex - start;
    }

    assertThat(result)
        .containsExactly(
            new TestDatum("A", 2),
            new TestDatum("B", 1),
            new TestDatum("C", 1),
            new TestDatum("C", 2))
        .inOrder();
  }

  public void testMergeSorted_stable_allEqual() {
    ImmutableList<TestDatum> first = ImmutableList.of(new TestDatum("A", 1), new TestDatum("A", 2));
    ImmutableList<TestDatum> second =

    /**
     * Default constructor
     */
    public MetadataXpp3Reader() {
        delegate = new MetadataStaxReader();
    }

    /**
     * Constructor with ContentTransformer
     *
     * @param contentTransformer a transformer
     */
    public MetadataXpp3Reader(ContentTransformer contentTransformer) {
        delegate = new MetadataStaxReader(contentTransformer::transform);
    }

    /**

        final Map<String, Object> doc1 = new HashMap<>();
        doc1.put("title", "Installation Guide");
        doc1.put("url", "http://example.com/install");
        msg.addSource(new ChatSource(1, doc1));
        final Map<String, Object> doc2 = new HashMap<>();
        doc2.put("title", "Quick Start");
        doc2.put("url", "http://example.com/start");
        msg.addSource(new ChatSource(2, doc2));

        IOException cause = new IOException("IO error");
        CurlException exception = new CurlException(null, cause);

        assertNull(exception.getMessage());
        assertSame(cause, exception.getCause());
    }

    @Test
    public void testConstructorWithMessageAndNullCause() {
        String message = "Test error message";
        CurlException exception = new CurlException(message, null);

public class TransportException extends IOException {

    /** The root cause exception */
    private Throwable rootCause;

    /**
     * Constructs a new TransportException with no detail message.
     */
    public TransportException() {
    }

    /**
     * Constructs a new TransportException with the specified detail message.
     *
     * @param msg the detail message
     */
    public TransportException(final String msg) {

    /**
     * Test the readParameterWordsWireFormat method.
     */
    @Test
    void testReadParameterWordsWireFormat() {
        SmbComWriteAndXResponse response = new SmbComWriteAndXResponse();
        byte[] buffer = new byte[] { 0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; // count = 10

        int bytesRead = response.readParameterWordsWireFormat(buffer, 0);

        // The count should be read from the buffer.