}
    }

    /**
     * Validate string from server response
     *
     * @param str string to validate
     * @param maxLength maximum allowed length
     * @param fieldName field name for error messages
     * @throws SmbException if string is invalid
     */
    public void validateString(String str, int maxLength, String fieldName) throws SmbException {
        totalValidations.incrementAndGet();

                && Objects.equals(a1.getArtifactId(), a2.getArtifactId())
                && Objects.equals(a1.getVersion(), a2.getVersion());
    }

    private Properties toProperties(Map<String, String> dominant, Map<String, String> recessive) {
        Properties props = new Properties();
        if (recessive != null) {
            props.putAll(recessive);
        }
        if (dominant != null) {

}

// Wrapper functions to os.MkdirAll, which calls reliableMkdirAll
// this is to ensure that if there is a racy parent directory
// delete in between we can simply retry the operation.
func mkdirAll(dirPath string, mode os.FileMode, baseDir string) (err error) {
	if dirPath == "" {
		return errInvalidArgument
	}

	if err = checkPathLength(dirPath); err != nil {
		return err
	}

            t.setDir(jvmOptionsDir);
            t.setDirMode(0750);
        });
    }

    private static String archiveTaskToSubprojectName(String taskName) {
        return archiveToSubprojectName(taskName).substring("build".length() + 1);
    }

    private static String archiveToSubprojectName(String taskName) {
        return taskName.replaceAll("[A-Z]", "-$0").toLowerCase();
    }

                // Simulate storing documents
                Map<String, Object> doc1 = new HashMap<>();
                doc1.put("id", "1");
                doc1.put("title", "Document 1");
                callback.store(initParamMap, doc1);

                Map<String, Object> doc2 = new HashMap<>();
                doc2.put("id", "2");

    fun assertArchivedFilesSeen(vararg archiveFileNames: String) {
        val rootDirFiles = projectDir.resolve("build").walk().toList()

        archiveFileNames.forEach { fileName ->
            assertTrue(rootDirFiles.any { it.name == fileName }, "File $fileName does not exist")
        }
    }

    private
    fun assertLeftoverFilesCleanedUpEventually(vararg leftoverFiles: String) {
        leftoverFiles.forEach {

            return a;
        }
        case WITH_CONFIG: {
            // Use the constructor that sets a StaticJAASConfiguration to exercise that branch
            return new JAASAuthenticator(new HashMap<String, String>(), "DOM", "user", "pass");
        }
        case DEFAULT_NO_PS:
        default:
            return new JAASAuthenticator();
        }
    }

    @Test

class NetServerEnum2Response extends SmbComTransactionResponse {

    class ServerInfo1 implements FileEntry {
        String name;
        int versionMajor;
        int versionMinor;
        int type;
        String commentOrMasterBrowser;

        @Override
        public String getName() {
            return name;
        }

        @Override
        public int getType() {

            }
        }

        LinkedHashMap<String, CoreExtension> selectedExtensions = new LinkedHashMap<>();
        List<String> conflicts = new ArrayList<>();
        for (CoreExtensions coreExtensions : configuredCoreExtensions) {
            for (CoreExtension coreExtension : coreExtensions.coreExtensions()) {
                String key = coreExtension.getGroupId() + ":" + coreExtension.getArtifactId();

    return new TestStringMultisetGenerator() {
      @Override
      protected Multiset<String> create(String[] elements) {
        return HashMultiset.create(asList(elements));
      }
    };
  }

  public void testCreate() {
    Multiset<String> multiset = HashMultiset.create();
    multiset.add("foo", 2);
    multiset.add("bar");
    assertEquals(3, multiset.size());