@dxworks/insider 2.9.1

package/src/main/java/org/dxworks/insider/technology/finder/model/json/TechnologyJsonDTO.java

@@ -0,0 +1,66 @@
+package org.dxworks.insider.technology.finder.model.json;
+
+import lombok.Data;
+import org.dxworks.insider.technology.finder.model.Technology;
+import org.dxworks.insider.utils.ImportUtils;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.stream.Collectors;
+
+import static org.dxworks.insider.utils.ImportUtils.IMPORT_SUFFIX;
+import static org.dxworks.insider.utils.ImportUtils.unwrapImportPackage;
+
+@Data
+public class TechnologyJsonDTO {
+
+    private String category;
+    private String name;
+    private List<String> languages;
+    private List<String> extensions;
+    private List<String> fingerprints;
+
+    private boolean wrapAsImports;
+
+    public static TechnologyJsonDTO fromTechnology(Technology technology) {
+        TechnologyJsonDTO technologyJsonDTO = new TechnologyJsonDTO();
+
+        technologyJsonDTO.setName(technology.getName());
+        technologyJsonDTO.setCategory(technology.getCategory());
+        technologyJsonDTO.setExtensions(technology.getExtensions());
+        technologyJsonDTO.setLanguages(technology.getLanguages());
+
+        AtomicBoolean shouldWrapAsImports = new AtomicBoolean(false);
+
+        List<String> fingerPrints = technology.getFingerprints().stream().map(fingerPrint -> {
+            if (fingerPrint.contains(IMPORT_SUFFIX)) {
+                shouldWrapAsImports.set(true);
+                return unwrapImportPackage(fingerPrint);
+            }
+            return fingerPrint;
+        }).collect(Collectors.toList());
+
+        technologyJsonDTO.setFingerprints(fingerPrints);
+        technologyJsonDTO.setWrapAsImports(shouldWrapAsImports.get());
+
+        return technologyJsonDTO;
+    }
+
+    public Technology toTechnology() {
+        Technology technology = new Technology();
+
+        technology.setName(name);
+        technology.setCategory(category);
+        technology.setLanguages(languages != null ? languages : Collections.emptyList());
+        technology.setExtensions(extensions != null ? extensions : Collections.emptyList());
+        technology.setFingerprints(fingerprints == null ? Collections.emptyList() : wrapAsImports ? fingerprintsWrappedAsImports() : fingerprints);
+
+        return technology;
+    }
+
+    protected List<String> fingerprintsWrappedAsImports() {
+        return fingerprints.stream().map(ImportUtils::wrapImportPackage).collect(Collectors.toList());
+    }
+
+}

package/src/main/java/org/dxworks/insider/technology/finder/model/xml/old/CategoryXmlDTO.java

@@ -0,0 +1,21 @@
+package org.dxworks.insider.technology.finder.model.xml.old;
+
+
+import lombok.Data;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlElement;
+import javax.xml.bind.annotation.XmlRootElement;
+import java.util.List;
+
+@XmlRootElement(name = "technology")
+@XmlAccessorType(XmlAccessType.FIELD)
+@Data
+public class CategoryXmlDTO {
+
+    private String name;
+
+    @XmlElement(name = "fingerprint")
+    private List<FingerprintXmlDTO> fingerprints;
+}

package/src/main/java/org/dxworks/insider/technology/finder/model/xml/old/ConfigurationDataXmlDTO.java

@@ -0,0 +1,17 @@
+package org.dxworks.insider.technology.finder.model.xml.old;
+
+import lombok.Data;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlElement;
+import javax.xml.bind.annotation.XmlRootElement;
+
+@XmlRootElement(name = "data")
+@XmlAccessorType(XmlAccessType.FIELD)
+@Data
+public class ConfigurationDataXmlDTO {
+
+    @XmlElement(name = "languages")
+    private LanguagesXmlDTO languages;
+}

