From 9c3ece5fb10dd65b10ab442c09188ac6a97dbda3 Mon Sep 17 00:00:00 2001 From: annoing-morda Date: Mon, 15 Dec 2014 15:25:09 +0300 Subject: [PATCH 01/10] JUnit --- .../junit/BadDBFileException.java | 9 + .../dmitry_morozov/junit/ChangingCommand.java | 24 ++ .../dmitry_morozov/junit/DBCollection.java | 96 ++++++ .../dmitry_morozov/junit/FileMap.java | 196 ++++++++++++ .../students/dmitry_morozov/junit/Main.java | 125 ++++++++ .../junit/MultiFileHashMap.java | 209 +++++++++++++ .../junit/MyTableProviderFactory.java | 22 ++ .../dmitry_morozov/junit/ReversableMFHM.java | 53 ++++ .../students/dmitry_morozov/junit/Utils.java | 53 ++++ .../junit/interpreter/DBInterpreter.java | 291 ++++++++++++++++++ .../junit/interpreter/HandlerReturn.java | 18 ++ .../interpreter/HandlerReturnResult.java | 5 + .../junit/tests/DBCollectionTest.java | 93 ++++++ .../tests/MyTableProviderFactoryTest.java | 39 +++ .../junit/tests/ReversableMFHPTest.java | 133 ++++++++ 15 files changed, 1366 insertions(+) create mode 100644 src/ru/fizteh/fivt/students/dmitry_morozov/junit/BadDBFileException.java create mode 100644 src/ru/fizteh/fivt/students/dmitry_morozov/junit/ChangingCommand.java create mode 100644 src/ru/fizteh/fivt/students/dmitry_morozov/junit/DBCollection.java create mode 100644 src/ru/fizteh/fivt/students/dmitry_morozov/junit/FileMap.java create mode 100644 src/ru/fizteh/fivt/students/dmitry_morozov/junit/Main.java create mode 100644 src/ru/fizteh/fivt/students/dmitry_morozov/junit/MultiFileHashMap.java create mode 100644 src/ru/fizteh/fivt/students/dmitry_morozov/junit/MyTableProviderFactory.java create mode 100644 src/ru/fizteh/fivt/students/dmitry_morozov/junit/ReversableMFHM.java create mode 100644 src/ru/fizteh/fivt/students/dmitry_morozov/junit/Utils.java create mode 100644 src/ru/fizteh/fivt/students/dmitry_morozov/junit/interpreter/DBInterpreter.java create mode 100644 src/ru/fizteh/fivt/students/dmitry_morozov/junit/interpreter/HandlerReturn.java create mode 100644 src/ru/fizteh/fivt/students/dmitry_morozov/junit/interpreter/HandlerReturnResult.java create mode 100644 src/ru/fizteh/fivt/students/dmitry_morozov/junit/tests/DBCollectionTest.java create mode 100644 src/ru/fizteh/fivt/students/dmitry_morozov/junit/tests/MyTableProviderFactoryTest.java create mode 100644 src/ru/fizteh/fivt/students/dmitry_morozov/junit/tests/ReversableMFHPTest.java diff --git a/src/ru/fizteh/fivt/students/dmitry_morozov/junit/BadDBFileException.java b/src/ru/fizteh/fivt/students/dmitry_morozov/junit/BadDBFileException.java new file mode 100644 index 000000000..e2c413824 --- /dev/null +++ b/src/ru/fizteh/fivt/students/dmitry_morozov/junit/BadDBFileException.java @@ -0,0 +1,9 @@ +package ru.fizteh.fivt.students.dmitry_morozov.junit; + +public class BadDBFileException extends Exception { + + public BadDBFileException(String msg) { + super(msg); + } + +} diff --git a/src/ru/fizteh/fivt/students/dmitry_morozov/junit/ChangingCommand.java b/src/ru/fizteh/fivt/students/dmitry_morozov/junit/ChangingCommand.java new file mode 100644 index 000000000..3382d57ed --- /dev/null +++ b/src/ru/fizteh/fivt/students/dmitry_morozov/junit/ChangingCommand.java @@ -0,0 +1,24 @@ +package ru.fizteh.fivt.students.dmitry_morozov.junit; + +enum CommandName{ + PUT, + REMOVE +}; + +public class ChangingCommand { + public CommandName _c; + public String [] args; + public ChangingCommand(CommandName c, String arg1, String arg2) { + _c = c; + if (_c == CommandName.PUT) { + args = new String [2]; + args[0] = arg1; + args[1] = arg2; + } + if (_c == CommandName.REMOVE) { + args = new String [1]; + args[0] = arg1; + } + } + +} diff --git a/src/ru/fizteh/fivt/students/dmitry_morozov/junit/DBCollection.java b/src/ru/fizteh/fivt/students/dmitry_morozov/junit/DBCollection.java new file mode 100644 index 000000000..a90bc1e02 --- /dev/null +++ b/src/ru/fizteh/fivt/students/dmitry_morozov/junit/DBCollection.java @@ -0,0 +1,96 @@ +package ru.fizteh.fivt.students.dmitry_morozov.junit; + +import java.util.List; +import java.io.File; +import java.io.IOException; + +import ru.fizteh.fivt.storage.strings.Table; +import ru.fizteh.fivt.storage.strings.TableProvider; + +public class DBCollection implements TableProvider { + private String dirPath; + private FileMap maps; + + public DBCollection(String dirPath) throws Exception { + this.dirPath = dirPath; + maps = null; + if (dirPath == null) { + throw new IllegalArgumentException("path is null"); + } + if (dirPath.endsWith("/") && !dirPath.equals("/")) { + String tmp = ""; + for (int i = 0; i < dirPath.length() - 1; i++) { + tmp += dirPath.charAt(i); + } + dirPath = tmp; + } + try { + maps = new FileMap(dirPath + "/tables_info.dat"); + } catch (Exception e) { + throw new IllegalArgumentException(); + } + } + + public List showTables() { // Actually doesn't + // throw anything. + return maps.list(); + } + + @Override + public Table getTable(String name) throws IllegalArgumentException { + String fullPath = maps.get(name); + if (fullPath == null) { + return null; + } + Table res; + try { + res = new ReversableMFHM(name); + } catch (Exception e) { + throw new IllegalArgumentException(); + } + return res; + } + + @Override + public Table createTable(String name) { + // TODO Auto-generated method stub + if (maps.get(name) != null) { + return null; + } + maps.put(name, dirPath + "/" + name); + File dir = new File(dirPath + "/" + name); + if(!dir.mkdirs()) { + throw new IllegalArgumentException(); + } + ReversableMFHM res; + try { + res = new ReversableMFHM(dirPath + "/" + name); + } catch (Exception e) { + maps.remove(name); + throw new IllegalStateException(); + } + return res; + } + + @Override + public void removeTable(String name) { + String tname = maps.get(name); + if (tname != null) { // Database found. + if (!Utils.removeDirectory(tname)) { + System.err.println("deleting table from disk failed"); + } else { + maps.remove(name); + } + } else { // Database not found. + throw new IllegalStateException(); + } + } + + public void emeregencyExit() { + try { + maps.exit(); + } catch (IOException e) { + e.printStackTrace(); + } + } +} diff --git a/src/ru/fizteh/fivt/students/dmitry_morozov/junit/FileMap.java b/src/ru/fizteh/fivt/students/dmitry_morozov/junit/FileMap.java new file mode 100644 index 000000000..7a8b7038e --- /dev/null +++ b/src/ru/fizteh/fivt/students/dmitry_morozov/junit/FileMap.java @@ -0,0 +1,196 @@ +package ru.fizteh.fivt.students.dmitry_morozov.junit; + +import java.io.DataInputStream; +import java.io.DataOutputStream; +import java.io.File; +import java.io.FileInputStream; +import java.io.FileOutputStream; +import java.io.IOException; +import java.io.PrintWriter; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.Iterator; +import java.util.List; +import java.util.Map; +import java.util.Map.Entry; +import java.util.Set; + +import ru.fizteh.fivt.storage.strings.Table; + +public class FileMap implements Table { + private Map table; + private File dbFile; + + public FileMap(String path) throws BadDBFileException, IOException { + table = new HashMap<>(); + dbFile = new File(path); + if (!dbFile.exists()) { + if (!dbFile.createNewFile()) { + throw new BadDBFileException("Couldldn't create db file"); + } + } else { + if (!dbFile.isFile()) { + throw new BadDBFileException("Is not a file"); + } + } + if (!(dbFile.setReadable(true)) && dbFile.setWritable(true)) { + throw new BadDBFileException("Couldn't set rw options"); + } + DataInputStream in = new DataInputStream(new FileInputStream(dbFile)); + + + + while (true) { + String key = readString(in); + if(key == null) + break; + String value = readString(in); + if (value == null) { + in.close(); + throw new BadDBFileException("Couldn't set rw options"); + } + table.put(key, value); + } + in.close(); + + } + + /** + * @return String read from file. If meets end of file, returns null. + * @throws BadDBFileException + * @throws IOException + * */ + + private String readString(DataInputStream in) throws IOException, BadDBFileException { + final int sizeOfInt= 4; + int len; + String res = ""; + if (in.available() >= sizeOfInt) { + len = in.readInt(); + if (0 != len % 2 || in.available() < len) { + in.close(); + throw new BadDBFileException("File was damaged"); + } + len /= 2; + while (len > 0) { + char curChar = in.readChar(); + res += curChar; + len--; + } + } else + return null; + return res; + } + + public String put(String key, String value) throws IllegalArgumentException { + if (key == null) { + throw new IllegalArgumentException(); + } + String res = table.get(key); + table.put(key, value); + return res; + } + + public String get(String key) throws IllegalArgumentException { + if (key == null) { + throw new IllegalArgumentException(); + } + String val = table.get(key); + return val; + } + + public String clearGet(String key) { + return table.get(key); + } + + public List list() { + List res = new ArrayList<>(); + Set> tableSet = table.entrySet(); + for (Entry i : tableSet) { + res.add(i.getKey()); + } + return res; + } + + public void printList(PrintWriter pw) { + Set> tableSet = table.entrySet(); + Iterator> checkLast = tableSet.iterator(); + if (checkLast.hasNext()) { + checkLast.next(); + } + for (Entry i : tableSet) { + if (checkLast.hasNext()) { + pw.print(i.getKey() + ", "); + checkLast.next(); + } else { + pw.print(i.getKey()); + } + } + pw.flush(); + } + + public void fullList(PrintWriter pw) { + Set> tableSet = table.entrySet(); + Iterator> checkLast = tableSet.iterator(); + if (checkLast.hasNext()) { + checkLast.next(); + } + for (Entry i : tableSet) { + if (checkLast.hasNext()) { + pw.println(i.getKey() + " " + i.getValue()); + checkLast.next(); + } else { + pw.print(i.getKey() + " " + i.getValue()); + } + } + pw.flush(); + } + + public String remove(String key) throws IllegalArgumentException { + if (key == null) { + throw new IllegalArgumentException(); + } + return table.remove(key); + } + + public void exit() throws IOException { + DataOutputStream out = new DataOutputStream( + new FileOutputStream(dbFile)); + Set> tableSet = table.entrySet(); + for (Entry it : tableSet) { + writeData(out, it.getKey()); + writeData(out, it.getValue()); + } + out.flush(); + out.close(); + } + + private void writeData(DataOutputStream out, String toWrite) throws IOException { + int len = toWrite.length(); + out.writeInt(len * 2); + out.writeChars(toWrite); + } + + public boolean isEmpty() { + return table.isEmpty(); + } + + public int size() { + return table.size(); + } + + @Override + public String getName() { + return dbFile.getName(); + } + + @Override + public int commit() { + return 0; + } + + @Override + public int rollback() { + return 0; + } +} diff --git a/src/ru/fizteh/fivt/students/dmitry_morozov/junit/Main.java b/src/ru/fizteh/fivt/students/dmitry_morozov/junit/Main.java new file mode 100644 index 000000000..a84161e0d --- /dev/null +++ b/src/ru/fizteh/fivt/students/dmitry_morozov/junit/Main.java @@ -0,0 +1,125 @@ +package ru.fizteh.fivt.students.dmitry_morozov.junit; + +import java.util.Scanner; + +import ru.fizteh.fivt.students.dmitry_morozov.junit.interpreter.DBInterpreter; +import ru.fizteh.fivt.students.dmitry_morozov.junit.interpreter.HandlerReturn; +import ru.fizteh.fivt.students.dmitry_morozov.junit.interpreter.HandlerReturnResult; + +public class Main { + + public static HandlerReturn commandSplitting(String command, DBInterpreter inter) { + String[] firstSplitted = command.split(" "); + String[] toGive = new String[firstSplitted.length]; + int j = 0; + for (int i = 0; i < firstSplitted.length; i++) { + if (firstSplitted[i].length() > 0) { + toGive[j] = firstSplitted[i]; + j++; + } + } + if (0 == j) { + return new HandlerReturn(HandlerReturnResult.SUCCESS, ""); + } + return inter.handle(toGive, 0, j); + } + + public static void batchMode(String[] args, DBInterpreter inter) { + String currentLine = ""; + for (int i = 0; i < args.length; i++) { + currentLine += args[i] + " "; + } + String[] commands = currentLine.split(";"); + try { + for (int i = 0; i < commands.length; i++) { + if (commands[i].length() > 0) { + HandlerReturn ret = commandSplitting(commands[i], inter); + switch (ret.getVal()) { + case SUCCESS: + System.out.print(ret.getMessage()); + break; + case NO_SUCH_COMMAND: + System.out + .print("No such command: " + ret.getMessage()); + break; + case NOT_ENOUGH_PARAMETRES: + System.out.println("Not enough parametres for command " + + ret.getMessage()); + break; + case ERROR: + System.out.print("Error occured " + ret.getMessage()); + break; + case TABLE_NOT_CHOSEN: + System.out.println("Table not chosen"); + break; + case EXIT: + System.out.print(ret.getMessage()); + i = commands.length; + break; + } + } + } + + } catch (Exception e) { + System.err.println(e.getMessage()); + inter.emeregencyExit(); + System.exit(1); + } + inter.handleExit(); + System.exit(0); + } + + public static void main(String[] args) { + DBInterpreter inter = new DBInterpreter(System.getProperty("db.file")); + if (args.length > 0) { + batchMode(args, inter); + } + Scanner in = new Scanner(System.in); + + boolean contFlag = true; + try { + while (contFlag) { + System.out.print(" $ "); + String currentLine = in.nextLine(); + String[] commands = currentLine.split(";"); + for (int i = 0; i < commands.length; i++) { + if (commands[i].length() > 0) { + HandlerReturn ret = commandSplitting(commands[i], inter); + switch (ret.getVal()) { + case SUCCESS: + System.out.print(ret.getMessage()); + break; + case NO_SUCH_COMMAND: + System.out.print("No such command: " + + ret.getMessage()); + break; + case NOT_ENOUGH_PARAMETRES: + System.out + .println("Not enough parametres for command " + + ret.getMessage()); + break; + case ERROR: + System.out.print("Error occured " + + ret.getMessage()); + break; + case TABLE_NOT_CHOSEN: + System.out.println("Table not chosen"); + break; + case EXIT: + System.out.print(ret.getMessage()); + contFlag = false; + break; + } + } + } + } + } catch (Exception e) { + e.printStackTrace(); + inter.emeregencyExit(); + } finally { + in.close(); + } + + } + +} diff --git a/src/ru/fizteh/fivt/students/dmitry_morozov/junit/MultiFileHashMap.java b/src/ru/fizteh/fivt/students/dmitry_morozov/junit/MultiFileHashMap.java new file mode 100644 index 000000000..f8742cf7d --- /dev/null +++ b/src/ru/fizteh/fivt/students/dmitry_morozov/junit/MultiFileHashMap.java @@ -0,0 +1,209 @@ +package ru.fizteh.fivt.students.dmitry_morozov.junit; + +import java.io.File; +import java.io.IOException; +import java.util.ArrayList; +import java.util.BitSet; +import java.util.List; +import java.util.TreeSet; + +import ru.fizteh.fivt.storage.strings.Table; + +public class MultiFileHashMap implements Table { + private final static int FILE_MAPS_CNT = 256; + private final static int DIRS_CNT = 16; + private File rootDir; + private BitSet openedMaps; + private FileMap[] maps; + private String name; + int size; + + public MultiFileHashMap(String path) throws BadDBFileException { + String[] splittedPath = path.split("/"); + name = splittedPath[splittedPath.length - 1]; + size = 0; + rootDir = Utils.safeMkDir(path); + openedMaps = new BitSet(FILE_MAPS_CNT); + openedMaps.clear(); + maps = new FileMap[FILE_MAPS_CNT]; + for (int i = 0; i < DIRS_CNT; ++i) { + String suffix = "/"; + if (i < 10) { + suffix += "0"; + } + suffix += Integer.toString(i); + suffix += ".dir"; + Utils.safeMkDir(path + suffix); + } + } + + public String put(String key, String value) throws IllegalArgumentException { + if (key == null || value == null) { + throw new IllegalArgumentException(); + } + int mapNum = Math.abs(key.hashCode() % FILE_MAPS_CNT); + if (openedMaps.get(mapNum)) { + return maps[mapNum].put(key, value); + } else { + String curPath = getPath(mapNum); + try { + maps[mapNum] = new FileMap(curPath); + } catch (Exception e) { + e.printStackTrace(); + System.err.println("Couldn't access" + curPath); + } + openedMaps.set(mapNum); + return maps[mapNum].put(key, value); + } + } + + public String get(String key) throws IllegalArgumentException { + if (key == null) { + throw new IllegalArgumentException(); + } + int mapNum = Math.abs(key.hashCode() % FILE_MAPS_CNT); + if (openedMaps.get(mapNum)) { + return maps[mapNum].get(key); + } else { + String curPath = getPath(mapNum); + try { + maps[mapNum] = new FileMap(curPath); + } catch (Exception e) { + e.printStackTrace(); + System.err.println("Couldn't access" + curPath); + } + openedMaps.set(mapNum); + return maps[mapNum].get(key); + } + } + + public String remove(String key) throws IllegalArgumentException { + if (key == null) { + throw new IllegalArgumentException(); + } + int mapNum = Math.abs(key.hashCode() % FILE_MAPS_CNT); + if (openedMaps.get(mapNum)) { + return maps[mapNum].remove(key); + } else { + String curPath = getPath(mapNum); + try { + maps[mapNum] = new FileMap(curPath); + } catch (Exception e) { + System.err.println("Couldn't access" + curPath); + e.printStackTrace(); + } + openedMaps.set(mapNum); + return maps[mapNum].remove(key); + } + } + + public List list() { + List res = new ArrayList(); + for (int i = 0; i < FILE_MAPS_CNT; i++) { + List t; + if (openedMaps.get(i)) { + t = maps[i].list(); + res.addAll(t); + } else { + String curPath = getPath(i); + try { + maps[i] = new FileMap(curPath); + } catch (Exception e) { + System.err.println("Couldn't access" + curPath); + e.printStackTrace(); + } + t = maps[i].list(); + res.addAll(t); + openedMaps.set(i); + } + } + return res; + + } + + public void exit() throws IOException { + TreeSet toDelete = new TreeSet(); + for (int i = 0; i < FILE_MAPS_CNT; i++) { + if (openedMaps.get(i)) { + if (maps[i].isEmpty()) { + toDelete.add(i); + } + maps[i].exit(); + } + } + for (Integer num : toDelete) { + File tdel = new File(getPath(num)); + tdel.delete(); + } + for (int i = 0; i < DIRS_CNT; i++) { + String suffix = "/"; + if (i < 10) { + suffix += "0"; + } + suffix += Integer.toString(i); + suffix += ".dir"; + File tdir = new File(rootDir.getAbsolutePath() + suffix); + tdir.delete(); // Won't be deleted if there're any files. + } + } + + /** + * @return Path to database file by number of database + */ + private String getPath(int hash) { + int ndir = Math.abs(hash % DIRS_CNT); + int nfile = Math.abs(hash / DIRS_CNT % DIRS_CNT); + String path = rootDir.getAbsolutePath(); + String suffix = "/"; + if (ndir < 10) { + suffix += "0"; + } + suffix += Integer.toString(ndir) + ".dir/"; + if (nfile < 10) { + suffix += "0"; + } + suffix += Integer.toString(nfile) + ".dat"; + path += suffix; + + return path; + } + + public int getUnsavedChanges() { + return 0; + } + + @Override + public String getName() { + return name; + } + + @Override + public int size() { + int res = 0; + for (int i = 0; i < FILE_MAPS_CNT; ++i) { + if (openedMaps.get(i)) { + res += maps[i].size(); + } else { + try { + maps[i] = new FileMap(getPath(i)); // If couldn't access + // subdatabase,there are + // no records. + res += maps[i].size(); + openedMaps.set(i); + } catch (Exception e) { + } + } + } + return res; + } + + @Override + public int commit() { + return 0; + } + + @Override + public int rollback() { + return 0; + } +} diff --git a/src/ru/fizteh/fivt/students/dmitry_morozov/junit/MyTableProviderFactory.java b/src/ru/fizteh/fivt/students/dmitry_morozov/junit/MyTableProviderFactory.java new file mode 100644 index 000000000..5e1d75987 --- /dev/null +++ b/src/ru/fizteh/fivt/students/dmitry_morozov/junit/MyTableProviderFactory.java @@ -0,0 +1,22 @@ +package ru.fizteh.fivt.students.dmitry_morozov.junit; + +import ru.fizteh.fivt.storage.strings.TableProvider; +import ru.fizteh.fivt.storage.strings.TableProviderFactory; + +public class MyTableProviderFactory implements TableProviderFactory { + + public MyTableProviderFactory() { + } + + @Override + public TableProvider create(String dir) throws IllegalArgumentException { + TableProvider res; + try { + res = new DBCollection(dir); + } catch (Exception e) { + throw new IllegalArgumentException(); + } + return res; + } + +} diff --git a/src/ru/fizteh/fivt/students/dmitry_morozov/junit/ReversableMFHM.java b/src/ru/fizteh/fivt/students/dmitry_morozov/junit/ReversableMFHM.java new file mode 100644 index 000000000..7ecb615cd --- /dev/null +++ b/src/ru/fizteh/fivt/students/dmitry_morozov/junit/ReversableMFHM.java @@ -0,0 +1,53 @@ +package ru.fizteh.fivt.students.dmitry_morozov.junit; + +import java.util.Stack; + +public class ReversableMFHM extends MultiFileHashMap { + Stack opStack; + + public ReversableMFHM(String path) throws Exception { + super(path); + opStack = new Stack<>(); + } + + public String put(String key, String value) throws IllegalArgumentException { + String result = super.put(key, value); + if (result == null) { // If PUT has just pushed new value + opStack.push(new ChangingCommand(CommandName.REMOVE, key, "")); + } else { // If PUT has overwritten old value + opStack.push(new ChangingCommand(CommandName.PUT, key, result)); + } + return result; + } + + public String remove(String key) throws IllegalArgumentException { + String result = super.remove(key); + if (result != null) { // Key found. + opStack.push(new ChangingCommand(CommandName.PUT, key, result)); + } + return result; + } + + public int rollback() { + int cnt = opStack.size(); + while (!opStack.isEmpty()) { + ChangingCommand t = opStack.pop(); + if (t._c == CommandName.PUT) { + super.put(t.args[0], t.args[1]); + } else { + super.remove(t.args[0]); + } + } + return cnt; + } + + public int commit() { + int cnt = opStack.size(); + opStack.clear(); + return cnt; + } + + public int getUnsavedChanges() { + return opStack.size(); + } +} diff --git a/src/ru/fizteh/fivt/students/dmitry_morozov/junit/Utils.java b/src/ru/fizteh/fivt/students/dmitry_morozov/junit/Utils.java new file mode 100644 index 000000000..30f248230 --- /dev/null +++ b/src/ru/fizteh/fivt/students/dmitry_morozov/junit/Utils.java @@ -0,0 +1,53 @@ +package ru.fizteh.fivt.students.dmitry_morozov.junit; + +import java.io.File; + +public class Utils { + /** + * @return False is something was wrong + */ + static boolean removeDirectory(String path) { + File dir = new File(path); + if (!dir.exists()) { + System.err.println("table has been already deleted from disk"); + return false; + } + if (!dir.isDirectory()) { + System.err.println("table directory has been damaged"); + return false; + } + File[] flist = dir.listFiles(); + for (int i = 0; i < flist.length; i++) { + if (flist[i].isDirectory()) { + if (0 == flist[i].listFiles().length) { + if (!flist[i].delete()) { + return false; + } + } else { + if (!removeDirectory(flist[i].getAbsolutePath())) { + return false; + } + } + } else { + if (!flist[i].delete()) { + return false; + } + } + + } + return dir.delete(); + } + + static File safeMkDir(String path) throws BadDBFileException { + File dir = new File(path); + if (dir.exists()) { + if (!dir.isDirectory()) { + throw new BadDBFileException("File " + path + + " already exists and it's not a directory"); + } + } else { + dir.mkdir(); + } + return dir; + } +} diff --git a/src/ru/fizteh/fivt/students/dmitry_morozov/junit/interpreter/DBInterpreter.java b/src/ru/fizteh/fivt/students/dmitry_morozov/junit/interpreter/DBInterpreter.java new file mode 100644 index 000000000..2bfc49b19 --- /dev/null +++ b/src/ru/fizteh/fivt/students/dmitry_morozov/junit/interpreter/DBInterpreter.java @@ -0,0 +1,291 @@ +package ru.fizteh.fivt.students.dmitry_morozov.junit.interpreter; + +import java.io.IOException; +import java.util.HashMap; +import java.util.TreeSet; +import java.util.List; + +import ru.fizteh.fivt.storage.strings.Table; +import ru.fizteh.fivt.storage.strings.TableProviderFactory; +import ru.fizteh.fivt.students.dmitry_morozov.junit.DBCollection; +import ru.fizteh.fivt.students.dmitry_morozov.junit.MyTableProviderFactory; +import ru.fizteh.fivt.students.dmitry_morozov.junit.ReversableMFHM; + +public class DBInterpreter { + private DBCollection provider; + private ReversableMFHM table; + private HashMap argsCount; + private TreeSet commandsForTable; + + public DBInterpreter(String path) { + TableProviderFactory factory = new MyTableProviderFactory(); + try { + provider = (DBCollection) factory.create(path); + if (provider == null) { + System.out.println("Usage: java -Ddb.file="); + return; + } + } catch (IllegalArgumentException e) { + System.out + .println("Usage: java -Ddb.file=. Your path could have had incorrect value"); + throw new IllegalArgumentException(); + } + table = null; + argsCount = new HashMap<>(); + argsCount.put("use", 1); + argsCount.put("create", 1); + argsCount.put("drop", 1); + argsCount.put("put", 2); + argsCount.put("get", 1); + argsCount.put("remove", 1); + argsCount.put("list", 0); + argsCount.put("size", 0); + argsCount.put("rollback", 0); + argsCount.put("commit", 0); + argsCount.put("exit", 0); + argsCount.put("show", 1); + commandsForTable = new TreeSet<>(); + commandsForTable.add("put"); + commandsForTable.add("get"); + commandsForTable.add("remove"); + commandsForTable.add("list"); + commandsForTable.add("size"); + commandsForTable.add("rollback"); + commandsForTable.add("commit"); + + } + + public HandlerReturn handle(String[] comAndParams, int bIndex, int eIndex) { + if (comAndParams.length < 1) { + return new HandlerReturn(HandlerReturnResult.EXIT, ""); + } + String command = comAndParams[bIndex].toLowerCase(); + Integer expectedArgsCount = argsCount.get(command); + if (expectedArgsCount == null) { + return new HandlerReturn(HandlerReturnResult.NO_SUCH_COMMAND, ""); + } else { + if (expectedArgsCount > eIndex - bIndex - 1) { + return new HandlerReturn( + HandlerReturnResult.NOT_ENOUGH_PARAMETRES, + comAndParams[bIndex]); + } + } + if (commandsForTable.contains(command) && table == null) { + return new HandlerReturn(HandlerReturnResult.TABLE_NOT_CHOSEN, ""); + } + switch (command) { + case "put": + return handlePut(comAndParams, bIndex + 1, eIndex); + case "get": + return handleGet(comAndParams, bIndex + 1, eIndex); + case "remove": + return handleRemove(comAndParams, bIndex + 1, eIndex); + case "list": + return handleList(); + case "size": + return handleSize(); + case "rollback": + return handleRollback(comAndParams, bIndex + 1, eIndex); + case "commit": + return handleCommit(comAndParams, bIndex + 1, eIndex); + case "use": + return handleUse(comAndParams, bIndex + 1, eIndex); + case "create": + return handleCreate(comAndParams, bIndex + 1, eIndex); + case "drop": + return handleDrop(comAndParams, bIndex + 1, eIndex); + case "exit": + return handleExit(); + case "show": + return handleShowTables(comAndParams, bIndex + 1, eIndex); + } + + return new HandlerReturn(HandlerReturnResult.EXIT, ""); + + } + + public HandlerReturn handlePut(String[] comAndParams, int bIndex, int eIndex) { + String res; + try { + res = table.put(comAndParams[bIndex], comAndParams[bIndex + 1]); + } catch (IllegalArgumentException e) { + return new HandlerReturn(HandlerReturnResult.ERROR, ""); + } + if (res == null) { + res = "new\n"; + } else { + res = "overwrite\n" + res + "\n"; + } + return new HandlerReturn(HandlerReturnResult.SUCCESS, res); + } + + public HandlerReturn handleGet(String[] comAndParams, int bIndex, int eIndex) { + String res; + try { + res = table.get(comAndParams[bIndex]); + } catch (IllegalArgumentException e) { + return new HandlerReturn(HandlerReturnResult.ERROR, ""); + } + if (res == null) { + res = "not found\n"; + } else { + res = "found\n" + res + "\n"; + } + return new HandlerReturn(HandlerReturnResult.SUCCESS, res); + } + + public HandlerReturn handleRemove(String[] comAndParams, int bIndex, + int eIndex) { + String res; + try { + res = table.get(comAndParams[bIndex]); + } catch (IllegalArgumentException e) { + return new HandlerReturn(HandlerReturnResult.ERROR, ""); + } + if (res == null) { + res = "not found\n"; + } else { + res = "removed\n"; + } + return new HandlerReturn(HandlerReturnResult.SUCCESS, res); + } + + public HandlerReturn handleList() { + String res; + res = String.join(", ", table.list()); + return new HandlerReturn(HandlerReturnResult.SUCCESS, res); + } + + public HandlerReturn handleSize() { + return new HandlerReturn(HandlerReturnResult.SUCCESS, table.size() + + "\n"); + } + + public HandlerReturn handleRollback(String[] comAndParams, int bIndex, + int eIndex) { + return new HandlerReturn(HandlerReturnResult.SUCCESS, table.rollback() + + "\n"); + } + + public HandlerReturn handleCommit(String[] comAndParams, int bIndex, + int eIndex) { + return new HandlerReturn(HandlerReturnResult.SUCCESS, table.commit() + + "\n"); + } + + public HandlerReturn handleUse(String[] comAndParams, int bIndex, int eIndex) { + if (table == null) { + try { + table = (ReversableMFHM) provider + .getTable(comAndParams[bIndex]); + } catch (IllegalArgumentException e) { + return new HandlerReturn(HandlerReturnResult.ERROR, ""); + } + if (table == null) { + return new HandlerReturn(HandlerReturnResult.SUCCESS, + comAndParams[bIndex] + "not exists\n"); + } else { + return new HandlerReturn(HandlerReturnResult.SUCCESS, "using " + + comAndParams[bIndex] + "\n"); + } + } + int unsaved = table.getUnsavedChanges(); + if (unsaved > 0) { + return new HandlerReturn(HandlerReturnResult.SUCCESS, unsaved + + "unsaved changes\n"); + } + try { + table.exit(); + } catch (IOException e) { + System.err.println("Couldn't save" + table.getName() + "on disk"); + } + try { + table = (ReversableMFHM) provider.getTable(comAndParams[bIndex]); + } catch (IllegalArgumentException e) { + return new HandlerReturn(HandlerReturnResult.ERROR, ""); + } + if (table == null) { + return new HandlerReturn(HandlerReturnResult.SUCCESS, + comAndParams[bIndex] + "not exists\n"); + } else { + return new HandlerReturn(HandlerReturnResult.SUCCESS, "using " + + comAndParams[bIndex] + "\n"); + } + } + + public HandlerReturn handleCreate(String[] comAndParams, int bIndex, + int eIndex) { + Table newTable; + try { + newTable = provider.createTable(comAndParams[bIndex]); + } catch (IllegalArgumentException e) { + return new HandlerReturn(HandlerReturnResult.ERROR, + "wrong tablename\n"); + } + if (newTable == null) { + return new HandlerReturn(HandlerReturnResult.SUCCESS, + comAndParams[bIndex] + " exists\n"); + } + return new HandlerReturn(HandlerReturnResult.SUCCESS, "created\n"); + } + + public HandlerReturn handleDrop(String[] comAndParams, int bIndex, + int eIndex) { + + try { + provider.removeTable(comAndParams[bIndex]); + } catch (IllegalStateException e) { + return new HandlerReturn(HandlerReturnResult.SUCCESS, + comAndParams[bIndex] + " not exists\n"); + } catch (IllegalArgumentException e) { + return new HandlerReturn(HandlerReturnResult.ERROR, + "wrong tablename\n"); + } + + return new HandlerReturn(HandlerReturnResult.SUCCESS, "dropped\n"); + } + + public HandlerReturn handleShowTables(String[] comAndParams, int bIndex, + int eIndex) { + if (!comAndParams[bIndex].toLowerCase().equals("tables")) { + return new HandlerReturn(HandlerReturnResult.NO_SUCH_COMMAND, + "show " + comAndParams[bIndex] + "\n"); + } + String res = ""; + List tnames = provider.showTables(); + String tableName = table == null ? "" : table.getName(); + for (String curName : tnames) { + if (tableName.equals(curName)) { + res += curName + " " + table.size() + "\n"; + } else { + res += curName + " " + provider.getTable(curName).size() + "\n"; + } + } + return new HandlerReturn(HandlerReturnResult.SUCCESS, res); + } + + public HandlerReturn handleExit() { + if (table == null) { + return new HandlerReturn(HandlerReturnResult.EXIT, "good bye\n"); + } + if (table.getUnsavedChanges() > 0) { + return new HandlerReturn(HandlerReturnResult.ERROR, + "there're unsaved changes\n"); + } + return new HandlerReturn(HandlerReturnResult.EXIT, "good bye\n"); + } + + public void emeregencyExit() { + try { + if (table != null) { + table.exit(); + } + } catch (IOException e) { + e.printStackTrace(); + } finally { + provider.emeregencyExit(); + } + + } + +} diff --git a/src/ru/fizteh/fivt/students/dmitry_morozov/junit/interpreter/HandlerReturn.java b/src/ru/fizteh/fivt/students/dmitry_morozov/junit/interpreter/HandlerReturn.java new file mode 100644 index 000000000..bfe7321a8 --- /dev/null +++ b/src/ru/fizteh/fivt/students/dmitry_morozov/junit/interpreter/HandlerReturn.java @@ -0,0 +1,18 @@ +package ru.fizteh.fivt.students.dmitry_morozov.junit.interpreter; + + +public class HandlerReturn { + HandlerReturnResult ret; + String res; + public HandlerReturn(HandlerReturnResult rret, String rres) { + ret = rret; + res = rres; + } + public String getMessage() { + return res; + } + + public HandlerReturnResult getVal() { + return ret; + } +} diff --git a/src/ru/fizteh/fivt/students/dmitry_morozov/junit/interpreter/HandlerReturnResult.java b/src/ru/fizteh/fivt/students/dmitry_morozov/junit/interpreter/HandlerReturnResult.java new file mode 100644 index 000000000..b5dc930de --- /dev/null +++ b/src/ru/fizteh/fivt/students/dmitry_morozov/junit/interpreter/HandlerReturnResult.java @@ -0,0 +1,5 @@ +package ru.fizteh.fivt.students.dmitry_morozov.junit.interpreter; + +public enum HandlerReturnResult { + EXIT, SUCCESS, NO_SUCH_COMMAND, NOT_ENOUGH_PARAMETRES, TABLE_NOT_CHOSEN, ERROR +} diff --git a/src/ru/fizteh/fivt/students/dmitry_morozov/junit/tests/DBCollectionTest.java b/src/ru/fizteh/fivt/students/dmitry_morozov/junit/tests/DBCollectionTest.java new file mode 100644 index 000000000..845d56a41 --- /dev/null +++ b/src/ru/fizteh/fivt/students/dmitry_morozov/junit/tests/DBCollectionTest.java @@ -0,0 +1,93 @@ +package ru.fizteh.fivt.students.dmitry_morozov.junit.tests; + +import java.io.File; +import java.io.IOException; + +import org.junit.Assert; +import org.junit.Before; +import org.junit.Rule; +import org.junit.Test; +import org.junit.rules.TemporaryFolder; + +import ru.fizteh.fivt.storage.strings.TableProvider; +import ru.fizteh.fivt.storage.strings.TableProviderFactory; +import ru.fizteh.fivt.students.dmitry_morozov.junit.MyTableProviderFactory; + +public class DBCollectionTest { + private TableProvider provider; + private String dirPath; + + @Rule + public TemporaryFolder tmpFolder = new TemporaryFolder(); + + @Before + public void before() throws IOException { + TableProviderFactory factory = new MyTableProviderFactory(); + dirPath = tmpFolder.newFolder().getAbsolutePath(); + provider = factory.create(dirPath); + } + + @Test + public void createTable() { + provider.createTable("table"); + } + + @Test + public void createTableTwice() { + provider.createTable("table"); + Assert.assertNull(provider.createTable("table")); + } + + @Test(expected = IllegalArgumentException.class) + public void createTableNull() { + provider.createTable(null); + } + + @Test(expected = IllegalArgumentException.class) + public void createWrong() throws IOException { + File file = new File(dirPath + "/qqqqqqqqq.smt"); + file.createNewFile(); + provider.createTable(file.getName()); + } + + @Test + public void getTable() { + provider.createTable("table"); + Assert.assertNotNull(provider.getTable("table")); + } + + @Test + public void getUnexistingTable() { + Assert.assertNull(provider.getTable("table")); + } + + @Test(expected = IllegalArgumentException.class) + public void getTableNull() { + Assert.assertNull(provider.getTable(null)); + } + + @Test + public void getTableWrong() throws IOException { + File file = new File(dirPath + "/qqqqqqqqq.smt"); + file.createNewFile(); + Assert.assertNull(provider.getTable(file.getName())); + } + + @Test + public void removeTable() { + provider.createTable("table"); + provider.removeTable("table"); + File removed = new File(dirPath + "/table"); + Assert.assertFalse(removed.exists()); + } + + @Test(expected = IllegalStateException.class) + public void removeUnexistingTable() { + provider.removeTable("table"); + } + + @Test(expected = IllegalArgumentException.class) + public void removeNull() { + provider.removeTable(null); + } +} diff --git a/src/ru/fizteh/fivt/students/dmitry_morozov/junit/tests/MyTableProviderFactoryTest.java b/src/ru/fizteh/fivt/students/dmitry_morozov/junit/tests/MyTableProviderFactoryTest.java new file mode 100644 index 000000000..cb9d9e3a7 --- /dev/null +++ b/src/ru/fizteh/fivt/students/dmitry_morozov/junit/tests/MyTableProviderFactoryTest.java @@ -0,0 +1,39 @@ +package ru.fizteh.fivt.students.dmitry_morozov.junit.tests; + +import java.io.IOException; + +import org.junit.Before; +import org.junit.Rule; +import org.junit.Test; +import org.junit.rules.TemporaryFolder; + +import ru.fizteh.fivt.storage.strings.TableProviderFactory; +import ru.fizteh.fivt.students.dmitry_morozov.junit.MyTableProviderFactory; + +public class MyTableProviderFactoryTest { + private TableProviderFactory factory; + + @Rule + public TemporaryFolder tmpFolder = new TemporaryFolder(); + + @Before + public void before() { + factory = new MyTableProviderFactory(); + } + + @Test + public void create() throws IOException { + factory.create(tmpFolder.newFolder().getAbsolutePath()); + } + + @Test (expected = IllegalArgumentException.class) + public void createNull() { + factory.create(null); + } + + @Test (expected = IllegalArgumentException.class) + public void createWrong() throws IOException { + factory.create(tmpFolder.newFile().getAbsolutePath()); + } + +} diff --git a/src/ru/fizteh/fivt/students/dmitry_morozov/junit/tests/ReversableMFHPTest.java b/src/ru/fizteh/fivt/students/dmitry_morozov/junit/tests/ReversableMFHPTest.java new file mode 100644 index 000000000..f7b0e3222 --- /dev/null +++ b/src/ru/fizteh/fivt/students/dmitry_morozov/junit/tests/ReversableMFHPTest.java @@ -0,0 +1,133 @@ +package ru.fizteh.fivt.students.dmitry_morozov.junit.tests; + +import java.util.List; +import java.util.TreeSet; +import java.io.IOException; + +import org.junit.Assert; +import org.junit.Before; +import org.junit.Rule; +import org.junit.Test; +import org.junit.rules.TemporaryFolder; + +import ru.fizteh.fivt.storage.strings.Table; +import ru.fizteh.fivt.storage.strings.TableProvider; +import ru.fizteh.fivt.storage.strings.TableProviderFactory; +import ru.fizteh.fivt.students.dmitry_morozov.junit.*; + +public class ReversableMFHPTest { + private Table table; + + @Rule + public TemporaryFolder tmpFolder = new TemporaryFolder(); + + @Before + public void before() throws IOException { + TableProviderFactory factory = new MyTableProviderFactory(); + TableProvider provider = factory.create(tmpFolder.newFolder().getAbsolutePath()); + table = provider.createTable("table"); + } + + @Test + public void getNameTest() { + Assert.assertEquals("table", table.getName()); + } + + @Test + public void getNothingTest() { + Assert.assertNull(table.get("weather")); + } + + @Test + public void putTest() { + Assert.assertNull(table.put("weather", "sunny")); + Assert.assertEquals("sunny", table.put("weather", "snow")); + } + + @Test + public void getTest() { + table.put("weather", "rain"); + Assert.assertEquals("rain", table.get("weather")); + } + + @Test (expected = IllegalArgumentException.class) + public void getNullTest() { + table.get(null); + } + + @Test (expected = IllegalArgumentException.class) + public void putKeyNullTest() { + table.put(null, "smth"); + } + + @Test (expected = IllegalArgumentException.class) + public void putValueNullTest() { + table.put("null", null); + } + + @Test (expected = IllegalArgumentException.class) + public void putBothNullTest() { + table.put(null, null); + } + + @Test + public void removeTest() { + Assert.assertNull(table.remove("nothing")); + table.put("nothing", "something"); + Assert.assertEquals("something", table.remove("nothing")); + } + + @Test(expected = IllegalArgumentException.class) + public void removeNullTest() { + table.remove(null); + } + + @Test + public void rollbackTest() { + table.put("1", "one"); + table.put("2", "two"); + table.remove("3"); + table.remove("1"); + table.put("1", "uno"); + Assert.assertEquals(4, table.rollback()); + } + + @Test + public void commitTest() { + table.put("1", "one"); + table.put("2", "two"); + table.remove("3"); + table.remove("1"); + table.put("1", "uno"); + Assert.assertEquals(4, table.commit()); + } + + @Test + public void sizeTest() { + Assert.assertEquals(0, table.size()); + table.put("1", "one"); + Assert.assertEquals(1, table.size()); + table.remove("1"); + Assert.assertEquals(0, table.size()); + } + + @Test + public void listTest() { + table.put("1", "one"); + table.put("1", "one"); + table.put("1", "one"); + table.put("3", "one"); + table.put("4", "one"); + table.put("5", "one"); + table.remove("1"); + List list = table.list(); + TreeSet keySet = new TreeSet(); + keySet.addAll(list); + Assert.assertEquals(3, keySet.size()); + Assert.assertTrue(keySet.contains("3")); + Assert.assertTrue(keySet.contains("4")); + Assert.assertTrue(keySet.contains("5")); + Assert.assertFalse(keySet.contains("1")); + + } +} From 0dc5159638b71829c6e8f008de89c6c98e284f43 Mon Sep 17 00:00:00 2001 From: annoing-morda Date: Mon, 15 Dec 2014 20:17:41 +0300 Subject: [PATCH 02/10] Checkstyle 1 --- .../dmitry_morozov/junit/DBCollection.java | 22 +++++++++---------- .../junit/MultiFileHashMap.java | 17 +++++++------- .../junit/MyTableProviderFactory.java | 14 +++++------- .../dmitry_morozov/junit/ReversableMFHM.java | 2 +- .../junit/interpreter/DBInterpreter.java | 5 ++--- 5 files changed, 28 insertions(+), 32 deletions(-) diff --git a/src/ru/fizteh/fivt/students/dmitry_morozov/junit/DBCollection.java b/src/ru/fizteh/fivt/students/dmitry_morozov/junit/DBCollection.java index a90bc1e02..905552e35 100644 --- a/src/ru/fizteh/fivt/students/dmitry_morozov/junit/DBCollection.java +++ b/src/ru/fizteh/fivt/students/dmitry_morozov/junit/DBCollection.java @@ -10,8 +10,8 @@ public class DBCollection implements TableProvider { private String dirPath; private FileMap maps; - - public DBCollection(String dirPath) throws Exception { + + public DBCollection(String dirPath) throws IllegalArgumentException { this.dirPath = dirPath; maps = null; if (dirPath == null) { @@ -25,14 +25,14 @@ public DBCollection(String dirPath) throws Exception { dirPath = tmp; } try { - maps = new FileMap(dirPath + "/tables_info.dat"); - } catch (Exception e) { - throw new IllegalArgumentException(); + maps = new FileMap(dirPath + "/tables_info.dat"); + } catch (BadDBFileException | IOException e) { + throw new IllegalArgumentException(e.getMessage()); } } public List showTables() { // Actually doesn't - // throw anything. + // throw anything. return maps.list(); } @@ -45,8 +45,8 @@ public Table getTable(String name) throws IllegalArgumentException { Table res; try { res = new ReversableMFHM(name); - } catch (Exception e) { - throw new IllegalArgumentException(); + } catch (BadDBFileException e) { + throw new IllegalArgumentException(e.getMessage()); } return res; } @@ -59,13 +59,13 @@ public Table createTable(String name) { } maps.put(name, dirPath + "/" + name); File dir = new File(dirPath + "/" + name); - if(!dir.mkdirs()) { + if (!dir.mkdirs()) { throw new IllegalArgumentException(); } ReversableMFHM res; try { res = new ReversableMFHM(dirPath + "/" + name); - } catch (Exception e) { + } catch (BadDBFileException e) { maps.remove(name); throw new IllegalStateException(); } @@ -85,7 +85,7 @@ public void removeTable(String name) { throw new IllegalStateException(); } } - + public void emeregencyExit() { try { maps.exit(); diff --git a/src/ru/fizteh/fivt/students/dmitry_morozov/junit/MultiFileHashMap.java b/src/ru/fizteh/fivt/students/dmitry_morozov/junit/MultiFileHashMap.java index f8742cf7d..7dcea0be0 100644 --- a/src/ru/fizteh/fivt/students/dmitry_morozov/junit/MultiFileHashMap.java +++ b/src/ru/fizteh/fivt/students/dmitry_morozov/junit/MultiFileHashMap.java @@ -48,7 +48,7 @@ public String put(String key, String value) throws IllegalArgumentException { String curPath = getPath(mapNum); try { maps[mapNum] = new FileMap(curPath); - } catch (Exception e) { + } catch (IOException | BadDBFileException e) { e.printStackTrace(); System.err.println("Couldn't access" + curPath); } @@ -68,7 +68,7 @@ public String get(String key) throws IllegalArgumentException { String curPath = getPath(mapNum); try { maps[mapNum] = new FileMap(curPath); - } catch (Exception e) { + } catch (IOException | BadDBFileException e) { e.printStackTrace(); System.err.println("Couldn't access" + curPath); } @@ -88,7 +88,7 @@ public String remove(String key) throws IllegalArgumentException { String curPath = getPath(mapNum); try { maps[mapNum] = new FileMap(curPath); - } catch (Exception e) { + } catch (IOException | BadDBFileException e) { System.err.println("Couldn't access" + curPath); e.printStackTrace(); } @@ -108,7 +108,7 @@ public List list() { String curPath = getPath(i); try { maps[i] = new FileMap(curPath); - } catch (Exception e) { + } catch (IOException | BadDBFileException e) { System.err.println("Couldn't access" + curPath); e.printStackTrace(); } @@ -184,13 +184,14 @@ public int size() { if (openedMaps.get(i)) { res += maps[i].size(); } else { + String curPath = getPath(i); try { - maps[i] = new FileMap(getPath(i)); // If couldn't access - // subdatabase,there are - // no records. + maps[i] = new FileMap(curPath); res += maps[i].size(); openedMaps.set(i); - } catch (Exception e) { + } catch (IOException | BadDBFileException e) { + System.err.println("Couldn't access" + curPath); + e.printStackTrace(); } } } diff --git a/src/ru/fizteh/fivt/students/dmitry_morozov/junit/MyTableProviderFactory.java b/src/ru/fizteh/fivt/students/dmitry_morozov/junit/MyTableProviderFactory.java index 5e1d75987..685094afe 100644 --- a/src/ru/fizteh/fivt/students/dmitry_morozov/junit/MyTableProviderFactory.java +++ b/src/ru/fizteh/fivt/students/dmitry_morozov/junit/MyTableProviderFactory.java @@ -3,20 +3,16 @@ import ru.fizteh.fivt.storage.strings.TableProvider; import ru.fizteh.fivt.storage.strings.TableProviderFactory; -public class MyTableProviderFactory implements TableProviderFactory { +public class MyTableProviderFactory implements TableProviderFactory { - public MyTableProviderFactory() { + public MyTableProviderFactory() { } - + @Override public TableProvider create(String dir) throws IllegalArgumentException { TableProvider res; - try { - res = new DBCollection(dir); - } catch (Exception e) { - throw new IllegalArgumentException(); - } + res = new DBCollection(dir); return res; } - + } diff --git a/src/ru/fizteh/fivt/students/dmitry_morozov/junit/ReversableMFHM.java b/src/ru/fizteh/fivt/students/dmitry_morozov/junit/ReversableMFHM.java index 7ecb615cd..c28cb1991 100644 --- a/src/ru/fizteh/fivt/students/dmitry_morozov/junit/ReversableMFHM.java +++ b/src/ru/fizteh/fivt/students/dmitry_morozov/junit/ReversableMFHM.java @@ -5,7 +5,7 @@ public class ReversableMFHM extends MultiFileHashMap { Stack opStack; - public ReversableMFHM(String path) throws Exception { + public ReversableMFHM(String path) throws BadDBFileException { super(path); opStack = new Stack<>(); } diff --git a/src/ru/fizteh/fivt/students/dmitry_morozov/junit/interpreter/DBInterpreter.java b/src/ru/fizteh/fivt/students/dmitry_morozov/junit/interpreter/DBInterpreter.java index 2bfc49b19..c481dbb20 100644 --- a/src/ru/fizteh/fivt/students/dmitry_morozov/junit/interpreter/DBInterpreter.java +++ b/src/ru/fizteh/fivt/students/dmitry_morozov/junit/interpreter/DBInterpreter.java @@ -98,10 +98,9 @@ public HandlerReturn handle(String[] comAndParams, int bIndex, int eIndex) { return handleExit(); case "show": return handleShowTables(comAndParams, bIndex + 1, eIndex); + default: + return new HandlerReturn(HandlerReturnResult.NO_SUCH_COMMAND, ""); } - - return new HandlerReturn(HandlerReturnResult.EXIT, ""); - } public HandlerReturn handlePut(String[] comAndParams, int bIndex, int eIndex) { From 7d718aa8101442da0928ec9d29dc3f7f50cd201c Mon Sep 17 00:00:00 2001 From: annoing-morda Date: Mon, 15 Dec 2014 20:37:23 +0300 Subject: [PATCH 03/10] Checkstyle 2 --- .../dmitry_morozov/junit/ChangingCommand.java | 20 +++++++------- .../dmitry_morozov/junit/FileMap.java | 27 ++++++++++--------- .../students/dmitry_morozov/junit/Main.java | 7 ++++- .../junit/MultiFileHashMap.java | 4 +-- .../dmitry_morozov/junit/ReversableMFHM.java | 2 +- 5 files changed, 33 insertions(+), 27 deletions(-) diff --git a/src/ru/fizteh/fivt/students/dmitry_morozov/junit/ChangingCommand.java b/src/ru/fizteh/fivt/students/dmitry_morozov/junit/ChangingCommand.java index 3382d57ed..e8e0fb14f 100644 --- a/src/ru/fizteh/fivt/students/dmitry_morozov/junit/ChangingCommand.java +++ b/src/ru/fizteh/fivt/students/dmitry_morozov/junit/ChangingCommand.java @@ -1,22 +1,22 @@ package ru.fizteh.fivt.students.dmitry_morozov.junit; -enum CommandName{ - PUT, - REMOVE +enum CommandName { + PUT, REMOVE }; public class ChangingCommand { - public CommandName _c; - public String [] args; + public CommandName cName; + public String[] args; + public ChangingCommand(CommandName c, String arg1, String arg2) { - _c = c; - if (_c == CommandName.PUT) { - args = new String [2]; + cName = c; + if (cName == CommandName.PUT) { + args = new String[2]; args[0] = arg1; args[1] = arg2; } - if (_c == CommandName.REMOVE) { - args = new String [1]; + if (cName == CommandName.REMOVE) { + args = new String[1]; args[0] = arg1; } } diff --git a/src/ru/fizteh/fivt/students/dmitry_morozov/junit/FileMap.java b/src/ru/fizteh/fivt/students/dmitry_morozov/junit/FileMap.java index 7a8b7038e..299385ad3 100644 --- a/src/ru/fizteh/fivt/students/dmitry_morozov/junit/FileMap.java +++ b/src/ru/fizteh/fivt/students/dmitry_morozov/junit/FileMap.java @@ -38,17 +38,15 @@ public FileMap(String path) throws BadDBFileException, IOException { } DataInputStream in = new DataInputStream(new FileInputStream(dbFile)); - - while (true) { String key = readString(in); - if(key == null) + if (key == null) break; - String value = readString(in); + String value = readString(in); if (value == null) { in.close(); throw new BadDBFileException("Couldn't set rw options"); - } + } table.put(key, value); } in.close(); @@ -57,12 +55,13 @@ public FileMap(String path) throws BadDBFileException, IOException { /** * @return String read from file. If meets end of file, returns null. - * @throws BadDBFileException - * @throws IOException + * @throws BadDBFileException + * @throws IOException * */ - private String readString(DataInputStream in) throws IOException, BadDBFileException { - final int sizeOfInt= 4; + private String readString(DataInputStream in) throws IOException, + BadDBFileException { + final int sizeOfInt = 4; int len; String res = ""; if (in.available() >= sizeOfInt) { @@ -77,9 +76,10 @@ private String readString(DataInputStream in) throws IOException, BadDBFileExcep res += curChar; len--; } - } else + } else { return null; - return res; + } + return res; } public String put(String key, String value) throws IllegalArgumentException { @@ -164,8 +164,9 @@ public void exit() throws IOException { out.flush(); out.close(); } - - private void writeData(DataOutputStream out, String toWrite) throws IOException { + + private void writeData(DataOutputStream out, String toWrite) + throws IOException { int len = toWrite.length(); out.writeInt(len * 2); out.writeChars(toWrite); diff --git a/src/ru/fizteh/fivt/students/dmitry_morozov/junit/Main.java b/src/ru/fizteh/fivt/students/dmitry_morozov/junit/Main.java index a84161e0d..19271fe4f 100644 --- a/src/ru/fizteh/fivt/students/dmitry_morozov/junit/Main.java +++ b/src/ru/fizteh/fivt/students/dmitry_morozov/junit/Main.java @@ -8,7 +8,8 @@ public class Main { - public static HandlerReturn commandSplitting(String command, DBInterpreter inter) { + public static HandlerReturn commandSplitting(String command, + DBInterpreter inter) { String[] firstSplitted = command.split(" "); String[] toGive = new String[firstSplitted.length]; int j = 0; @@ -56,6 +57,8 @@ public static void batchMode(String[] args, DBInterpreter inter) { System.out.print(ret.getMessage()); i = commands.length; break; + default: + break; } } } @@ -109,6 +112,8 @@ public static void main(String[] args) { System.out.print(ret.getMessage()); contFlag = false; break; + default: + break; } } } diff --git a/src/ru/fizteh/fivt/students/dmitry_morozov/junit/MultiFileHashMap.java b/src/ru/fizteh/fivt/students/dmitry_morozov/junit/MultiFileHashMap.java index 7dcea0be0..1aaf7c661 100644 --- a/src/ru/fizteh/fivt/students/dmitry_morozov/junit/MultiFileHashMap.java +++ b/src/ru/fizteh/fivt/students/dmitry_morozov/junit/MultiFileHashMap.java @@ -10,8 +10,8 @@ import ru.fizteh.fivt.storage.strings.Table; public class MultiFileHashMap implements Table { - private final static int FILE_MAPS_CNT = 256; - private final static int DIRS_CNT = 16; + final static int FILE_MAPS_CNT = 256; + final static int DIRS_CNT = 16; private File rootDir; private BitSet openedMaps; private FileMap[] maps; diff --git a/src/ru/fizteh/fivt/students/dmitry_morozov/junit/ReversableMFHM.java b/src/ru/fizteh/fivt/students/dmitry_morozov/junit/ReversableMFHM.java index c28cb1991..c64fbe5de 100644 --- a/src/ru/fizteh/fivt/students/dmitry_morozov/junit/ReversableMFHM.java +++ b/src/ru/fizteh/fivt/students/dmitry_morozov/junit/ReversableMFHM.java @@ -32,7 +32,7 @@ public int rollback() { int cnt = opStack.size(); while (!opStack.isEmpty()) { ChangingCommand t = opStack.pop(); - if (t._c == CommandName.PUT) { + if (t.cName == CommandName.PUT) { super.put(t.args[0], t.args[1]); } else { super.remove(t.args[0]); From 49244737965cc0e54c4611e16dc4e7a8183b2cff Mon Sep 17 00:00:00 2001 From: annoing-morda Date: Mon, 15 Dec 2014 20:54:47 +0300 Subject: [PATCH 04/10] Checkstyle 3 --- src/ru/fizteh/fivt/students/dmitry_morozov/junit/FileMap.java | 3 ++- .../fivt/students/dmitry_morozov/junit/MultiFileHashMap.java | 4 ++-- 2 files changed, 4 insertions(+), 3 deletions(-) diff --git a/src/ru/fizteh/fivt/students/dmitry_morozov/junit/FileMap.java b/src/ru/fizteh/fivt/students/dmitry_morozov/junit/FileMap.java index 299385ad3..adb16e92e 100644 --- a/src/ru/fizteh/fivt/students/dmitry_morozov/junit/FileMap.java +++ b/src/ru/fizteh/fivt/students/dmitry_morozov/junit/FileMap.java @@ -40,8 +40,9 @@ public FileMap(String path) throws BadDBFileException, IOException { while (true) { String key = readString(in); - if (key == null) + if (key == null) { break; + } String value = readString(in); if (value == null) { in.close(); diff --git a/src/ru/fizteh/fivt/students/dmitry_morozov/junit/MultiFileHashMap.java b/src/ru/fizteh/fivt/students/dmitry_morozov/junit/MultiFileHashMap.java index 1aaf7c661..d04b9b8d8 100644 --- a/src/ru/fizteh/fivt/students/dmitry_morozov/junit/MultiFileHashMap.java +++ b/src/ru/fizteh/fivt/students/dmitry_morozov/junit/MultiFileHashMap.java @@ -10,8 +10,8 @@ import ru.fizteh.fivt.storage.strings.Table; public class MultiFileHashMap implements Table { - final static int FILE_MAPS_CNT = 256; - final static int DIRS_CNT = 16; + final int FILE_MAPS_CNT = 256; + final int DIRS_CNT = 16; private File rootDir; private BitSet openedMaps; private FileMap[] maps; From db466ce1e3ccdb86de15b205794cbf806b7ad858 Mon Sep 17 00:00:00 2001 From: annoing-morda Date: Mon, 15 Dec 2014 21:11:21 +0300 Subject: [PATCH 05/10] Checkstyle 3 --- .../fivt/students/dmitry_morozov/junit/MultiFileHashMap.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/ru/fizteh/fivt/students/dmitry_morozov/junit/MultiFileHashMap.java b/src/ru/fizteh/fivt/students/dmitry_morozov/junit/MultiFileHashMap.java index d04b9b8d8..ff672ec51 100644 --- a/src/ru/fizteh/fivt/students/dmitry_morozov/junit/MultiFileHashMap.java +++ b/src/ru/fizteh/fivt/students/dmitry_morozov/junit/MultiFileHashMap.java @@ -10,8 +10,8 @@ import ru.fizteh.fivt.storage.strings.Table; public class MultiFileHashMap implements Table { - final int FILE_MAPS_CNT = 256; - final int DIRS_CNT = 16; + private static final int FILE_MAPS_CNT = 256; + private static final int DIRS_CNT = 16; private File rootDir; private BitSet openedMaps; private FileMap[] maps; From c490fcd059431bb028ba147dcd05338c59ff62e9 Mon Sep 17 00:00:00 2001 From: annoing-morda Date: Sun, 21 Dec 2014 07:37:12 +0300 Subject: [PATCH 06/10] Fixed --- .../dmitry_morozov/junit/DBCollection.java | 8 +- .../dmitry_morozov/junit/FileMap.java | 2 +- .../students/dmitry_morozov/junit/Main.java | 13 +- .../dmitry_morozov/junit/MyTable.java | 53 +++++++ .../junit/interpreter/DBInterpreter.java | 79 ++++++----- .../junit/interpreter/HandlerReturn.java | 10 +- .../junit/tests/DBCollectionTest.java | 2 +- .../junit/tests/MyTableTest.java | 133 ++++++++++++++++++ 8 files changed, 247 insertions(+), 53 deletions(-) create mode 100644 src/ru/fizteh/fivt/students/dmitry_morozov/junit/MyTable.java create mode 100644 src/ru/fizteh/fivt/students/dmitry_morozov/junit/tests/MyTableTest.java diff --git a/src/ru/fizteh/fivt/students/dmitry_morozov/junit/DBCollection.java b/src/ru/fizteh/fivt/students/dmitry_morozov/junit/DBCollection.java index 905552e35..0caac6bc8 100644 --- a/src/ru/fizteh/fivt/students/dmitry_morozov/junit/DBCollection.java +++ b/src/ru/fizteh/fivt/students/dmitry_morozov/junit/DBCollection.java @@ -44,7 +44,7 @@ public Table getTable(String name) throws IllegalArgumentException { } Table res; try { - res = new ReversableMFHM(name); + res = new MyTable(name); } catch (BadDBFileException e) { throw new IllegalArgumentException(e.getMessage()); } @@ -62,9 +62,9 @@ public Table createTable(String name) { if (!dir.mkdirs()) { throw new IllegalArgumentException(); } - ReversableMFHM res; + MyTable res; try { - res = new ReversableMFHM(dirPath + "/" + name); + res = new MyTable(dirPath + "/" + name); } catch (BadDBFileException e) { maps.remove(name); throw new IllegalStateException(); @@ -86,7 +86,7 @@ public void removeTable(String name) { } } - public void emeregencyExit() { + public void exit() { try { maps.exit(); } catch (IOException e) { diff --git a/src/ru/fizteh/fivt/students/dmitry_morozov/junit/FileMap.java b/src/ru/fizteh/fivt/students/dmitry_morozov/junit/FileMap.java index adb16e92e..b8a5321e3 100644 --- a/src/ru/fizteh/fivt/students/dmitry_morozov/junit/FileMap.java +++ b/src/ru/fizteh/fivt/students/dmitry_morozov/junit/FileMap.java @@ -26,7 +26,7 @@ public FileMap(String path) throws BadDBFileException, IOException { dbFile = new File(path); if (!dbFile.exists()) { if (!dbFile.createNewFile()) { - throw new BadDBFileException("Couldldn't create db file"); + throw new BadDBFileException("Couldn't create db file"); } } else { if (!dbFile.isFile()) { diff --git a/src/ru/fizteh/fivt/students/dmitry_morozov/junit/Main.java b/src/ru/fizteh/fivt/students/dmitry_morozov/junit/Main.java index 19271fe4f..f417c12fd 100644 --- a/src/ru/fizteh/fivt/students/dmitry_morozov/junit/Main.java +++ b/src/ru/fizteh/fivt/students/dmitry_morozov/junit/Main.java @@ -65,7 +65,7 @@ public static void batchMode(String[] args, DBInterpreter inter) { } catch (Exception e) { System.err.println(e.getMessage()); - inter.emeregencyExit(); + inter.emergencyExit(); System.exit(1); } inter.handleExit(); @@ -73,7 +73,12 @@ public static void batchMode(String[] args, DBInterpreter inter) { } public static void main(String[] args) { - DBInterpreter inter = new DBInterpreter(System.getProperty("db.file")); + DBInterpreter inter; + try { + inter = new DBInterpreter(System.getProperty("fizteh.db.dir")); + } catch (IllegalArgumentException e1) { + return; + } if (args.length > 0) { batchMode(args, inter); } @@ -106,7 +111,7 @@ public static void main(String[] args) { + ret.getMessage()); break; case TABLE_NOT_CHOSEN: - System.out.println("Table not chosen"); + System.out.println("no table"); break; case EXIT: System.out.print(ret.getMessage()); @@ -120,7 +125,7 @@ public static void main(String[] args) { } } catch (Exception e) { e.printStackTrace(); - inter.emeregencyExit(); + inter.emergencyExit(); } finally { in.close(); } diff --git a/src/ru/fizteh/fivt/students/dmitry_morozov/junit/MyTable.java b/src/ru/fizteh/fivt/students/dmitry_morozov/junit/MyTable.java new file mode 100644 index 000000000..7c4147d14 --- /dev/null +++ b/src/ru/fizteh/fivt/students/dmitry_morozov/junit/MyTable.java @@ -0,0 +1,53 @@ +package ru.fizteh.fivt.students.dmitry_morozov.junit; + +import java.util.Stack; + +public class MyTable extends MultiFileHashMap { + Stack opStack; + + public MyTable(String path) throws BadDBFileException { + super(path); + opStack = new Stack<>(); + } + + public String put(String key, String value) throws IllegalArgumentException { + String result = super.put(key, value); + if (result == null) { // If PUT has just pushed new value + opStack.push(new ChangingCommand(CommandName.REMOVE, key, "")); + } else { // If PUT has overwritten old value + opStack.push(new ChangingCommand(CommandName.PUT, key, result)); + } + return result; + } + + public String remove(String key) throws IllegalArgumentException { + String result = super.remove(key); + if (result != null) { // Key found. + opStack.push(new ChangingCommand(CommandName.PUT, key, result)); + } + return result; + } + + public int rollback() { + int cnt = opStack.size(); + while (!opStack.isEmpty()) { + ChangingCommand t = opStack.pop(); + if (t.cName == CommandName.PUT) { + super.put(t.args[0], t.args[1]); + } else { + super.remove(t.args[0]); + } + } + return cnt; + } + + public int commit() { + int cnt = opStack.size(); + opStack.clear(); + return cnt; + } + + public int getUnsavedChanges() { + return opStack.size(); + } +} diff --git a/src/ru/fizteh/fivt/students/dmitry_morozov/junit/interpreter/DBInterpreter.java b/src/ru/fizteh/fivt/students/dmitry_morozov/junit/interpreter/DBInterpreter.java index c481dbb20..03356f501 100644 --- a/src/ru/fizteh/fivt/students/dmitry_morozov/junit/interpreter/DBInterpreter.java +++ b/src/ru/fizteh/fivt/students/dmitry_morozov/junit/interpreter/DBInterpreter.java @@ -2,18 +2,18 @@ import java.io.IOException; import java.util.HashMap; -import java.util.TreeSet; import java.util.List; +import java.util.TreeSet; import ru.fizteh.fivt.storage.strings.Table; import ru.fizteh.fivt.storage.strings.TableProviderFactory; import ru.fizteh.fivt.students.dmitry_morozov.junit.DBCollection; +import ru.fizteh.fivt.students.dmitry_morozov.junit.MyTable; import ru.fizteh.fivt.students.dmitry_morozov.junit.MyTableProviderFactory; -import ru.fizteh.fivt.students.dmitry_morozov.junit.ReversableMFHM; public class DBInterpreter { private DBCollection provider; - private ReversableMFHM table; + private MyTable table; private HashMap argsCount; private TreeSet commandsForTable; @@ -22,7 +22,7 @@ public DBInterpreter(String path) { try { provider = (DBCollection) factory.create(path); if (provider == null) { - System.out.println("Usage: java -Ddb.file="); + System.out.println("Usage: java -Dfizteh.db.dir="); return; } } catch (IllegalArgumentException e) { @@ -62,7 +62,8 @@ public HandlerReturn handle(String[] comAndParams, int bIndex, int eIndex) { String command = comAndParams[bIndex].toLowerCase(); Integer expectedArgsCount = argsCount.get(command); if (expectedArgsCount == null) { - return new HandlerReturn(HandlerReturnResult.NO_SUCH_COMMAND, ""); + return new HandlerReturn(HandlerReturnResult.NO_SUCH_COMMAND, + command + "\n"); } else { if (expectedArgsCount > eIndex - bIndex - 1) { return new HandlerReturn( @@ -99,7 +100,8 @@ public HandlerReturn handle(String[] comAndParams, int bIndex, int eIndex) { case "show": return handleShowTables(comAndParams, bIndex + 1, eIndex); default: - return new HandlerReturn(HandlerReturnResult.NO_SUCH_COMMAND, ""); + return new HandlerReturn(HandlerReturnResult.NO_SUCH_COMMAND, + command + "\n"); } } @@ -136,8 +138,9 @@ public HandlerReturn handleGet(String[] comAndParams, int bIndex, int eIndex) { public HandlerReturn handleRemove(String[] comAndParams, int bIndex, int eIndex) { String res; + String key = comAndParams[bIndex]; try { - res = table.get(comAndParams[bIndex]); + res = table.get(key); } catch (IllegalArgumentException e) { return new HandlerReturn(HandlerReturnResult.ERROR, ""); } @@ -145,13 +148,19 @@ public HandlerReturn handleRemove(String[] comAndParams, int bIndex, res = "not found\n"; } else { res = "removed\n"; + table.remove(key); } return new HandlerReturn(HandlerReturnResult.SUCCESS, res); } public HandlerReturn handleList() { String res; - res = String.join(", ", table.list()); + List list = table.list(); + if (list.size() == 0) { + return new HandlerReturn(HandlerReturnResult.SUCCESS, ""); + } + res = String.join(", ", list); + res += (res == "") ? "" : "\n"; return new HandlerReturn(HandlerReturnResult.SUCCESS, res); } @@ -173,21 +182,23 @@ public HandlerReturn handleCommit(String[] comAndParams, int bIndex, } public HandlerReturn handleUse(String[] comAndParams, int bIndex, int eIndex) { + MyTable newTable; + try { + newTable = (MyTable) provider.getTable(comAndParams[bIndex]); + } catch (IllegalArgumentException e1) { + return new HandlerReturn(HandlerReturnResult.ERROR, ""); + } + if (newTable == null) { + return new HandlerReturn(HandlerReturnResult.SUCCESS, + comAndParams[bIndex] + " not exists\n"); + } + // If table isn't chosen. if (table == null) { - try { - table = (ReversableMFHM) provider - .getTable(comAndParams[bIndex]); - } catch (IllegalArgumentException e) { - return new HandlerReturn(HandlerReturnResult.ERROR, ""); - } - if (table == null) { - return new HandlerReturn(HandlerReturnResult.SUCCESS, - comAndParams[bIndex] + "not exists\n"); - } else { - return new HandlerReturn(HandlerReturnResult.SUCCESS, "using " - + comAndParams[bIndex] + "\n"); - } + table = newTable; + return new HandlerReturn(HandlerReturnResult.SUCCESS, "using " + + comAndParams[bIndex] + "\n"); } + // If table is already chosen. int unsaved = table.getUnsavedChanges(); if (unsaved > 0) { return new HandlerReturn(HandlerReturnResult.SUCCESS, unsaved @@ -198,18 +209,9 @@ public HandlerReturn handleUse(String[] comAndParams, int bIndex, int eIndex) { } catch (IOException e) { System.err.println("Couldn't save" + table.getName() + "on disk"); } - try { - table = (ReversableMFHM) provider.getTable(comAndParams[bIndex]); - } catch (IllegalArgumentException e) { - return new HandlerReturn(HandlerReturnResult.ERROR, ""); - } - if (table == null) { - return new HandlerReturn(HandlerReturnResult.SUCCESS, - comAndParams[bIndex] + "not exists\n"); - } else { - return new HandlerReturn(HandlerReturnResult.SUCCESS, "using " - + comAndParams[bIndex] + "\n"); - } + table = newTable; + return new HandlerReturn(HandlerReturnResult.SUCCESS, "using " + + comAndParams[bIndex] + "\n"); } public HandlerReturn handleCreate(String[] comAndParams, int bIndex, @@ -251,9 +253,9 @@ public HandlerReturn handleShowTables(String[] comAndParams, int bIndex, "show " + comAndParams[bIndex] + "\n"); } String res = ""; - List tnames = provider.showTables(); + List tableNames = provider.showTables(); String tableName = table == null ? "" : table.getName(); - for (String curName : tnames) { + for (String curName : tableNames) { if (tableName.equals(curName)) { res += curName + " " + table.size() + "\n"; } else { @@ -265,16 +267,18 @@ public HandlerReturn handleShowTables(String[] comAndParams, int bIndex, public HandlerReturn handleExit() { if (table == null) { + provider.exit(); return new HandlerReturn(HandlerReturnResult.EXIT, "good bye\n"); } if (table.getUnsavedChanges() > 0) { return new HandlerReturn(HandlerReturnResult.ERROR, "there're unsaved changes\n"); } + provider.exit(); return new HandlerReturn(HandlerReturnResult.EXIT, "good bye\n"); } - public void emeregencyExit() { + public void emergencyExit() { try { if (table != null) { table.exit(); @@ -282,9 +286,8 @@ public void emeregencyExit() { } catch (IOException e) { e.printStackTrace(); } finally { - provider.emeregencyExit(); + provider.exit(); } - } } diff --git a/src/ru/fizteh/fivt/students/dmitry_morozov/junit/interpreter/HandlerReturn.java b/src/ru/fizteh/fivt/students/dmitry_morozov/junit/interpreter/HandlerReturn.java index bfe7321a8..0f15f5e73 100644 --- a/src/ru/fizteh/fivt/students/dmitry_morozov/junit/interpreter/HandlerReturn.java +++ b/src/ru/fizteh/fivt/students/dmitry_morozov/junit/interpreter/HandlerReturn.java @@ -3,13 +3,13 @@ public class HandlerReturn { HandlerReturnResult ret; - String res; - public HandlerReturn(HandlerReturnResult rret, String rres) { - ret = rret; - res = rres; + String message; + public HandlerReturn(HandlerReturnResult _ret, String _message) { + ret = _ret; + message = _message; } public String getMessage() { - return res; + return message; } public HandlerReturnResult getVal() { diff --git a/src/ru/fizteh/fivt/students/dmitry_morozov/junit/tests/DBCollectionTest.java b/src/ru/fizteh/fivt/students/dmitry_morozov/junit/tests/DBCollectionTest.java index 845d56a41..d9fb5aeaf 100644 --- a/src/ru/fizteh/fivt/students/dmitry_morozov/junit/tests/DBCollectionTest.java +++ b/src/ru/fizteh/fivt/students/dmitry_morozov/junit/tests/DBCollectionTest.java @@ -26,7 +26,7 @@ public void before() throws IOException { dirPath = tmpFolder.newFolder().getAbsolutePath(); provider = factory.create(dirPath); } - + @Test public void createTable() { provider.createTable("table"); diff --git a/src/ru/fizteh/fivt/students/dmitry_morozov/junit/tests/MyTableTest.java b/src/ru/fizteh/fivt/students/dmitry_morozov/junit/tests/MyTableTest.java new file mode 100644 index 000000000..d47a4066d --- /dev/null +++ b/src/ru/fizteh/fivt/students/dmitry_morozov/junit/tests/MyTableTest.java @@ -0,0 +1,133 @@ +package ru.fizteh.fivt.students.dmitry_morozov.junit.tests; + +import java.util.List; +import java.util.TreeSet; +import java.io.IOException; + +import org.junit.Assert; +import org.junit.Before; +import org.junit.Rule; +import org.junit.Test; +import org.junit.rules.TemporaryFolder; + +import ru.fizteh.fivt.storage.strings.Table; +import ru.fizteh.fivt.storage.strings.TableProvider; +import ru.fizteh.fivt.storage.strings.TableProviderFactory; +import ru.fizteh.fivt.students.dmitry_morozov.junit.*; + +public class MyTableTest { + private Table table; + + @Rule + public TemporaryFolder tmpFolder = new TemporaryFolder(); + + @Before + public void before() throws IOException { + TableProviderFactory factory = new MyTableProviderFactory(); + TableProvider provider = factory.create(tmpFolder.newFolder().getAbsolutePath()); + table = provider.createTable("table"); + } + + @Test + public void getNameTest() { + Assert.assertEquals("table", table.getName()); + } + + @Test + public void getNothingTest() { + Assert.assertNull(table.get("weather")); + } + + @Test + public void putTest() { + Assert.assertNull(table.put("weather", "sunny")); + Assert.assertEquals("sunny", table.put("weather", "snow")); + } + + @Test + public void getTest() { + table.put("weather", "rain"); + Assert.assertEquals("rain", table.get("weather")); + } + + @Test (expected = IllegalArgumentException.class) + public void getNullTest() { + table.get(null); + } + + @Test (expected = IllegalArgumentException.class) + public void putKeyNullTest() { + table.put(null, "smth"); + } + + @Test (expected = IllegalArgumentException.class) + public void putValueNullTest() { + table.put("null", null); + } + + @Test (expected = IllegalArgumentException.class) + public void putBothNullTest() { + table.put(null, null); + } + + @Test + public void removeTest() { + Assert.assertNull(table.remove("nothing")); + table.put("nothing", "something"); + Assert.assertEquals("something", table.remove("nothing")); + } + + @Test(expected = IllegalArgumentException.class) + public void removeNullTest() { + table.remove(null); + } + + @Test + public void rollbackTest() { + table.put("1", "one"); + table.put("2", "two"); + table.remove("3"); + table.remove("1"); + table.put("1", "uno"); + Assert.assertEquals(4, table.rollback()); + } + + @Test + public void commitTest() { + table.put("1", "one"); + table.put("2", "two"); + table.remove("3"); + table.remove("1"); + table.put("1", "uno"); + Assert.assertEquals(4, table.commit()); + } + + @Test + public void sizeTest() { + Assert.assertEquals(0, table.size()); + table.put("1", "one"); + Assert.assertEquals(1, table.size()); + table.remove("1"); + Assert.assertEquals(0, table.size()); + } + + @Test + public void listTest() { + table.put("1", "one"); + table.put("1", "one"); + table.put("1", "one"); + table.put("3", "one"); + table.put("4", "one"); + table.put("5", "one"); + table.remove("1"); + List list = table.list(); + TreeSet keySet = new TreeSet(); + keySet.addAll(list); + Assert.assertEquals(3, keySet.size()); + Assert.assertTrue(keySet.contains("3")); + Assert.assertTrue(keySet.contains("4")); + Assert.assertTrue(keySet.contains("5")); + Assert.assertFalse(keySet.contains("1")); + + } +} From a2a1546c69e24bcfa021784a51707f50d29ed047 Mon Sep 17 00:00:00 2001 From: annoing-morda Date: Sun, 21 Dec 2014 07:44:41 +0300 Subject: [PATCH 07/10] Fixed 1 and checkstyle --- .../junit/interpreter/DBInterpreter.java | 10 +++------- .../junit/interpreter/HandlerReturn.java | 6 +++--- 2 files changed, 6 insertions(+), 10 deletions(-) diff --git a/src/ru/fizteh/fivt/students/dmitry_morozov/junit/interpreter/DBInterpreter.java b/src/ru/fizteh/fivt/students/dmitry_morozov/junit/interpreter/DBInterpreter.java index 03356f501..80d68f1a3 100644 --- a/src/ru/fizteh/fivt/students/dmitry_morozov/junit/interpreter/DBInterpreter.java +++ b/src/ru/fizteh/fivt/students/dmitry_morozov/junit/interpreter/DBInterpreter.java @@ -154,13 +154,9 @@ public HandlerReturn handleRemove(String[] comAndParams, int bIndex, } public HandlerReturn handleList() { - String res; - List list = table.list(); - if (list.size() == 0) { - return new HandlerReturn(HandlerReturnResult.SUCCESS, ""); - } - res = String.join(", ", list); - res += (res == "") ? "" : "\n"; + String res; + res = String.join(", ", table.list()); + res += (res.equals("")) ? "" : "\n"; return new HandlerReturn(HandlerReturnResult.SUCCESS, res); } diff --git a/src/ru/fizteh/fivt/students/dmitry_morozov/junit/interpreter/HandlerReturn.java b/src/ru/fizteh/fivt/students/dmitry_morozov/junit/interpreter/HandlerReturn.java index 0f15f5e73..9493d7bce 100644 --- a/src/ru/fizteh/fivt/students/dmitry_morozov/junit/interpreter/HandlerReturn.java +++ b/src/ru/fizteh/fivt/students/dmitry_morozov/junit/interpreter/HandlerReturn.java @@ -4,9 +4,9 @@ public class HandlerReturn { HandlerReturnResult ret; String message; - public HandlerReturn(HandlerReturnResult _ret, String _message) { - ret = _ret; - message = _message; + public HandlerReturn(HandlerReturnResult argRet, String argMessage) { + ret = argRet; + message = argMessage; } public String getMessage() { return message; From 7fc4f4a44278822e5e383457d440b0bec6d832b2 Mon Sep 17 00:00:00 2001 From: annoing-morda Date: Tue, 23 Dec 2014 22:29:11 +0300 Subject: [PATCH 08/10] Fixed1 --- .../junit/interpreter/DBInterpreter.java | 18 +++++++++++++++--- 1 file changed, 15 insertions(+), 3 deletions(-) diff --git a/src/ru/fizteh/fivt/students/dmitry_morozov/junit/interpreter/DBInterpreter.java b/src/ru/fizteh/fivt/students/dmitry_morozov/junit/interpreter/DBInterpreter.java index 80d68f1a3..2f12760b7 100644 --- a/src/ru/fizteh/fivt/students/dmitry_morozov/junit/interpreter/DBInterpreter.java +++ b/src/ru/fizteh/fivt/students/dmitry_morozov/junit/interpreter/DBInterpreter.java @@ -255,7 +255,13 @@ public HandlerReturn handleShowTables(String[] comAndParams, int bIndex, if (tableName.equals(curName)) { res += curName + " " + table.size() + "\n"; } else { - res += curName + " " + provider.getTable(curName).size() + "\n"; + MyTable curTable = (MyTable) provider.getTable(curName); + res += curName + " " + curTable.size() + "\n"; + try { + curTable.exit(); + } catch (IOException e) { + System.err.println("Interrupted access to database: " + curName); + } } } return new HandlerReturn(HandlerReturnResult.SUCCESS, res); @@ -264,14 +270,20 @@ public HandlerReturn handleShowTables(String[] comAndParams, int bIndex, public HandlerReturn handleExit() { if (table == null) { provider.exit(); - return new HandlerReturn(HandlerReturnResult.EXIT, "good bye\n"); + return new HandlerReturn(HandlerReturnResult.EXIT, "goodbye\n"); } if (table.getUnsavedChanges() > 0) { return new HandlerReturn(HandlerReturnResult.ERROR, "there're unsaved changes\n"); } + try { + table.exit(); + } catch (IOException e) { + System.err.println("Couldn't save " + table.getName()); + return new HandlerReturn(HandlerReturnResult.EXIT, ""); + } provider.exit(); - return new HandlerReturn(HandlerReturnResult.EXIT, "good bye\n"); + return new HandlerReturn(HandlerReturnResult.EXIT, "goodbye\n"); } public void emergencyExit() { From 7f17c5b6a7bcd9634d07248a740d6ece0ab74a7f Mon Sep 17 00:00:00 2001 From: annoing-morda Date: Thu, 25 Dec 2014 18:33:37 +0300 Subject: [PATCH 09/10] Fixed stuff --- .../junit/BadDBFileException.java | 2 +- .../dmitry_morozov/junit/DBCollection.java | 31 +++++------ .../dmitry_morozov/junit/FileMap.java | 50 ++--------------- .../students/dmitry_morozov/junit/Main.java | 27 ++++++++-- .../junit/MultiFileHashMap.java | 51 ++++++------------ .../junit/MyTableProviderFactory.java | 3 -- .../junit/TableWithTransactions.java | 53 +++++++++++++++++++ .../students/dmitry_morozov/junit/Utils.java | 2 - .../junit/interpreter/DBInterpreter.java | 22 ++++---- .../junit/tests/DBCollectionTest.java | 1 + .../junit/tests/MyTableTest.java | 7 ++- 11 files changed, 128 insertions(+), 121 deletions(-) create mode 100644 src/ru/fizteh/fivt/students/dmitry_morozov/junit/TableWithTransactions.java diff --git a/src/ru/fizteh/fivt/students/dmitry_morozov/junit/BadDBFileException.java b/src/ru/fizteh/fivt/students/dmitry_morozov/junit/BadDBFileException.java index e2c413824..dba295158 100644 --- a/src/ru/fizteh/fivt/students/dmitry_morozov/junit/BadDBFileException.java +++ b/src/ru/fizteh/fivt/students/dmitry_morozov/junit/BadDBFileException.java @@ -1,6 +1,6 @@ package ru.fizteh.fivt.students.dmitry_morozov.junit; -public class BadDBFileException extends Exception { +public class BadDBFileException extends RuntimeException { public BadDBFileException(String msg) { super(msg); diff --git a/src/ru/fizteh/fivt/students/dmitry_morozov/junit/DBCollection.java b/src/ru/fizteh/fivt/students/dmitry_morozov/junit/DBCollection.java index 0caac6bc8..b4938a472 100644 --- a/src/ru/fizteh/fivt/students/dmitry_morozov/junit/DBCollection.java +++ b/src/ru/fizteh/fivt/students/dmitry_morozov/junit/DBCollection.java @@ -10,6 +10,7 @@ public class DBCollection implements TableProvider { private String dirPath; private FileMap maps; + private static final String INFO_FILE_NAME = "tables_info.dat"; public DBCollection(String dirPath) throws IllegalArgumentException { this.dirPath = dirPath; @@ -17,15 +18,11 @@ public DBCollection(String dirPath) throws IllegalArgumentException { if (dirPath == null) { throw new IllegalArgumentException("path is null"); } - if (dirPath.endsWith("/") && !dirPath.equals("/")) { - String tmp = ""; - for (int i = 0; i < dirPath.length() - 1; i++) { - tmp += dirPath.charAt(i); - } - dirPath = tmp; + if (dirPath.endsWith(File.separator) && !dirPath.equals(File.separator)) { + this.dirPath = dirPath.substring(0, dirPath.length() - 1); } try { - maps = new FileMap(dirPath + "/tables_info.dat"); + maps = new FileMap(dirPath + File.separator + INFO_FILE_NAME); } catch (BadDBFileException | IOException e) { throw new IllegalArgumentException(e.getMessage()); } @@ -44,7 +41,7 @@ public Table getTable(String name) throws IllegalArgumentException { } Table res; try { - res = new MyTable(name); + res = new TableWithTransactions(name); } catch (BadDBFileException e) { throw new IllegalArgumentException(e.getMessage()); } @@ -57,14 +54,14 @@ public Table createTable(String name) { if (maps.get(name) != null) { return null; } - maps.put(name, dirPath + "/" + name); - File dir = new File(dirPath + "/" + name); + maps.put(name, dirPath + File.separator + name); + File dir = new File(dirPath + File.separator + name); if (!dir.mkdirs()) { throw new IllegalArgumentException(); } - MyTable res; + TableWithTransactions res; try { - res = new MyTable(dirPath + "/" + name); + res = new TableWithTransactions(dirPath + File.separator + name); } catch (BadDBFileException e) { maps.remove(name); throw new IllegalStateException(); @@ -77,7 +74,7 @@ public void removeTable(String name) { String tname = maps.get(name); if (tname != null) { // Database found. if (!Utils.removeDirectory(tname)) { - System.err.println("deleting table from disk failed"); + throw new IllegalStateException("Couldn't remove directory"); } else { maps.remove(name); } @@ -86,11 +83,7 @@ public void removeTable(String name) { } } - public void exit() { - try { - maps.exit(); - } catch (IOException e) { - e.printStackTrace(); - } + public void close() throws IOException { + maps.close(); } } diff --git a/src/ru/fizteh/fivt/students/dmitry_morozov/junit/FileMap.java b/src/ru/fizteh/fivt/students/dmitry_morozov/junit/FileMap.java index b8a5321e3..d3895c46c 100644 --- a/src/ru/fizteh/fivt/students/dmitry_morozov/junit/FileMap.java +++ b/src/ru/fizteh/fivt/students/dmitry_morozov/junit/FileMap.java @@ -6,10 +6,8 @@ import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.IOException; -import java.io.PrintWriter; import java.util.ArrayList; import java.util.HashMap; -import java.util.Iterator; import java.util.List; import java.util.Map; import java.util.Map.Entry; @@ -63,8 +61,8 @@ public FileMap(String path) throws BadDBFileException, IOException { private String readString(DataInputStream in) throws IOException, BadDBFileException { final int sizeOfInt = 4; - int len; - String res = ""; + int len; + StringBuilder res = new StringBuilder(); if (in.available() >= sizeOfInt) { len = in.readInt(); if (0 != len % 2 || in.available() < len) { @@ -74,13 +72,13 @@ private String readString(DataInputStream in) throws IOException, len /= 2; while (len > 0) { char curChar = in.readChar(); - res += curChar; + res.append(curChar); len--; } } else { return null; } - return res; + return res.toString(); } public String put(String key, String value) throws IllegalArgumentException { @@ -100,10 +98,6 @@ public String get(String key) throws IllegalArgumentException { return val; } - public String clearGet(String key) { - return table.get(key); - } - public List list() { List res = new ArrayList<>(); Set> tableSet = table.entrySet(); @@ -113,40 +107,6 @@ public List list() { return res; } - public void printList(PrintWriter pw) { - Set> tableSet = table.entrySet(); - Iterator> checkLast = tableSet.iterator(); - if (checkLast.hasNext()) { - checkLast.next(); - } - for (Entry i : tableSet) { - if (checkLast.hasNext()) { - pw.print(i.getKey() + ", "); - checkLast.next(); - } else { - pw.print(i.getKey()); - } - } - pw.flush(); - } - - public void fullList(PrintWriter pw) { - Set> tableSet = table.entrySet(); - Iterator> checkLast = tableSet.iterator(); - if (checkLast.hasNext()) { - checkLast.next(); - } - for (Entry i : tableSet) { - if (checkLast.hasNext()) { - pw.println(i.getKey() + " " + i.getValue()); - checkLast.next(); - } else { - pw.print(i.getKey() + " " + i.getValue()); - } - } - pw.flush(); - } - public String remove(String key) throws IllegalArgumentException { if (key == null) { throw new IllegalArgumentException(); @@ -154,7 +114,7 @@ public String remove(String key) throws IllegalArgumentException { return table.remove(key); } - public void exit() throws IOException { + public void close() throws IOException { DataOutputStream out = new DataOutputStream( new FileOutputStream(dbFile)); Set> tableSet = table.entrySet(); diff --git a/src/ru/fizteh/fivt/students/dmitry_morozov/junit/Main.java b/src/ru/fizteh/fivt/students/dmitry_morozov/junit/Main.java index f417c12fd..7f069b74c 100644 --- a/src/ru/fizteh/fivt/students/dmitry_morozov/junit/Main.java +++ b/src/ru/fizteh/fivt/students/dmitry_morozov/junit/Main.java @@ -1,5 +1,6 @@ package ru.fizteh.fivt.students.dmitry_morozov.junit; +import java.io.IOException; import java.util.Scanner; import ru.fizteh.fivt.students.dmitry_morozov.junit.interpreter.DBInterpreter; @@ -22,7 +23,11 @@ public static HandlerReturn commandSplitting(String command, if (0 == j) { return new HandlerReturn(HandlerReturnResult.SUCCESS, ""); } - return inter.handle(toGive, 0, j); + try { + return inter.handle(toGive, 0, j); + } catch (IOException e) { + return new HandlerReturn (HandlerReturnResult.ERROR, "Couldn't close provider"); + } } public static void batchMode(String[] args, DBInterpreter inter) { @@ -65,10 +70,19 @@ public static void batchMode(String[] args, DBInterpreter inter) { } catch (Exception e) { System.err.println(e.getMessage()); - inter.emergencyExit(); + try { + inter.emergencyExit(); + System.err.println("Emergency exit succeeded"); + } catch (IOException e1) { + System.err.println("Emergency exit failed"); + } + System.exit(1); + } + try { + inter.handleExit(); + } catch (IOException e) { System.exit(1); } - inter.handleExit(); System.exit(0); } @@ -125,7 +139,12 @@ public static void main(String[] args) { } } catch (Exception e) { e.printStackTrace(); - inter.emergencyExit(); + try { + inter.emergencyExit(); + System.err.println("Emergency exit succeeded"); + } catch (IOException e1) { + System.err.println("Emergency exit failed"); + } } finally { in.close(); } diff --git a/src/ru/fizteh/fivt/students/dmitry_morozov/junit/MultiFileHashMap.java b/src/ru/fizteh/fivt/students/dmitry_morozov/junit/MultiFileHashMap.java index ff672ec51..fca569dd8 100644 --- a/src/ru/fizteh/fivt/students/dmitry_morozov/junit/MultiFileHashMap.java +++ b/src/ru/fizteh/fivt/students/dmitry_morozov/junit/MultiFileHashMap.java @@ -12,6 +12,8 @@ public class MultiFileHashMap implements Table { private static final int FILE_MAPS_CNT = 256; private static final int DIRS_CNT = 16; + private static final String DIR_SUFFIX = ".dir"; + private static final String FILE_SUFFIX = ".dat"; private File rootDir; private BitSet openedMaps; private FileMap[] maps; @@ -19,7 +21,7 @@ public class MultiFileHashMap implements Table { int size; public MultiFileHashMap(String path) throws BadDBFileException { - String[] splittedPath = path.split("/"); + String[] splittedPath = path.split(File.separator); name = splittedPath[splittedPath.length - 1]; size = 0; rootDir = Utils.safeMkDir(path); @@ -27,12 +29,9 @@ public MultiFileHashMap(String path) throws BadDBFileException { openedMaps.clear(); maps = new FileMap[FILE_MAPS_CNT]; for (int i = 0; i < DIRS_CNT; ++i) { - String suffix = "/"; - if (i < 10) { - suffix += "0"; - } + String suffix = File.separator; suffix += Integer.toString(i); - suffix += ".dir"; + suffix += DIR_SUFFIX; Utils.safeMkDir(path + suffix); } } @@ -49,8 +48,7 @@ public String put(String key, String value) throws IllegalArgumentException { try { maps[mapNum] = new FileMap(curPath); } catch (IOException | BadDBFileException e) { - e.printStackTrace(); - System.err.println("Couldn't access" + curPath); + throw new BadDBFileException(e.getMessage()); } openedMaps.set(mapNum); return maps[mapNum].put(key, value); @@ -69,8 +67,7 @@ public String get(String key) throws IllegalArgumentException { try { maps[mapNum] = new FileMap(curPath); } catch (IOException | BadDBFileException e) { - e.printStackTrace(); - System.err.println("Couldn't access" + curPath); + throw new BadDBFileException(e.getMessage()); } openedMaps.set(mapNum); return maps[mapNum].get(key); @@ -89,8 +86,7 @@ public String remove(String key) throws IllegalArgumentException { try { maps[mapNum] = new FileMap(curPath); } catch (IOException | BadDBFileException e) { - System.err.println("Couldn't access" + curPath); - e.printStackTrace(); + throw new BadDBFileException(e.getMessage()); } openedMaps.set(mapNum); return maps[mapNum].remove(key); @@ -109,8 +105,7 @@ public List list() { try { maps[i] = new FileMap(curPath); } catch (IOException | BadDBFileException e) { - System.err.println("Couldn't access" + curPath); - e.printStackTrace(); + throw new BadDBFileException(e.getMessage()); } t = maps[i].list(); res.addAll(t); @@ -128,7 +123,7 @@ public void exit() throws IOException { if (maps[i].isEmpty()) { toDelete.add(i); } - maps[i].exit(); + maps[i].close(); } } for (Integer num : toDelete) { @@ -136,12 +131,9 @@ public void exit() throws IOException { tdel.delete(); } for (int i = 0; i < DIRS_CNT; i++) { - String suffix = "/"; - if (i < 10) { - suffix += "0"; - } + String suffix = File.separator; suffix += Integer.toString(i); - suffix += ".dir"; + suffix += DIR_SUFFIX; File tdir = new File(rootDir.getAbsolutePath() + suffix); tdir.delete(); // Won't be deleted if there're any files. } @@ -154,24 +146,14 @@ private String getPath(int hash) { int ndir = Math.abs(hash % DIRS_CNT); int nfile = Math.abs(hash / DIRS_CNT % DIRS_CNT); String path = rootDir.getAbsolutePath(); - String suffix = "/"; - if (ndir < 10) { - suffix += "0"; - } - suffix += Integer.toString(ndir) + ".dir/"; - if (nfile < 10) { - suffix += "0"; - } - suffix += Integer.toString(nfile) + ".dat"; + String suffix = File.separator; + suffix += Integer.toString(ndir) + DIR_SUFFIX; + suffix += Integer.toString(nfile) + FILE_SUFFIX; path += suffix; return path; } - public int getUnsavedChanges() { - return 0; - } - @Override public String getName() { return name; @@ -190,8 +172,7 @@ public int size() { res += maps[i].size(); openedMaps.set(i); } catch (IOException | BadDBFileException e) { - System.err.println("Couldn't access" + curPath); - e.printStackTrace(); + throw new BadDBFileException(e.getMessage()); } } } diff --git a/src/ru/fizteh/fivt/students/dmitry_morozov/junit/MyTableProviderFactory.java b/src/ru/fizteh/fivt/students/dmitry_morozov/junit/MyTableProviderFactory.java index 685094afe..b0326abf2 100644 --- a/src/ru/fizteh/fivt/students/dmitry_morozov/junit/MyTableProviderFactory.java +++ b/src/ru/fizteh/fivt/students/dmitry_morozov/junit/MyTableProviderFactory.java @@ -5,9 +5,6 @@ public class MyTableProviderFactory implements TableProviderFactory { - public MyTableProviderFactory() { - } - @Override public TableProvider create(String dir) throws IllegalArgumentException { TableProvider res; diff --git a/src/ru/fizteh/fivt/students/dmitry_morozov/junit/TableWithTransactions.java b/src/ru/fizteh/fivt/students/dmitry_morozov/junit/TableWithTransactions.java new file mode 100644 index 000000000..5ac15596e --- /dev/null +++ b/src/ru/fizteh/fivt/students/dmitry_morozov/junit/TableWithTransactions.java @@ -0,0 +1,53 @@ +package ru.fizteh.fivt.students.dmitry_morozov.junit; + +import java.util.Stack; + +public class TableWithTransactions extends MultiFileHashMap { + Stack opStack; + + public TableWithTransactions(String path) throws BadDBFileException { + super(path); + opStack = new Stack<>(); + } + + public String put(String key, String value) throws IllegalArgumentException { + String result = super.put(key, value); + if (result == null) { // If PUT has just pushed new value + opStack.push(new ChangingCommand(CommandName.REMOVE, key, "")); + } else { // If PUT has overwritten old value + opStack.push(new ChangingCommand(CommandName.PUT, key, result)); + } + return result; + } + + public String remove(String key) throws IllegalArgumentException { + String result = super.remove(key); + if (result != null) { // Key found. + opStack.push(new ChangingCommand(CommandName.PUT, key, result)); + } + return result; + } + + public int rollback() { + int cnt = opStack.size(); + while (!opStack.isEmpty()) { + ChangingCommand t = opStack.pop(); + if (t.cName == CommandName.PUT) { + super.put(t.args[0], t.args[1]); + } else { + super.remove(t.args[0]); + } + } + return cnt; + } + + public int commit() { + int cnt = opStack.size(); + opStack.clear(); + return cnt; + } + + public int getUnsavedChanges() { + return opStack.size(); + } +} diff --git a/src/ru/fizteh/fivt/students/dmitry_morozov/junit/Utils.java b/src/ru/fizteh/fivt/students/dmitry_morozov/junit/Utils.java index 30f248230..236e4b5f3 100644 --- a/src/ru/fizteh/fivt/students/dmitry_morozov/junit/Utils.java +++ b/src/ru/fizteh/fivt/students/dmitry_morozov/junit/Utils.java @@ -9,11 +9,9 @@ public class Utils { static boolean removeDirectory(String path) { File dir = new File(path); if (!dir.exists()) { - System.err.println("table has been already deleted from disk"); return false; } if (!dir.isDirectory()) { - System.err.println("table directory has been damaged"); return false; } File[] flist = dir.listFiles(); diff --git a/src/ru/fizteh/fivt/students/dmitry_morozov/junit/interpreter/DBInterpreter.java b/src/ru/fizteh/fivt/students/dmitry_morozov/junit/interpreter/DBInterpreter.java index 2f12760b7..522dc8185 100644 --- a/src/ru/fizteh/fivt/students/dmitry_morozov/junit/interpreter/DBInterpreter.java +++ b/src/ru/fizteh/fivt/students/dmitry_morozov/junit/interpreter/DBInterpreter.java @@ -8,12 +8,12 @@ import ru.fizteh.fivt.storage.strings.Table; import ru.fizteh.fivt.storage.strings.TableProviderFactory; import ru.fizteh.fivt.students.dmitry_morozov.junit.DBCollection; -import ru.fizteh.fivt.students.dmitry_morozov.junit.MyTable; +import ru.fizteh.fivt.students.dmitry_morozov.junit.TableWithTransactions; import ru.fizteh.fivt.students.dmitry_morozov.junit.MyTableProviderFactory; public class DBInterpreter { private DBCollection provider; - private MyTable table; + private TableWithTransactions table; private HashMap argsCount; private TreeSet commandsForTable; @@ -55,7 +55,7 @@ public DBInterpreter(String path) { } - public HandlerReturn handle(String[] comAndParams, int bIndex, int eIndex) { + public HandlerReturn handle(String[] comAndParams, int bIndex, int eIndex) throws IOException{ if (comAndParams.length < 1) { return new HandlerReturn(HandlerReturnResult.EXIT, ""); } @@ -178,9 +178,9 @@ public HandlerReturn handleCommit(String[] comAndParams, int bIndex, } public HandlerReturn handleUse(String[] comAndParams, int bIndex, int eIndex) { - MyTable newTable; + TableWithTransactions newTable; try { - newTable = (MyTable) provider.getTable(comAndParams[bIndex]); + newTable = (TableWithTransactions) provider.getTable(comAndParams[bIndex]); } catch (IllegalArgumentException e1) { return new HandlerReturn(HandlerReturnResult.ERROR, ""); } @@ -255,7 +255,7 @@ public HandlerReturn handleShowTables(String[] comAndParams, int bIndex, if (tableName.equals(curName)) { res += curName + " " + table.size() + "\n"; } else { - MyTable curTable = (MyTable) provider.getTable(curName); + TableWithTransactions curTable = (TableWithTransactions) provider.getTable(curName); res += curName + " " + curTable.size() + "\n"; try { curTable.exit(); @@ -267,9 +267,9 @@ public HandlerReturn handleShowTables(String[] comAndParams, int bIndex, return new HandlerReturn(HandlerReturnResult.SUCCESS, res); } - public HandlerReturn handleExit() { + public HandlerReturn handleExit() throws IOException { if (table == null) { - provider.exit(); + provider.close(); return new HandlerReturn(HandlerReturnResult.EXIT, "goodbye\n"); } if (table.getUnsavedChanges() > 0) { @@ -282,11 +282,11 @@ public HandlerReturn handleExit() { System.err.println("Couldn't save " + table.getName()); return new HandlerReturn(HandlerReturnResult.EXIT, ""); } - provider.exit(); + provider.close(); return new HandlerReturn(HandlerReturnResult.EXIT, "goodbye\n"); } - public void emergencyExit() { + public void emergencyExit() throws IOException { try { if (table != null) { table.exit(); @@ -294,7 +294,7 @@ public void emergencyExit() { } catch (IOException e) { e.printStackTrace(); } finally { - provider.exit(); + provider.close(); } } diff --git a/src/ru/fizteh/fivt/students/dmitry_morozov/junit/tests/DBCollectionTest.java b/src/ru/fizteh/fivt/students/dmitry_morozov/junit/tests/DBCollectionTest.java index d9fb5aeaf..a293ec6ee 100644 --- a/src/ru/fizteh/fivt/students/dmitry_morozov/junit/tests/DBCollectionTest.java +++ b/src/ru/fizteh/fivt/students/dmitry_morozov/junit/tests/DBCollectionTest.java @@ -25,6 +25,7 @@ public void before() throws IOException { TableProviderFactory factory = new MyTableProviderFactory(); dirPath = tmpFolder.newFolder().getAbsolutePath(); provider = factory.create(dirPath); + System.err.println(File.separator); } @Test diff --git a/src/ru/fizteh/fivt/students/dmitry_morozov/junit/tests/MyTableTest.java b/src/ru/fizteh/fivt/students/dmitry_morozov/junit/tests/MyTableTest.java index d47a4066d..3d0e42e16 100644 --- a/src/ru/fizteh/fivt/students/dmitry_morozov/junit/tests/MyTableTest.java +++ b/src/ru/fizteh/fivt/students/dmitry_morozov/junit/tests/MyTableTest.java @@ -30,7 +30,8 @@ public void before() throws IOException { @Test public void getNameTest() { - Assert.assertEquals("table", table.getName()); + String actualName = table.getName(); + Assert.assertEquals("table", actualName); } @Test @@ -90,6 +91,7 @@ public void rollbackTest() { table.remove("1"); table.put("1", "uno"); Assert.assertEquals(4, table.rollback()); + Assert.assertEquals(0, table.size()); } @Test @@ -100,6 +102,9 @@ public void commitTest() { table.remove("1"); table.put("1", "uno"); Assert.assertEquals(4, table.commit()); + Assert.assertNull(table.get("3")); + Assert.assertEquals("two", table.get("2")); + Assert.assertEquals("uno", table.get("1")); } @Test From 0a5b849fe72dac77ff863b03fc95e3c24215a979 Mon Sep 17 00:00:00 2001 From: annoing-morda Date: Thu, 25 Dec 2014 18:40:17 +0300 Subject: [PATCH 10/10] Fixed stuff + checkstyle --- .../fivt/students/dmitry_morozov/junit/Main.java | 3 ++- .../junit/interpreter/DBInterpreter.java | 14 +++++++++----- 2 files changed, 11 insertions(+), 6 deletions(-) diff --git a/src/ru/fizteh/fivt/students/dmitry_morozov/junit/Main.java b/src/ru/fizteh/fivt/students/dmitry_morozov/junit/Main.java index 7f069b74c..cb08a6c23 100644 --- a/src/ru/fizteh/fivt/students/dmitry_morozov/junit/Main.java +++ b/src/ru/fizteh/fivt/students/dmitry_morozov/junit/Main.java @@ -26,7 +26,8 @@ public static HandlerReturn commandSplitting(String command, try { return inter.handle(toGive, 0, j); } catch (IOException e) { - return new HandlerReturn (HandlerReturnResult.ERROR, "Couldn't close provider"); + return new HandlerReturn(HandlerReturnResult.ERROR, + "Couldn't close provider"); } } diff --git a/src/ru/fizteh/fivt/students/dmitry_morozov/junit/interpreter/DBInterpreter.java b/src/ru/fizteh/fivt/students/dmitry_morozov/junit/interpreter/DBInterpreter.java index 522dc8185..836b9fc06 100644 --- a/src/ru/fizteh/fivt/students/dmitry_morozov/junit/interpreter/DBInterpreter.java +++ b/src/ru/fizteh/fivt/students/dmitry_morozov/junit/interpreter/DBInterpreter.java @@ -55,7 +55,8 @@ public DBInterpreter(String path) { } - public HandlerReturn handle(String[] comAndParams, int bIndex, int eIndex) throws IOException{ + public HandlerReturn handle(String[] comAndParams, int bIndex, int eIndex) + throws IOException { if (comAndParams.length < 1) { return new HandlerReturn(HandlerReturnResult.EXIT, ""); } @@ -154,7 +155,7 @@ public HandlerReturn handleRemove(String[] comAndParams, int bIndex, } public HandlerReturn handleList() { - String res; + String res; res = String.join(", ", table.list()); res += (res.equals("")) ? "" : "\n"; return new HandlerReturn(HandlerReturnResult.SUCCESS, res); @@ -180,7 +181,8 @@ public HandlerReturn handleCommit(String[] comAndParams, int bIndex, public HandlerReturn handleUse(String[] comAndParams, int bIndex, int eIndex) { TableWithTransactions newTable; try { - newTable = (TableWithTransactions) provider.getTable(comAndParams[bIndex]); + newTable = (TableWithTransactions) provider + .getTable(comAndParams[bIndex]); } catch (IllegalArgumentException e1) { return new HandlerReturn(HandlerReturnResult.ERROR, ""); } @@ -255,12 +257,14 @@ public HandlerReturn handleShowTables(String[] comAndParams, int bIndex, if (tableName.equals(curName)) { res += curName + " " + table.size() + "\n"; } else { - TableWithTransactions curTable = (TableWithTransactions) provider.getTable(curName); + TableWithTransactions curTable = (TableWithTransactions) provider + .getTable(curName); res += curName + " " + curTable.size() + "\n"; try { curTable.exit(); } catch (IOException e) { - System.err.println("Interrupted access to database: " + curName); + System.err.println("Interrupted access to database: " + + curName); } } }