diff --git a/.gitignore b/.gitignore index cedaa518..49803047 100644 --- a/.gitignore +++ b/.gitignore @@ -3,7 +3,6 @@ *.jar *.war *.ear -*.class hs_err_pid* .idea *.iml @@ -18,4 +17,5 @@ workbench.xmi *.swp .settings .checkstyle +GoogleMapsAPI.properties twitter4j.properties diff --git a/EkaterinaVishnevskaya/.gitignore b/EkaterinaVishnevskaya/.gitignore new file mode 100644 index 00000000..7f59e8c1 --- /dev/null +++ b/EkaterinaVishnevskaya/.gitignore @@ -0,0 +1 @@ +twitter4j.properties \ No newline at end of file diff --git a/EkaterinaVishnevskaya/pom.xml b/EkaterinaVishnevskaya/pom.xml new file mode 100644 index 00000000..880dee95 --- /dev/null +++ b/EkaterinaVishnevskaya/pom.xml @@ -0,0 +1,38 @@ + + + 4.0.0 + + + ru.fizteh.fivt.students + parent + 1.0-SNAPSHOT + + + EkaterinaVishnevskaya + jar + + + UTF-8 + + + + junit + junit + 3.8.1 + test + + + org.twitter4j + twitter4j-stream + [4.0,) + + + com.beust + jcommander + 1.48 + + + + \ No newline at end of file diff --git a/EkaterinaVishnevskaya/src/main/java/ru/fizteh/fivt/students/EkaterinaVishnevskaya/CollectionQl2/CollectionsQL.java b/EkaterinaVishnevskaya/src/main/java/ru/fizteh/fivt/students/EkaterinaVishnevskaya/CollectionQl2/CollectionsQL.java new file mode 100644 index 00000000..9a3625f5 --- /dev/null +++ b/EkaterinaVishnevskaya/src/main/java/ru/fizteh/fivt/students/EkaterinaVishnevskaya/CollectionQl2/CollectionsQL.java @@ -0,0 +1,32 @@ +package ru.fizteh.fivt.students.EkaterinaVishnevskaya.CollectionQl2; + +import java.time.LocalDate; +import java.util.ArrayList; + + +public class CollectionsQL { + + /** + * + * @param + * @param collection + * @return + */ + /*public static Selector from(AbstractCollection collection) + { + return new Selector<>(collection); + }*/ + + /** + * @param args the command line arguments + */ + public static void main(String[] args) { + ArrayList students = new ArrayList(); + students.add(new Student("ivanov", LocalDate.parse("1986-08-06"), "494")); + students.add(new Student("sidorov", LocalDate.parse("1999-08-06"), "495")); + students.add(new Student("john", LocalDate.parse("1987-08-06"), "494")); + Query q = new Query(students); + Iterable it = q.where(Conditions.rlike(Student::getName, ".*ov")).orderBy(Comparators.desc(Student::getGroup)).groupBy(Student::getGroup).select(Statistics.class, Student::getGroup).having(s -> s.getCount() > 0).execute(); + System.out.println(it); + } +} diff --git a/EkaterinaVishnevskaya/src/main/java/ru/fizteh/fivt/students/EkaterinaVishnevskaya/CollectionQl2/Comparators.java b/EkaterinaVishnevskaya/src/main/java/ru/fizteh/fivt/students/EkaterinaVishnevskaya/CollectionQl2/Comparators.java new file mode 100644 index 00000000..02caadb2 --- /dev/null +++ b/EkaterinaVishnevskaya/src/main/java/ru/fizteh/fivt/students/EkaterinaVishnevskaya/CollectionQl2/Comparators.java @@ -0,0 +1,28 @@ +package ru.fizteh.fivt.students.EkaterinaVishnevskaya.CollectionQl2; + +import java.util.Comparator; +import java.util.function.Function; + +/** + * Created by V on 19.12.2015. + */ +public class Comparators { + public static > Comparator asc(Function func){ + Comparator comparator = new Comparator() { + @Override + public int compare(Student o1, Student o2) { + return func.apply(o1).compareTo(func.apply(o2)); + } + }; + return comparator; + } + public static > Comparator desc(Function func){ + Comparator comparator = new Comparator() { + @Override + public int compare(Student o1, Student o2) { + return func.apply(o1).compareTo(func.apply(o2)); + } + }; + return comparator.reversed(); + } +} diff --git a/EkaterinaVishnevskaya/src/main/java/ru/fizteh/fivt/students/EkaterinaVishnevskaya/CollectionQl2/Conditions.java b/EkaterinaVishnevskaya/src/main/java/ru/fizteh/fivt/students/EkaterinaVishnevskaya/CollectionQl2/Conditions.java new file mode 100644 index 00000000..4de5e5e7 --- /dev/null +++ b/EkaterinaVishnevskaya/src/main/java/ru/fizteh/fivt/students/EkaterinaVishnevskaya/CollectionQl2/Conditions.java @@ -0,0 +1,20 @@ +package ru.fizteh.fivt.students.EkaterinaVishnevskaya.CollectionQl2; + +import java.util.function.Function; +import java.util.function.Predicate; + +/** + * Created by V on 19.12.2015. + */ +public class Conditions { + public static Predicate rlike(Function expression, String regexp) { + Predicate p = s -> expression.apply(s).endsWith(regexp); + return p; + } + public static Predicate like(Function expression, String pattern) { + Predicate p1 = s -> expression.apply(s).startsWith(pattern); + Predicate p2 = s -> expression.apply(s).endsWith(pattern); + Predicate p3 = p1.and(p2); + return p3; + } +} diff --git a/EkaterinaVishnevskaya/src/main/java/ru/fizteh/fivt/students/EkaterinaVishnevskaya/CollectionQl2/Query.java b/EkaterinaVishnevskaya/src/main/java/ru/fizteh/fivt/students/EkaterinaVishnevskaya/CollectionQl2/Query.java new file mode 100644 index 00000000..f951412a --- /dev/null +++ b/EkaterinaVishnevskaya/src/main/java/ru/fizteh/fivt/students/EkaterinaVishnevskaya/CollectionQl2/Query.java @@ -0,0 +1,186 @@ +package ru.fizteh.fivt.students.EkaterinaVishnevskaya.CollectionQl2; + +import java.lang.reflect.Constructor; +import java.util.*; +import java.util.function.Function; +import java.util.function.Predicate; +import java.util.logging.Level; +import java.util.logging.Logger; +import java.util.stream.Collectors; +import java.util.stream.Stream; + +/** + * Created by V on 19.12.2015. + */ + public class Query { + public Query(AbstractCollection collection) + { + result = new ArrayList<>(); + actionsForInput = new ArrayList(); + actionsForOutput = new ArrayList(); + selectAction = null; + sequence = collection.stream(); + selectResult = null; + } + + /*private Query(AbstractCollection collection, ArrayList > other) + { + + }*/ + + public Query where(Predicate predicate) + { + actionsForInput.add(() -> { + whereImpl(predicate); + }); + return this; + } + + public Query select(Class resultType, Function... functions) + { + selectAction = () -> { + try { + selectImpl(resultType, functions); + } catch (InstantiationException ex) { + Logger.getLogger(Query.class.getName()).log(Level.SEVERE, null, ex); + } + }; + return this; + } + + + private void selectImpl(Class resultType, Function... functions) throws InstantiationException + { + //ArrayList selected = new ArrayList<>(); + Iterator it = sequence.iterator(); + //ArrayList result = new ArrayList<>(); + while(it.hasNext()) + { + ArrayList selected = new ArrayList<>(); + for(Function f : functions) + { + selected.add(f.apply(it.next())); + } + Constructor[] constructors = resultType.getConstructors(); + ResultType t = null; + for(int i = 0; i < constructors.length; ++i) + { + if( t!= null) break; + try { + t = (ResultType) constructors[i].newInstance(selected.toArray()); + } catch (Exception ex) + { + } + } + if( t== null) throw new InstantiationException(); + result.add(t); + } + resultTypeStream = result.stream(); + selectResult = result; + } + + public Query orderBy(Comparator... comparators) + { + actionsForInput.add(() -> { + orderByImpl(comparators); + }); + return this; + } + + public Query groupBy(Function... functors) + { + actionsForInput.add(() -> groupByImpl(functors)); + return this; + } + + //�� ����� ���� ������ ���� Iterable + public Iterable execute() + { + for( Runnable r : actionsForInput) + { + r.run(); + } + selectAction.run(); + for(Runnable r1 : actionsForOutput){ + r1.run(); + } + + return (Iterable) selectResult; + } + + private void whereImpl(Predicate predicate) + { + sequence = sequence.filter(predicate).collect(Collectors.toList()).stream(); + } + + private void orderByImpl(Comparator... comparators) + { + for(Comparator comparator : comparators) + { + sequence = sequence.sorted().collect(Collectors.toList()).stream(); + } + } + + private void groupByImpl(Function... functors) + { + for(Function f : functors) + { + ArrayList filtered = new ArrayList<>(); + Map> grouped = (Map>) sequence.collect(Collectors.groupingBy(f)); + //apply aggreagate smth like: + //grouped.forEach(aggregate); + grouped.forEach((T key, List value) -> filtered.add(value.get(0))); + sequence = filtered.stream(); + } + } + + public Query having(Predicate predicate){ + actionsForOutput.add(()->{ + havingImpl(predicate); + }); + return this; + } + + public void havingImpl(Predicate predicate){ + resultTypeStream= resultTypeStream. + filter(s -> predicate.test(s)) + .collect(Collectors.toList()) + .stream(); + } + + public Query selectDistinct(){ + actionsForOutput.add(()->{ + selectDistinctImpl(); + }); + return this; + } + + public void selectDistinctImpl(){ + resultTypeStream = resultTypeStream + .distinct() + .collect(Collectors.toList()) + .stream(); + } + + public Query limit(int n){ + actionsForOutput.add(()->{ + limitImpl(n); + }); + return this; + } + + public void limitImpl(int count){ + if(resultTypeStream.count() > count){ + resultTypeStream=resultTypeStream.limit(count); + } + } + + private Stream resultTypeStream; + private ArrayList result; + private ArrayList actionsForInput; + private Runnable selectAction; + private ArrayList actionsForOutput; + private Stream sequence; + private Object selectResult; + } + diff --git a/EkaterinaVishnevskaya/src/main/java/ru/fizteh/fivt/students/EkaterinaVishnevskaya/CollectionQl2/Student.java b/EkaterinaVishnevskaya/src/main/java/ru/fizteh/fivt/students/EkaterinaVishnevskaya/CollectionQl2/Student.java new file mode 100644 index 00000000..d34c09a1 --- /dev/null +++ b/EkaterinaVishnevskaya/src/main/java/ru/fizteh/fivt/students/EkaterinaVishnevskaya/CollectionQl2/Student.java @@ -0,0 +1,99 @@ +package ru.fizteh.fivt.students.EkaterinaVishnevskaya.CollectionQl2; + +import org.apache.commons.lang3.builder.HashCodeBuilder; + +import java.time.LocalDate; +import java.time.LocalDateTime; +import java.time.temporal.ChronoUnit; + +public 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 this.name + " " + this.dateOfBith.toString() + " " + this.group.toString(); + } + +} + +class Statistics { + + private final String group; + private final Long count; + private final Long age; + + public String getGroup() { + return group; + } + + public Long getCount() { + return count; + } + + public Long getAge() { + return age; + } + + public Statistics(String group) { + this.group = group; + this.count = Long.MAX_VALUE; + this.age = Long.MAX_VALUE; + } + + public boolean equals(Object o){ + if(o == null){ + return false; + } + if(getClass() != o.getClass()){ + return false; + } + Statistics st = (Statistics) o; + return (o == this); + } + + public int hashCode() { + HashCodeBuilder builder = new HashCodeBuilder(); + builder.append(getGroup()); + return builder.hashCode(); + } + + @Override + public String toString() { + return "Statistics{" + + "group='" + group + '\'' + + ", count=" + count + + ", age=" + age + + '}'; + } +} diff --git a/EkaterinaVishnevskaya/src/main/java/ru/fizteh/fivt/students/EkaterinaVishnevskaya/TwitterStream/CommandParser.java b/EkaterinaVishnevskaya/src/main/java/ru/fizteh/fivt/students/EkaterinaVishnevskaya/TwitterStream/CommandParser.java new file mode 100644 index 00000000..3220e860 --- /dev/null +++ b/EkaterinaVishnevskaya/src/main/java/ru/fizteh/fivt/students/EkaterinaVishnevskaya/TwitterStream/CommandParser.java @@ -0,0 +1,43 @@ +package ru.fizteh.fivt.students.EkaterinaVishnevskaya.TwitterStream; + +import com.beust.jcommander.Parameter; + +public class CommandParser { + @Parameter(names = {"--query", "-q"}, + description = "Ключевые слова поиска.") + private String queryWord = null; + + @Parameter(names = {"--help", "-h"}, description = "Вывод справки.") + private boolean help = false; + + @Parameter(names = {"--stream", "-s"}, + description = "Режим Stream: равномерный вывод твитов на экран с задержкой в 1 секунду.") + private boolean stream = false; + + @Parameter(names = {"--hideRetweets", "-hrt"}, + description = "Фильтровать ретвиты.") + private boolean isFilter = false; + + @Parameter(names = {"--limit", "-l"}, + description = "Режим Limited: вывод только заданного количества твитов. Несовместим с режимом Stream.") + private int number = -1; + + public boolean isHelpOn() { + return help; + } + public int getNumber() { + return number; + } + public boolean isStream() { + return stream; + } + public boolean isLimit() { + return (number != -1); + } + public String getQueryWord() { + return queryWord; + } + public boolean isFilterRetweets() { + return isFilter; + } +} diff --git a/EkaterinaVishnevskaya/src/main/java/ru/fizteh/fivt/students/EkaterinaVishnevskaya/TwitterStream/Printing.java b/EkaterinaVishnevskaya/src/main/java/ru/fizteh/fivt/students/EkaterinaVishnevskaya/TwitterStream/Printing.java new file mode 100644 index 00000000..6fe713d8 --- /dev/null +++ b/EkaterinaVishnevskaya/src/main/java/ru/fizteh/fivt/students/EkaterinaVishnevskaya/TwitterStream/Printing.java @@ -0,0 +1,121 @@ +package ru.fizteh.fivt.students.EkaterinaVishnevskaya.TwitterStream; + +import twitter4j.Status; + +import java.io.IOException; +import java.io.PrintStream; +import java.time.LocalDateTime; +import java.time.ZoneId; +import java.time.temporal.ChronoUnit; + +public class Printing { + + private static final String NAME_COLOR = "\u001B[36m"; + private static final String TIME_COLOR = "\u001B[33m"; + private static final String STANDART_COLOR = "\u001B[0m"; + private static final String RT_COLOR = "\u001B[31m"; + + public static String formatTime(LocalDateTime when) throws IOException { + String out = ""; + LocalDateTime currentTime = LocalDateTime.now(); + long minute = ChronoUnit.MINUTES.between(when, currentTime); + long hour = ChronoUnit.HOURS.between(when, currentTime); + long day = ChronoUnit.DAYS.between(when, currentTime); + out = out + TIME_COLOR; + if (minute < 1) { + out = out + "Только что "; + } else if (hour < 1) { + out = out + minute + dislForm(minute, Printing.ETime.MINUTE) + " назад "; + } else if (day < 1) { + out = out + hour + dislForm(hour, Printing.ETime.HOUR) + " назад "; + } else { + if (day == 1) { + out = out + "Вчера "; + } else { + out = out + day + dislForm(day, Printing.ETime.DAY) + " назад "; + } + } + out = out + STANDART_COLOR; + return out; + } + + private static String formatName(String name) throws IOException { + String out = ""; + out = out + NAME_COLOR + "@" + name + STANDART_COLOR + ": "; + return out; + } + + private static String formatStatus(String text, boolean rt, int rtCount) throws IOException { + String out = ""; + if (rt) { + out = out + RT_COLOR + " ретвитнул "; + String[] splited = text.split(" "); + out = out + formatName(splited[1].split("@|:")[1]); + for (int i = 2; i < splited.length; ++i) { + out = out + splited[i] + "\n"; + } + out = out + "\n"; + } else { + out = out + (text + " (" + rtCount + " " + + RETWEET_FORMS[getCorrectForm(rtCount).getType()] + ")\n"); + } + return out; + } + + public static void printTweet(PrintStream out, Status tweet, boolean time) throws IOException { + if (time) { + out.print(formatTime(tweet.getCreatedAt().toInstant().atZone(ZoneId.systemDefault()).toLocalDateTime())); + } + out.print(formatName(tweet.getUser().getScreenName())); + out.print(formatStatus(tweet.getText(), tweet.isRetweet(), tweet.getRetweetCount())); + } + + private static final int HUNDRED = 100; + private static final int ELEVEN = 11; + private static final int TEN = 10; + private static final int FIVE = 5; + private static final int ONE = 1; + private static final int NINETEEN = 19; + + private static final String[] MINUTES_FORMS = {"минуту", "минуты", "минут"}; + private static final String[] HOURS_FORMS = {"час", "часа", "часов"}; + private static final String[] DAYS_FORMS = {"день", "дня", "дней"}; + public static final String[] RETWEET_FORMS = {"ретвит", "ретвита", "ретвитов"}; + + private static final String[][] TIME_FORMS = {MINUTES_FORMS, HOURS_FORMS, DAYS_FORMS}; + + public enum ETime { + MINUTE (0), + HOUR (1), + DAY (2); + + private int type; + + public int getType() { + return type; + } + + ETime(int type) { + this.type = type; + } + } + + public static ETime getCorrectForm(long number) { + if (number % TEN == ONE && number % HUNDRED != ELEVEN) { + return ETime.MINUTE; + } + if (number % TEN > ONE && number % TEN < FIVE + && !(number % HUNDRED >= ELEVEN && number % HUNDRED <= NINETEEN)) { + return ETime.HOUR; + } + return ETime.DAY; + } + + public static final int MILISEC_IN_SEC = 1000; + + public static String dislForm(long hours, ETime type) { + ETime correctForm = getCorrectForm(hours); + return " " + TIME_FORMS[type.getType()][correctForm.getType()]; + } + +} diff --git a/EkaterinaVishnevskaya/src/main/java/ru/fizteh/fivt/students/EkaterinaVishnevskaya/TwitterStream/TwitterStreamMain.java b/EkaterinaVishnevskaya/src/main/java/ru/fizteh/fivt/students/EkaterinaVishnevskaya/TwitterStream/TwitterStreamMain.java new file mode 100644 index 00000000..f84f86fa --- /dev/null +++ b/EkaterinaVishnevskaya/src/main/java/ru/fizteh/fivt/students/EkaterinaVishnevskaya/TwitterStream/TwitterStreamMain.java @@ -0,0 +1,106 @@ +package ru.fizteh.fivt.students.EkaterinaVishnevskaya.TwitterStream; + +import com.beust.jcommander.JCommander; +import twitter4j.*; + +import java.io.IOException; +import java.util.List; + +import static java.lang.Thread.sleep; + +import static ru.fizteh.fivt.students.EkaterinaVishnevskaya.TwitterStream.Printing.*; + +public class TwitterStreamMain { + public static void main(String[] args) throws IOException { + CommandParser parsed = new CommandParser(); + JCommander command = new JCommander(parsed, args); + if (parsed.isHelpOn()) { + printHelp(command); + } + + if (parsed.isStream() && parsed.isLimit()) { + System.out.println("Несовместимые режимы Stream и Limited."); + return; + } + if (parsed.isStream()) { + streamMode(parsed.isFilterRetweets(), parsed.getQueryWord()); + } else { + limitedMode(parsed.isFilterRetweets(), parsed.getNumber(), parsed.getQueryWord()); + } + } + + private static void printHelp(JCommander command) { + command.usage(); + } + + private static void streamMode(boolean filterRetweets, String keyWord) throws IOException { + TwitterStream twitter = new TwitterStreamFactory().getInstance(); + if (keyWord == null) { + System.out.println("Пустой запрос."); + return; + } + twitter.addListener(new StatusAdapter() { + @Override + public void onStatus(Status tweet) { + try { + if ((tweet.isRetweet() && !filterRetweets) || !tweet.isRetweet()) { + printTweet(System.out, tweet, false); + } + } catch (IOException e) { + e.printStackTrace(); + } + try { + sleep(MILISEC_IN_SEC); + } catch (InterruptedException e) { + e.printStackTrace(); + } + } + + @Override + public void onException(Exception ex) { + ex.printStackTrace(); + } + }); + + twitter.filter(new FilterQuery().track(new String[] {keyWord})); + } + + private static void limitedMode(boolean filterRetweets, int limit, String keyWord) throws IOException { + try { + Twitter twitter = new TwitterFactory().getInstance(); + if (keyWord == null) { + System.out.println("Пустой запрос."); + return; + } + Query query = new Query(); + query.setQuery(keyWord); + QueryResult result; + int count = 0; + boolean isAnyTweets = false; + result = twitter.search(query); + List tweets = result.getTweets(); + for (Status tweet : tweets) { + if ((tweet.isRetweet() && !filterRetweets) || !tweet.isRetweet()) { + printTweet(System.out, tweet, true); + count++; + isAnyTweets = true; + if ((count == limit) && (count != -1)) { + break; + } + } + } + if (!isAnyTweets) { + System.out.println("\nНе найдено ни одного твита по запросу #" + + keyWord + ".\n"); + } else + if ((count < limit) && (count != -1)) { + System.out.println("\nНайдено меньшее количество твитов по запросу #" + + keyWord + ".\n"); + } + + } catch (TwitterException te) { + //te.printStackTrace(); + System.out.println(te.getMessage()); + } + } +} diff --git a/EkaterinaVishnevskaya/src/main/java/ru/fizteh/fivt/students/EkaterinaVishnevskaya/moduletests/Main.java b/EkaterinaVishnevskaya/src/main/java/ru/fizteh/fivt/students/EkaterinaVishnevskaya/moduletests/Main.java new file mode 100644 index 00000000..87de7aca --- /dev/null +++ b/EkaterinaVishnevskaya/src/main/java/ru/fizteh/fivt/students/EkaterinaVishnevskaya/moduletests/Main.java @@ -0,0 +1,35 @@ +package ru.fizteh.fivt.students.EkaterinaVishnevskaya.ModuleTests; + +import ru.fizteh.fivt.students.EkaterinaVishnevskaya.ModuleTests.library.TwitterService; +import ru.fizteh.fivt.students.EkaterinaVishnevskaya.ModuleTests.library.TwitterServiceImpl; +import twitter4j.TwitterException; +import twitter4j.TwitterFactory; +import twitter4j.TwitterStreamFactory; + + +public class Main { + + public static void main(String[] args) { + if (args.length != 1) { + System.out.println("Неверные параметры. Нужно: Main "); + System.exit(1); + } + + TwitterService twitterService = + new TwitterServiceImpl(TwitterFactory.getSingleton(), TwitterStreamFactory.getSingleton()); + try { + System.out.println("Query result:"); + twitterService.getFormattedTweets(args[0]) + .forEach(System.out::println); + + System.out.println(); + System.out.println("And new ones with streaming:"); + twitterService.listenForTweets(args[0], System.out::println); + } catch (TwitterException e) { + System.out.println("Ошибка при получении твитов."); + + e.printStackTrace(); + System.exit(1); + } + } +} diff --git a/EkaterinaVishnevskaya/src/main/java/ru/fizteh/fivt/students/EkaterinaVishnevskaya/moduletests/library/TwitterService.java b/EkaterinaVishnevskaya/src/main/java/ru/fizteh/fivt/students/EkaterinaVishnevskaya/moduletests/library/TwitterService.java new file mode 100644 index 00000000..df882574 --- /dev/null +++ b/EkaterinaVishnevskaya/src/main/java/ru/fizteh/fivt/students/EkaterinaVishnevskaya/moduletests/library/TwitterService.java @@ -0,0 +1,15 @@ +package ru.fizteh.fivt.students.EkaterinaVishnevskaya.ModuleTests.library; + +import twitter4j.TwitterException; + +import java.util.List; +import java.util.function.Consumer; + +/** + * Created by kormushin on 30.09.15. + */ +public interface TwitterService { + List getFormattedTweets(String query) throws TwitterException; + + void listenForTweets(String query, Consumer listener); +} diff --git a/EkaterinaVishnevskaya/src/main/java/ru/fizteh/fivt/students/EkaterinaVishnevskaya/moduletests/library/TwitterServiceImpl.java b/EkaterinaVishnevskaya/src/main/java/ru/fizteh/fivt/students/EkaterinaVishnevskaya/moduletests/library/TwitterServiceImpl.java new file mode 100644 index 00000000..dc981b60 --- /dev/null +++ b/EkaterinaVishnevskaya/src/main/java/ru/fizteh/fivt/students/EkaterinaVishnevskaya/moduletests/library/TwitterServiceImpl.java @@ -0,0 +1,61 @@ +package ru.fizteh.fivt.students.EkaterinaVishnevskaya.ModuleTests.library; + +import twitter4j.*; + +import java.util.List; +import java.util.function.Consumer; + +import static java.util.stream.Collectors.toList; + + +public class TwitterServiceImpl implements TwitterService { + + private final Twitter twitter; + private final TwitterStream twitterStream; + + + public TwitterServiceImpl(Twitter twitter, TwitterStream twitterStream) { + this.twitter = twitter; + this.twitterStream = twitterStream; + } + + + @Override + public List getFormattedTweets(String query) throws TwitterException { + if (query == null) { + throw new IllegalArgumentException("Query is required"); + } + + return twitter + .search(new Query(query)).getTweets().stream() + .map(this::formatTweet) + .collect(toList()); + } + + /** + * @param query + * @param listener + */ + @Override + public void listenForTweets(String query, Consumer listener) { + twitterStream.addListener(new StatusAdapter() { + @Override + public void onStatus(Status status) { + listener.accept(formatTweet(status)); + } + + @Override + public void onException(Exception ex) { + ex.printStackTrace(); + } + }); + + String[] s = new String[1]; + s[0] = query; + twitterStream.filter(new FilterQuery().track(s)); + } + + private String formatTweet(Status status) { + return "@" + status.getUser().getScreenName() + ": " + status.getText(); + } +} diff --git a/EkaterinaVishnevskaya/src/main/java/ru/fizteh/fivt/students/EkaterinaVishnevskaya/thread/counter.java b/EkaterinaVishnevskaya/src/main/java/ru/fizteh/fivt/students/EkaterinaVishnevskaya/thread/counter.java new file mode 100644 index 00000000..8f9b0b76 --- /dev/null +++ b/EkaterinaVishnevskaya/src/main/java/ru/fizteh/fivt/students/EkaterinaVishnevskaya/thread/counter.java @@ -0,0 +1,201 @@ +package ru.fizteh.fivt.students.EkaterinaVishnevskaya.thread; + +import javax.naming.LimitExceededException; +import java.util.ArrayList; +import java.util.List; +import java.util.Random; +import java.util.concurrent.BlockingQueue; +import java.util.concurrent.LinkedBlockingQueue; +import java.util.concurrent.locks.ReentrantLock; +import java.util.logging.Level; +import java.util.logging.Logger; +import java.util.stream.Collectors; + +import static java.lang.Thread.currentThread; + +/** + * Created by V on 14.12.2015. + */ +class MyRunnable implements Runnable { + private final Object lock; + private final BlockingQueue queue; + + + public MyRunnable(Object lock, BlockingQueue queue) { + this.queue = queue; + this.lock = lock; + } + + public void run() { + synchronized (lock) { + try { + lock.wait(); + queue.put(currentThread().getName()); + } catch (InterruptedException ignore) {/*NOP*/} + } + } +} + +class count{ + private static Object lock = new Object(); + private static BlockingQueue queue = new LinkedBlockingQueue(); + int n; + count(int N){ + n = N; + } + public void muster()throws InterruptedException{ + Thread th[] = new Thread[n]; + for (int k = 0; k < n; k++) { + th[k] = new Thread(new MyRunnable(lock, queue), "Thread - " + k); + th[k].start(); + Thread.sleep(100); + } + + Thread.sleep(100); + + for (int k = 0; k < n; k++) { + synchronized (lock) { + lock.notify(); + } + System.out.println(queue.take()); + th[k].join(); + } + } +} + +class Game{ + private int gamesNumber; + Game(int Num){ + gamesNumber = Num; + } + public void roller()throws InterruptedException{ + Boolean good = false; + results = new ArrayList(); + for( int i = 0; i < gamesNumber; ++i) + { + results.add( false); + } + + while (!good) + { + ArrayList calls = new ArrayList(); + for( int i = 0; i < gamesNumber; ++i) + { + calls.add( new rollcall(i)); + } + calls.forEach((rollcall r) -> { + r.start(); + }); + calls.forEach((rollcall r) -> { + try { + r.join(); + } catch (InterruptedException ex) { + Logger.getLogger(Game.class.getName()).log(Level.SEVERE, null, ex); + } + }); + good = true; + for(Boolean b : results ) + { + if (!b) + { + good = false; + } + } + } + } + + class rollcall extends Thread { + private int index; + public rollcall(int idx){ + index = idx; + } + + @Override + public void run() { + double random = new Random().nextDouble(); + if(random > 0.1) { + System.out.println("Yes"); + results.set(index, Boolean.TRUE); + } + else{ + System.out.println("No"); + results.set(index, Boolean.FALSE); + } + } + } + static public ArrayList results; + +} + +class Queue +{ + private int maxQueueSize; + Queue(int N){ + locker = new ReentrantLock(); + elems = new ArrayList(); + maxQueueSize = N; + } + void offer(List offered) throws LimitExceededException { + if(offered.size()+elems.size() < maxQueueSize){ + locker.lock(); + offered.stream().forEach(p->{ + elems.add(p); + }); + locker.unlock(); + } + else { + throw new LimitExceededException(); + } + } + + List take(int n) throws LimitExceededException { + if(elems.size() > n) { + locker.lock(); + List res = new ArrayList(); + res = elems.stream().limit(n).collect(Collectors.toList()); + for (int i = 0; i < n; ++i) { + elems.remove(0); + } + locker.unlock(); + return res; + } + else{ + throw new LimitExceededException(); + } + + } + + private ArrayList elems; + private ReentrantLock locker; +} + + class counter + { + public static void main (String[] args) throws InterruptedException { + count c = new count(5); + c.muster(); + Game g = new Game(5); + g.roller(); + Queue myQueue = new Queue<>(10); + List myList = new ArrayList<>(); + for(int i = 0 ; i < 8 ; ++i){ + myList.add(i); + } + try{ + myQueue.offer(myList); + } + catch (Exception ex){ + System.out.println(ex.getMessage()); + } + try{ + List returnList = myQueue.take(5); + for(Integer k: returnList){ + System.out.println(k); + } + } + catch (Exception ex){ + System.out.println(ex.getMessage()); + } + } + } + diff --git a/EkaterinaVishnevskaya/src/test/java/ru/fizteh/fivt/students/EkaterinaVishnevskaya/ModuleTest/AppTest.java b/EkaterinaVishnevskaya/src/test/java/ru/fizteh/fivt/students/EkaterinaVishnevskaya/ModuleTest/AppTest.java new file mode 100644 index 00000000..1b6783c3 --- /dev/null +++ b/EkaterinaVishnevskaya/src/test/java/ru/fizteh/fivt/students/EkaterinaVishnevskaya/ModuleTest/AppTest.java @@ -0,0 +1,38 @@ +package test.java.ru.fizteh.fivt.students.EkaterinaVishnevskaya.ModuleTest; + +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/EkaterinaVishnevskaya/src/test/java/ru/fizteh/fivt/students/EkaterinaVishnevskaya/ModuleTest/library/TwitterTest.java b/EkaterinaVishnevskaya/src/test/java/ru/fizteh/fivt/students/EkaterinaVishnevskaya/ModuleTest/library/TwitterTest.java new file mode 100644 index 00000000..97243904 --- /dev/null +++ b/EkaterinaVishnevskaya/src/test/java/ru/fizteh/fivt/students/EkaterinaVishnevskaya/ModuleTest/library/TwitterTest.java @@ -0,0 +1,113 @@ +package ru.fizteh.fivt.students.akormushin.moduletests.library; + +import org.junit.Before; +import org.junit.BeforeClass; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.ArgumentCaptor; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.runners.MockitoJUnitRunner; +import ru.fizteh.fivt.students.EkaterinaVishnevskaya.Moduletest.library.TwitterServiceImpl; +import ru.fizteh.fivt.students.EkaterinaVishnevskaya.TwitterStream.Printing; +import twitter4j.*; + +import java.io.File; +import java.io.PrintStream; +import java.io.PrintWriter; +import java.lang.String; +import java.lang.System; +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; + +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.Matchers.*; +import static org.mockito.Matchers.any; +import static org.mockito.Matchers.argThat; +import static org.mockito.Mockito.*; + + +@RunWith(MockitoJUnitRunner.class) +public class TwitterlTest { + + @Mock + private Twitter twitter; + + @Mock + private TwitterStream twitterStream; + + @BeforeClass + public static void loadSampleData() { + statuses = Twitter4jTestUtils.tweetsFromJson("/search-java-response.json"); + } + + @Before + public void setUp() throws Exception { + QueryResult queryResult = mock(QueryResult.class); + when(queryResult.getTweets()).thenReturn(statuses); + + when(twitter.search(argThat(hasProperty("query", equalTo("java"))))) + .thenReturn(queryResult); + + QueryResult emptyQueryResult = mock(QueryResult.class); + when(emptyQueryResult.getTweets()).thenReturn(Collections.emptyList()); + + when(twitter.search(argThat(hasProperty("query", not(equalTo("java")))))) + .thenReturn(emptyQueryResult); + } + + @Test + public void testGetFormattedTweets() throws Exception { + List tweets = twitterService.getFormattedTweets("java"); + + assertThat(tweets, hasSize(15)); + assertThat(tweets, hasItems( + "@lxwalls: RT @Space_Station: How do astronauts take their coffee?\n#NationalCoffeeDay \nhttp://t.co/fx4lQcu0Xp http://t.co/NbOZoQDags", + "@Ankit__Tomar: #Hiring Java Lead Developer - Click here for job details : http://t.co/0slLn3YVTW" + )); + + verify(twitter).search(argThat(hasProperty("query", equalTo("java")))); + } + + + @Test + public void testListenForTweets() throws Exception { + //Use ArgumentCaptor to remember argument between different stub invocations + ArgumentCaptor statusListener = ArgumentCaptor.forClass(StatusListener.class); + //Mocking void method + doNothing().when(twitterStream).addListener((StatusListener) statusListener.capture()); + doAnswer(i -> { + statuses.forEach(s -> statusListener.getValue().onStatus(s)); + return null; + }).when(twitterStream).filter(any(FilterQuery.class)); + + List tweets = new ArrayList<>(); + + twitterService.listenForTweets("java", tweets::add); + + assertThat(tweets, hasSize(15)); + assertThat(tweets, hasItems( + "@lxwalls: RT @Space_Station: How do astronauts take their coffee?\n#NationalCoffeeDay \nhttp://t.co/fx4lQcu0Xp http://t.co/NbOZoQDags", + "@Ankit__Tomar: #Hiring Java Lead Developer - Click here for job details : http://t.co/0slLn3YVTW" + )); + + verify(twitterStream).addListener((StatusListener) any(StatusAdapter.class)); + verify(twitterStream).filter(any(FilterQuery.class)); + } + + @Test + public void testPrintingName() throws Exception { + assert Printing.formatName("miptdihtjava2015") == "\u001B[36m" + "@mmiptdihtjava2015" + "+\u001B[0m" + ": "; + } + + @Test + public void testPrintingRTStatus() throws Exception { + assert Printing.formatStatus("RT @mipt: a", true, 5) == "\u001B[31m" + " ретвитнул " + formatName("mipt") + "a"; + } + + @Test + public void testPrintingNotRTStatus() throws Exception { + assert Printing.formatStatus("This is java!!!", false, 5) =="This is java!!! (5 ретвитов)"; + } +} \ No newline at end of file diff --git a/pom.xml b/pom.xml index e5997648..0756c0fc 100644 --- a/pom.xml +++ b/pom.xml @@ -1,5 +1,5 @@ - - + 4.0.0 ru.fizteh.fivt.students @@ -22,21 +22,32 @@ egiby akormushin + + okalitova xmanatee mamaevads cache-nez ocksumoron zerts thefacetakt + loulett riazanovskiy andrewgark fminkin sergmiller zakharovas zemen + w4r10ck1337 + preidman + Jettriangle + nmakeenkov - preidman - + oshch + ladyae + nikitarykov + duha666 + EkaterinaVishnevskaya +