package/src/main/java/org/dxworks/insider/technology/finder/model/xml/old/FingerprintXmlDTO.java

@@ -0,0 +1,17 @@
+package org.dxworks.insider.technology.finder.model.xml.old;
+
+import lombok.Data;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlRootElement;
+import javax.xml.bind.annotation.XmlValue;
+
+@XmlRootElement(name = "fingerprint")
+@XmlAccessorType(XmlAccessType.FIELD)
+@Data
+public class FingerprintXmlDTO {
+
+    @XmlValue
+    private String value;
+}

package/src/main/java/org/dxworks/insider/technology/finder/model/xml/old/LanguageXmlDTO.java

@@ -0,0 +1,20 @@
+package org.dxworks.insider.technology.finder.model.xml.old;
+
+import lombok.Data;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlElement;
+import javax.xml.bind.annotation.XmlRootElement;
+import java.util.List;
+
+@XmlRootElement(name = "language")
+@XmlAccessorType(XmlAccessType.FIELD)
+@Data
+public class LanguageXmlDTO {
+    private String name;
+    private int version;
+
+    @XmlElement(name = "technology")
+    private List<TechnologyXmlDTO> technologies;
+}

package/src/main/java/org/dxworks/insider/technology/finder/model/xml/old/LanguagesXmlDTO.java

@@ -0,0 +1,18 @@
+package org.dxworks.insider.technology.finder.model.xml.old;
+
+import lombok.Data;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlElement;
+import javax.xml.bind.annotation.XmlRootElement;
+import java.util.List;
+
+@XmlRootElement(name = "languages")
+@XmlAccessorType(XmlAccessType.FIELD)
+@Data
+public class LanguagesXmlDTO {
+
+    @XmlElement(name = "language")
+    private List<LanguageXmlDTO> languages;
+}

package/src/main/java/org/dxworks/insider/technology/finder/model/xml/old/TechnologyXmlDTO.java

@@ -0,0 +1,19 @@
+package org.dxworks.insider.technology.finder.model.xml.old;
+
+import lombok.Data;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlElement;
+import javax.xml.bind.annotation.XmlRootElement;
+import java.util.List;
+
+@XmlRootElement(name = "technology")
+@XmlAccessorType(XmlAccessType.FIELD)
+@Data
+public class TechnologyXmlDTO {
+    private String name;
+
+    @XmlElement(name = "category")
+    private List<CategoryXmlDTO> categories;
+}

package/src/main/java/org/dxworks/insider/technology/finder/model/xml/old/XmlConfigurationDTO.java

@@ -0,0 +1,17 @@
+package org.dxworks.insider.technology.finder.model.xml.old;
+
+import lombok.Data;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlRootElement;
+
+@XmlRootElement(name = "config")
+@XmlAccessorType(XmlAccessType.FIELD)
+@Data
+public class XmlConfigurationDTO {
+    private String name;
+    private int version;
+
+    private ConfigurationDataXmlDTO data;
+}

package/src/main/java/org/dxworks/insider/technology/finder/parsers/FingerprintsParser.java

@@ -0,0 +1,14 @@
+package org.dxworks.insider.technology.finder.parsers;
+
+import org.dxworks.insider.technology.finder.exceptions.FingerprintParseException;
+import org.dxworks.insider.technology.finder.model.Technology;
+
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.List;
+
+public interface FingerprintsParser {
+    List<Technology> parseTechnologiesFile(String filePath) throws FingerprintParseException;
+
+    void writeTechnologiesToFile(List<Technology> technologies, Path filePath) throws IOException;
+}

package/src/main/java/org/dxworks/insider/technology/finder/parsers/FingerprintsXmlParser.java

