diff --git a/okalitova/pom.xml b/okalitova/pom.xml index 2ee9231d..ccef77e5 100644 --- a/okalitova/pom.xml +++ b/okalitova/pom.xml @@ -16,12 +16,6 @@ UTF-8 - - junit - junit - 3.8.1 - test - org.twitter4j @@ -53,5 +47,17 @@ 0.4 + + junit + junit + 4.12 + + + + com.h2database + h2 + 1.4.190 + + diff --git a/okalitova/src/main/java/ru/fizteh/fivt/students/okalitova/collectionsql/Aggregates.java b/okalitova/src/main/java/ru/fizteh/fivt/students/okalitova/collectionsql/Aggregates.java new file mode 100644 index 00000000..e0a2d198 --- /dev/null +++ b/okalitova/src/main/java/ru/fizteh/fivt/students/okalitova/collectionsql/Aggregates.java @@ -0,0 +1,27 @@ +package ru.fizteh.fivt.students.okalitova.collectionsql; + +import ru.fizteh.fivt.students.okalitova.collectionsql.Aggregators.Avg; +import ru.fizteh.fivt.students.okalitova.collectionsql.Aggregators.Count; +import ru.fizteh.fivt.students.okalitova.collectionsql.Aggregators.Max; +import ru.fizteh.fivt.students.okalitova.collectionsql.Aggregators.Min; + +import java.util.function.Function; + +public class Aggregates { + public static Function max(Function expression) { + return new Max<>(expression); + } + + public static > Function min(Function expression) { + return new Min<>(expression); + } + + public static Function count(Function expression) { + return new Count<>(expression); + } + + public static Function avg(Function expression) { + return new Avg<>(expression); + } + +} diff --git a/okalitova/src/main/java/ru/fizteh/fivt/students/okalitova/collectionsql/Aggregators/Aggregator.java b/okalitova/src/main/java/ru/fizteh/fivt/students/okalitova/collectionsql/Aggregators/Aggregator.java new file mode 100644 index 00000000..1109cc26 --- /dev/null +++ b/okalitova/src/main/java/ru/fizteh/fivt/students/okalitova/collectionsql/Aggregators/Aggregator.java @@ -0,0 +1,11 @@ +package ru.fizteh.fivt.students.okalitova.collectionsql.Aggregators; + +import java.util.List; +import java.util.function.Function; + +/** + * Created by nimloth on 16.12.15. + */ +public interface Aggregator extends Function { + R apply(List elements); +} diff --git a/okalitova/src/main/java/ru/fizteh/fivt/students/okalitova/collectionsql/Aggregators/Avg.java b/okalitova/src/main/java/ru/fizteh/fivt/students/okalitova/collectionsql/Aggregators/Avg.java new file mode 100644 index 00000000..606af628 --- /dev/null +++ b/okalitova/src/main/java/ru/fizteh/fivt/students/okalitova/collectionsql/Aggregators/Avg.java @@ -0,0 +1,33 @@ +package ru.fizteh.fivt.students.okalitova.collectionsql.Aggregators; + +/** + * Created by nimloth on 17.12.15. + */ +import java.util.List; +import java.util.function.Function; + +public class Avg implements Aggregator { + + private Function function; + public Avg(Function expression) { + this.function = expression; + } + + @Override + public Double apply(List elements) { + return elements + .stream() + .map(function) + .mapToDouble(element -> (Double) element) + .average() + .getAsDouble(); + } + + @Override + public Double apply(T t) { + return null; + } +} + + + diff --git a/okalitova/src/main/java/ru/fizteh/fivt/students/okalitova/collectionsql/Aggregators/Count.java b/okalitova/src/main/java/ru/fizteh/fivt/students/okalitova/collectionsql/Aggregators/Count.java new file mode 100644 index 00000000..ccc24aed --- /dev/null +++ b/okalitova/src/main/java/ru/fizteh/fivt/students/okalitova/collectionsql/Aggregators/Count.java @@ -0,0 +1,30 @@ +package ru.fizteh.fivt.students.okalitova.collectionsql.Aggregators; + +import java.util.List; +import java.util.function.Function; + +/** + * Created by nimloth on 17.12.15. + */ +public class Count implements Aggregator { + + private Function function; + public Count(Function expression) { + this.function = expression; + } + + @Override + public Long apply(List elements) { + Long longAns = elements + .stream() + .map(function) + .distinct() + .count(); + return longAns; + } + + @Override + public Long apply(T t) { + return null; + } +} diff --git a/okalitova/src/main/java/ru/fizteh/fivt/students/okalitova/collectionsql/Aggregators/Max.java b/okalitova/src/main/java/ru/fizteh/fivt/students/okalitova/collectionsql/Aggregators/Max.java new file mode 100644 index 00000000..a102d8d4 --- /dev/null +++ b/okalitova/src/main/java/ru/fizteh/fivt/students/okalitova/collectionsql/Aggregators/Max.java @@ -0,0 +1,29 @@ +package ru.fizteh.fivt.students.okalitova.collectionsql.Aggregators; + +import java.util.List; +import java.util.function.Function; + +/** + * Created by nimloth on 16.12.15. + */ +public class Max> implements Aggregator { + + private Function function; + public Max(Function expression) { + this.function = expression; + } + + @Override + public R apply(List elements) { + return elements + .stream() + .map(function) + .max(R::compareTo) + .get(); + } + + @Override + public R apply(T t) { + return null; + } +} diff --git a/okalitova/src/main/java/ru/fizteh/fivt/students/okalitova/collectionsql/Aggregators/Min.java b/okalitova/src/main/java/ru/fizteh/fivt/students/okalitova/collectionsql/Aggregators/Min.java new file mode 100644 index 00000000..00e16c2a --- /dev/null +++ b/okalitova/src/main/java/ru/fizteh/fivt/students/okalitova/collectionsql/Aggregators/Min.java @@ -0,0 +1,29 @@ +package ru.fizteh.fivt.students.okalitova.collectionsql.Aggregators; + +import java.util.List; +import java.util.function.Function; + +/** + * Created by nimloth on 17.12.15. + */ +public class Min> implements Aggregator { + + private Function function; + public Min(Function expression) { + this.function = expression; + } + + @Override + public R apply(List elements) { + return elements + .stream() + .map(function) + .min(R::compareTo) + .get(); + } + + @Override + public R apply(T t) { + return null; + } +} diff --git a/okalitova/src/main/java/ru/fizteh/fivt/students/okalitova/collectionsql/CollectionsQL.java b/okalitova/src/main/java/ru/fizteh/fivt/students/okalitova/collectionsql/CollectionsQL.java new file mode 100644 index 00000000..46d14e03 --- /dev/null +++ b/okalitova/src/main/java/ru/fizteh/fivt/students/okalitova/collectionsql/CollectionsQL.java @@ -0,0 +1,276 @@ +package ru.fizteh.fivt.students.okalitova.collectionsql; + +import java.lang.reflect.InvocationTargetException; +import java.time.LocalDate; +import java.time.LocalDateTime; +import java.time.temporal.ChronoUnit; + +/** + * Created by nimloth on 16.12.15. + */ +public class CollectionsQL { + + public static void main(String[] args) throws InvocationTargetException, NoSuchMethodException, + InstantiationException, IllegalAccessException { + } + + + public static class Student { + private final String name; + + private final LocalDate dateOfBith; + + private final String group; + + public String getName() { + return name; + } + + public Student(String name, LocalDate dateOfBith, String group) { + this.name = name; + this.dateOfBith = dateOfBith; + this.group = group; + } + + public LocalDate getDateOfBith() { + return dateOfBith; + } + + public String getGroup() { + return group; + } + + public long age() { + return ChronoUnit.YEARS.between(getDateOfBith(), LocalDateTime.now()); + } + + public static Student student(String name, LocalDate dateOfBith, String group) { + return new Student(name, dateOfBith, group); + } + + @Override + public String toString() { + return "Student{" + + "name='" + name + '\'' + + ", dateOfBith=" + dateOfBith + + ", group=" + group + + '}'; + } + + + + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (o == null || getClass() != o.getClass()) { + return false; + } + + Student student = (Student) o; + + if (name != null) { + if (!name.equals(student.name)) { + return false; + } + } else { + if (student.name != null) { + return false; + } + } + if (dateOfBith != null) { + if (!dateOfBith.equals(student.dateOfBith)) { + return false; + } + } else { + if (student.dateOfBith != null) { + return false; + } + } + if (group != null) { + return !!group.equals(student.group); + } else { + return !(student.group != null); + } + + } + + @Override + public int hashCode() { + int result; + if (name != null) { + result = name.hashCode(); + } else { + result = 0; + } + if (dateOfBith != null) { + result = 31 * result + dateOfBith.hashCode(); + } else { + result = 31 * result + 0; + } + if (group != null) { + result = 31 * result + group.hashCode(); + } else { + result = 31 * result + 0; + } + return result; + } + } + + public static class Group { + private final String group; + private final String mentor; + + public Group(String group, String mentor) { + this.group = group; + this.mentor = mentor; + } + + public String getGroup() { + return group; + } + + public String getMentor() { + return mentor; + } + + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (o == null || getClass() != o.getClass()) { + return false; + } + + Group group1 = (Group) o; + + if (group != null) { + if (!group.equals(group1.group)) { + return false; + } + } else { + if (group1.group != null) { + return false; + } + } + if (mentor != null) { + return !!mentor.equals(group1.mentor); + } else { + return !(group1.mentor != null); + } + + } + + @Override + public int hashCode() { + int result; + if (group != null) { + result = group.hashCode(); + } else { + result = 0; + } + if (mentor != null) { + result = 31 * result + mentor.hashCode(); + } else { + result = 31 * result + 0; + } + return result; + } + } + + + public static class Statistics { + + private final String group; + private Long count = Long.valueOf(0); + private final Long age; + + public String getGroup() { + return group; + } + + public Long getCount() { + return count; + } + + public Long getAge() { + return age; + } + + public Statistics(String group, Long age, Long count) { + this.group = group; + this.count = count; + this.age = age; + } + + @Override + public String toString() { + return "Statistics{" + + "group='" + group + '\'' + + ", count=" + count + + ", age=" + age + + '}'; + } + + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (o == null || getClass() != o.getClass()) { + return false; + } + + Statistics that = (Statistics) o; + + if (group != null) { + if (!group.equals(that.group)) { + return false; + } + } else { + if (that.group != null) { + return false; + } + } + if (count != null) { + if (!count.equals(that.count)) { + return false; + } + } else { + if (that.count != null) { + return false; + } + } + if (age != null) { + return !!age.equals(that.age); + } else { + return !(that.age != null); + } + + } + + @Override + public int hashCode() { + int result; + if (group != null) { + result = group.hashCode(); + } else { + result = 0; + } + if (count != null) { + result = 31 * result + count.hashCode(); + } else { + result = 31 * result + 0; + } + if (age != null) { + result = 31 * result + age.hashCode(); + } else { + result = 31 * result + 0; + } + return result; + } + } + +} diff --git a/okalitova/src/main/java/ru/fizteh/fivt/students/okalitova/collectionsql/Conditions.java b/okalitova/src/main/java/ru/fizteh/fivt/students/okalitova/collectionsql/Conditions.java new file mode 100644 index 00000000..23041f81 --- /dev/null +++ b/okalitova/src/main/java/ru/fizteh/fivt/students/okalitova/collectionsql/Conditions.java @@ -0,0 +1,23 @@ +package ru.fizteh.fivt.students.okalitova.collectionsql; + +import java.util.function.Function; +import java.util.function.Predicate; + +/** + * Created by nimloth on 16.12.15. + */ +public class Conditions { + public static Predicate rlike(Function expression, + String regexp) { + return (item -> expression.apply(item).matches(regexp)); + } + + public static Predicate like(Function expression, + String pattern) { + return (item -> expression.apply(item).equals(pattern)); + } + + public static Predicate notNull(Function expression) { + return (item -> !expression.apply(item).equals(null)); + } +} diff --git a/okalitova/src/main/java/ru/fizteh/fivt/students/okalitova/collectionsql/From.java b/okalitova/src/main/java/ru/fizteh/fivt/students/okalitova/collectionsql/From.java new file mode 100644 index 00000000..450b6ef4 --- /dev/null +++ b/okalitova/src/main/java/ru/fizteh/fivt/students/okalitova/collectionsql/From.java @@ -0,0 +1,87 @@ +package ru.fizteh.fivt.students.okalitova.collectionsql; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.function.BiPredicate; +import java.util.function.Function; + +/** + * Created by nimloth on 16.12.15. + */ +public class From { + private List elements = new ArrayList<>(); + + public From(Iterable initElements) { + for (T elem : initElements) { + elements.add(elem); + } + } + + public static From from(Iterable iterable) { + return new From<>(iterable); + } + + public Select select(Class myClass, + Function... functions) { + return new Select<>(elements, myClass, false, functions); + } + + public Select selectDistinct(Class myClass, + Function... functions) { + return new Select<>(elements, myClass, true, functions); + } + public final Select> select(Function first, Function second) { + return new Select<>(elements, false, first, second); + } + + + public Join join(Iterable iterable) { + return new Join<>(elements, iterable); + } + + public class Join { + private List firstElements = new ArrayList<>(); + private List secondElements = new ArrayList<>(); + private List> elements = new ArrayList<>(); + Join(List initElements, Iterable initIterable) { + for (T elem : initElements) { + firstElements.add(elem); + } + for (J it : initIterable) { + secondElements.add(it); + } + } + public From> on(BiPredicate predicate) { + for (T first : firstElements) { + for (J second : secondElements) { + if (predicate.test(first, second)) { + elements.add(new Tuple<>(first, second)); + } + } + } + return new From<>(elements); + } + + public > From> on( + Function leftKey, + Function rightKey) { + HashMap> map = new HashMap<>(); + for (J element : secondElements) { + K key = rightKey.apply(element); + if (!map.containsKey(key)) { + map.put(key, new ArrayList<>()); + } + map.get(key).add(element); + } + for (T first : firstElements) { + K key = leftKey.apply(first); + if (map.containsKey(key)) { + List second = map.get(key); + second.forEach(s -> elements.add(new Tuple<>(first, s))); + } + } + return new From<>(elements); + } + } +} diff --git a/okalitova/src/main/java/ru/fizteh/fivt/students/okalitova/collectionsql/OrderByConditions.java b/okalitova/src/main/java/ru/fizteh/fivt/students/okalitova/collectionsql/OrderByConditions.java new file mode 100644 index 00000000..61790c13 --- /dev/null +++ b/okalitova/src/main/java/ru/fizteh/fivt/students/okalitova/collectionsql/OrderByConditions.java @@ -0,0 +1,17 @@ +package ru.fizteh.fivt.students.okalitova.collectionsql; + +import java.util.Comparator; +import java.util.function.Function; + +/** + * Created by nimloth on 17.12.15. + */ +public class OrderByConditions { + public static > Comparator asc(Function expression) { + return (o1, o2) -> expression.apply(o1).compareTo(expression.apply(o2)); + } + + public static > Comparator desc(Function expression) { + return (o1, o2) -> expression.apply(o2).compareTo(expression.apply(o1)); + } +} diff --git a/okalitova/src/main/java/ru/fizteh/fivt/students/okalitova/collectionsql/Select.java b/okalitova/src/main/java/ru/fizteh/fivt/students/okalitova/collectionsql/Select.java new file mode 100644 index 00000000..d46f22d9 --- /dev/null +++ b/okalitova/src/main/java/ru/fizteh/fivt/students/okalitova/collectionsql/Select.java @@ -0,0 +1,175 @@ +package ru.fizteh.fivt.students.okalitova.collectionsql; + +import ru.fizteh.fivt.students.okalitova.collectionsql.Aggregators.Aggregator; + +import java.lang.reflect.InvocationTargetException; +import java.util.*; +import java.util.function.Function; +import java.util.function.Predicate; +import java.util.stream.Collectors; + +/** + * Created by nimloth on 16.12.15. + */ +public class Select { + private Iterable iterable; + private Class myClass; + private Class joinClass; + private boolean distinct; + private boolean isJoin = false; + private Function[] functions; + + private Predicate wherePredicate; + private Predicate havingPredicate; + + private int limit = -1; + private Function[] groupByFunctions; + private Comparator[] comporators; + + + public Select(Iterable initIterable, + Class initClass, + boolean initDistinct, + Function[] initFunctions) { + iterable = initIterable; + myClass = initClass; + distinct = initDistinct; + functions = initFunctions; + } + + public Select(List initElements, boolean isDistinct, Function first, Function second) { + iterable = initElements; + joinClass = initElements.get(0).getClass(); + distinct = isDistinct; + functions = new Function[]{first, second}; + isJoin = true; + } + + public Select where(Predicate initPredicate) { + wherePredicate = initPredicate; + return this; + } + + public Select limit(int initLimit) { + limit = initLimit; + return this; + } + + public Select groupBy(Function... initGroupByFunctions) { + groupByFunctions = initGroupByFunctions; + distinct = true; + return this; + } + + public Select having(Predicate initHavingPredicate) { + havingPredicate = initHavingPredicate; + return this; + } + + public Select orderBy(Comparator... initComparators) { + comporators = initComparators; + return this; + } + + public List execute() throws IllegalAccessException, + InvocationTargetException, InstantiationException { + List elements = new ArrayList<>(); + for (T it : iterable) { + elements.add(it); + } + + if (wherePredicate != null) { + elements = elements.stream().filter(wherePredicate).collect(Collectors.toList()); + } + + if (distinct) { + elements = elements.stream().distinct().collect(Collectors.toList()); + } + + if (limit != -1) { + elements = elements.stream().limit(limit).collect(Collectors.toList()); + } + + Map> resultMap = new HashMap<>(); + if (groupByFunctions != null) { + Map> groupByResult = elements.stream().collect(Collectors.groupingBy((T elem) -> { + List list = new ArrayList(); + for (int i = 0; i < groupByFunctions.length; ++i) { + list.add(groupByFunctions[i].apply(elem)); + } + return list.hashCode(); + })); + for (Integer key : groupByResult.keySet()) { + resultMap.put(key, groupByResult.get(key)); + } + } else { + resultMap.put(0, elements); + } + + List result = new ArrayList<>(); + for (Integer key : resultMap.keySet()) { + List currentResult = new ArrayList<>(); + if (groupByFunctions == null) { + for (T element : resultMap.get(key)) { + for (int i = 0; i < functions.length; ++i) { + currentResult.add(functions[i].apply(element)); + } + } + } else { + for (int i = 0; i < functions.length; ++i) { + if (functions[i] instanceof Aggregator) { + currentResult.add(((Aggregator) functions[i]).apply(resultMap.get(key))); + } else { + currentResult.add(functions[i].apply(resultMap.get(key).get(0))); + } + } + } + + Class[] returnClasses = new Class[functions.length]; + for (int j = 0; j < currentResult.size() + / functions.length; ++j) { + Object[] arguments = new Object[functions.length]; + for (int i = 0; i < arguments.length; ++i) { + arguments[i] = currentResult.get(j * arguments.length + i); + if (arguments[i] != null) { + returnClasses[i] = arguments[i].getClass(); + } else { + throw new IllegalStateException("Null result of operation"); + } + } + + if (isJoin) { + isJoin = false; + // Tuple addItem = new joinClass.get(arguments[0], arguments[1]); + // if (havingPredicate == null || havingPredicate.test((R) addItem)) { + // result.add((R) addItem); + // } + } else { + + R addItem = null; + try { + addItem = myClass + .getConstructor(returnClasses) + .newInstance(arguments); + } catch (NoSuchMethodException e) { + e.printStackTrace(); + e.getMessage(); + } + if (havingPredicate == null || havingPredicate.test(addItem)) { + result.add(addItem); + } + } + } + } + if (comporators != null) { + for (Comparator compare : comporators) { + result.sort(compare); + } + } + return result; + } + + public Union union() { + return new Union(this); + } +} diff --git a/okalitova/src/main/java/ru/fizteh/fivt/students/okalitova/collectionsql/Sources.java b/okalitova/src/main/java/ru/fizteh/fivt/students/okalitova/collectionsql/Sources.java new file mode 100644 index 00000000..eec05b8c --- /dev/null +++ b/okalitova/src/main/java/ru/fizteh/fivt/students/okalitova/collectionsql/Sources.java @@ -0,0 +1,55 @@ +package ru.fizteh.fivt.students.okalitova.collectionsql; + +import java.io.InputStream; +import java.nio.file.Path; +import java.util.Arrays; +import java.util.List; +import java.util.Set; +import java.util.stream.Stream; + +/** + * Helper methods to create collections. + * + * @author akormushin + */ +public class Sources { + + /** + * @param items + * @param + * @return + */ + @SafeVarargs + public static List list(T... items) { + return Arrays.asList(items); + } + + /** + * @param items + * @param + * @return + */ + @SafeVarargs + public static Set set(T... items) { + throw new UnsupportedOperationException(); + } + + /** + * @param inputStream + * @param + * @return + */ + public static Stream lines(InputStream inputStream) { + throw new UnsupportedOperationException(); + } + + /** + * @param file + * @param + * @return + */ + public static Stream lines(Path file) { + throw new UnsupportedOperationException(); + } + +} diff --git a/okalitova/src/main/java/ru/fizteh/fivt/students/okalitova/collectionsql/Tuple.java b/okalitova/src/main/java/ru/fizteh/fivt/students/okalitova/collectionsql/Tuple.java new file mode 100644 index 00000000..320ab56e --- /dev/null +++ b/okalitova/src/main/java/ru/fizteh/fivt/students/okalitova/collectionsql/Tuple.java @@ -0,0 +1,31 @@ +package ru.fizteh.fivt.students.okalitova.collectionsql; + +/** + * Created by nimloth on 17.12.15. + */ +public class Tuple { + + private final F first; + private final S second; + + public Tuple(F first, S second) { + this.first = first; + this.second = second; + } + + public F getFirst() { + return first; + } + + public S getSecond() { + return second; + } + + @Override + public String toString() { + return "Tuple{" + + "first=" + first + + ", second=" + second + + "}\n"; + } +} diff --git a/okalitova/src/main/java/ru/fizteh/fivt/students/okalitova/collectionsql/Union.java b/okalitova/src/main/java/ru/fizteh/fivt/students/okalitova/collectionsql/Union.java new file mode 100644 index 00000000..d9aa0049 --- /dev/null +++ b/okalitova/src/main/java/ru/fizteh/fivt/students/okalitova/collectionsql/Union.java @@ -0,0 +1,78 @@ +package ru.fizteh.fivt.students.okalitova.collectionsql; + +import java.lang.reflect.InvocationTargetException; +import java.util.ArrayList; +import java.util.Comparator; +import java.util.List; +import java.util.function.Function; +import java.util.function.Predicate; + +/** + * Created by nimloth on 17.12.15. + */ +public class Union { + private List> selects = new ArrayList<>(); + private Select current; + private From curFrom; + public Union(Select initSelect) { + selects.add(initSelect); + } + + public Union from(Iterable iterable) { + curFrom = new From(iterable); + return this; + } + + public Union select(Class resultClass, + Function... constructorFunctions) + throws IllegalAccessException, InstantiationException, InvocationTargetException { + current = curFrom.select(resultClass, constructorFunctions); + return this; + } + + public Union selectDistinct(Class resultClass, + Function... constructorFunctions) { + current = curFrom.selectDistinct(resultClass, constructorFunctions); + return this; + } + + public Union orderBy(Comparator... comparators) { + current = current.orderBy(comparators); + return this; + } + + public Union limit(int initLimit) { + current = current.limit(initLimit); + return this; + } + + public Union where(Predicate predicate) { + current = current.where(predicate); + return this; + } + + public Union having(Predicate predicate) { + current = current.having(predicate); + return this; + } + + public Union groupBy(Function... groupByFunctions) { + current = current.groupBy(groupByFunctions); + return this; + } + + public Union union() { + selects.add(current); + return this; + } + + public List execute() throws NoSuchMethodException, + IllegalAccessException, InstantiationException, InvocationTargetException { + List result = new ArrayList<>(); + selects.add(current); + for (Select select : selects) { + result.addAll(select.execute()); + } + return result; + } +} diff --git a/okalitova/src/main/java/ru/fizteh/fivt/students/okalitova/miniorm/Column.java b/okalitova/src/main/java/ru/fizteh/fivt/students/okalitova/miniorm/Column.java new file mode 100644 index 00000000..c450e15d --- /dev/null +++ b/okalitova/src/main/java/ru/fizteh/fivt/students/okalitova/miniorm/Column.java @@ -0,0 +1,15 @@ +package ru.fizteh.fivt.students.okalitova.miniorm; + +import java.lang.annotation.ElementType; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; + +/** + * Created by nimloth on 18.12.15. + */ +@Retention(value = RetentionPolicy.RUNTIME) +@Target(value = ElementType.FIELD) +public @interface Column { + String name() default "first_name"; +} diff --git a/okalitova/src/main/java/ru/fizteh/fivt/students/okalitova/miniorm/DatabaseService.java b/okalitova/src/main/java/ru/fizteh/fivt/students/okalitova/miniorm/DatabaseService.java new file mode 100644 index 00000000..71dbbbb5 --- /dev/null +++ b/okalitova/src/main/java/ru/fizteh/fivt/students/okalitova/miniorm/DatabaseService.java @@ -0,0 +1,209 @@ +package ru.fizteh.fivt.students.okalitova.miniorm; + +import java.lang.reflect.Field; +import java.sql.*; +import java.util.ArrayList; +import java.util.List; + + + +/** + * Created by nimloth on 18.12.15. + */ + +public class DatabaseService { + private Class tableClass; + private List columns = new ArrayList<>(); + private String tableName; + private Field primaryKey; + private boolean hasTable; + private static final String DATABASE_URL = "jdbc:h2:~/database"; + private StringBuilder request; + + public DatabaseService(Class initTableClass) throws Exception { + Class.forName("org.h2.Driver"); + this.tableClass = initTableClass; + Table table = initTableClass.getAnnotation(Table.class); + if (table == null) { + throw new Exception(); + } + tableName = table.name(); + boolean countKeys = false; + for (Field field : tableClass.getFields()) { + if (field.getAnnotation(Column.class) != null) { + columns.add(field); + } + if (field.getAnnotation(PrimaryKey.class) != null) { + if (field.getAnnotation(Column.class) == null || countKeys) { + throw new Exception(); + } else { + countKeys = true; + primaryKey = field; + } + } + } + try (Connection connection = DriverManager.getConnection(DATABASE_URL)) { + try (ResultSet resultSet = connection.getMetaData().getTables(null, null, tableName, null)) { + if (resultSet.next()) { + hasTable = true; + } + } + } + } + + public void createTable() throws Exception { + if (hasTable) { + throw new Exception(); + } + request = new StringBuilder("CREATE TABLE ").append(tableName); + for (Field field : columns) { + request.append(field.getAnnotation(Column.class).name()).append(" "); + request.append(SqlType.getSqlType(field.getType())); + if (field.equals(primaryKey)) { + request.append(" PRIMARY KEY"); + } + request.append(","); + } + System.out.println(request); + request.deleteCharAt(request.lastIndexOf(",")); + request.append(");"); + execute(); + } + + public void dropTable() throws Exception { + if (!hasTable) { + throw new Exception(); + } + request = new StringBuilder("DROP TABLE ").append(tableName).append(";"); + } + + void insert(T t) throws Exception { + if (!hasTable) { + throw new Exception(); + } + request = new StringBuilder("INSERT INTO ").append(tableName).append(" "); + request.append("VALUES ("); + for (Field field : columns) { + request.append("?").append(","); + } + System.out.println(request); + request.deleteCharAt(request.lastIndexOf(",")); + request.append(");"); + try (Connection connection = DriverManager.getConnection(DATABASE_URL)) { + try (PreparedStatement statement = connection.prepareStatement(request.toString())) { + for (int i = 0; i < columns.size(); ++i) { + try { + statement.setObject(i + 1, columns.get(i).get(t)); + } catch (IllegalAccessException e) { + throw new IllegalArgumentException("bad argument for insert"); + } + } + statement.execute(); + } + } + } + + + public void update(T element) throws Exception, SQLException { + if (!hasTable) { + throw new Exception(); + } + if (primaryKey == null) { + throw new Exception(); + } + request = new StringBuilder(); + request.append("UPDATE ").append(tableName).append(" SET "); + for (Field field : columns) { + request.append(field.getAnnotation(Column.class).name()).append(" = ?, "); + } + request.deleteCharAt(request.lastIndexOf(",")); + request.append(" WHERE ") + .append(primaryKey.getAnnotation(Column.class).name()).append(" = ?"); + try (Connection connection = DriverManager.getConnection(DATABASE_URL)) { + try (PreparedStatement statement = connection.prepareStatement(request.toString())) { + try { + for (int i = 0; i < columns.size(); ++i) { + statement.setObject(i + 1, columns.get(i).get(element)); + } + statement.setObject(columns.size() + 1, primaryKey.get(element)); + } catch (IllegalAccessException e) { + throw new Exception(); + } + statement.execute(); + } + } + } + + void delete(T t) throws Exception { + if (!hasTable) { + throw new Exception(); + } + request = new StringBuilder("DELETE FROM ").append(tableName).append(" "); + request.append(" WHERE ").append(primaryKey.getAnnotation(Column.class).name()).append("=?"); + try (Connection connection = DriverManager.getConnection(DATABASE_URL)) { + try (PreparedStatement statement = connection.prepareStatement(request.toString())) { + statement.setObject(1, primaryKey.get(t)); + statement.execute(); + } + } + } + + public T queryById(K key) throws SQLException, InstantiationException, IllegalAccessException { + request = new StringBuilder().append("SELECT * FROM ").append(tableName).append(" WHERE ") + .append(primaryKey.getAnnotation(Column.class).name()).append("=").append(key.toString()); + //System.out.println(query.toString()); + ResultSet resultSet; + try (Connection connection = DriverManager.getConnection(DATABASE_URL)) { + try (Statement statement = connection.createStatement()) { + resultSet = statement.executeQuery(request.toString()); + } + } + if (resultSet.next()) { + return getElement(resultSet); + } + return null; + } + + public T getElement(ResultSet resultSet) throws IllegalAccessException, InstantiationException, SQLException { + T element = tableClass.newInstance(); + for (Field field : columns) { + if (field.getType().isAssignableFrom(Number.class)) { + Long currValue = resultSet.getLong(field.getAnnotation(Column.class).name()); + field.set(element, currValue); + } else if (field.getType() == String.class) { + String currValue = resultSet.getString(field.getAnnotation(Column.class).name()); + field.set(element, currValue); + } else { + Object currValue = resultSet.getObject(field.getAnnotation(Column.class).name()); + field.set(element, currValue); + } + } + return element; + } + + public List queryForAll() throws SQLException, IllegalAccessException, InstantiationException { + List result = new ArrayList<>(); + request = new StringBuilder().append("SELECT * FROM ").append(tableName); + //System.out.println(query.toString()); + ResultSet resultSet; + try (Connection connection = DriverManager.getConnection(DATABASE_URL)) { + try (Statement statement = connection.createStatement()) { + resultSet = statement.executeQuery(request.toString()); + } + } + while (resultSet.next()) { + result.add(getElement(resultSet)); + } + return result; + } + + void execute() throws SQLException { + try (Connection connection = DriverManager.getConnection(DATABASE_URL)) { + try (Statement statement = connection.createStatement()) { + statement.execute(request.toString()); + hasTable = true; + } + } + } +} + diff --git a/okalitova/src/main/java/ru/fizteh/fivt/students/okalitova/miniorm/PrimaryKey.java b/okalitova/src/main/java/ru/fizteh/fivt/students/okalitova/miniorm/PrimaryKey.java new file mode 100644 index 00000000..6b76cafa --- /dev/null +++ b/okalitova/src/main/java/ru/fizteh/fivt/students/okalitova/miniorm/PrimaryKey.java @@ -0,0 +1,14 @@ +package ru.fizteh.fivt.students.okalitova.miniorm; + +import java.lang.annotation.ElementType; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; + +/** + * Created by nimloth on 18.12.15. + */ +@Retention(value = RetentionPolicy.RUNTIME) +@Target(value = ElementType.FIELD) +public @interface PrimaryKey { +} diff --git a/okalitova/src/main/java/ru/fizteh/fivt/students/okalitova/miniorm/SqlType.java b/okalitova/src/main/java/ru/fizteh/fivt/students/okalitova/miniorm/SqlType.java new file mode 100644 index 00000000..54bd06b1 --- /dev/null +++ b/okalitova/src/main/java/ru/fizteh/fivt/students/okalitova/miniorm/SqlType.java @@ -0,0 +1,38 @@ +package ru.fizteh.fivt.students.okalitova.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; + +/** + * Created by nimloth on 18.12.15. + */ +public class SqlType { + 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 getSqlType(Class currClass) { + if (classes.containsKey(currClass)) { + return classes.get(currClass); + } + return "OTHER"; + } +} diff --git a/okalitova/src/main/java/ru/fizteh/fivt/students/okalitova/miniorm/Table.java b/okalitova/src/main/java/ru/fizteh/fivt/students/okalitova/miniorm/Table.java new file mode 100644 index 00000000..28d25dc9 --- /dev/null +++ b/okalitova/src/main/java/ru/fizteh/fivt/students/okalitova/miniorm/Table.java @@ -0,0 +1,15 @@ +package ru.fizteh.fivt.students.okalitova.miniorm; + +import java.lang.annotation.ElementType; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; + +/** + * Created by nimloth on 18.12.15. + */ +@Retention(value = RetentionPolicy.RUNTIME) +@Target(value = ElementType.TYPE) +public @interface Table { + String name() default "my_table"; +} diff --git a/okalitova/src/main/java/ru/fizteh/fivt/students/okalitova/miniorm/User.java b/okalitova/src/main/java/ru/fizteh/fivt/students/okalitova/miniorm/User.java new file mode 100644 index 00000000..93fd4320 --- /dev/null +++ b/okalitova/src/main/java/ru/fizteh/fivt/students/okalitova/miniorm/User.java @@ -0,0 +1,99 @@ +package ru.fizteh.fivt.students.okalitova.miniorm; + + +import java.util.List; + +/** + * Created by nimloth on 18.12.15. + */ + +public class User { + @Table(name = "TESTTABLE") + static class Tab { + @PrimaryKey + @Column(name = "ID") + private Integer a; + + @Column(name = "STRING") + private String s; + + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (o == null || getClass() != o.getClass()) { + return false; + } + + Tab tab = (Tab) o; + + if (a != null) { + if (!a.equals(tab.a)) { + return false; + } + } else { + if (tab.a != null) { + return false; + } + } + if (s != null) { + return !!s.equals(tab.s); + } else { + return !(tab.s != null); + } + + } + + @Override + public int hashCode() { + int result; + if (a != null) { + result = a.hashCode(); + } else { + result = 0; + } + if (s != null) { + result = 31 * result + s.hashCode(); + } else { + result = 31 * result + 0; + } + return result; + } + + 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[] args) throws Exception { + DatabaseService bd = new DatabaseService<>(Tab.class); + //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); + //} finally { + //bd.dropTable(); + //} + } +} diff --git a/okalitova/src/main/java/ru/fizteh/fivt/students/okalitova/threads/BlockingQueue.java b/okalitova/src/main/java/ru/fizteh/fivt/students/okalitova/threads/BlockingQueue.java new file mode 100644 index 00000000..26de69a0 --- /dev/null +++ b/okalitova/src/main/java/ru/fizteh/fivt/students/okalitova/threads/BlockingQueue.java @@ -0,0 +1,73 @@ +package ru.fizteh.fivt.students.okalitova.threads; + +import java.util.LinkedList; +import java.util.List; +import java.util.Queue; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.locks.Condition; +import java.util.concurrent.locks.ReentrantLock; + +/** + * Created by nimloth on 08.12.15. + */ +public class BlockingQueue { + private Queue queue = new LinkedList(); + private static int maxQueueSize = 0; + private ReentrantLock lock = new ReentrantLock(); + private Condition empty = lock.newCondition(); + private Condition nonEmpty = lock.newCondition(); + + public BlockingQueue(int maxQueueSize) { + this.maxQueueSize = maxQueueSize; + } + + public synchronized void offer(List e) throws InterruptedException { + try { + lock.lock(); + while (e.size() + queue.size() > maxQueueSize) { + try { + boolean flag = empty.await(5, TimeUnit.SECONDS); //таймаут 5 секунд + if (!flag) { + return; + } + } catch (InterruptedException ex) { + throw ex; + } + } + for (T elem : e) { + queue.add(elem); + } + if (queue.size() > 0) { + nonEmpty.signal(); + } + } finally { + lock.unlock(); + } + } + + public synchronized List take(int n) throws InterruptedException { + try { + lock.lock(); + List result = new LinkedList(); + + while (queue.size() < n) { + try { + boolean flag = nonEmpty.await(5, TimeUnit.SECONDS); //таймаут 5 секунд + if (!flag) { + return result; + } + } catch (InterruptedException e) { + throw e; + } + } + + for (int i = 0; i < n; ++i) { + result.add(queue.remove()); + } + empty.signal(); + return result; + } finally { + lock.unlock(); + } + } +} diff --git a/okalitova/src/main/java/ru/fizteh/fivt/students/okalitova/threads/ThreadsCounter.java b/okalitova/src/main/java/ru/fizteh/fivt/students/okalitova/threads/ThreadsCounter.java new file mode 100644 index 00000000..11d8051a --- /dev/null +++ b/okalitova/src/main/java/ru/fizteh/fivt/students/okalitova/threads/ThreadsCounter.java @@ -0,0 +1,46 @@ +package ru.fizteh.fivt.students.okalitova.threads; + +import java.util.ArrayList; +import java.util.concurrent.locks.Condition; +import java.util.concurrent.locks.ReentrantLock; + +/** + * Created by nimloth on 06.12.15. + */ + +public class ThreadsCounter { + private static int counter = -1; + private static ReentrantLock lock = new ReentrantLock(); + private static Condition cond = lock.newCondition(); + + private static Runnable countThread = () -> { + try { + String threadName = Thread.currentThread().getName(); + lock.lock(); + + while (counter + 1 != Integer.parseInt(threadName)) { + try { + cond.await(); + } catch (InterruptedException e) { + e.printStackTrace(); + } + } + + counter++; + System.out.println("Thread-" + counter); + cond.signalAll(); + } finally { + lock.unlock(); + } + }; + + public static void main(String[] args) { + int n = Integer.parseInt(args[0]); + System.out.println(n); + ArrayList t = new ArrayList<>(); + for (int i = 0; i < n; ++i) { + t.add(i, new Thread(countThread, String.valueOf(i))); + t.get(i).start(); + } + } +} diff --git a/okalitova/src/main/java/ru/fizteh/fivt/students/okalitova/threads/ThreadsRollCall.java b/okalitova/src/main/java/ru/fizteh/fivt/students/okalitova/threads/ThreadsRollCall.java new file mode 100644 index 00000000..42271267 --- /dev/null +++ b/okalitova/src/main/java/ru/fizteh/fivt/students/okalitova/threads/ThreadsRollCall.java @@ -0,0 +1,56 @@ +package ru.fizteh.fivt.students.okalitova.threads; + +import java.util.ArrayList; +import java.util.Random; +import java.util.concurrent.BrokenBarrierException; +import java.util.concurrent.CyclicBarrier; + +/** + * Created by nimloth on 06.12.15. + */ +public class ThreadsRollCall { + private static boolean ready = false; + private static boolean flag = false; + private static CyclicBarrier barrier; + private static volatile Random random = new Random(43); + + private static Runnable rollCall = () -> { + while (!ready) { + int randInt = random.nextInt(9); + if (randInt == 0) { + System.out.println("No"); + flag = true; + } else { + System.out.println("Yes"); + } + try { + barrier.await(); + } catch (InterruptedException e) { + e.printStackTrace(); + } catch (BrokenBarrierException e) { + e.printStackTrace(); + } + } + }; + + public static void main(String[] args) { + int n = Integer.parseInt(args[0]); + + barrier = new CyclicBarrier(n, () -> { + if (flag) { + System.out.println("Are you ready?"); + ready = false; + flag = false; + } else { + System.exit(0); + } + }); + + System.out.println("Are you ready?"); + ArrayList t = new ArrayList<>(); + for (int i = 0; i < n; ++i) { + t.add(i, new Thread(rollCall)); + t.get(i).start(); + } + } +} diff --git a/okalitova/src/test/java/ru/fizteh/fivt/students/collectionsqltest/SelectTest.java b/okalitova/src/test/java/ru/fizteh/fivt/students/collectionsqltest/SelectTest.java new file mode 100644 index 00000000..1201fa42 --- /dev/null +++ b/okalitova/src/test/java/ru/fizteh/fivt/students/collectionsqltest/SelectTest.java @@ -0,0 +1,138 @@ +package ru.fizteh.fivt.students.collectionsqltest; + +import org.junit.Test; +import ru.fizteh.fivt.students.okalitova.collectionsql.CollectionsQL; +import ru.fizteh.fivt.students.okalitova.collectionsql.Tuple; + +import java.lang.reflect.InvocationTargetException; +import java.time.LocalDate; +import java.util.List; +import java.util.Objects; + +import static org.hamcrest.Matchers.*; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertThat; +import static ru.fizteh.fivt.students.okalitova.collectionsql.Aggregates.count; +import static ru.fizteh.fivt.students.okalitova.collectionsql.Aggregates.max; +import static ru.fizteh.fivt.students.okalitova.collectionsql.CollectionsQL.Student.student; +import static ru.fizteh.fivt.students.okalitova.collectionsql.Conditions.rlike; +import static ru.fizteh.fivt.students.okalitova.collectionsql.From.from; +import static ru.fizteh.fivt.students.okalitova.collectionsql.OrderByConditions.asc; +import static ru.fizteh.fivt.students.okalitova.collectionsql.OrderByConditions.desc; +import static ru.fizteh.fivt.students.okalitova.collectionsql.Sources.list; + +/** + * Created by nimloth on 17.12.15. + */ +public class SelectTest { + + @Test + public void selectTest() throws IllegalAccessException, InstantiationException, InvocationTargetException { + List statistics = + from(list( + student("ivanov", LocalDate.parse("1985-08-06"), "494"), + student("sidorov", LocalDate.parse("1986-08-06"), "495"), + student("smith", LocalDate.parse("1986-08-06"), "495"), + student("petrov", LocalDate.parse("2006-08-06"), "494"))) + .select(CollectionsQL.Statistics.class, + CollectionsQL.Student::getGroup, + CollectionsQL.Student::age, + CollectionsQL.Student::age) + .execute(); + CollectionsQL.Statistics item = new CollectionsQL.Statistics("495", Long.parseLong("29"), + Long.parseLong("29")); + assertThat(statistics, hasSize(4)); + assertThat(statistics, hasItem(item)); + } + + @Test + public void whereTest() throws IllegalAccessException, InstantiationException, InvocationTargetException { + List statistics = + from(list( + student("ivanov", LocalDate.parse("1985-08-06"), "494"), + student("sidorov", LocalDate.parse("1986-08-06"), "495"), + student("smith", LocalDate.parse("1986-08-06"), "495"), + student("petrov", LocalDate.parse("2006-08-06"), "494"))) + .select(CollectionsQL.Statistics.class, + CollectionsQL.Student::getGroup, + CollectionsQL.Student::age, + CollectionsQL.Student::age) + .where(rlike(CollectionsQL.Student::getName, ".*ov").and(s -> s.age() > 20)) + .execute(); + CollectionsQL.Statistics item = new CollectionsQL.Statistics("495", Long.parseLong("29"), + Long.parseLong("29")); + assertThat(statistics, hasSize(2)); + assertThat(statistics, hasItem(item)); + } + + @Test + public void groupByTest() throws IllegalAccessException, InstantiationException, InvocationTargetException { + List statistics = + from(list( + student("ivanov", LocalDate.parse("1985-08-06"), "494"), + student("sidorov", LocalDate.parse("1986-08-06"), "495"), + student("smith", LocalDate.parse("1986-08-06"), "495"), + student("petrov", LocalDate.parse("2006-08-06"), "494"), + student("pechatnikov", LocalDate.parse("1996-08-04"), "495"))) + .select(CollectionsQL.Statistics.class, + CollectionsQL.Student::getGroup, + max(CollectionsQL.Student::age), + count(CollectionsQL.Student::getName)) + .groupBy(CollectionsQL.Student::getGroup) + .execute(); + CollectionsQL.Statistics item = new CollectionsQL.Statistics("495", Long.parseLong("29"), + Long.parseLong("3")); + assertThat(statistics, hasSize(2)); + assertThat(statistics, hasItem(item)); + item = new CollectionsQL.Statistics("494", Long.parseLong("30"), + Long.parseLong("2")); + assertThat(statistics, hasItem(item)); + } + + @Test + public void executeTest() throws IllegalAccessException, InstantiationException, InvocationTargetException, NoSuchMethodException { + List statistics = + from(list( + student("ivanov", LocalDate.parse("1985-08-06"), "494"), + student("sidorov", LocalDate.parse("1986-08-06"), "495"), + student("smith", LocalDate.parse("1986-08-06"), "495"), + student("petrov", LocalDate.parse("2006-08-06"), "494"), + student("pechatnikov", LocalDate.parse("1996-08-04"), "495"))) + .select(CollectionsQL.Statistics.class, + CollectionsQL.Student::getGroup, + max(CollectionsQL.Student::age), + count(CollectionsQL.Student::getName)) + .where(rlike(CollectionsQL.Student::getName, ".*ov")) + .groupBy(CollectionsQL.Student::getGroup) + .having(s -> s.getGroup() == "495") + .orderBy(asc(CollectionsQL.Statistics::getGroup), desc(CollectionsQL.Statistics::getCount)) + .limit(100) + .union() + .from(list(student("ivanov", LocalDate.parse("1985-08-06"), "494"))) + .select(CollectionsQL.Statistics.class, + CollectionsQL.Student::getGroup, + (CollectionsQL.Student::age), + (CollectionsQL.Student::age)) + .execute(); + assertThat(statistics, hasSize(2)); + CollectionsQL.Statistics item = new CollectionsQL.Statistics("495", Long.parseLong("29"), + Long.parseLong("2")); + assertThat(statistics, hasItem(item)); + item = new CollectionsQL.Statistics("494", Long.parseLong("30"), + Long.parseLong("30")); + assertThat(statistics, hasItem(item)); + } + + @Test + public void joinTest() throws IllegalAccessException, InstantiationException, InvocationTargetException { + Iterable> mentorsByStudent = + from(list(student("ivanov", LocalDate.parse("1985-08-06"), "494"))) + .join(list(new CollectionsQL.Group("494", "mr.sidorov"))) + .on((s, g) -> Objects.equals(s.getGroup(), g.getGroup())) + .select(sg -> sg.getFirst().getName(), sg -> sg.getSecond().getMentor()) + .execute(); + for (Tuple it : mentorsByStudent) { + assertEquals(it, new Tuple<>("ivanov", "mr.sidorov")); + } + } +} diff --git a/okalitova/src/test/java/ru/fizteh/fivt/students/threadstest/BlockingQueueTest.java b/okalitova/src/test/java/ru/fizteh/fivt/students/threadstest/BlockingQueueTest.java new file mode 100644 index 00000000..0315ee03 --- /dev/null +++ b/okalitova/src/test/java/ru/fizteh/fivt/students/threadstest/BlockingQueueTest.java @@ -0,0 +1,104 @@ +package ru.fizteh.fivt.students.threadstest; + +import org.junit.Test; +import ru.fizteh.fivt.students.okalitova.threads.BlockingQueue; +import java.util.Arrays; +import java.util.List; + +import static java.lang.Thread.sleep; +import static org.hamcrest.CoreMatchers.is; +import static org.hamcrest.Matchers.contains; +import static org.junit.Assert.assertThat; + +/** + * Created by nimloth on 10.12.15. + */ +public class BlockingQueueTest { + + @Test + public void offerBLockTest() throws InterruptedException { + BlockingQueue blockingQueue = new BlockingQueue(5); + List e1 = Arrays.asList(1, 2, 3, 4, 5, 6); + Thread thread1 = new Thread(() -> { + try { + blockingQueue.offer(e1); + } catch (InterruptedException e) { + e.getMessage(); + } + }); + thread1.start(); + sleep(3); + assertThat(thread1.getState().equals(Thread.State.TIMED_WAITING), is(true)); + + List e2 = Arrays.asList(1, 2, 3, 4, 5, 6); + Thread thread2 = new Thread(() -> { + try { + blockingQueue.offer(e2); + } catch (InterruptedException e) { + e.getMessage(); + } + }); + thread2.start(); + sleep(3); + assertThat(thread2.getState().equals(Thread.State.BLOCKED), is(true)); + } + + @Test + public void offerNonBLockTest() throws InterruptedException { + BlockingQueue blockingQueue = new BlockingQueue(5); + List e1 = Arrays.asList(1, 2); + Thread thread1 = new Thread(() -> { + try { + blockingQueue.offer(e1); + } catch (InterruptedException e) { + e.getMessage(); + } + }); + thread1.start(); + sleep(3); + assertThat(thread1.getState().equals(Thread.State.TERMINATED), is(true)); + + List e2 = Arrays.asList(3, 4); + Thread thread2 = new Thread(() -> { + try { + blockingQueue.offer(e2); + } catch (InterruptedException e) { + e.getMessage(); + } + }); + thread2.start(); + sleep(3); + assertThat(thread2.getState().equals(Thread.State.TERMINATED), is(true)); + } + + @Test + public void takeBLockTest() throws InterruptedException { + BlockingQueue blockingQueue = new BlockingQueue(5); + List e1 = Arrays.asList(1, 2); + blockingQueue.offer(e1); + List e2 = Arrays.asList(3, 4); + blockingQueue.offer(e2); + Thread thread = new Thread(() -> { + try { + blockingQueue.take(5); + } catch (InterruptedException e) { + e.getMessage(); + } + }); + thread.start(); + sleep(3); + assertThat(thread.getState().equals(Thread.State.TIMED_WAITING), is(true)); + } + + @Test + public void takeNonBLockTest() throws InterruptedException { + BlockingQueue blockingQueue = new BlockingQueue(5); + List e1 = Arrays.asList(1, 2); + blockingQueue.offer(e1); + List e2 = Arrays.asList(3, 4); + blockingQueue.offer(e2); + List result = blockingQueue.take(3); + assertThat(result.size(), is(3)); + assertThat(result, contains(1, 2, 3)); + } +}