} else {
                resolveOrder = new int[3];
                resolveOrder[0] = RESOLVER_LMHOSTS;
                resolveOrder[1] = RESOLVER_WINS;
                resolveOrder[2] = RESOLVER_BCAST;
            }
        } else {
            final int[] tmp = new int[3];
            final StringTokenizer st = new StringTokenizer(RO, ",");
            int i = 0;
            while (st.hasMoreTokens()) {

                resolveOrder[2] = RESOLVER_BCAST;
            } else {
                resolveOrder = new int[4];
                resolveOrder[0] = RESOLVER_LMHOSTS;
                resolveOrder[1] = RESOLVER_WINS;
                resolveOrder[2] = RESOLVER_DNS;
                resolveOrder[3] = RESOLVER_BCAST;
            }
        } else {
            final int[] tmp = new int[4];

        List<ResolverType> resolveOrder = testConfig.getResolveOrder();
        assertNotNull(resolveOrder);
        assertEquals(3, resolveOrder.size());
        assertEquals(ResolverType.RESOLVER_WINS, resolveOrder.get(0));
        assertEquals(ResolverType.RESOLVER_BCAST, resolveOrder.get(1));
        assertEquals(ResolverType.RESOLVER_DNS, resolveOrder.get(2));
    }

    @Test

        }

        /*
         * If a target address to query was not specified explicitly
         * with the addr parameter we fall into this resolveOrder routine.
         */

        for (final ResolverType resolverType : this.resolveOrder) {
            try {
                switch (resolverType) {
                case RESOLVER_LMHOSTS:

            if (this.winsServer.length == 0) {
                this.resolverOrder.add(ResolverType.RESOLVER_LMHOSTS);
                this.resolverOrder.add(ResolverType.RESOLVER_DNS);
            } else {
                this.resolverOrder.add(ResolverType.RESOLVER_LMHOSTS);
                this.resolverOrder.add(ResolverType.RESOLVER_DNS);
                this.resolverOrder.add(ResolverType.RESOLVER_WINS);
            }

            } catch (UnknownHostException e) {
                // Invalid address ignored
            }
        }

        value = props.getProperty("jcifs.resolveOrder");
        if (value != null) {
            initResolverOrder(value);
        }

        value = props.getProperty("jcifs.native.os");
        if (value != null) {
            this.nativeOs = value;

     *
     * @return whether the usage of plaintext passwords is prohibited, defaults to false
     */
    boolean isDisablePlainTextPasswords();

    /**
     *
     *
     * Property {@code jcifs.resolveOrder} (string, default {@code LMHOSTS,DNS,WINS,BCAST})
     *
     * @return order and selection of resolver modules, see {@link ResolverType}
     */
    List<ResolverType> getResolveOrder();

    /**
     *

        // Given
        List<ResolverType> resolverOrder = Arrays.asList(ResolverType.RESOLVER_DNS, ResolverType.RESOLVER_WINS);
        when(mockDelegate.getResolveOrder()).thenReturn(resolverOrder);

        // When
        List<ResolverType> resultResolverOrder = delegatingConfig.getResolveOrder();

        // Then
        assertSame(resolverOrder, resultResolverOrder, "Should delegate resolver order");

    @DisplayName("Test initDefaults with pre-set resolver order")
    void testInitDefaultsWithPresetResolverOrder() throws CIFSException {
        BaseConfiguration testConfig = new BaseConfiguration(false);
        testConfig.resolverOrder = Arrays.asList(ResolverType.RESOLVER_DNS);

        testConfig.initDefaults();

        assertEquals(1, testConfig.getResolveOrder().size());