diff --git a/projects/elinrin/pom.xml b/projects/elinrin/pom.xml new file mode 100644 index 0000000..da941db --- /dev/null +++ b/projects/elinrin/pom.xml @@ -0,0 +1,115 @@ + + 4.0.0 + + ru.mipt.diht.students + elinrin + 1.0-SNAPSHOT + + + + org.apache.maven.plugins + maven-compiler-plugin + + 1.8 + 1.8 + + + + + jar + + elinrin + http://maven.apache.org + + + UTF-8 + + + + + + com.h2database + h2 + 1.4.190 + + + + junit + junit + 3.8.1 + test + + + + com.beust + jcommander + 1.48 + + + + org.twitter4j + twitter4j-stream + 4.0.4 + + + + org.json + json + 20141113 + + + + com.google.guava + guava + 17.0 + + + + junit + junit + 4.11 + test + + + + org.mockito + mockito-all + 1.9.5 + + + + org.powermock + powermock-module-junit4 + 1.6.1 + test + true + + + junit + junit + + + + + + org.powermock + powermock-api-mockito + 1.6.1 + test + true + + + mockito-all + org.mockito + + + + + com.tngtech.java + junit-dataprovider + 1.10.1 + + + + diff --git a/projects/elinrin/src/main/java/ru/mipt/diht/students/elinrin/miniorm/ClassConverter.java b/projects/elinrin/src/main/java/ru/mipt/diht/students/elinrin/miniorm/ClassConverter.java new file mode 100644 index 0000000..52b0777 --- /dev/null +++ b/projects/elinrin/src/main/java/ru/mipt/diht/students/elinrin/miniorm/ClassConverter.java @@ -0,0 +1,38 @@ +package ru.mipt.diht.students.elinrin.miniorm; + +import java.sql.Time; +import java.sql.Timestamp; +import java.util.Date; +import java.util.HashMap; +import java.util.Map; +import java.util.UUID; + + +public class +ClassConverter { + private static Map classes; + static { + classes = new HashMap<>(); + classes.put(Integer.class, "INTEGER"); + classes.put(Boolean.class, "BOOLEAN"); + classes.put(Byte.class, "TINYINT"); + classes.put(Short.class, "SMALLINT"); + classes.put(Long.class, "BIGINT"); + classes.put(Double.class, "DOUBLE"); + classes.put(Float.class, "FLOAT"); + classes.put(Time.class, "TIME"); + classes.put(Date.class, "DATE"); + classes.put(Timestamp.class, "TIMESTAMP"); + classes.put(Character.class, "CHAR"); + classes.put(String.class, "CLOB"); + classes.put(UUID.class, "UUID"); + } + + public static String convert(final Class currClass) { + if (classes.containsKey(currClass)) { + return classes.get(currClass); + } + return "OTHER"; + } + +} diff --git a/projects/elinrin/src/main/java/ru/mipt/diht/students/elinrin/miniorm/DatabaseService.java b/projects/elinrin/src/main/java/ru/mipt/diht/students/elinrin/miniorm/DatabaseService.java new file mode 100644 index 0000000..6151400 --- /dev/null +++ b/projects/elinrin/src/main/java/ru/mipt/diht/students/elinrin/miniorm/DatabaseService.java @@ -0,0 +1,255 @@ +package ru.mipt.diht.students.elinrin.miniorm; +import com.google.common.base.CaseFormat; +import ru.mipt.diht.students.elinrin.miniorm.annotations.Column; +import ru.mipt.diht.students.elinrin.miniorm.annotations.PrimaryKey; +import ru.mipt.diht.students.elinrin.miniorm.annotations.Table; +import ru.mipt.diht.students.elinrin.miniorm.exception.HandlerOfException; + +import javax.management.OperationsException; +import java.lang.reflect.Field; +import java.sql.*; +import java.util.ArrayList; +import java.util.List; + +/* + +T queryById(K) - возвращает запись по первичному ключу +T queryForAll() - возвращает все записи из таблицы +void insert(T) - добавляет запись +void update(T) - редактирует запись по первичному ключу +void delete(T) - удаляет запись по первичному ключу +void createTable() - создаёт таблицу по метаданным класса T. См. аннотации ниже. +void dropTable() - удаляет таблицу, соответствующую T. Класс нужно покрыть модульными тестами. +*/ +public class DatabaseService { + //Классы JDSC + private Connection connection = null; + private Statement statement = null; + private ResultSet resultSet = null; + private Field primaryKey = null; + private List columns = null; + private Field[] fields; + private String[] namesOfColumns; + private Class tableClass = null; + private String tableName = ""; + private int primaryKeyFieldNumber = -1; + + private boolean hasTableYet = false; + + + /*protected void finalize ( ) throws SQLException { + resultSet.close(); + statement.close(); + connection.close(); + }*/ + + // DatabaseService(Class) - коструктор, принимает тип объекта, с которым хотим работать + DatabaseService(final Class elementClass) throws ClassNotFoundException, + SQLException, InstantiationException, IllegalAccessException { + + Class.forName("org.h2.Driver").newInstance(); + //путь к файлу с БД, соединение с драйверами БД + connection = DriverManager.getConnection("jdbc:h2:~/test", "test", "test"); + statement = connection.createStatement(); + + columns = new ArrayList<>(); + tableClass = elementClass; + Table table = tableClass.getAnnotation(Table.class); + if (table == null) { + throw new IllegalArgumentException("Class should be annotated with Table"); + } + tableName = table.name(); + if (tableName.equals("")) { + tableName = "MY_TABLE"; + } + int i = 0; + for (Field elem : tableClass.getDeclaredFields()) { + if (elem.getAnnotation(Column.class) != null) { + columns.add(elem); + } + if (elem.getAnnotation(PrimaryKey.class) != null) { + if (elem.getAnnotation(Column.class) == null) { + throw new IllegalArgumentException("Not all fields are columns"); + } + if (primaryKey != null) { + throw new IllegalArgumentException("Not one primary Key"); + } + primaryKey = elem; + primaryKeyFieldNumber = i; + } + ++i; + } + + resultSet = connection.getMetaData().getTables(null, null, + CaseFormat.LOWER_UNDERSCORE.to(CaseFormat.UPPER_UNDERSCORE, tableName), null); + resultSet.next(); + } + public final T queryById(final K id) throws OperationsException, + SQLException, IllegalAccessException, InstantiationException { + if (!hasTableYet) { + throw new OperationsException("Для данного запроа необходимо создать таблицу"); + } + if (primaryKey == null) { + throw new OperationsException("Должен суущестовать первичный ключ"); + } + /*if (!id.getClass().isInstance(primaryKey.getType())){ + throw new IllegalArgumentException("Ключ должен иметь тот же тип, что и первичные ключи таблицы"); + }*/ + StringBuilder newRequest = new StringBuilder(); + newRequest.append("SELECT * FROM ").append(tableName).append(" WHERE ") + .append(columns.get(primaryKeyFieldNumber).getAnnotation(Column.class) + .name()).append(" = ").append(id.toString()); + resultSet = statement.executeQuery(newRequest.toString()); + List list = new ArrayList<>(); + while (resultSet.next()) { + T item = tableClass.newInstance(); + for (Field field: columns) { + if (field.getType().equals(Integer.class)) { + field.set(item, resultSet.getInt(field.getAnnotation(Column.class).name())); + } + if (field.getType().equals(String.class)) { + field.set(item, resultSet.getString(field.getAnnotation(Column.class).name())); + } + } + list.add(item); + } + if (list.size() == 0) { + return null; + } + if (list.size() > 1) { + throw new OperationsException("Ошибка получения результата"); + } + return list.get(0); + } + + final List queryForAll() throws OperationsException, SQLException, IllegalAccessException, + InstantiationException { + + if (!hasTableYet) { + throw new OperationsException("Для данного запроа необходимо создать таблицу"); + } + if (primaryKey == null) { + throw new OperationsException("Должен суущестовать первичный ключ"); + } + StringBuilder newRequest = new StringBuilder(); + newRequest.append("SELECT * FROM ").append(tableName); + resultSet = statement.executeQuery(newRequest.toString()); + List list = new ArrayList<>(); + while (resultSet.next()) { + T item = tableClass.newInstance(); + for (Field field: columns) { + if (field.getType().equals(Integer.class)) { + field.set(item, resultSet.getInt(field.getAnnotation(Column.class).name())); + } + if (field.getType().equals(String.class)) { + field.set(item, resultSet.getString(field.getAnnotation(Column.class).name())); + } + } + list.add(item); + } + return list; + } + + final void insert(final T key) throws SQLException { + StringBuilder newRequest = new StringBuilder(); + newRequest.append("INSERT INTO ").append(tableName).append(" VALUES("); + boolean first = true; + for (Field field:columns) { + if (!first) { + newRequest.append(", "); + } else { + first = false; + } + newRequest.append("?"); + } + newRequest.append(")"); + //System.out.println(newRequest); + PreparedStatement preparedStatement = connection.prepareStatement(newRequest.toString()); + + for (int i = 0; i < columns.size(); i++) { + try { + preparedStatement.setObject(i + 1, columns.get(i).get(key)); + } catch (IllegalAccessException e) { + HandlerOfException.handler(e); + } + } + //System.out.println(preparedStatement.toString()); + preparedStatement.execute(); + + } + + final void update(final T key) throws SQLException { + StringBuilder newRequest = new StringBuilder().append("UPDATE ").append(tableName).append(" SET "); + for (int i = 0; i < columns.size(); ++i) { + if (i != 0) { + newRequest.append(", "); + } + newRequest.append(columns.get(i).getAnnotation(Column.class).name()).append(" = ?"); + } + + newRequest.append(" WHERE ").append(columns.get(primaryKeyFieldNumber).getAnnotation(Column.class).name()) + .append(" = ?"); + PreparedStatement prepareStatement = connection.prepareStatement(newRequest.toString()); + for (int i = 0; i < columns.size(); i++) { + try { + prepareStatement.setObject(1, columns.get(i).get(key)); + prepareStatement.setObject(2, columns.get(primaryKeyFieldNumber).get(key)); + } catch (IllegalAccessException e) { + HandlerOfException.handler(e); + } + prepareStatement.execute(); + } + + + + } + + + final void delete(final T key) throws SQLException { + StringBuilder newRequest = new StringBuilder(); + newRequest.append("DELETE FROM ").append(tableName).append(columns.get(primaryKeyFieldNumber) + .getAnnotation(Column.class).name()).append(" = ").append("?"); + PreparedStatement preparedStatement = connection.prepareStatement(newRequest.toString()); + try { + preparedStatement.setObject(1, columns.get(primaryKeyFieldNumber).get(key)); + preparedStatement.execute(); + } catch (IllegalAccessException e) { + HandlerOfException.handler(e); + } + } + + final void createTable() throws OperationsException, SQLException { + if (hasTableYet) { + throw new OperationsException("Невозможно повторно создать таблицу"); + } + hasTableYet = true; + StringBuilder newRequest = new StringBuilder(); + newRequest.append("CREATE TABLE IF NOT EXISTS ").append(tableName).append(" ("); + int i = 0; + for (Field field : columns) { + //System.out.println(field.getType().toString()); + if (i != 0) { + newRequest.append(", "); + } + newRequest.append(field.getAnnotation(Column.class).name()).append(" "); + newRequest.append(ClassConverter.convert(columns.get(i).getType())).append(" "); + if (field.isAnnotationPresent(PrimaryKey.class)) { + newRequest.append("PRIMARY KEY"); + primaryKeyFieldNumber = i; + } + i++; + } + newRequest.append(") "); + //System.out.println(newRequest); + statement.execute(newRequest.toString()); + } + + final void dropTable() { + try { + statement.execute("DROP TABLE IF EXISTS " + tableName); + hasTableYet = false; + } catch (SQLException e) { + HandlerOfException.handler(e); + } + } +} diff --git a/projects/elinrin/src/main/java/ru/mipt/diht/students/elinrin/miniorm/User.java b/projects/elinrin/src/main/java/ru/mipt/diht/students/elinrin/miniorm/User.java new file mode 100644 index 0000000..8101341 --- /dev/null +++ b/projects/elinrin/src/main/java/ru/mipt/diht/students/elinrin/miniorm/User.java @@ -0,0 +1,80 @@ +package ru.mipt.diht.students.elinrin.miniorm; + +/* +import ru.mipt.diht.students.elinrin.miniorm.annotations.Column; +import ru.mipt.diht.students.elinrin.miniorm.annotations.PrimaryKey; +import ru.mipt.diht.students.elinrin.miniorm.annotations.Table; +import ru.mipt.diht.students.elinrin.miniorm.exception.HandlerOfException; + +import javax.management.OperationsException; +import java.sql.SQLException; +import java.util.List; +import java.util.Objects; +*/ + + +public class User { + /*@Table(name = "TESTTABLE") + static class Tab { + @PrimaryKey + @Column(name = "ID") + Integer a; + + @Column(name = "STRING") + String s; + + @Override + public boolean equals(Object obj) { + if (obj instanceof Tab) { + return ((Objects.equals(this.a, ((Tab) obj).a)) && (Objects.equals(this.s, ((Tab) obj).s))); + } + return false; + } + + Tab(Object a, Object s) { + this.a = (Integer) a; + this.s = (String) s; + } + + Tab() { + this.a = 0; + this.s = ""; + } + + @Override + public String toString() { + StringBuilder result = new StringBuilder().append("Id = ").append(a).append(", String = ").append(s); + return result.toString(); + } + } + + public static void main(String[] argv) { + DatabaseService bd = null; + try { + bd = new DatabaseService(Tab.class); + } catch (ClassNotFoundException | IllegalAccessException | InstantiationException | SQLException e) { + HandlerOfException.handler(e); + } + + try { + bd.createTable(); + bd.insert(new Tab(1, "one")); + List all = bd.queryForAll(); + all.forEach(System.out::println); + + bd.insert(new Tab(2, "two")); + bd.insert(new Tab(3, "three")); + bd.insert(new Tab(4, "four")); + + Tab elem = bd.queryById(3); + System.out.println(elem); + + all = bd.queryForAll(); + all.forEach(System.out::println); + } catch (IllegalAccessException | InstantiationException | OperationsException | SQLException e) { + HandlerOfException.handler(e); + } finally { + bd.dropTable(); + } + }*/ +} diff --git a/projects/elinrin/src/main/java/ru/mipt/diht/students/elinrin/miniorm/annotations/Column.java b/projects/elinrin/src/main/java/ru/mipt/diht/students/elinrin/miniorm/annotations/Column.java new file mode 100644 index 0000000..cbb2322 --- /dev/null +++ b/projects/elinrin/src/main/java/ru/mipt/diht/students/elinrin/miniorm/annotations/Column.java @@ -0,0 +1,13 @@ +package ru.mipt.diht.students.elinrin.miniorm.annotations; + +import java.lang.annotation.ElementType; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; + +@Target(value = ElementType.FIELD) +@Retention(value = RetentionPolicy.RUNTIME) +public @interface Column { + String name() default ""; +} + diff --git a/projects/elinrin/src/main/java/ru/mipt/diht/students/elinrin/miniorm/annotations/PrimaryKey.java b/projects/elinrin/src/main/java/ru/mipt/diht/students/elinrin/miniorm/annotations/PrimaryKey.java new file mode 100644 index 0000000..6234828 --- /dev/null +++ b/projects/elinrin/src/main/java/ru/mipt/diht/students/elinrin/miniorm/annotations/PrimaryKey.java @@ -0,0 +1,11 @@ +package ru.mipt.diht.students.elinrin.miniorm.annotations; + +import java.lang.annotation.ElementType; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; + +@Target(value = ElementType.FIELD) +@Retention(value = RetentionPolicy.RUNTIME) +public @interface PrimaryKey { +} diff --git a/projects/elinrin/src/main/java/ru/mipt/diht/students/elinrin/miniorm/annotations/Table.java b/projects/elinrin/src/main/java/ru/mipt/diht/students/elinrin/miniorm/annotations/Table.java new file mode 100644 index 0000000..bc3a545 --- /dev/null +++ b/projects/elinrin/src/main/java/ru/mipt/diht/students/elinrin/miniorm/annotations/Table.java @@ -0,0 +1,12 @@ +package ru.mipt.diht.students.elinrin.miniorm.annotations; + +import java.lang.annotation.ElementType; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; + +@Target(value = ElementType.TYPE) +@Retention(value = RetentionPolicy.RUNTIME) +public @interface Table { + String name() default ""; +} diff --git a/projects/elinrin/src/main/java/ru/mipt/diht/students/elinrin/miniorm/exception/HandlerOfException.java b/projects/elinrin/src/main/java/ru/mipt/diht/students/elinrin/miniorm/exception/HandlerOfException.java new file mode 100644 index 0000000..57f24a1 --- /dev/null +++ b/projects/elinrin/src/main/java/ru/mipt/diht/students/elinrin/miniorm/exception/HandlerOfException.java @@ -0,0 +1,23 @@ +package ru.mipt.diht.students.elinrin.miniorm.exception; + +public class HandlerOfException { + static final String USER_MOD = "user"; + + public static void handler(final String message, final Throwable cause) { + System.err.println(message + ". " + cause.getMessage()); + System.exit(1); + } + public static void handler(final Throwable cause) { + System.err.println(cause.getMessage()); + System.exit(1); + } + + public static void handler(final Throwable cause, final String mod) { + if (mod.equals(USER_MOD)) { + System.err.println(cause.getMessage()); + } else { + System.err.println(cause.getMessage()); + System.exit(1); + } + } +} diff --git a/projects/elinrin/src/main/java/ru/mipt/diht/students/elinrin/threads/BlockingQueue.java b/projects/elinrin/src/main/java/ru/mipt/diht/students/elinrin/threads/BlockingQueue.java new file mode 100644 index 0000000..2d9b413 --- /dev/null +++ b/projects/elinrin/src/main/java/ru/mipt/diht/students/elinrin/threads/BlockingQueue.java @@ -0,0 +1,89 @@ +package ru.mipt.diht.students.elinrin.threads; + +import java.util.ArrayDeque; +import java.util.ArrayList; +import java.util.List; +import java.util.Queue; +import java.util.concurrent.locks.Lock; +import java.util.concurrent.locks.ReentrantLock; + +public class BlockingQueue { + private int maxQueueSize; + private Queue queue; + private Lock queueLock = new ReentrantLock(); + private Lock offerLock = new ReentrantLock(); + private Lock takeLock = new ReentrantLock(); + private Object pushWait = new Object(); + private Object popWait = new Object(); + + public final void offer(final List list) { + offerLock.lock(); + try { + Integer last = 0; + while (last != list.size()) { + synchronized (popWait) { + while (queue.size() == maxQueueSize) { + try { + popWait.wait(); + } catch (InterruptedException e) { + System.err.println(e.getMessage()); + System.exit(1); + } + } + try { + queueLock.lock(); + while (last < Integer.min(last + maxQueueSize - queue.size(), list.size())) { + queue.add(list.get(last)); + last++; + } + } finally { + queueLock.unlock(); + } + } + } + } finally { + synchronized (pushWait) { + pushWait.notifyAll(); + } + offerLock.unlock(); + } + } + + public final List take(final int n) { + takeLock.lock(); + try { + List elements = new ArrayList<>(); + while (elements.size() != n) { + synchronized (pushWait) { + while (queue.size() == 0) { + try { + pushWait.wait(); + } catch (InterruptedException e) { + System.err.println(e.getMessage()); + System.exit(1); + } + } + try { + queueLock.lock(); + while (queue.size() > 0 && elements.size() != n) { + elements.add(queue.poll()); + } + } finally { + queueLock.unlock(); + } + } + } + return elements; + } finally { + synchronized (popWait) { + popWait.notifyAll(); + } + takeLock.unlock(); + } + } + + public BlockingQueue(final int maxSize) { + maxQueueSize = maxSize; + queue = new ArrayDeque<>(); + } +} diff --git a/projects/elinrin/src/main/java/ru/mipt/diht/students/elinrin/threads/Counter.java b/projects/elinrin/src/main/java/ru/mipt/diht/students/elinrin/threads/Counter.java new file mode 100644 index 0000000..8ae7c85 --- /dev/null +++ b/projects/elinrin/src/main/java/ru/mipt/diht/students/elinrin/threads/Counter.java @@ -0,0 +1,49 @@ +package ru.mipt.diht.students.elinrin.threads; + +import ru.mipt.diht.students.elinrin.threads.exception.HandlerOfException; + + +public class Counter { + + private static volatile int printId; + + public static void main(final String[] args) { + int number; + number = Parse.parse(args); + + for (int id = 0; id < number; id++) { + CounterThread thread = new CounterThread(id, (id + 1) % number); + thread.start(); + } + } + + + private static Object working = new Object(); + + private static class CounterThread extends Thread { + private int threadId, nextThreadId; + + CounterThread(final int id1, final int id2) { + threadId = id1; + nextThreadId = id2; + } + + @Override + public void run() { + while (true) { + synchronized (working) { + while (threadId != printId) { + try { + working.wait(); + } catch (InterruptedException e) { + HandlerOfException.handler(e); + } + } + System.out.println("Thread-" + (threadId + 1)); + printId = nextThreadId; + working.notifyAll(); + } + } + } + } +} diff --git a/projects/elinrin/src/main/java/ru/mipt/diht/students/elinrin/threads/Parse.java b/projects/elinrin/src/main/java/ru/mipt/diht/students/elinrin/threads/Parse.java new file mode 100644 index 0000000..6ecfb93 --- /dev/null +++ b/projects/elinrin/src/main/java/ru/mipt/diht/students/elinrin/threads/Parse.java @@ -0,0 +1,61 @@ +package ru.mipt.diht.students.elinrin.threads; + + +import ru.mipt.diht.students.elinrin.threads.exception.HandlerOfException; +import ru.mipt.diht.students.elinrin.threads.exception.UserException; + +import java.util.Scanner; + +import static java.lang.Thread.sleep; + +public class Parse { + + static final String USER_MOD = "user"; + static final int SLEEP_TIME = 500; + + private static int checkArgument(final String arguments) throws UserException { + int number; + try { + number = Integer.valueOf(arguments); + if (number <= 0) { + throw new UserException("Expected positive number"); + } else { + return number; + } + } catch (NumberFormatException e) { + throw new UserException("Expected integer number"); + } + } + + public static int parse(final String[] args) { + int number = 0; + if (args.length != 1) { + try (Scanner in = new Scanner(System.in)) { + while (true) { + System.out.print("$ Counter "); + String arguments = in.nextLine().trim(); + try { + number = checkArgument(arguments); + break; + } catch (UserException e) { + HandlerOfException.handler(e, USER_MOD); + try { + sleep(SLEEP_TIME); + } catch (InterruptedException e1) { + HandlerOfException.handler(e1); + } + } + } + } + } else { + try { + number = checkArgument(args[0]); + } catch (UserException e) { + HandlerOfException.handler(e); + } + } + return number; + } + + +} diff --git a/projects/elinrin/src/main/java/ru/mipt/diht/students/elinrin/threads/Rollcall.java b/projects/elinrin/src/main/java/ru/mipt/diht/students/elinrin/threads/Rollcall.java new file mode 100644 index 0000000..9260787 --- /dev/null +++ b/projects/elinrin/src/main/java/ru/mipt/diht/students/elinrin/threads/Rollcall.java @@ -0,0 +1,78 @@ +package ru.mipt.diht.students.elinrin.threads; + +import ru.mipt.diht.students.elinrin.threads.exception.HandlerOfException; + +import java.util.Random; +import java.util.concurrent.BrokenBarrierException; +import java.util.concurrent.CyclicBarrier; + +public class Rollcall { + static final int NUMBER_EVENTS = 10; + + private static volatile boolean allSaidYes = false; + private static CyclicBarrier allReady, allAnswered; + + public static void main(final String[] args) { + int number; + number = Parse.parse(args); + + allReady = new CyclicBarrier(number + 1); + allAnswered = new CyclicBarrier(number + 1); + + for (int i = 0; i < number; i++) { + RollcallThread thread = new RollcallThread(); + thread.start(); + } + + while (!allSaidYes) { + System.out.println("Are you ready?"); + allSaidYes = true; + try { + allReady.await(); + } catch (InterruptedException | BrokenBarrierException e) { + HandlerOfException.handler(e); + } + allReady.reset(); + try { + allAnswered.await(); + } catch (InterruptedException | BrokenBarrierException e) { + HandlerOfException.handler(e); + } + allAnswered.reset(); + + if (allSaidYes) { + System.exit(0); + } + } + } + + private static class RollcallThread extends Thread { + private Boolean answer; + private Random rand = new Random(); + + @Override + public void run() { + while (true) { + try { + allReady.await(); + } catch (InterruptedException | BrokenBarrierException e) { + HandlerOfException.handler(e); + } + answer = rand.nextInt(NUMBER_EVENTS) != 0; + if (answer) { + System.out.println("Yes"); + } else { + System.out.println("No"); + } + if (!answer) { + allSaidYes = false; + } + try { + allAnswered.await(); + } catch (InterruptedException | BrokenBarrierException e) { + HandlerOfException.handler(e); + } + } + } + } +} diff --git a/projects/elinrin/src/main/java/ru/mipt/diht/students/elinrin/threads/exception/HandlerOfException.java b/projects/elinrin/src/main/java/ru/mipt/diht/students/elinrin/threads/exception/HandlerOfException.java new file mode 100644 index 0000000..4967b09 --- /dev/null +++ b/projects/elinrin/src/main/java/ru/mipt/diht/students/elinrin/threads/exception/HandlerOfException.java @@ -0,0 +1,23 @@ +package ru.mipt.diht.students.elinrin.threads.exception; + +public class HandlerOfException { + static final String USER_MOD = "user"; + + public static void handler(final String message, final Throwable cause) { + System.err.println(message + ". " + cause.getMessage()); + System.exit(1); + } + public static void handler(final Throwable cause) { + System.err.println(cause.getMessage()); + System.exit(1); + } + + public static void handler(final Throwable cause, final String mod) { + if (mod.equals(USER_MOD)) { + System.err.println(cause.getMessage()); + } else { + System.err.println(cause.getMessage()); + System.exit(1); + } + } +} diff --git a/projects/elinrin/src/main/java/ru/mipt/diht/students/elinrin/threads/exception/UserException.java b/projects/elinrin/src/main/java/ru/mipt/diht/students/elinrin/threads/exception/UserException.java new file mode 100644 index 0000000..da07f59 --- /dev/null +++ b/projects/elinrin/src/main/java/ru/mipt/diht/students/elinrin/threads/exception/UserException.java @@ -0,0 +1,9 @@ +package ru.mipt.diht.students.elinrin.threads.exception; + +public class UserException extends Exception { + + public UserException(final String message) { + super(message); + } +} + diff --git a/projects/elinrin/src/main/java/ru/mipt/diht/students/elinrin/twitterstream/InteractiveParse.java b/projects/elinrin/src/main/java/ru/mipt/diht/students/elinrin/twitterstream/InteractiveParse.java new file mode 100644 index 0000000..bb3238a --- /dev/null +++ b/projects/elinrin/src/main/java/ru/mipt/diht/students/elinrin/twitterstream/InteractiveParse.java @@ -0,0 +1,47 @@ +package ru.mipt.diht.students.elinrin.twitterstream; + +import ru.mipt.diht.students.elinrin.twitterstream.exception.HandlerOfException; +import ru.mipt.diht.students.elinrin.twitterstream.commands.Commands; + +import java.util.NoSuchElementException; +import java.util.Scanner; + +public class InteractiveParse { + static final String USER_MOD = "user"; + + public static void parse(final TwitterProvider twitterPr) { + Scanner in = new Scanner(System.in); + try { + while (true) { + System.out.print("$ "); + String arguments; + arguments = in.nextLine(); + arguments = arguments.trim(); + String[] current = arguments.split("\\s+"); + for (String argument : current) { + argument.trim(); + } + try { + Commands command = Commands.fromString(current); + command.execute(twitterPr); + } catch (NoSuchElementException e) { + HandlerOfException.handler(e, USER_MOD); + } + } + } catch (IllegalMonitorStateException e) { + if (e.getMessage().equals("Exit")) { + in.close(); + System.out.println("Goodbye"); + System.exit(0); + } else { + HandlerOfException.handler(e); + } + } catch (NoSuchElementException e) { + HandlerOfException.handler(e); + } catch (Exception e) { + in.close(); + HandlerOfException.handler(e); + } + in.close(); + } +} diff --git a/projects/elinrin/src/main/java/ru/mipt/diht/students/elinrin/twitterstream/PackageParse.java b/projects/elinrin/src/main/java/ru/mipt/diht/students/elinrin/twitterstream/PackageParse.java new file mode 100644 index 0000000..a4c0bf1 --- /dev/null +++ b/projects/elinrin/src/main/java/ru/mipt/diht/students/elinrin/twitterstream/PackageParse.java @@ -0,0 +1,50 @@ +package ru.mipt.diht.students.elinrin.twitterstream; + + +import ru.mipt.diht.students.elinrin.twitterstream.exception.HandlerOfException; +import ru.mipt.diht.students.elinrin.twitterstream.commands.Commands; + +import java.util.ArrayList; +import java.util.NoSuchElementException; + +public class PackageParse { + static final String USER_MOD = "user"; + + public static void parse(final TwitterProvider twitterPr, final String[] args) { + + + try { + ArrayList current = new ArrayList<>(); + for (int i = 0; i < args.length; ++i) { + current.clear(); + while (i < args.length) { + if (!(args[i].contains(";"))) { + current.add(args[i]); + i++; + } else { + current.add(args[i].substring(0, args[i].indexOf(";"))); + break; + } + } + if (current.isEmpty()) { + return; + } + String[] com = new String[current.size()]; + com = current.toArray(com); + try { + Commands command = Commands.fromString(com); + command.execute(twitterPr); + } catch (NoSuchElementException e) { + HandlerOfException.handler(e, USER_MOD); + } + } + } catch (IllegalMonitorStateException e) { + System.out.println("Goodbye"); + System.exit(0); + } catch (IllegalArgumentException e) { + HandlerOfException.handler("Wrong arguments", e); + } catch (Exception e) { + HandlerOfException.handler(e); + } + } +} diff --git a/projects/elinrin/src/main/java/ru/mipt/diht/students/elinrin/twitterstream/PrintTweet.java b/projects/elinrin/src/main/java/ru/mipt/diht/students/elinrin/twitterstream/PrintTweet.java new file mode 100644 index 0000000..3139321 --- /dev/null +++ b/projects/elinrin/src/main/java/ru/mipt/diht/students/elinrin/twitterstream/PrintTweet.java @@ -0,0 +1,115 @@ +package ru.mipt.diht.students.elinrin.twitterstream; + +import twitter4j.Status; + +import java.time.Duration; +import java.time.LocalDateTime; +import java.time.ZoneId; +import java.util.Date; + +import static java.lang.Math.abs; + +public class PrintTweet { + + static final int LENGTH = 170; + static final int MIN_MOD = 1; + static final int HOUR_MOD = 2; + static final int DAY_MOD = 3; + static final int RETWEET_MOD = 0; + + static final int NOUN_FORM_1 = 0; + static final int NOUN_FORM_2 = 1; + static final int NOUN_FORM_3 = 2; + + static final int ONE = 1; + static final int FIVE = 5; + static final int TEN = 10; + static final int TWENTY = 20; + static final int HUNDRED = 100; + + + static final String BLUE = "\033[34m"; + static final String BLACK = "\033[0m"; + + + static final String[][] NOUN_FORM = { + {"ретвит", "ретвита", "ретвитов" }, + {"минута", "минуты", "минут" }, + {"час", "часа", "часов" }, + {"день", "дня", "дней"} + }; + + public static int pluralForm(final long num) { + long numeral = abs(num) % HUNDRED; + if (numeral > TEN && numeral < TWENTY) { + return NOUN_FORM_3; + } + if ((numeral % TEN) > ONE && (numeral % TEN) < FIVE) { + return NOUN_FORM_2; + } + if ((numeral % TEN) == ONE) { + return NOUN_FORM_1; + } + return NOUN_FORM_3; + } + + public static String tweetDate(final Date givenDate) { + + StringBuilder result = new StringBuilder().append("[ "); + + LocalDateTime givenTime = LocalDateTime.ofInstant(givenDate.toInstant(), ZoneId.systemDefault()); + LocalDateTime nowTime = LocalDateTime.now(); + Duration goneTime = Duration.between(givenTime, nowTime); + + if (goneTime.toMinutes() < 2) { + result.append("Только что"); + } else if (goneTime.toHours() <= 0) { + result.append(goneTime.toMinutes()).append(" ") + .append(NOUN_FORM[MIN_MOD][pluralForm(goneTime.toMinutes())]).append(" назад"); + } else if (goneTime.toDays() <= 0) { + result.append(goneTime.toHours()).append(" ") + .append(NOUN_FORM[HOUR_MOD][pluralForm(goneTime.toHours())]).append(" назад"); + } else if (goneTime.toDays() == 1) { + result.append("Вчера"); + } else { + result.append(goneTime.toDays()).append(" ") + .append(NOUN_FORM[DAY_MOD][pluralForm(goneTime.toDays())]).append(" назад"); + } + return result.append(" ] ").toString(); + } + + public static String print(final Status tweet, final boolean stream) { + StringBuilder result = new StringBuilder(); + + if (!stream) { + result.append(tweetDate(tweet.getCreatedAt())); + } + + result.append(printUserName(tweet)); + + if (tweet.isRetweet()) { + result.append("ретвитнул ").append(printUserName(tweet.getRetweetedStatus())) + .append(tweet.getRetweetedStatus().getText()); + } else { + result.append(tweet.getText()); + } + if (!tweet.isRetweet() && tweet.getRetweetCount() != 0) { + result.append(" (").append(tweet.getRetweetCount()).append(" ") + .append(NOUN_FORM[RETWEET_MOD][pluralForm(tweet.getRetweetCount())]).append(")"); + } + + result.append("\n"); + for (int i = 0; i < LENGTH; i++) { + result.append("-"); + } + + return result.toString(); + } + + public static String printUserName(final Status tweet) { + String result = "@" + BLUE + tweet.getUser().getScreenName() + + BLACK + ": "; + return result; + } + +} diff --git a/projects/elinrin/src/main/java/ru/mipt/diht/students/elinrin/twitterstream/RunTwitter.java b/projects/elinrin/src/main/java/ru/mipt/diht/students/elinrin/twitterstream/RunTwitter.java new file mode 100644 index 0000000..6e9dc03 --- /dev/null +++ b/projects/elinrin/src/main/java/ru/mipt/diht/students/elinrin/twitterstream/RunTwitter.java @@ -0,0 +1,24 @@ +package ru.mipt.diht.students.elinrin.twitterstream; + +import ru.mipt.diht.students.elinrin.twitterstream.exception.HandlerOfException; +import twitter4j.Twitter; +import twitter4j.TwitterFactory; + +public class RunTwitter { + public static void main(final String[] args) { + + + + try { + Twitter twitter = new TwitterFactory().getInstance(); + TwitterProvider twitterPr = new TwitterProvider(twitter); + if (args.length == 0) { + InteractiveParse.parse(twitterPr); + } else { + PackageParse.parse(twitterPr, args); + } + } catch (IllegalArgumentException e) { + HandlerOfException.handler(e); + } + } +} diff --git a/projects/elinrin/src/main/java/ru/mipt/diht/students/elinrin/twitterstream/TwitterProvider.java b/projects/elinrin/src/main/java/ru/mipt/diht/students/elinrin/twitterstream/TwitterProvider.java new file mode 100644 index 0000000..1572be6 --- /dev/null +++ b/projects/elinrin/src/main/java/ru/mipt/diht/students/elinrin/twitterstream/TwitterProvider.java @@ -0,0 +1,40 @@ +package ru.mipt.diht.students.elinrin.twitterstream; + + +import twitter4j.Twitter; + +public class TwitterProvider { + private Twitter twitter; + private boolean hideRetweets; + private String place; + + public TwitterProvider(final Twitter twitterUser) { + + twitter = twitterUser; + hideRetweets = false; + place = " "; + } + + public final void changeParameterRetweets(final boolean parameter) { + hideRetweets = parameter; + } + + public final void changeParameterPlase(final String parameter) { + place = parameter; + } + + + public final Twitter twitter() { + return twitter; + } + + public final boolean isHideRetweets() { + return hideRetweets; + } + + public final String getPlace() { + return place; + } + + +} diff --git a/projects/elinrin/src/main/java/ru/mipt/diht/students/elinrin/twitterstream/commands/Commands.java b/projects/elinrin/src/main/java/ru/mipt/diht/students/elinrin/twitterstream/commands/Commands.java new file mode 100644 index 0000000..2b598e6 --- /dev/null +++ b/projects/elinrin/src/main/java/ru/mipt/diht/students/elinrin/twitterstream/commands/Commands.java @@ -0,0 +1,54 @@ +package ru.mipt.diht.students.elinrin.twitterstream.commands; + + +import ru.mipt.diht.students.elinrin.twitterstream.TwitterProvider; + +import java.util.HashMap; +import java.util.NoSuchElementException; + +public abstract class Commands { + private static final HashMap COMMANDS; + static { + COMMANDS = new HashMap<>(); + COMMANDS.put("--query", new QueryCommand()); + COMMANDS.put("-q", new QueryCommand()); + COMMANDS.put("--place", new PlaceCommand()); + COMMANDS.put("-p", new PlaceCommand()); + COMMANDS.put("--stream", new StreamCommand()); + COMMANDS.put("-s", new StreamCommand()); + COMMANDS.put("--hideRetweets", new HideCommand()); + COMMANDS.put("-hRtws", new HideCommand()); + COMMANDS.put("--limit", new LimitCommand()); + COMMANDS.put("-l", new LimitCommand()); + COMMANDS.put("--help", new HelpCommand()); + COMMANDS.put("-h", new HelpCommand()); + COMMANDS.put("-e", new ExitCommand()); + COMMANDS.put("-exit", new ExitCommand()); + } + + public static Commands fromString(final String[] arguments) { + if (arguments[0].equals("")) { + throw new NoSuchElementException(""); + } + + if (COMMANDS.containsKey(arguments[0])) { + Commands command = COMMANDS.get(arguments[0]); + if (arguments.length - 1 != command.numberOfArguments()) { + throw new NoSuchElementException("Unexpected number of arguments: " + + command.numberOfArguments() + " required"); + } + + command.putArguments(arguments); + return command; + } else { + throw new NoSuchElementException(arguments[0] + " is unknown command"); + } + } + + public abstract void execute(TwitterProvider twitter); + + protected void putArguments(final String[] args) { + } + + protected abstract int numberOfArguments(); +} diff --git a/projects/elinrin/src/main/java/ru/mipt/diht/students/elinrin/twitterstream/commands/ExitCommand.java b/projects/elinrin/src/main/java/ru/mipt/diht/students/elinrin/twitterstream/commands/ExitCommand.java new file mode 100644 index 0000000..c2d029e --- /dev/null +++ b/projects/elinrin/src/main/java/ru/mipt/diht/students/elinrin/twitterstream/commands/ExitCommand.java @@ -0,0 +1,16 @@ +package ru.mipt.diht.students.elinrin.twitterstream.commands; + +import ru.mipt.diht.students.elinrin.twitterstream.TwitterProvider; + +public class ExitCommand extends Commands { + + @Override + public final void execute(final TwitterProvider twitter) { + throw new IllegalMonitorStateException("Exit"); + } + + @Override + protected final int numberOfArguments() { + return 0; + } +} diff --git a/projects/elinrin/src/main/java/ru/mipt/diht/students/elinrin/twitterstream/commands/HelpCommand.java b/projects/elinrin/src/main/java/ru/mipt/diht/students/elinrin/twitterstream/commands/HelpCommand.java new file mode 100644 index 0000000..3b39442 --- /dev/null +++ b/projects/elinrin/src/main/java/ru/mipt/diht/students/elinrin/twitterstream/commands/HelpCommand.java @@ -0,0 +1,39 @@ +package ru.mipt.diht.students.elinrin.twitterstream.commands; + +import ru.mipt.diht.students.elinrin.twitterstream.TwitterProvider; + +public class HelpCommand extends Commands { + static final String LIGHT_BLUE = "\033[36m"; + static final String PURPLE = "\033[35m"; + static final String BLACK = "\033[0m"; + + @Override + public final void execute(final TwitterProvider twitter) { + + System.out.println(PURPLE + "Параметры\n" + + LIGHT_BLUE + "stream " + BLACK + + "- равномерно и непрерывно с задержкой в 1 секунду печатает твиты на экран. [--stream|-s]\n" + + LIGHT_BLUE + "limit " + BLACK + + "- n твитов. [--limit|-l ]\n" + + LIGHT_BLUE + "query " + BLACK + + " - поиск по заданному запросу. [--query|-q )]\n" + + LIGHT_BLUE + "place " + BLACK + + "- поиск по заданному региону. [--place|-p ]\n" + + LIGHT_BLUE + "allPlace " + BLACK + + "- отменить place режим. [--place|-p 0]\n" + + LIGHT_BLUE + "hideRetweets " + BLACK + + "- филтр ретвитов. [--hideRetweets|-hRtws +]\n" + + LIGHT_BLUE + "Retweets " + BLACK + + "- отменить hideRetweets режим. [--hideRetweets|-hRtws -]\n" + + LIGHT_BLUE + "help " + BLACK + + "- печатает справку. [--help|-h]\n" + + LIGHT_BLUE + "exit " + BLACK + + "- выход. [--exit|-e]\n"); + + } + + @Override + protected final int numberOfArguments() { + return 0; + } +} diff --git a/projects/elinrin/src/main/java/ru/mipt/diht/students/elinrin/twitterstream/commands/HideCommand.java b/projects/elinrin/src/main/java/ru/mipt/diht/students/elinrin/twitterstream/commands/HideCommand.java new file mode 100644 index 0000000..c86a1c6 --- /dev/null +++ b/projects/elinrin/src/main/java/ru/mipt/diht/students/elinrin/twitterstream/commands/HideCommand.java @@ -0,0 +1,32 @@ +package ru.mipt.diht.students.elinrin.twitterstream.commands; + + +import ru.mipt.diht.students.elinrin.twitterstream.TwitterProvider; + +import java.util.NoSuchElementException; + +public class HideCommand extends Commands { + private String parameter; + @Override + public final void execute(final TwitterProvider twitterPr) { + if (parameter.equals("+")) { + twitterPr.changeParameterRetweets(true); + } else { + twitterPr.changeParameterRetweets(false); + } + } + + @Override + protected final int numberOfArguments() { + return 1; + } + + @Override + protected final void putArguments(final String[] args) { + if (!((args[1].equals("+")) || (args[1].equals("-")))) { + throw new NoSuchElementException("Wrong second arguments. Expected + or -. "); + } + parameter = args[1]; + } + +} diff --git a/projects/elinrin/src/main/java/ru/mipt/diht/students/elinrin/twitterstream/commands/LimitCommand.java b/projects/elinrin/src/main/java/ru/mipt/diht/students/elinrin/twitterstream/commands/LimitCommand.java new file mode 100644 index 0000000..1aea04b --- /dev/null +++ b/projects/elinrin/src/main/java/ru/mipt/diht/students/elinrin/twitterstream/commands/LimitCommand.java @@ -0,0 +1,46 @@ +package ru.mipt.diht.students.elinrin.twitterstream.commands; + +import ru.mipt.diht.students.elinrin.twitterstream.TwitterProvider; +import ru.mipt.diht.students.elinrin.twitterstream.exception.HandlerOfException; +import ru.mipt.diht.students.elinrin.twitterstream.PrintTweet; +import twitter4j.Status; +import twitter4j.TwitterException; + +import java.util.List; + +public class LimitCommand extends Commands { + private int number; + + @Override + public final void execute(final TwitterProvider twitterPr) { + + + List statusList = null; + try { + statusList = twitterPr.twitter().getHomeTimeline(); + + } catch (TwitterException e) { + HandlerOfException.handler(e); + } + for (Status status: statusList) { + if ((!twitterPr.isHideRetweets()) || !(status.isRetweet())) { + System.out.println(new PrintTweet().print(status, false)); + } + number -= 1; + if (number == 0) { + break; + } + } + + } + + @Override + protected final int numberOfArguments() { + return 1; + } + + @Override + protected final void putArguments(final String[] args) { + number = Integer.parseInt(args[1]); + } +} diff --git a/projects/elinrin/src/main/java/ru/mipt/diht/students/elinrin/twitterstream/commands/PlaceCommand.java b/projects/elinrin/src/main/java/ru/mipt/diht/students/elinrin/twitterstream/commands/PlaceCommand.java new file mode 100644 index 0000000..1bf62b2 --- /dev/null +++ b/projects/elinrin/src/main/java/ru/mipt/diht/students/elinrin/twitterstream/commands/PlaceCommand.java @@ -0,0 +1,26 @@ +package ru.mipt.diht.students.elinrin.twitterstream.commands; + + +import ru.mipt.diht.students.elinrin.twitterstream.TwitterProvider; + +public class PlaceCommand extends Commands { + + private String searchPlace; + + @Override + public final void execute(final TwitterProvider twitterPr) { + + twitterPr.changeParameterPlase(searchPlace); + + } + + @Override + protected final int numberOfArguments() { + return 1; + } + + @Override + protected final void putArguments(final String[] args) { + searchPlace = args[1]; + } +} diff --git a/projects/elinrin/src/main/java/ru/mipt/diht/students/elinrin/twitterstream/commands/QueryCommand.java b/projects/elinrin/src/main/java/ru/mipt/diht/students/elinrin/twitterstream/commands/QueryCommand.java new file mode 100644 index 0000000..99f7c86 --- /dev/null +++ b/projects/elinrin/src/main/java/ru/mipt/diht/students/elinrin/twitterstream/commands/QueryCommand.java @@ -0,0 +1,43 @@ +package ru.mipt.diht.students.elinrin.twitterstream.commands; + +import ru.mipt.diht.students.elinrin.twitterstream.TwitterProvider; +import ru.mipt.diht.students.elinrin.twitterstream.exception.HandlerOfException; +import ru.mipt.diht.students.elinrin.twitterstream.PrintTweet; +import twitter4j.Query; +import twitter4j.QueryResult; +import twitter4j.Status; +import twitter4j.TwitterException; + +public class QueryCommand extends Commands { + + private String searchString; + + @Override + public final void execute(final TwitterProvider twitterPr) { + + Query query = new Query(searchString); + QueryResult result = null; + try { + result = twitterPr.twitter().search(query); + } catch (TwitterException e) { + HandlerOfException.handler(e); + } + for (Status status : result.getTweets()) { + if ((!twitterPr.isHideRetweets()) || !(status.isRetweet())) { + System.out.println(new PrintTweet().print(status, false)); + + } + } + + } + + @Override + protected final int numberOfArguments() { + return 1; + } + + @Override + protected final void putArguments(final String[] args) { + searchString = args[1]; + } +} diff --git a/projects/elinrin/src/main/java/ru/mipt/diht/students/elinrin/twitterstream/commands/StreamCommand.java b/projects/elinrin/src/main/java/ru/mipt/diht/students/elinrin/twitterstream/commands/StreamCommand.java new file mode 100644 index 0000000..9e77163 --- /dev/null +++ b/projects/elinrin/src/main/java/ru/mipt/diht/students/elinrin/twitterstream/commands/StreamCommand.java @@ -0,0 +1,43 @@ +package ru.mipt.diht.students.elinrin.twitterstream.commands; + +import ru.mipt.diht.students.elinrin.twitterstream.PrintTweet; +import ru.mipt.diht.students.elinrin.twitterstream.TwitterProvider; +import ru.mipt.diht.students.elinrin.twitterstream.exception.HandlerOfException; +import twitter4j.Status; +import twitter4j.TwitterException; + +import java.util.List; + +import static java.lang.Thread.sleep; + +public class StreamCommand extends Commands { + + static final int SLEEP_TIME = 1000; + @Override + public final void execute(final TwitterProvider twitterPr) { + + List statusList = null; + try { + statusList = twitterPr.twitter().getHomeTimeline(); + } catch (TwitterException e) { + HandlerOfException.handler(e); + } + for (Status status: statusList) { + if ((!twitterPr.isHideRetweets()) || !(status.isRetweet())) { + System.out.println(new PrintTweet().print(status, false)); + } + + try { + sleep(SLEEP_TIME); + } catch (InterruptedException e) { + e.printStackTrace(); + } + } + } + + @Override + protected final int numberOfArguments() { + return 0; + } + +} diff --git a/projects/elinrin/src/main/java/ru/mipt/diht/students/elinrin/twitterstream/exception/HandlerOfException.java b/projects/elinrin/src/main/java/ru/mipt/diht/students/elinrin/twitterstream/exception/HandlerOfException.java new file mode 100644 index 0000000..a057f1a --- /dev/null +++ b/projects/elinrin/src/main/java/ru/mipt/diht/students/elinrin/twitterstream/exception/HandlerOfException.java @@ -0,0 +1,23 @@ +package ru.mipt.diht.students.elinrin.twitterstream.exception; + +public class HandlerOfException { + static final String USER_MOD = "user"; + + public static void handler(final String message, final Throwable cause) { + System.err.println(message + ". " + cause.getMessage()); + System.exit(1); + } + public static void handler(final Throwable cause) { + System.err.println(cause.getMessage()); + System.exit(1); + } + + public static void handler(final Throwable cause, final String mod) { + if (mod.equals(USER_MOD)) { + System.err.println(cause.getMessage()); + } else { + System.err.println(cause.getMessage()); + System.exit(1); + } + } +} diff --git a/projects/elinrin/src/main/resourses/db.properties b/projects/elinrin/src/main/resourses/db.properties new file mode 100644 index 0000000..8a47781 --- /dev/null +++ b/projects/elinrin/src/main/resourses/db.properties @@ -0,0 +1,3 @@ +connection_name=jdbc:h2:~/test +username=test +password=test \ No newline at end of file diff --git a/projects/elinrin/src/test/java/ru/mipt/diht/students/elinrin/miniorm/AppTest.java b/projects/elinrin/src/test/java/ru/mipt/diht/students/elinrin/miniorm/AppTest.java new file mode 100644 index 0000000..3593c8d --- /dev/null +++ b/projects/elinrin/src/test/java/ru/mipt/diht/students/elinrin/miniorm/AppTest.java @@ -0,0 +1,38 @@ +package ru.mipt.diht.students.elinrin.miniorm; + +import junit.framework.Test; +import junit.framework.TestCase; +import junit.framework.TestSuite; + +/** + * Unit test for simple App. + */ +public class AppTest + extends TestCase +{ + /** + * Create the test case + * + * @param testName name of the test case + */ + public AppTest( String testName ) + { + super( testName ); + } + + /** + * @return the suite of tests being tested + */ + public static Test suite() + { + return new TestSuite( AppTest.class ); + } + + /** + * Rigourous Test :-) + */ + public void testApp() + { + assertTrue( true ); + } +} diff --git a/projects/elinrin/src/test/java/ru/mipt/diht/students/elinrin/threads/AppTest.java b/projects/elinrin/src/test/java/ru/mipt/diht/students/elinrin/threads/AppTest.java new file mode 100644 index 0000000..931b809 --- /dev/null +++ b/projects/elinrin/src/test/java/ru/mipt/diht/students/elinrin/threads/AppTest.java @@ -0,0 +1,38 @@ +package ru.mipt.diht.students.elinrin.threads; + +import junit.framework.Test; +import junit.framework.TestCase; +import junit.framework.TestSuite; + +/** + * Unit test for simple App. + */ +public class AppTest + extends TestCase +{ + /** + * Create the test case + * + * @param testName name of the test case + */ + public AppTest( String testName ) + { + super( testName ); + } + + /** + * @return the suite of tests being tested + */ + public static Test suite() + { + return new TestSuite( AppTest.class ); + } + + /** + * Rigourous Test :-) + */ + public void testApp() + { + assertTrue( true ); + } +} diff --git a/projects/pom.xml b/projects/pom.xml index 5d14966..a7a8bc2 100644 --- a/projects/pom.xml +++ b/projects/pom.xml @@ -30,6 +30,7 @@ dkhurtin ale3otik Pitovsky + elinrin