Software Development Now

David King, Software Developer and Enthusiast

Regular Expression Java – Mock Test Answers — April 22, 2017

Regular Expression Java – Mock Test Answers

The following string (inputs) is used to simulate a clients answers to five questions. The format is the question number followed by a delimiter and the alphabetic choice for that question.

import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;
@RunWith(JUnit4.class)
public class CoreJavaApplicationTests {
 final String inputs = "1:A, 2:B, 3:B, 4:A, 5:C";
 final String pattern = "[0-9]:[a-zA-Z],*";

 @Test
 public void parseAllSolution() {
 Matcher matchAll = Pattern.compile(pattern).matcher(inputs);
 printSections(matchAll);
 }

 private void printSections(Matcher matcher) {
 while (matcher.find()) {
 String item = matcher.group();

 Integer id = Integer.valueOf(item.replaceAll(patternSuffix,"").replaceAll(",",""));
 System.out.printf("\n PREFIX %s%n", id);

 String meta = item.replaceAll(patternPrefix,"").replaceAll(",","");
 System.out.printf("SUFFIX %s%n", meta);

 disp(id,meta);
 }

 }

 private void disp(Integer question, String response) {
 System.out.printf("ID: %d, RESP: %s%n", question, response);

 baselist.forEach(item -> {
 if (item.getId() == question && item.getResponse().equalsIgnoreCase(response)) {
 System.out.printf("Choice: Question - %d, Answer - %s, Data - %s%n", question, item.getResponse(), item.getDescriptor());
 }
 });
 }
}

 

Read Remote File Contents —

Read Remote File Contents

@Test
public void formatOutput() {
    final String routerJS =
            "static/master/router.js";
    readRemoteFileContents(routerJS);
}

private void readRemoteFileContents(final String fileToRead) {
    HttpURLConnection connection = null;
    try {
        connection = (HttpURLConnection)githubURL(fileToRead).openConnection();
    } catch (IOException e) {
        e.printStackTrace();
    }

    Scanner scanner = null;
    try (BufferedReader reader = new BufferedReader(new InputStreamReader(connection.getInputStream()))) {
        scanner = new Scanner(
                new StringReader(
                        reader.lines().collect(
                                Collectors.joining(System.getProperty("line.separator")))))
        .useDelimiter(System.getProperty("line.separator"));

        while(scanner.hasNext()) {
            System.out.printf("%s%n", scanner.next());
        }
    } catch (IOException e) {

    } finally {
        if (scanner != null) scanner.close();
        if (connection != null) connection.disconnect();
    }

}

private URL githubURL(final String fileToRead) throws MalformedURLException {
    final String baseGitHubFiles = "https://raw.githubusercontent.com/enterprisesaas/";
    final StringBuilder url = new StringBuilder(baseGitHubFiles).append(fileToRead);
    return new URL(url.toString());
}
View Zip File Contents —

View Zip File Contents