@@ -0,0 +1,57 @@
+package org.dxworks.insider.technology.finder.parsers;
+
+import org.apache.commons.lang3.NotImplementedException;
+import org.dxworks.insider.technology.finder.exceptions.FingerprintParseException;
+import org.dxworks.insider.technology.finder.model.Technology;
+import org.dxworks.insider.technology.finder.model.xml.old.FingerprintXmlDTO;
+import org.dxworks.insider.technology.finder.model.xml.old.XmlConfigurationDTO;
+
+import javax.xml.bind.JAXBContext;
+import javax.xml.bind.JAXBException;
+import javax.xml.bind.Unmarshaller;
+import java.io.IOException;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class FingerprintsXmlParser implements FingerprintsParser {
+
+    @Override
+    public List<Technology> parseTechnologiesFile(String filePath) {
+        Unmarshaller unmarshaller;
+        XmlConfigurationDTO xmlConfiguration;
+
+        try {
+            JAXBContext jaxbContext = JAXBContext.newInstance(XmlConfigurationDTO.class);
+            unmarshaller = jaxbContext.createUnmarshaller();
+            xmlConfiguration = (XmlConfigurationDTO) unmarshaller.unmarshal(Paths.get(filePath).toFile());
+
+        } catch (JAXBException e) {
+            throw new FingerprintParseException(e);
+        }
+
+        return xmlConfiguration.getData().getLanguages().getLanguages().stream()
+                .flatMap(languageDTO -> languageDTO.getTechnologies().stream()
+                        .flatMap(technologyDTO -> technologyDTO.getCategories().stream().map(categoryDTO -> {
+                            Technology technology = new Technology();
+                            technology.setLanguages(Collections.singletonList(languageDTO.getName()));
+                            technology.setExtensions(Collections.emptyList());
+                            technology.setCategory(technologyDTO.getName());
+                            technology.setName(categoryDTO.getName());
+
+                            technology.setFingerprints(categoryDTO.getFingerprints().stream()
+                                    .map(FingerprintXmlDTO::getValue)
+                                    .collect(Collectors.toList()));
+
+                            return technology;
+                        })))
+                .collect(Collectors.toList());
+    }
+
+    @Override
+    public void writeTechnologiesToFile(List<Technology> technologies, Path filePath) throws IOException {
+        throw new NotImplementedException("XML is not a supported format for export for the moment!");
+    }
+}

package/src/main/java/org/dxworks/insider/technology/finder/parsers/JavaLibrariesCsvParser.java

@@ -0,0 +1,71 @@
+package org.dxworks.insider.technology.finder.parsers;
+
+import com.opencsv.CSVReader;
+import com.opencsv.CSVWriter;
+import lombok.extern.slf4j.Slf4j;
+import org.dxworks.insider.technology.finder.exceptions.FingerprintParseException;
+import org.dxworks.insider.technology.finder.model.Technology;
+import org.dxworks.insider.utils.ImportUtils;
+import org.dxworks.insider.utils.LibraryImport;
+
+import java.io.FileReader;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+@Slf4j
+public class JavaLibrariesCsvParser implements FingerprintsParser {
+
+    @Override
+    public List<Technology> parseTechnologiesFile(String filePath) throws FingerprintParseException {
+        try {
+            CSVReader csvReader = new CSVReader(new FileReader(filePath));
+            Map<String, List<LibraryImport>> librariesImportsMap = csvReader.readAll().stream()
+                    .filter(strings -> {
+                        if (strings.length != 2) {
+                            log.error("Invalid input line for package " + strings.toString());
+                            return false;
+                        }
+                        if (strings[0].trim().isEmpty() || strings[1].trim().isEmpty()) {
+                            log.error("Invalid input line for package " + strings.toString());
+                            return false;
+                        }
+
+                        return true;
+                    })
+                    .map(strings -> new LibraryImport(strings[0].trim(), strings[1].trim()))
+                    .collect(Collectors.groupingBy(LibraryImport::getLibrary));
+
+            return librariesImportsMap.entrySet().stream()
+                    .map(stringListEntry -> new Technology("External Libraries",
+                            stringListEntry.getKey(),
+                            Collections.singletonList("java"),
+                            Collections.emptyList(),
+                            stringListEntry.getValue().stream()
+                                    .map(LibraryImport::get_import)
+                                    .map(ImportUtils::wrapImportPackage)
+                                    .collect(Collectors.toList())))
+                    .collect(Collectors.toList());
+        } catch (IOException e) {
+            log.error("Could not read JSON technologies file!", e);
+        }
+        return Collections.emptyList();
+    }
+
+    @Override
+    public void writeTechnologiesToFile(List<Technology> technologies, Path filePath) throws IOException {
+        List<String[]> stringArrays = technologies.stream().flatMap(technology -> technology.getFingerprints().stream()
+                .map(fingerPrint -> new String[]{ImportUtils.unwrapImportPackage(fingerPrint), technology.getName()}))
+                .collect(Collectors.toList());
+
+        CSVWriter writer = new CSVWriter(new FileWriter(filePath.toString()));
+        writer.writeAll(stringArrays);
+        writer.flush();
+        writer.close();
+    }
+}
+

