typedef struct {
		[string] wchar_t *netname;
	} ShareInfo0;

	typedef struct {
		int count;
		[size_is(count)] ShareInfo0 *array;
	} ShareInfoCtr0;

	typedef struct {
		[string] wchar_t *netname;
		int type;
		[string] wchar_t *remark;
	} ShareInfo1;

	typedef struct {
		int count;
		[size_is(count)] ShareInfo1 *array;
	} ShareInfoCtr1;

	typedef struct {
		[string] wchar_t *netname;
		int type;

        sidArray.sids[0].sid = new rpc.sid_t();
        sidArray.sids[0].sid.revision = 1;
        sidArray.sids[0].sid.identifier_authority = new byte[] { 0, 0, 0, 0, 0, 5 };
        sidArray.sids[0].sid.sub_authority_count = 1;
        sidArray.sids[0].sid.sub_authority = new int[] { 500 };

        sidArray.sids[1] = new lsarpc.LsarSidPtr();
        sidArray.sids[1].sid = new rpc.sid_t();
        sidArray.sids[1].sid.revision = 1;

	BlueBold    = "\033[34;1m"
	MagentaBold = "\033[35;1m"
	RedBold     = "\033[31;1m"
	YellowBold  = "\033[33;1m"
)

// LogLevel log level
type LogLevel int

const (
	// Silent silent log level
	Silent LogLevel = iota + 1
	// Error error log level
	Error
	// Warn warn log level
	Warn
	// Info info log level
	Info
)

// Writer log writer interface
type Writer interface {

    @ParameterizedTest
    @ValueSource(ints = { 1, 5, 10, 20, 50 })
    void constructor_shouldHandleVariousSidArraySizes(int size) {
        // Arrange
        testSids = new jcifs.SID[size];
        for (int i = 0; i < size; i++) {
            testSids[i] = mock(jcifs.SID.class);
            when(testSids[i].unwrap(sid_t.class)).thenReturn(mockSidT);
        }

        // Act

import jcifs.dcerpc.rpc.sid_t;
import jcifs.smb.SID;

class LsarSidArrayXTest {

    @Test
    void testConstructorWithJcifsSIDArrayAndUnwrap() {
        // Create mock SID objects
        SID mockSid1 = mock(SID.class);
        SID mockSid2 = mock(SID.class);

        // Mock the unwrap method to return a sid_t instance
        sid_t sidT1 = new sid_t();
        sid_t sidT2 = new sid_t();

Joe Tsai <******@****.***> 1446603151 -0800

                CollectSpliterators.flatMap(
                    Arrays.spliterator(new String[] {"abc", "", "de", "f", "g", ""}),
                    (String str) -> charactersOf(str).spliterator(),
                    Spliterator.SIZED | Spliterator.DISTINCT | Spliterator.NONNULL,
                    7))
        .expect('a', 'b', 'c', 'd', 'e', 'f', 'g');
  }

  public void testFlatMap_nullStream() {
    SpliteratorTester.of(
            () ->

import jcifs.CIFSContext;
import jcifs.CIFSException;
import jcifs.SidResolver;
import jcifs.dcerpc.rpc;

class SIDTest {

    // Helper to build a minimal sid_t
    private static rpc.sid_t buildSidT(byte revision, byte[] identAuth, int... subs) {
        rpc.sid_t s = new rpc.sid_t();
        s.revision = revision;
        s.sub_authority_count = (byte) subs.length;
        s.identifier_authority = Arrays.copyOf(identAuth, 6);

        public LsarDomainInfo() {
            // Default constructor
        }

        /** Domain name. */
        public rpc.unicode_string name;
        /** Domain security identifier. */
        public rpc.sid_t sid;

        @Override
        public void encode(NdrBuffer _dst) throws NdrException {
            _dst.align(4);
            _dst.enc_ndr_short(this.name.length);

    assertEquals(expectedSize, multimap.size());

    int size = 0;
    for (Entry<K, V> entry : multimap.entries()) {
      assertTrue(multimap.containsEntry(entry.getKey(), entry.getValue()));
      size++;
    }
    assertEquals(expectedSize, size);

    int size2 = 0;
    for (Entry<K, Collection<V>> entry2 : multimap.asMap().entrySet()) {
      size2 += entry2.getValue().size();
    }
    assertEquals(expectedSize, size2);