@Test
public void viewCompressedStreamContents() {
    final String basePath = "/Server/path/";
    final String zip = basePath + "favicons.zip";

    try (InputStream zipStream = Files.newInputStream(Paths.get(zip))) {
        ZipInputStream buffered = new ZipInputStream(zipStream);
        ZipEntry entry;
        while ((entry = buffered.getNextEntry()) != null) {
            System.out.println(entry.toString());
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
}
Functions as a Service — February 6, 2017
web xml for servlet 3.0 — September 7, 2014
Mock Utility Class — July 23, 2014

Mock Utility Class

Doing some exploration, I created the following Mock class with a mix of methods for filtering using different methods. The client simply invokes the method in a static way.


public final class Mock {
private static String mockFileBaseLocation = System.getProperty("user.dir");
private static String mockFileResourcesLocation = "src\\test\\resources";

public Mock() {
}

public static Map<String, Object> getEachXmlFileAsString(Map<String, Object> data) {
return iterateAndConvert(data).get();
}

public static String getXmlAsString(final String whichFileFromTheMockDatabase) {
return readContentsOfFileIntoString(
Mock.buildFullPathToXmlTestFile(whichFileFromTheMockDatabase));
}

public static Observable<Map<String, Object>> map(Map<String, Object> data) {
return Observable.from(data).map(Mock::transformMap);
}

public static Observable<Map<String, Object>> filter(Map<String, Object> data, String removeKey) {
return Observable.from(data).filter((entry) -> isItemInDataThenRemove(entry, removeKey));
}

public static Observable<Map<String, Object>> preserve(Map<String, Object> data, String preserveKey) {
return Observable.from(data).filter((entry) -> isItemInDataThenPreserveAndRemoveEverythingElse(data, preserveKey));
}

private static Map<String, Object> iterateAndConvertValueXmlToString(Map<String, Object> data) {
Map<String, Object> returnMap = new HashMap<>();
for (Map.Entry<String,Object> entry : data.entrySet()) {
returnMap.put(entry.getKey(), getXmlAsString((String)entry.getValue()));
}
return returnMap;
}

private static boolean isItemInDataThenRemove(Map<String, Object> data, String removeKey) {
data.entrySet().stream().filter(entry ->
entry.getKey().equalsIgnoreCase(removeKey)).forEach(entry -> {
data.remove(entry.getKey());
});
return true;
}

private static boolean isItemInDataThenPreserveAndRemoveEverythingElse(Map<String, Object> data, String preserveKey) {
data.entrySet().stream().filter(entry -> !entry.getKey().equalsIgnoreCase(preserveKey)).forEach(entry -> {
System.out.printf("Found element that is not to be preserved %s, removing. %n", entry.getKey());
data.remove(entry.getKey());
});

return data.get(preserveKey) != null;
}

private static Supplier<Map<String, Object>> iterateAndConvert(Map<String, Object> data) {
Map<String, Object> returnMap = new HashMap<>();
data.entrySet().forEach((entry) ->
returnMap.put(entry.getKey(), getXmlAsString((String)entry.getValue())));
return () -> returnMap;
}

private static Map<String, Object> transformMap(Map<String, Object> data) {
Map<String, Object> returnMap = new HashMap<>();
data.entrySet().forEach((entry) ->
returnMap.put(entry.getKey(), getXmlAsString((String)entry.getValue())));
return returnMap;
}

private static String buildFullPathToXmlTestFile(final String xmlFileName) {
return String.format("%s\\%s\\%s",
Mock.getMockFileBaseLocation(), Mock.getMockFileResourcesLocation(),
xmlFileName);
}

private static String getMockFileBaseLocation() {
return mockFileBaseLocation;
}

private static String getMockFileResourcesLocation() {
return mockFileResourcesLocation;
}

private static String readContentsOfFileIntoString(final String whichFileFromTheMockDatabase) {
String contentToReturn = "";

try (Scanner scanner = new Scanner(new File(whichFileFromTheMockDatabase))) {
scanner.useDelimiter("\\A");
contentToReturn = scanner.next();
} catch (IOException ioe) {
System.out.printf("IOException occured: %s%n", ioe.toString());
ioe.printStackTrace();
}

return contentToReturn;
}

private static InputStream openXmlFile(String fileClassPath) {
File temp = new File(fileClassPath);

try (InputStream inputStream = new FileInputStream(temp)) {
System.out.printf("Returning openXmlFile: %s%n", temp.getAbsolutePath());
return inputStream;
} catch (IOException ioe) {
System.out.printf("IOException occured: %s%n", ioe.toString());
ioe.printStackTrace();
}

return null;
}

private static File createFileFromInputStream(String fileNameAndPath, InputStream inputStream) {
File outFile = new File(fileNameAndPath);

try (OutputStream outputStream = new FileOutputStream(outFile)) {
int readBytes = 0;
byte[] byteBuffer = new byte[2048];
while ((readBytes = inputStream.read(byteBuffer)) != -1) {
outputStream.write(byteBuffer, 0, readBytes);
}
} catch (IOException ioe) {
System.out.printf("IOException occured: %s%n", ioe.toString());
ioe.printStackTrace();
} finally {
if (inputStream != null) {
try { inputStream.close(); } catch (IOException ioe) {
System.out.printf("IOException occured: %s%n", ioe.toString());
ioe.printStackTrace();
}
}
}

return outFile;
}
}

Create Nested Directories From List — July 21, 2014

Create Nested Directories From List


import org.junit.Before;
import org.junit.Test;

import java.io.File;
import java.io.IOException;
import java.net.URI;
import java.nio.file.FileSystems;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.List;

import static org.junit.Assert.assertNotNull;

/**
* Created by dking on 7/18/2014.
*/
public class NioStructureTest {
final String FILE_PREFIX = "file://";
final String DIRECTORY_FILE_PREFIX = "file:///";
final List<URI> dirsList = new ArrayList<>();
final List<String> dirNamesList = new ArrayList<>();

@Test
public void initializeFrontEndStructure() throws IOException {
//URI rootPathStr = URI.create(String.format("%s%s", DIRECTORY_FILE_PREFIX, "Temp//niostructuretest"));
//boolean yesOverwriteExistingDirectory = true;
//createDirectory(rootPathStr.getPath(), yesOverwriteExistingDirectory);
}

private void createDirectory(String rootPathStr, boolean overwrite, boolean isNested) throws IOException {
if (!FileSystems.getDefault().getPath(rootPathStr).toFile().exists()) {
doCreateDirectory(rootPathStr, isNested);
} else if (FileSystems.getDefault().getPath(rootPathStr).toFile().exists() && overwrite) {
doDeleteDirectory(rootPathStr);
doCreateDirectory(rootPathStr, isNested);
} else
System.out.println("RootPath already exists.");
}

private void doDeleteDirectory(String rootPathStr) throws IOException {
System.out.printf("doDeleteDirectory with arg: %s%n", rootPathStr);
Files.delete(Paths.get(URI.create(String.format("%s%s", FILE_PREFIX, rootPathStr))));
}

private void doCreateDirectory(String rootPathStr, boolean isNested) throws IOException {
System.out.printf("doCreateDirectory with arg: %s%n", rootPathStr);
if (isNested) {
File file = new File(rootPathStr);
boolean wasDirsCreated = file.mkdirs();
if (wasDirsCreated) {
System.out.printf("Directories were created: %s%n", file.getAbsolutePath());
} else {
System.out.printf("Directores were NOT created: %s%n", file.getAbsolutePath());
}
} else {
Path rootPath = Files.createDirectory(Paths.get(URI.create(String.format("%s%s", FILE_PREFIX, rootPathStr))));
assertNotNull("RootPath was null", rootPath);
System.out.printf("Path created: %s%n", rootPath.toString());
}
}

@Before
public void setUp() throws IOException {
dirNamesList.add("Temp//niostructuretest");
dirNamesList.add("Temp//niostructuretest//src//main//java");
dirNamesList.add("Temp//niostructuretest//src//main//resources");
dirNamesList.add("Temp//niostructuretest//src//main//webapp");
dirNamesList.add("Temp//niostructuretest//src//main//webapp//WEB-INF");

System.out.println("Building directory structure in memory.");
for (String directoryName : dirNamesList) {
if (null != directoryName) {
dirsList.add(URI.create(String.format("%s%s", DIRECTORY_FILE_PREFIX, directoryName)));
}
}
System.out.println("In memory structure is: " + dirsList);

//createDirectory(dirsList.get(4).getPath(), true, false);

System.out.println("Creating the directories from the stored structures.");
for (URI uriPath : dirsList) {
if (null != uriPath) {
try {
createDirectory(uriPath.getPath(), false, true);
} catch (IOException e) {
e.printStackTrace();
}
}
}

System.out.println("Done with directories setup.");
}
}

&nbsp;