package/src/main/java/org/dxworks/insider/technology/finder/parsers/JsonFingerprintParser.java

@@ -0,0 +1,58 @@
+package org.dxworks.insider.technology.finder.parsers;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import lombok.extern.slf4j.Slf4j;
+import org.dxworks.insider.technology.finder.model.Technology;
+import org.dxworks.insider.technology.finder.model.json.JsonConfigurationDTO;
+import org.dxworks.insider.technology.finder.model.json.TechnologyJsonDTO;
+
+import java.io.FileNotFoundException;
+import java.io.FileReader;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.Collectors;
+
+@Slf4j
+public class JsonFingerprintParser implements FingerprintsParser {
+    @Override
+    public List<Technology> parseTechnologiesFile(String filePath) {
+        JsonConfigurationDTO configurationDTO = getConfigurationDTO(filePath);
+        if (configurationDTO == null)
+            return Collections.emptyList();
+
+        return configurationDTO.getTechnologies().stream()
+                .map(TechnologyJsonDTO::toTechnology)
+                .collect(Collectors.toList());
+    }
+
+    @Override
+    public void writeTechnologiesToFile(List<Technology> technologies, Path filePath) throws IOException {
+        ObjectMapper objectMapper = new ObjectMapper();
+        try {
+            List<TechnologyJsonDTO> technologyJsonDTOS = technologies.stream().map(TechnologyJsonDTO::fromTechnology).collect(Collectors.toList());
+            JsonConfigurationDTO jsonConfigurationDTO = new JsonConfigurationDTO();
+            jsonConfigurationDTO.setTechnologies(technologyJsonDTOS);
+            objectMapper.writerWithDefaultPrettyPrinter().writeValue(new FileWriter(filePath.toFile()), jsonConfigurationDTO);
+        } catch (IOException e) {
+            log.error("Could not write JSON file!", e);
+            throw e;
+        }
+    }
+
+    public JsonConfigurationDTO getConfigurationDTO(String filePath) {
+        ObjectMapper objectMapper = new ObjectMapper();
+        try {
+            return objectMapper.readValue(new FileReader(Paths.get(filePath).toFile()), JsonConfigurationDTO.class);
+        } catch (FileNotFoundException e) {
+            log.error("Could not read JSON technologies file!", e);
+        } catch (IOException e) {
+            log.error("File " + filePath + " is could not be parsed as a JSON Technology file!", e);
+        }
+
+        return null;
+    }
+}

package/src/main/java/org/dxworks/insider/utils/FileUtils.java

