// Validate the input
	for scanner.Scan() {
		fmt.Printf("%s\n", scanner.Text())
	}

	if err := scanner.Err(); err != nil {
		fmt.Printf("Invalid input: %s", err)
	}
	// Output:
	// 1234
	// 5678
	// Invalid input: strconv.ParseInt: parsing "1234567901234567890": value out of range
}

// Use a Scanner with a custom split function to parse a comma-separated
// list with an empty final value.

        assertEquals(0, msg.getFlags(), "Initial flags should be 0");
    }

    @ParameterizedTest(name = "setFlags({0}) ➜ getFlags() == {0}")
    @ValueSource(ints = { 0x0, 0x1, 0x2, 0xFFFFFFFF, -123456 })
    void testSetAndGetFlags(int value) {
        msg.setFlags(value);
        assertEquals(value, msg.getFlags(), "getFlags should return the value set");
    }

    @Test

            assertEquals("2001:db8:0:1::1", method.invoke(null, "2001:0db8:0:1:0:0:0:1"));

            // No compression when all segments are non-zero (just remove leading zeros)
            assertEquals("2001:db8:1:2:3:4:5:6", method.invoke(null, "2001:0db8:0001:0002:0003:0004:0005:0006"));

            // Single zero should not be compressed
            assertEquals("2001:db8:1:0:2:3:4:5", method.invoke(null, "2001:0db8:1:0:2:3:4:5"));

            // Given
            ByteBuffer buffer = ByteBuffer.allocate(32);
            buffer.order(ByteOrder.LITTLE_ENDIAN);
            buffer.putLong(123456L);
            buffer.putLong(78910L);
            buffer.putLong(80000L);
            buffer.putInt(16);
            buffer.putInt(4096);

            // When

        setFieldValue(response, "fileSize", 12345);

        String result = response.toString();

        assertNotNull(result);
        assertTrue(result.contains("SmbComQueryInformationResponse"));
        assertTrue(result.contains("fileAttributes=0x"));
        assertTrue(result.contains("lastWriteTime="));
        assertTrue(result.contains("fileSize=12345"));
    }

    @Test

	}, {
		header:  &Header{ChangeTime: time.Unix(123, 456)},
		paxHdrs: map[string]string{paxCtime: "123.000000456"},
		formats: FormatPAX | FormatGNU,
	}, {
		header:  &Header{ChangeTime: time.Unix(123, 456), Format: FormatUSTAR},
		paxHdrs: map[string]string{paxCtime: "123.000000456"},
		formats: FormatUnknown,
	}, {
		header:  &Header{ChangeTime: time.Unix(123, 456), Format: FormatGNU},

        dnsDomainInfo.domain_guid.clock_seq_hi_and_reserved = 0x12;
        dnsDomainInfo.domain_guid.clock_seq_low = 0x34;
        dnsDomainInfo.domain_guid.node = new byte[] { 1, 2, 3, 4, 5, 6 };

        dnsDomainInfo.sid = new rpc.sid_t();
        dnsDomainInfo.sid.revision = 1;
        dnsDomainInfo.sid.identifier_authority = new byte[] { 0, 0, 0, 0, 0, 5 };

        doc.put("longStr", "123456789");
        assertEquals(Long.valueOf(123456789L), DocumentUtil.getValue(doc, "longStr", Long.class));

        doc.put("doubleStr", "123.45");
        assertEquals(Double.valueOf(123.45), DocumentUtil.getValue(doc, "doubleStr", Double.class));

        doc.put("floatStr", "123.45");

                org.junit.jupiter.params.provider.Arguments.of(0xFFFF, 0x12345678),
                org.junit.jupiter.params.provider.Arguments.of(-1, -123456));
    }

    @ParameterizedTest
    @MethodSource("validInputs")
    void writeParametersWireFormat_writesCorrectly(int fid, int securityInformation) {

// along with this program.  If not, see <http://www.gnu.org/licenses/>.

package dsync

import (
	"context"
	"fmt"
	"runtime"
	"sync/atomic"
	"testing"
	"time"
)

const (
	id     = "1234-5678"
	source = "main.go"
)

func testSimpleWriteLock(t *testing.T, duration time.Duration) (locked bool) {
	drwm1 := NewDRWMutex(ds, "simplelock")
	ctx1, cancel1 := context.WithCancel(t.Context())