@@ -0,0 +1,45 @@
+package org.dxworks.insider.utils;
+
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+public class FileUtils {
+
+    public static String removeComments(String fileContent) {
+        String ret = fileContent;
+
+        Pattern p = Pattern.compile("(\\/\\*([\\S\\s]+?)\\*\\/)");
+        Matcher m = p.matcher(ret);
+
+        char[] charArray = ret.toCharArray();
+        while (m.find()) {
+            int startIndex = m.start();
+            int stopIndex = m.end();
+
+            for (int i = startIndex + 2; i < stopIndex - 2; i++) {
+                if (!Character.isSpaceChar(charArray[i]) && !Character.isWhitespace(charArray[i]))
+                    charArray[i] = '#';
+            }
+        }
+
+        ret = String.valueOf(charArray);
+
+        p = Pattern.compile("(?:\\/\\/.*)");
+        m = p.matcher(ret);
+
+        charArray = ret.toCharArray();
+        while (m.find()) {
+            int startIndex = m.start();
+            int stopIndex = m.end();
+
+            for (int i = startIndex + 2; i < stopIndex; i++) {
+                if (!Character.isSpaceChar(charArray[i]) && !Character.isWhitespace(charArray[i]))
+                    charArray[i] = '#';
+            }
+        }
+
+        ret = String.valueOf(charArray);
+
+        return ret;
+    }
+}

package/src/main/java/org/dxworks/insider/utils/ImportUtils.java

@@ -0,0 +1,21 @@
+package org.dxworks.insider.utils;
+
+public class ImportUtils {
+
+    public static final String IMPORT_SUFFIX = "([\\.;])([a-zA-Z_0-9]*\\.)*([a-zA-Z_0-9]*|\\*)*(;){0,1}";
+
+    public static String wrapImportPackage(String _import) {
+        return "(" + _import.replace(".", "\\.") + ")" + IMPORT_SUFFIX;
+    }
+
+    public static String unwrapImportPackage(String wrappedImport) {
+        int index = wrappedImport.indexOf(IMPORT_SUFFIX);
+        if (index == -1)
+            return wrappedImport;
+
+        String _import = wrappedImport.substring(1, index - 1);
+        _import = _import.replace("\\", "");
+
+        return _import;
+    }
+}

package/src/main/java/org/dxworks/insider/utils/LibraryImport.java

@@ -0,0 +1,17 @@
+package org.dxworks.insider.utils;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+public class LibraryImport {
+    private String _import;
+    private String library;
+
+    public String[] toStringArray() {
+        return new String[]{_import, library};
+    }
+}

package/src/main/java/org/dxworks/insider/utils/LibraryImportInOtherTechnology.java

@@ -0,0 +1,30 @@
+package org.dxworks.insider.utils;
+
+import lombok.Data;
+import lombok.ToString;
+
+import java.util.Objects;
+
+@Data
+@ToString(callSuper = true)
+public class LibraryImportInOtherTechnology extends LibraryImport {
+    private String otherTechnology;
+
+    public LibraryImportInOtherTechnology(String _import, String library, String otherTechnology) {
+        super(_import, library);
+        this.otherTechnology = otherTechnology;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        LibraryImportInOtherTechnology that = (LibraryImportInOtherTechnology) o;
+        return Objects.equals(get_import(), that.get_import());
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(get_import());
+    }
+}

package/src/main/java/org/dxworks/insider/utils/MapUtils.java

@@ -0,0 +1,19 @@
+package org.dxworks.insider.utils;
+
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+import static java.util.stream.Collectors.toMap;
+
+public class MapUtils {
+
+    public static Map<String, Integer> sortMapByValuesDesc(Map<String, Integer> unsortedMap) {
+        return unsortedMap
+                .entrySet()
+                .stream()
+                .sorted(Collections.reverseOrder(Map.Entry.comparingByValue()))
+                .collect(toMap(Map.Entry::getKey, Map.Entry::getValue, (e1, e2) -> e2,
+                        LinkedHashMap::new));
+    }
+}

package/src/main/resources/insider-version

@@ -0,0 +1 @@
+2.9.1

package/src/test/java/org/dxworks/insider/application/inspector/services/CommentServiceTest.java

@@ -0,0 +1,40 @@
+package org.dxworks.insider.application.inspector.services;
+
+import org.apache.commons.lang.math.IntRange;
+import org.dxworks.insider.InsiderFile;
+import org.dxworks.insider.technology.finder.LinguistService;
+import org.junit.Test;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.util.List;
+
+import static org.dxworks.insider.constants.InsiderConstants.DEFAULT_LINGUIST_FILE;
+import static org.junit.Assert.assertEquals;
+
+public class CommentServiceTest {
+
+    @Test
+    public void extractCommentsForCobol() throws IOException {
+
+        LinguistService.getInstance().initLinguist(DEFAULT_LINGUIST_FILE);
+
+        String filePathAsString = getClass().getClassLoader().getResource("cobol/CM201M.CBL").getPath();
+        File file = new File(filePathAsString);
+        String content = new String(Files.readAllBytes(Paths.get(file.getAbsolutePath())));
+
+        CommentService commentService = CommentService.getInstance();
+        List<IntRange> commentRanges = commentService.extractInlineCommentLines(
+                InsiderFile.builder()
+                        .name("CM201M.CBL")
+                        .path("cobol/CM201M.CBL")
+                        .extension(".CBL")
+                        .content(content)
+                        .build());
+
+        assertEquals(6, commentRanges.size());
+
+    }
+}

package/src/test/java/org/dxworks/insider/technology/finder/parsers/FingerprintsXmlParserTest.java

@@ -0,0 +1,15 @@
+package org.dxworks.insider.technology.finder.parsers;
+
+import org.junit.Test;
+
+import javax.xml.bind.JAXBException;
+
+public class FingerprintsXmlParserTest {
+
+    @Test
+    public void parseString() throws JAXBException {
+        FingerprintsXmlParser fingerprintsXmlParser = new FingerprintsXmlParser();
+
+//        fingerprintsXmlParser.parseString(Paths.get("config\\libraries.xml").toFile());
+    }
+}

package/src/test/java/org/dxworks/insider/utils/FileUtilsTest.java

@@ -0,0 +1,31 @@
+package org.dxworks.insider.utils;
+
+import org.junit.Test;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+
+import static org.junit.Assert.assertEquals;
+
+public class FileUtilsTest {
+
+    @Test
+    public void removeComments() throws IOException {
+        String contentWithComments = getContentOfResourceFile("Test1.java");
+        String expectedContentWithoutComments = getContentOfResourceFile("Test2.java");
+
+        String computedContentWithoutComments = FileUtils.removeComments(contentWithComments);
+
+        assertEquals(expectedContentWithoutComments, computedContentWithoutComments);
+    }
+
+    private String getContentOfResourceFile(String resourceFile) throws IOException {
+        String filePathAsString = getClass().getClassLoader().getResource(resourceFile).getPath();
+        File file = new File(filePathAsString);
+        String content = new String(Files.readAllBytes(Paths.get(file.getAbsolutePath())));
+
+        return content;
+    }
+}

package/src/test/java/org/dxworks/insider/utils/ImportUtilsTest.java

@@ -0,0 +1,24 @@
+package org.dxworks.insider.utils;
+
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+public class ImportUtilsTest {
+
+    @Test
+    public void fingerprintsWrappedAsImports() {
+        String expected = "(org\\.dxworks\\.dxplatform)([\\.;])([a-zA-Z_0-9]*\\.)*([a-zA-Z_0-9]*|\\*)*(;){0,1}";
+        String actual = ImportUtils.wrapImportPackage("org.dxworks.dxplatform");
+
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    public void testUnwrapImport() {
+        String expected = "org.dxworks.dxplatform";
+        String actual = ImportUtils.unwrapImportPackage("(org\\.dxworks\\.dxplatform)([\\.;])([a-zA-Z_0-9]*\\.)*([a-zA-Z_0-9]*|\\*)*(;){0,1}");
+
+        assertEquals(expected, actual);
+    }
+}