Datasets:
jitx
/
Methods2Test_java_unit_test_code

Dataset card Data Studio Files Community
target
stringlengths
20
113k
src_fm
stringlengths
11
86.3k
src_fm_fc
stringlengths
21
86.4k
src_fm_fc_co
stringlengths
30
86.4k
src_fm_fc_ms
stringlengths
42
86.8k
src_fm_fc_ms_ff
stringlengths
43
86.8k
@Test public void any_length_delimiter() { Assert.assertEquals(6, this.calculator.add(" }
public int add(String input) { if ("".equals(input)) return 0; String delimiter = extractDelimiter(input); String[] numberArray = extractNumbers(input, delimiter); return sumNumberArray(numberArray); }
StringCalculator { public int add(String input) { if ("".equals(input)) return 0; String delimiter = extractDelimiter(input); String[] numberArray = extractNumbers(input, delimiter); return sumNumberArray(numberArray); } }
StringCalculator { public int add(String input) { if ("".equals(input)) return 0; String delimiter = extractDelimiter(input); String[] numberArray = extractNumbers(input, delimiter); return sumNumberArray(numberArray); } }
StringCalculator { public int add(String input) { if ("".equals(input)) return 0; String delimiter = extractDelimiter(input); String[] numberArray = extractNumbers(input, delimiter); return sumNumberArray(numberArray); } int add(String input); }
StringCalculator { public int add(String input) { if ("".equals(input)) return 0; String delimiter = extractDelimiter(input); String[] numberArray = extractNumbers(input, delimiter); return sumNumberArray(numberArray); } int add(String input); }
@Test public void any_multiple_length_delimiter() { Assert.assertEquals(6, this.calculator.add(" }
public int add(String input) { if ("".equals(input)) return 0; String delimiter = extractDelimiter(input); String[] numberArray = extractNumbers(input, delimiter); return sumNumberArray(numberArray); }
StringCalculator { public int add(String input) { if ("".equals(input)) return 0; String delimiter = extractDelimiter(input); String[] numberArray = extractNumbers(input, delimiter); return sumNumberArray(numberArray); } }
StringCalculator { public int add(String input) { if ("".equals(input)) return 0; String delimiter = extractDelimiter(input); String[] numberArray = extractNumbers(input, delimiter); return sumNumberArray(numberArray); } }
StringCalculator { public int add(String input) { if ("".equals(input)) return 0; String delimiter = extractDelimiter(input); String[] numberArray = extractNumbers(input, delimiter); return sumNumberArray(numberArray); } int add(String input); }
StringCalculator { public int add(String input) { if ("".equals(input)) return 0; String delimiter = extractDelimiter(input); String[] numberArray = extractNumbers(input, delimiter); return sumNumberArray(numberArray); } int add(String input); }
@Test public void emptyStringReturnsZero() { assertEquals(0, this.stringCalculator.add("")); }
public int add(String input) { if (input.isEmpty()) return 0; String delimiter = getDelimiter(input); String numbers = getNumbers(input); return calculateSum(numbers.split(delimiter)); }
StringCalculator { public int add(String input) { if (input.isEmpty()) return 0; String delimiter = getDelimiter(input); String numbers = getNumbers(input); return calculateSum(numbers.split(delimiter)); } }
StringCalculator { public int add(String input) { if (input.isEmpty()) return 0; String delimiter = getDelimiter(input); String numbers = getNumbers(input); return calculateSum(numbers.split(delimiter)); } }
StringCalculator { public int add(String input) { if (input.isEmpty()) return 0; String delimiter = getDelimiter(input); String numbers = getNumbers(input); return calculateSum(numbers.split(delimiter)); } int add(String input); }
StringCalculator { public int add(String input) { if (input.isEmpty()) return 0; String delimiter = getDelimiter(input); String numbers = getNumbers(input); return calculateSum(numbers.split(delimiter)); } int add(String input); }
@Test public void numberStringReturnsNumber() { assertEquals(1, this.stringCalculator.add("1")); }
public int add(String input) { if (input.isEmpty()) return 0; String delimiter = getDelimiter(input); String numbers = getNumbers(input); return calculateSum(numbers.split(delimiter)); }
StringCalculator { public int add(String input) { if (input.isEmpty()) return 0; String delimiter = getDelimiter(input); String numbers = getNumbers(input); return calculateSum(numbers.split(delimiter)); } }
StringCalculator { public int add(String input) { if (input.isEmpty()) return 0; String delimiter = getDelimiter(input); String numbers = getNumbers(input); return calculateSum(numbers.split(delimiter)); } }
StringCalculator { public int add(String input) { if (input.isEmpty()) return 0; String delimiter = getDelimiter(input); String numbers = getNumbers(input); return calculateSum(numbers.split(delimiter)); } int add(String input); }
StringCalculator { public int add(String input) { if (input.isEmpty()) return 0; String delimiter = getDelimiter(input); String numbers = getNumbers(input); return calculateSum(numbers.split(delimiter)); } int add(String input); }
@Test public void stringNumbersCommaDelimitedReturnsSum() { assertEquals(3, this.stringCalculator.add("1,2")); }
public int add(String input) { if (input.isEmpty()) return 0; String delimiter = getDelimiter(input); String numbers = getNumbers(input); return calculateSum(numbers.split(delimiter)); }
StringCalculator { public int add(String input) { if (input.isEmpty()) return 0; String delimiter = getDelimiter(input); String numbers = getNumbers(input); return calculateSum(numbers.split(delimiter)); } }
StringCalculator { public int add(String input) { if (input.isEmpty()) return 0; String delimiter = getDelimiter(input); String numbers = getNumbers(input); return calculateSum(numbers.split(delimiter)); } }
StringCalculator { public int add(String input) { if (input.isEmpty()) return 0; String delimiter = getDelimiter(input); String numbers = getNumbers(input); return calculateSum(numbers.split(delimiter)); } int add(String input); }
StringCalculator { public int add(String input) { if (input.isEmpty()) return 0; String delimiter = getDelimiter(input); String numbers = getNumbers(input); return calculateSum(numbers.split(delimiter)); } int add(String input); }
@Test public void TestNumberStringReturnValue() { Assert.assertEquals(1, stringCalculator.add("1")); Assert.assertEquals(2, stringCalculator.add("2")); }
public int add(String input) { if ("".equals(input)) { return 0; } String numbers = extractNumbers(input); String delimiter = extractDelimiter(input); return stringSum(numbers, delimiter); }
StringCalculator { public int add(String input) { if ("".equals(input)) { return 0; } String numbers = extractNumbers(input); String delimiter = extractDelimiter(input); return stringSum(numbers, delimiter); } }
StringCalculator { public int add(String input) { if ("".equals(input)) { return 0; } String numbers = extractNumbers(input); String delimiter = extractDelimiter(input); return stringSum(numbers, delimiter); } }
StringCalculator { public int add(String input) { if ("".equals(input)) { return 0; } String numbers = extractNumbers(input); String delimiter = extractDelimiter(input); return stringSum(numbers, delimiter); } int add(String input); }
StringCalculator { public int add(String input) { if ("".equals(input)) { return 0; } String numbers = extractNumbers(input); String delimiter = extractDelimiter(input); return stringSum(numbers, delimiter); } int add(String input); }
@Test public void multipleStringNumbersCommaDelimitedReturnsSum() { assertEquals(6, this.stringCalculator.add("1,2,3")); }
public int add(String input) { if (input.isEmpty()) return 0; String delimiter = getDelimiter(input); String numbers = getNumbers(input); return calculateSum(numbers.split(delimiter)); }
StringCalculator { public int add(String input) { if (input.isEmpty()) return 0; String delimiter = getDelimiter(input); String numbers = getNumbers(input); return calculateSum(numbers.split(delimiter)); } }
StringCalculator { public int add(String input) { if (input.isEmpty()) return 0; String delimiter = getDelimiter(input); String numbers = getNumbers(input); return calculateSum(numbers.split(delimiter)); } }
StringCalculator { public int add(String input) { if (input.isEmpty()) return 0; String delimiter = getDelimiter(input); String numbers = getNumbers(input); return calculateSum(numbers.split(delimiter)); } int add(String input); }
StringCalculator { public int add(String input) { if (input.isEmpty()) return 0; String delimiter = getDelimiter(input); String numbers = getNumbers(input); return calculateSum(numbers.split(delimiter)); } int add(String input); }
@Test public void multipleStringNumbersCommaOrReturnLineDelimitedReturnsSum() { assertEquals(6, this.stringCalculator.add("1\n2,3")); assertEquals(6, this.stringCalculator.add("1,2\n3")); }
public int add(String input) { if (input.isEmpty()) return 0; String delimiter = getDelimiter(input); String numbers = getNumbers(input); return calculateSum(numbers.split(delimiter)); }
StringCalculator { public int add(String input) { if (input.isEmpty()) return 0; String delimiter = getDelimiter(input); String numbers = getNumbers(input); return calculateSum(numbers.split(delimiter)); } }
StringCalculator { public int add(String input) { if (input.isEmpty()) return 0; String delimiter = getDelimiter(input); String numbers = getNumbers(input); return calculateSum(numbers.split(delimiter)); } }
StringCalculator { public int add(String input) { if (input.isEmpty()) return 0; String delimiter = getDelimiter(input); String numbers = getNumbers(input); return calculateSum(numbers.split(delimiter)); } int add(String input); }
StringCalculator { public int add(String input) { if (input.isEmpty()) return 0; String delimiter = getDelimiter(input); String numbers = getNumbers(input); return calculateSum(numbers.split(delimiter)); } int add(String input); }
@Test public void multipleStringNumbersCustomDelimitedReturnsSum() { assertEquals("Should return 3", 3, this.stringCalculator.add(" }
public int add(String input) { if (input.isEmpty()) return 0; String delimiter = getDelimiter(input); String numbers = getNumbers(input); return calculateSum(numbers.split(delimiter)); }
StringCalculator { public int add(String input) { if (input.isEmpty()) return 0; String delimiter = getDelimiter(input); String numbers = getNumbers(input); return calculateSum(numbers.split(delimiter)); } }
StringCalculator { public int add(String input) { if (input.isEmpty()) return 0; String delimiter = getDelimiter(input); String numbers = getNumbers(input); return calculateSum(numbers.split(delimiter)); } }
StringCalculator { public int add(String input) { if (input.isEmpty()) return 0; String delimiter = getDelimiter(input); String numbers = getNumbers(input); return calculateSum(numbers.split(delimiter)); } int add(String input); }
StringCalculator { public int add(String input) { if (input.isEmpty()) return 0; String delimiter = getDelimiter(input); String numbers = getNumbers(input); return calculateSum(numbers.split(delimiter)); } int add(String input); }
@Test public final void sameMovesReturnDraw() { Assert.assertEquals(RockPaper.DRAW, this.GAME.play(RockPaper.SCISSORS, RockPaper.SCISSORS)); Assert.assertEquals(RockPaper.DRAW, this.GAME.play(RockPaper.PAPER, RockPaper.PAPER)); Assert.assertEquals(RockPaper.DRAW, this.GAME.play(RockPaper.ROCK, RockPaper.ROCK)); Assert.assertEquals(RockPaper.DRAW, this.GAME.play(RockPaper.LIZZARD, RockPaper.LIZZARD)); Assert.assertEquals(RockPaper.DRAW, this.GAME.play(RockPaper.SPOCK, RockPaper.SPOCK)); }
public final int play(final String playerOne, final String playerTwo) { int response = DRAW; if (isDraw(playerOne, playerTwo)) { response = DRAW; } else if (PAPER.equals(playerOne)) { return checkPaperRulesPlayerOne(playerTwo); } else if (ROCK.equals(playerOne) && PAPER.equals(playerTwo)) { response = WINPLAYERTWO; } else if (SCISSORS.equals(playerOne) && PAPER.equals(playerTwo)) { response = WINPLAYERONE; } else if (ROCK.equals(playerOne) && LIZZARD.equals(playerTwo)) { response = WINPLAYERONE; } else if (LIZZARD.equals(playerOne) && ROCK.equals(playerTwo)) { response = WINPLAYERTWO; } else if (SPOCK.equals(playerOne) && PAPER.equals(playerTwo)) { response = WINPLAYERTWO; } return response; }
RockPaper { public final int play(final String playerOne, final String playerTwo) { int response = DRAW; if (isDraw(playerOne, playerTwo)) { response = DRAW; } else if (PAPER.equals(playerOne)) { return checkPaperRulesPlayerOne(playerTwo); } else if (ROCK.equals(playerOne) && PAPER.equals(playerTwo)) { response = WINPLAYERTWO; } else if (SCISSORS.equals(playerOne) && PAPER.equals(playerTwo)) { response = WINPLAYERONE; } else if (ROCK.equals(playerOne) && LIZZARD.equals(playerTwo)) { response = WINPLAYERONE; } else if (LIZZARD.equals(playerOne) && ROCK.equals(playerTwo)) { response = WINPLAYERTWO; } else if (SPOCK.equals(playerOne) && PAPER.equals(playerTwo)) { response = WINPLAYERTWO; } return response; } }
RockPaper { public final int play(final String playerOne, final String playerTwo) { int response = DRAW; if (isDraw(playerOne, playerTwo)) { response = DRAW; } else if (PAPER.equals(playerOne)) { return checkPaperRulesPlayerOne(playerTwo); } else if (ROCK.equals(playerOne) && PAPER.equals(playerTwo)) { response = WINPLAYERTWO; } else if (SCISSORS.equals(playerOne) && PAPER.equals(playerTwo)) { response = WINPLAYERONE; } else if (ROCK.equals(playerOne) && LIZZARD.equals(playerTwo)) { response = WINPLAYERONE; } else if (LIZZARD.equals(playerOne) && ROCK.equals(playerTwo)) { response = WINPLAYERTWO; } else if (SPOCK.equals(playerOne) && PAPER.equals(playerTwo)) { response = WINPLAYERTWO; } return response; } }
RockPaper { public final int play(final String playerOne, final String playerTwo) { int response = DRAW; if (isDraw(playerOne, playerTwo)) { response = DRAW; } else if (PAPER.equals(playerOne)) { return checkPaperRulesPlayerOne(playerTwo); } else if (ROCK.equals(playerOne) && PAPER.equals(playerTwo)) { response = WINPLAYERTWO; } else if (SCISSORS.equals(playerOne) && PAPER.equals(playerTwo)) { response = WINPLAYERONE; } else if (ROCK.equals(playerOne) && LIZZARD.equals(playerTwo)) { response = WINPLAYERONE; } else if (LIZZARD.equals(playerOne) && ROCK.equals(playerTwo)) { response = WINPLAYERTWO; } else if (SPOCK.equals(playerOne) && PAPER.equals(playerTwo)) { response = WINPLAYERTWO; } return response; } final int play(final String playerOne, final String playerTwo); }
RockPaper { public final int play(final String playerOne, final String playerTwo) { int response = DRAW; if (isDraw(playerOne, playerTwo)) { response = DRAW; } else if (PAPER.equals(playerOne)) { return checkPaperRulesPlayerOne(playerTwo); } else if (ROCK.equals(playerOne) && PAPER.equals(playerTwo)) { response = WINPLAYERTWO; } else if (SCISSORS.equals(playerOne) && PAPER.equals(playerTwo)) { response = WINPLAYERONE; } else if (ROCK.equals(playerOne) && LIZZARD.equals(playerTwo)) { response = WINPLAYERONE; } else if (LIZZARD.equals(playerOne) && ROCK.equals(playerTwo)) { response = WINPLAYERTWO; } else if (SPOCK.equals(playerOne) && PAPER.equals(playerTwo)) { response = WINPLAYERTWO; } return response; } final int play(final String playerOne, final String playerTwo); static final int DRAW; static final int WINPLAYERONE; static final int WINPLAYERTWO; static final String SPOCK; static final String LIZZARD; static final String ROCK; static final String PAPER; static final String SCISSORS; }
@Test public final void scissorsCutPaper() { Assert.assertEquals(RockPaper.WINPLAYERONE, this.GAME.play(RockPaper.SCISSORS, RockPaper.PAPER)); Assert.assertEquals(RockPaper.WINPLAYERTWO, this.GAME.play(RockPaper.PAPER, RockPaper.SCISSORS)); }
public final int play(final String playerOne, final String playerTwo) { int response = DRAW; if (isDraw(playerOne, playerTwo)) { response = DRAW; } else if (PAPER.equals(playerOne)) { return checkPaperRulesPlayerOne(playerTwo); } else if (ROCK.equals(playerOne) && PAPER.equals(playerTwo)) { response = WINPLAYERTWO; } else if (SCISSORS.equals(playerOne) && PAPER.equals(playerTwo)) { response = WINPLAYERONE; } else if (ROCK.equals(playerOne) && LIZZARD.equals(playerTwo)) { response = WINPLAYERONE; } else if (LIZZARD.equals(playerOne) && ROCK.equals(playerTwo)) { response = WINPLAYERTWO; } else if (SPOCK.equals(playerOne) && PAPER.equals(playerTwo)) { response = WINPLAYERTWO; } return response; }
RockPaper { public final int play(final String playerOne, final String playerTwo) { int response = DRAW; if (isDraw(playerOne, playerTwo)) { response = DRAW; } else if (PAPER.equals(playerOne)) { return checkPaperRulesPlayerOne(playerTwo); } else if (ROCK.equals(playerOne) && PAPER.equals(playerTwo)) { response = WINPLAYERTWO; } else if (SCISSORS.equals(playerOne) && PAPER.equals(playerTwo)) { response = WINPLAYERONE; } else if (ROCK.equals(playerOne) && LIZZARD.equals(playerTwo)) { response = WINPLAYERONE; } else if (LIZZARD.equals(playerOne) && ROCK.equals(playerTwo)) { response = WINPLAYERTWO; } else if (SPOCK.equals(playerOne) && PAPER.equals(playerTwo)) { response = WINPLAYERTWO; } return response; } }
RockPaper { public final int play(final String playerOne, final String playerTwo) { int response = DRAW; if (isDraw(playerOne, playerTwo)) { response = DRAW; } else if (PAPER.equals(playerOne)) { return checkPaperRulesPlayerOne(playerTwo); } else if (ROCK.equals(playerOne) && PAPER.equals(playerTwo)) { response = WINPLAYERTWO; } else if (SCISSORS.equals(playerOne) && PAPER.equals(playerTwo)) { response = WINPLAYERONE; } else if (ROCK.equals(playerOne) && LIZZARD.equals(playerTwo)) { response = WINPLAYERONE; } else if (LIZZARD.equals(playerOne) && ROCK.equals(playerTwo)) { response = WINPLAYERTWO; } else if (SPOCK.equals(playerOne) && PAPER.equals(playerTwo)) { response = WINPLAYERTWO; } return response; } }
RockPaper { public final int play(final String playerOne, final String playerTwo) { int response = DRAW; if (isDraw(playerOne, playerTwo)) { response = DRAW; } else if (PAPER.equals(playerOne)) { return checkPaperRulesPlayerOne(playerTwo); } else if (ROCK.equals(playerOne) && PAPER.equals(playerTwo)) { response = WINPLAYERTWO; } else if (SCISSORS.equals(playerOne) && PAPER.equals(playerTwo)) { response = WINPLAYERONE; } else if (ROCK.equals(playerOne) && LIZZARD.equals(playerTwo)) { response = WINPLAYERONE; } else if (LIZZARD.equals(playerOne) && ROCK.equals(playerTwo)) { response = WINPLAYERTWO; } else if (SPOCK.equals(playerOne) && PAPER.equals(playerTwo)) { response = WINPLAYERTWO; } return response; } final int play(final String playerOne, final String playerTwo); }
RockPaper { public final int play(final String playerOne, final String playerTwo) { int response = DRAW; if (isDraw(playerOne, playerTwo)) { response = DRAW; } else if (PAPER.equals(playerOne)) { return checkPaperRulesPlayerOne(playerTwo); } else if (ROCK.equals(playerOne) && PAPER.equals(playerTwo)) { response = WINPLAYERTWO; } else if (SCISSORS.equals(playerOne) && PAPER.equals(playerTwo)) { response = WINPLAYERONE; } else if (ROCK.equals(playerOne) && LIZZARD.equals(playerTwo)) { response = WINPLAYERONE; } else if (LIZZARD.equals(playerOne) && ROCK.equals(playerTwo)) { response = WINPLAYERTWO; } else if (SPOCK.equals(playerOne) && PAPER.equals(playerTwo)) { response = WINPLAYERTWO; } return response; } final int play(final String playerOne, final String playerTwo); static final int DRAW; static final int WINPLAYERONE; static final int WINPLAYERTWO; static final String SPOCK; static final String LIZZARD; static final String ROCK; static final String PAPER; static final String SCISSORS; }
@Test public final void paperCoversRock() { Assert.assertEquals(RockPaper.WINPLAYERONE, this.GAME.play(RockPaper.PAPER, RockPaper.ROCK)); Assert.assertEquals(RockPaper.WINPLAYERTWO, this.GAME.play(RockPaper.ROCK, RockPaper.PAPER)); }
public final int play(final String playerOne, final String playerTwo) { int response = DRAW; if (isDraw(playerOne, playerTwo)) { response = DRAW; } else if (PAPER.equals(playerOne)) { return checkPaperRulesPlayerOne(playerTwo); } else if (ROCK.equals(playerOne) && PAPER.equals(playerTwo)) { response = WINPLAYERTWO; } else if (SCISSORS.equals(playerOne) && PAPER.equals(playerTwo)) { response = WINPLAYERONE; } else if (ROCK.equals(playerOne) && LIZZARD.equals(playerTwo)) { response = WINPLAYERONE; } else if (LIZZARD.equals(playerOne) && ROCK.equals(playerTwo)) { response = WINPLAYERTWO; } else if (SPOCK.equals(playerOne) && PAPER.equals(playerTwo)) { response = WINPLAYERTWO; } return response; }
RockPaper { public final int play(final String playerOne, final String playerTwo) { int response = DRAW; if (isDraw(playerOne, playerTwo)) { response = DRAW; } else if (PAPER.equals(playerOne)) { return checkPaperRulesPlayerOne(playerTwo); } else if (ROCK.equals(playerOne) && PAPER.equals(playerTwo)) { response = WINPLAYERTWO; } else if (SCISSORS.equals(playerOne) && PAPER.equals(playerTwo)) { response = WINPLAYERONE; } else if (ROCK.equals(playerOne) && LIZZARD.equals(playerTwo)) { response = WINPLAYERONE; } else if (LIZZARD.equals(playerOne) && ROCK.equals(playerTwo)) { response = WINPLAYERTWO; } else if (SPOCK.equals(playerOne) && PAPER.equals(playerTwo)) { response = WINPLAYERTWO; } return response; } }
RockPaper { public final int play(final String playerOne, final String playerTwo) { int response = DRAW; if (isDraw(playerOne, playerTwo)) { response = DRAW; } else if (PAPER.equals(playerOne)) { return checkPaperRulesPlayerOne(playerTwo); } else if (ROCK.equals(playerOne) && PAPER.equals(playerTwo)) { response = WINPLAYERTWO; } else if (SCISSORS.equals(playerOne) && PAPER.equals(playerTwo)) { response = WINPLAYERONE; } else if (ROCK.equals(playerOne) && LIZZARD.equals(playerTwo)) { response = WINPLAYERONE; } else if (LIZZARD.equals(playerOne) && ROCK.equals(playerTwo)) { response = WINPLAYERTWO; } else if (SPOCK.equals(playerOne) && PAPER.equals(playerTwo)) { response = WINPLAYERTWO; } return response; } }
RockPaper { public final int play(final String playerOne, final String playerTwo) { int response = DRAW; if (isDraw(playerOne, playerTwo)) { response = DRAW; } else if (PAPER.equals(playerOne)) { return checkPaperRulesPlayerOne(playerTwo); } else if (ROCK.equals(playerOne) && PAPER.equals(playerTwo)) { response = WINPLAYERTWO; } else if (SCISSORS.equals(playerOne) && PAPER.equals(playerTwo)) { response = WINPLAYERONE; } else if (ROCK.equals(playerOne) && LIZZARD.equals(playerTwo)) { response = WINPLAYERONE; } else if (LIZZARD.equals(playerOne) && ROCK.equals(playerTwo)) { response = WINPLAYERTWO; } else if (SPOCK.equals(playerOne) && PAPER.equals(playerTwo)) { response = WINPLAYERTWO; } return response; } final int play(final String playerOne, final String playerTwo); }
RockPaper { public final int play(final String playerOne, final String playerTwo) { int response = DRAW; if (isDraw(playerOne, playerTwo)) { response = DRAW; } else if (PAPER.equals(playerOne)) { return checkPaperRulesPlayerOne(playerTwo); } else if (ROCK.equals(playerOne) && PAPER.equals(playerTwo)) { response = WINPLAYERTWO; } else if (SCISSORS.equals(playerOne) && PAPER.equals(playerTwo)) { response = WINPLAYERONE; } else if (ROCK.equals(playerOne) && LIZZARD.equals(playerTwo)) { response = WINPLAYERONE; } else if (LIZZARD.equals(playerOne) && ROCK.equals(playerTwo)) { response = WINPLAYERTWO; } else if (SPOCK.equals(playerOne) && PAPER.equals(playerTwo)) { response = WINPLAYERTWO; } return response; } final int play(final String playerOne, final String playerTwo); static final int DRAW; static final int WINPLAYERONE; static final int WINPLAYERTWO; static final String SPOCK; static final String LIZZARD; static final String ROCK; static final String PAPER; static final String SCISSORS; }
@Test public final void rockCrushersLizard() { Assert.assertEquals(RockPaper.WINPLAYERONE, this.GAME.play(RockPaper.ROCK, RockPaper.LIZZARD)); Assert.assertEquals(RockPaper.WINPLAYERTWO, this.GAME.play(RockPaper.LIZZARD, RockPaper.ROCK)); }
public final int play(final String playerOne, final String playerTwo) { int response = DRAW; if (isDraw(playerOne, playerTwo)) { response = DRAW; } else if (PAPER.equals(playerOne)) { return checkPaperRulesPlayerOne(playerTwo); } else if (ROCK.equals(playerOne) && PAPER.equals(playerTwo)) { response = WINPLAYERTWO; } else if (SCISSORS.equals(playerOne) && PAPER.equals(playerTwo)) { response = WINPLAYERONE; } else if (ROCK.equals(playerOne) && LIZZARD.equals(playerTwo)) { response = WINPLAYERONE; } else if (LIZZARD.equals(playerOne) && ROCK.equals(playerTwo)) { response = WINPLAYERTWO; } else if (SPOCK.equals(playerOne) && PAPER.equals(playerTwo)) { response = WINPLAYERTWO; } return response; }
RockPaper { public final int play(final String playerOne, final String playerTwo) { int response = DRAW; if (isDraw(playerOne, playerTwo)) { response = DRAW; } else if (PAPER.equals(playerOne)) { return checkPaperRulesPlayerOne(playerTwo); } else if (ROCK.equals(playerOne) && PAPER.equals(playerTwo)) { response = WINPLAYERTWO; } else if (SCISSORS.equals(playerOne) && PAPER.equals(playerTwo)) { response = WINPLAYERONE; } else if (ROCK.equals(playerOne) && LIZZARD.equals(playerTwo)) { response = WINPLAYERONE; } else if (LIZZARD.equals(playerOne) && ROCK.equals(playerTwo)) { response = WINPLAYERTWO; } else if (SPOCK.equals(playerOne) && PAPER.equals(playerTwo)) { response = WINPLAYERTWO; } return response; } }
RockPaper { public final int play(final String playerOne, final String playerTwo) { int response = DRAW; if (isDraw(playerOne, playerTwo)) { response = DRAW; } else if (PAPER.equals(playerOne)) { return checkPaperRulesPlayerOne(playerTwo); } else if (ROCK.equals(playerOne) && PAPER.equals(playerTwo)) { response = WINPLAYERTWO; } else if (SCISSORS.equals(playerOne) && PAPER.equals(playerTwo)) { response = WINPLAYERONE; } else if (ROCK.equals(playerOne) && LIZZARD.equals(playerTwo)) { response = WINPLAYERONE; } else if (LIZZARD.equals(playerOne) && ROCK.equals(playerTwo)) { response = WINPLAYERTWO; } else if (SPOCK.equals(playerOne) && PAPER.equals(playerTwo)) { response = WINPLAYERTWO; } return response; } }
RockPaper { public final int play(final String playerOne, final String playerTwo) { int response = DRAW; if (isDraw(playerOne, playerTwo)) { response = DRAW; } else if (PAPER.equals(playerOne)) { return checkPaperRulesPlayerOne(playerTwo); } else if (ROCK.equals(playerOne) && PAPER.equals(playerTwo)) { response = WINPLAYERTWO; } else if (SCISSORS.equals(playerOne) && PAPER.equals(playerTwo)) { response = WINPLAYERONE; } else if (ROCK.equals(playerOne) && LIZZARD.equals(playerTwo)) { response = WINPLAYERONE; } else if (LIZZARD.equals(playerOne) && ROCK.equals(playerTwo)) { response = WINPLAYERTWO; } else if (SPOCK.equals(playerOne) && PAPER.equals(playerTwo)) { response = WINPLAYERTWO; } return response; } final int play(final String playerOne, final String playerTwo); }
RockPaper { public final int play(final String playerOne, final String playerTwo) { int response = DRAW; if (isDraw(playerOne, playerTwo)) { response = DRAW; } else if (PAPER.equals(playerOne)) { return checkPaperRulesPlayerOne(playerTwo); } else if (ROCK.equals(playerOne) && PAPER.equals(playerTwo)) { response = WINPLAYERTWO; } else if (SCISSORS.equals(playerOne) && PAPER.equals(playerTwo)) { response = WINPLAYERONE; } else if (ROCK.equals(playerOne) && LIZZARD.equals(playerTwo)) { response = WINPLAYERONE; } else if (LIZZARD.equals(playerOne) && ROCK.equals(playerTwo)) { response = WINPLAYERTWO; } else if (SPOCK.equals(playerOne) && PAPER.equals(playerTwo)) { response = WINPLAYERTWO; } return response; } final int play(final String playerOne, final String playerTwo); static final int DRAW; static final int WINPLAYERONE; static final int WINPLAYERTWO; static final String SPOCK; static final String LIZZARD; static final String ROCK; static final String PAPER; static final String SCISSORS; }
@Test public final void paperDisprovesSpock() { Assert.assertEquals(RockPaper.WINPLAYERONE, this.GAME.play(RockPaper.PAPER, RockPaper.SPOCK)); Assert.assertEquals(RockPaper.WINPLAYERTWO, this.GAME.play(RockPaper.SPOCK, RockPaper.PAPER)); }
public final int play(final String playerOne, final String playerTwo) { int response = DRAW; if (isDraw(playerOne, playerTwo)) { response = DRAW; } else if (PAPER.equals(playerOne)) { return checkPaperRulesPlayerOne(playerTwo); } else if (ROCK.equals(playerOne) && PAPER.equals(playerTwo)) { response = WINPLAYERTWO; } else if (SCISSORS.equals(playerOne) && PAPER.equals(playerTwo)) { response = WINPLAYERONE; } else if (ROCK.equals(playerOne) && LIZZARD.equals(playerTwo)) { response = WINPLAYERONE; } else if (LIZZARD.equals(playerOne) && ROCK.equals(playerTwo)) { response = WINPLAYERTWO; } else if (SPOCK.equals(playerOne) && PAPER.equals(playerTwo)) { response = WINPLAYERTWO; } return response; }
RockPaper { public final int play(final String playerOne, final String playerTwo) { int response = DRAW; if (isDraw(playerOne, playerTwo)) { response = DRAW; } else if (PAPER.equals(playerOne)) { return checkPaperRulesPlayerOne(playerTwo); } else if (ROCK.equals(playerOne) && PAPER.equals(playerTwo)) { response = WINPLAYERTWO; } else if (SCISSORS.equals(playerOne) && PAPER.equals(playerTwo)) { response = WINPLAYERONE; } else if (ROCK.equals(playerOne) && LIZZARD.equals(playerTwo)) { response = WINPLAYERONE; } else if (LIZZARD.equals(playerOne) && ROCK.equals(playerTwo)) { response = WINPLAYERTWO; } else if (SPOCK.equals(playerOne) && PAPER.equals(playerTwo)) { response = WINPLAYERTWO; } return response; } }
RockPaper { public final int play(final String playerOne, final String playerTwo) { int response = DRAW; if (isDraw(playerOne, playerTwo)) { response = DRAW; } else if (PAPER.equals(playerOne)) { return checkPaperRulesPlayerOne(playerTwo); } else if (ROCK.equals(playerOne) && PAPER.equals(playerTwo)) { response = WINPLAYERTWO; } else if (SCISSORS.equals(playerOne) && PAPER.equals(playerTwo)) { response = WINPLAYERONE; } else if (ROCK.equals(playerOne) && LIZZARD.equals(playerTwo)) { response = WINPLAYERONE; } else if (LIZZARD.equals(playerOne) && ROCK.equals(playerTwo)) { response = WINPLAYERTWO; } else if (SPOCK.equals(playerOne) && PAPER.equals(playerTwo)) { response = WINPLAYERTWO; } return response; } }
RockPaper { public final int play(final String playerOne, final String playerTwo) { int response = DRAW; if (isDraw(playerOne, playerTwo)) { response = DRAW; } else if (PAPER.equals(playerOne)) { return checkPaperRulesPlayerOne(playerTwo); } else if (ROCK.equals(playerOne) && PAPER.equals(playerTwo)) { response = WINPLAYERTWO; } else if (SCISSORS.equals(playerOne) && PAPER.equals(playerTwo)) { response = WINPLAYERONE; } else if (ROCK.equals(playerOne) && LIZZARD.equals(playerTwo)) { response = WINPLAYERONE; } else if (LIZZARD.equals(playerOne) && ROCK.equals(playerTwo)) { response = WINPLAYERTWO; } else if (SPOCK.equals(playerOne) && PAPER.equals(playerTwo)) { response = WINPLAYERTWO; } return response; } final int play(final String playerOne, final String playerTwo); }
RockPaper { public final int play(final String playerOne, final String playerTwo) { int response = DRAW; if (isDraw(playerOne, playerTwo)) { response = DRAW; } else if (PAPER.equals(playerOne)) { return checkPaperRulesPlayerOne(playerTwo); } else if (ROCK.equals(playerOne) && PAPER.equals(playerTwo)) { response = WINPLAYERTWO; } else if (SCISSORS.equals(playerOne) && PAPER.equals(playerTwo)) { response = WINPLAYERONE; } else if (ROCK.equals(playerOne) && LIZZARD.equals(playerTwo)) { response = WINPLAYERONE; } else if (LIZZARD.equals(playerOne) && ROCK.equals(playerTwo)) { response = WINPLAYERTWO; } else if (SPOCK.equals(playerOne) && PAPER.equals(playerTwo)) { response = WINPLAYERTWO; } return response; } final int play(final String playerOne, final String playerTwo); static final int DRAW; static final int WINPLAYERONE; static final int WINPLAYERTWO; static final String SPOCK; static final String LIZZARD; static final String ROCK; static final String PAPER; static final String SCISSORS; }
@Test public void TestTwoNumbersStringReturnSum() { Assert.assertEquals(3, stringCalculator.add("1,2")); Assert.assertEquals(5, stringCalculator.add("2,3")); }
public int add(String input) { if ("".equals(input)) { return 0; } String numbers = extractNumbers(input); String delimiter = extractDelimiter(input); return stringSum(numbers, delimiter); }
StringCalculator { public int add(String input) { if ("".equals(input)) { return 0; } String numbers = extractNumbers(input); String delimiter = extractDelimiter(input); return stringSum(numbers, delimiter); } }
StringCalculator { public int add(String input) { if ("".equals(input)) { return 0; } String numbers = extractNumbers(input); String delimiter = extractDelimiter(input); return stringSum(numbers, delimiter); } }
StringCalculator { public int add(String input) { if ("".equals(input)) { return 0; } String numbers = extractNumbers(input); String delimiter = extractDelimiter(input); return stringSum(numbers, delimiter); } int add(String input); }
StringCalculator { public int add(String input) { if ("".equals(input)) { return 0; } String numbers = extractNumbers(input); String delimiter = extractDelimiter(input); return stringSum(numbers, delimiter); } int add(String input); }
@Test public void TestAnyNumbersStringReturnSum() { Assert.assertEquals(10, stringCalculator.add("1,2,3,4")); }
public int add(String input) { if ("".equals(input)) { return 0; } String numbers = extractNumbers(input); String delimiter = extractDelimiter(input); return stringSum(numbers, delimiter); }
StringCalculator { public int add(String input) { if ("".equals(input)) { return 0; } String numbers = extractNumbers(input); String delimiter = extractDelimiter(input); return stringSum(numbers, delimiter); } }
StringCalculator { public int add(String input) { if ("".equals(input)) { return 0; } String numbers = extractNumbers(input); String delimiter = extractDelimiter(input); return stringSum(numbers, delimiter); } }
StringCalculator { public int add(String input) { if ("".equals(input)) { return 0; } String numbers = extractNumbers(input); String delimiter = extractDelimiter(input); return stringSum(numbers, delimiter); } int add(String input); }
StringCalculator { public int add(String input) { if ("".equals(input)) { return 0; } String numbers = extractNumbers(input); String delimiter = extractDelimiter(input); return stringSum(numbers, delimiter); } int add(String input); }
@Test public void TestAnyNumbersComaOrReturnLineDelimiterStringReturnSum() { Assert.assertEquals(6, stringCalculator.add("1,2\n3")); }
public int add(String input) { if ("".equals(input)) { return 0; } String numbers = extractNumbers(input); String delimiter = extractDelimiter(input); return stringSum(numbers, delimiter); }
StringCalculator { public int add(String input) { if ("".equals(input)) { return 0; } String numbers = extractNumbers(input); String delimiter = extractDelimiter(input); return stringSum(numbers, delimiter); } }
StringCalculator { public int add(String input) { if ("".equals(input)) { return 0; } String numbers = extractNumbers(input); String delimiter = extractDelimiter(input); return stringSum(numbers, delimiter); } }
StringCalculator { public int add(String input) { if ("".equals(input)) { return 0; } String numbers = extractNumbers(input); String delimiter = extractDelimiter(input); return stringSum(numbers, delimiter); } int add(String input); }
StringCalculator { public int add(String input) { if ("".equals(input)) { return 0; } String numbers = extractNumbers(input); String delimiter = extractDelimiter(input); return stringSum(numbers, delimiter); } int add(String input); }
@Test public void TestAnyNumbersCustomDelimiterStringReturnSum() { Assert.assertEquals(3, stringCalculator.add(" }
public int add(String input) { if ("".equals(input)) { return 0; } String numbers = extractNumbers(input); String delimiter = extractDelimiter(input); return stringSum(numbers, delimiter); }
StringCalculator { public int add(String input) { if ("".equals(input)) { return 0; } String numbers = extractNumbers(input); String delimiter = extractDelimiter(input); return stringSum(numbers, delimiter); } }
StringCalculator { public int add(String input) { if ("".equals(input)) { return 0; } String numbers = extractNumbers(input); String delimiter = extractDelimiter(input); return stringSum(numbers, delimiter); } }
StringCalculator { public int add(String input) { if ("".equals(input)) { return 0; } String numbers = extractNumbers(input); String delimiter = extractDelimiter(input); return stringSum(numbers, delimiter); } int add(String input); }
StringCalculator { public int add(String input) { if ("".equals(input)) { return 0; } String numbers = extractNumbers(input); String delimiter = extractDelimiter(input); return stringSum(numbers, delimiter); } int add(String input); }
@Test public void empty_string_return_zero() { Assert.assertEquals(0, this.calculator.add("")); }
public int add(String input) { if ("".equals(input)) return 0; String delimiter = extractDelimiter(input); String[] numberArray = extractNumbers(input, delimiter); return sumNumberArray(numberArray); }
StringCalculator { public int add(String input) { if ("".equals(input)) return 0; String delimiter = extractDelimiter(input); String[] numberArray = extractNumbers(input, delimiter); return sumNumberArray(numberArray); } }
StringCalculator { public int add(String input) { if ("".equals(input)) return 0; String delimiter = extractDelimiter(input); String[] numberArray = extractNumbers(input, delimiter); return sumNumberArray(numberArray); } }
StringCalculator { public int add(String input) { if ("".equals(input)) return 0; String delimiter = extractDelimiter(input); String[] numberArray = extractNumbers(input, delimiter); return sumNumberArray(numberArray); } int add(String input); }
StringCalculator { public int add(String input) { if ("".equals(input)) return 0; String delimiter = extractDelimiter(input); String[] numberArray = extractNumbers(input, delimiter); return sumNumberArray(numberArray); } int add(String input); }
@Test public void one_number_return_number() { Assert.assertEquals(1, this.calculator.add("1")); Assert.assertEquals(2, this.calculator.add("2")); }
public int add(String input) { if ("".equals(input)) return 0; String delimiter = extractDelimiter(input); String[] numberArray = extractNumbers(input, delimiter); return sumNumberArray(numberArray); }
StringCalculator { public int add(String input) { if ("".equals(input)) return 0; String delimiter = extractDelimiter(input); String[] numberArray = extractNumbers(input, delimiter); return sumNumberArray(numberArray); } }
StringCalculator { public int add(String input) { if ("".equals(input)) return 0; String delimiter = extractDelimiter(input); String[] numberArray = extractNumbers(input, delimiter); return sumNumberArray(numberArray); } }
StringCalculator { public int add(String input) { if ("".equals(input)) return 0; String delimiter = extractDelimiter(input); String[] numberArray = extractNumbers(input, delimiter); return sumNumberArray(numberArray); } int add(String input); }
StringCalculator { public int add(String input) { if ("".equals(input)) return 0; String delimiter = extractDelimiter(input); String[] numberArray = extractNumbers(input, delimiter); return sumNumberArray(numberArray); } int add(String input); }
@Test public void two_comma_separated_number_return_sum() { Assert.assertEquals(3, this.calculator.add("1,2")); }
public int add(String input) { if ("".equals(input)) return 0; String delimiter = extractDelimiter(input); String[] numberArray = extractNumbers(input, delimiter); return sumNumberArray(numberArray); }
StringCalculator { public int add(String input) { if ("".equals(input)) return 0; String delimiter = extractDelimiter(input); String[] numberArray = extractNumbers(input, delimiter); return sumNumberArray(numberArray); } }
StringCalculator { public int add(String input) { if ("".equals(input)) return 0; String delimiter = extractDelimiter(input); String[] numberArray = extractNumbers(input, delimiter); return sumNumberArray(numberArray); } }
StringCalculator { public int add(String input) { if ("".equals(input)) return 0; String delimiter = extractDelimiter(input); String[] numberArray = extractNumbers(input, delimiter); return sumNumberArray(numberArray); } int add(String input); }
StringCalculator { public int add(String input) { if ("".equals(input)) return 0; String delimiter = extractDelimiter(input); String[] numberArray = extractNumbers(input, delimiter); return sumNumberArray(numberArray); } int add(String input); }
@Test public void comma_separated_numbers_return_sum() { Assert.assertEquals(6, this.calculator.add("1,2,3")); }
public int add(String input) { if ("".equals(input)) return 0; String delimiter = extractDelimiter(input); String[] numberArray = extractNumbers(input, delimiter); return sumNumberArray(numberArray); }
StringCalculator { public int add(String input) { if ("".equals(input)) return 0; String delimiter = extractDelimiter(input); String[] numberArray = extractNumbers(input, delimiter); return sumNumberArray(numberArray); } }
StringCalculator { public int add(String input) { if ("".equals(input)) return 0; String delimiter = extractDelimiter(input); String[] numberArray = extractNumbers(input, delimiter); return sumNumberArray(numberArray); } }
StringCalculator { public int add(String input) { if ("".equals(input)) return 0; String delimiter = extractDelimiter(input); String[] numberArray = extractNumbers(input, delimiter); return sumNumberArray(numberArray); } int add(String input); }
StringCalculator { public int add(String input) { if ("".equals(input)) return 0; String delimiter = extractDelimiter(input); String[] numberArray = extractNumbers(input, delimiter); return sumNumberArray(numberArray); } int add(String input); }
@Test public void headersAndStatus() { Map<String, List<String>> headers = Maps.newHashMap(); headers.put("Etag", Lists.newArrayList("c1dc8d7be85325149", "ed5fc4d62b84752")); headers.put("Date", Lists.newArrayList("Wed, 11 Jan 2017 13:00:18 GMT")); HashMap<String, String> config = Maps.newHashMap(); HtmlAnalysisResult result = PageAnalyzer.analyze(config, "http: assertEquals(new Integer(200), result.getHttpStatus()); assertEquals(2, result.getHeaders().size()); assertEquals("c1dc8d7be85325149\ned5fc4d62b84752", result.getHeaders().get("Etag")); assertEquals("Wed, 11 Jan 2017 13:00:18 GMT", result.getHeaders().get("Date")); }
public static HtmlAnalysisResult analyze(Map<String, String> config, String url) { try { String userAgent = config.getOrDefault(CONFIG_USER_AGENT, DEFAULT_USER_AGENT); HttpResponse<String> response = Unirest.get(url) .header("User-Agent", userAgent) .asString(); return analyze(config, url, response.getBody(), response.getStatus(), response.getHeaders()); } catch (UnirestException e) { throw new RuntimeException(e); } }
PageAnalyzer { public static HtmlAnalysisResult analyze(Map<String, String> config, String url) { try { String userAgent = config.getOrDefault(CONFIG_USER_AGENT, DEFAULT_USER_AGENT); HttpResponse<String> response = Unirest.get(url) .header("User-Agent", userAgent) .asString(); return analyze(config, url, response.getBody(), response.getStatus(), response.getHeaders()); } catch (UnirestException e) { throw new RuntimeException(e); } } }
PageAnalyzer { public static HtmlAnalysisResult analyze(Map<String, String> config, String url) { try { String userAgent = config.getOrDefault(CONFIG_USER_AGENT, DEFAULT_USER_AGENT); HttpResponse<String> response = Unirest.get(url) .header("User-Agent", userAgent) .asString(); return analyze(config, url, response.getBody(), response.getStatus(), response.getHeaders()); } catch (UnirestException e) { throw new RuntimeException(e); } } }
PageAnalyzer { public static HtmlAnalysisResult analyze(Map<String, String> config, String url) { try { String userAgent = config.getOrDefault(CONFIG_USER_AGENT, DEFAULT_USER_AGENT); HttpResponse<String> response = Unirest.get(url) .header("User-Agent", userAgent) .asString(); return analyze(config, url, response.getBody(), response.getStatus(), response.getHeaders()); } catch (UnirestException e) { throw new RuntimeException(e); } } static HtmlAnalysisResult analyze(Map<String, String> config, String url); static HtmlAnalysisResult analyze(Map<String, String> config, String url, String html); static HtmlAnalysisResult analyze(Map<String, String> config, String url, String html, Integer status, Map<String, List<String>> headers); static void parseRobotsTxt(String userAgent, String robotsUrl, String robotsTxt, HtmlAnalysisResult result); }
PageAnalyzer { public static HtmlAnalysisResult analyze(Map<String, String> config, String url) { try { String userAgent = config.getOrDefault(CONFIG_USER_AGENT, DEFAULT_USER_AGENT); HttpResponse<String> response = Unirest.get(url) .header("User-Agent", userAgent) .asString(); return analyze(config, url, response.getBody(), response.getStatus(), response.getHeaders()); } catch (UnirestException e) { throw new RuntimeException(e); } } static HtmlAnalysisResult analyze(Map<String, String> config, String url); static HtmlAnalysisResult analyze(Map<String, String> config, String url, String html); static HtmlAnalysisResult analyze(Map<String, String> config, String url, String html, Integer status, Map<String, List<String>> headers); static void parseRobotsTxt(String userAgent, String robotsUrl, String robotsTxt, HtmlAnalysisResult result); static final String CONFIG_USER_AGENT; static final String CONFIG_ANALYZE_ROBOTS_TXT; }
@Test public void formats() { MatchedDate matchedDate = new MatchedDate("2017-01-16 01:45:05 -0500", null); MatchedDate parse = DateParser.parse(matchedDate, new HttpSource()); assertEquals("2017-01-16T06:45:05", DataUtils.formatInUTC(parse.getDate())); matchedDate = new MatchedDate("Jan 17, 2017 06:08AM ET", null); parse = DateParser.parse(matchedDate, new HttpSource()); assertEquals("2017-01-17T11:08:00", DataUtils.formatInUTC(parse.getDate())); matchedDate = new MatchedDate("January 18, 2017", null); parse = DateParser.parse(matchedDate, new HttpSource()); assertEquals("2017-01-18T00:00:00", DataUtils.formatInUTC(parse.getDate())); assertEquals("2017-01-18T13:45:00", parse("Wed Jan 18 13:45:00 GMT 2017")); assertEquals("2017-02-14T00:00:00", parse("02142017")); assertEquals("2017-02-27T00:00:00", parse("Monday, February 27, 2017 @ 05:02 PM gHale")); assertEquals("2017-03-09T00:00:00", parse("March 9, 2017 8:43 AM")); assertEquals("2017-03-13T15:49:00", parse("13 Mar, 2017 15:49")); assertEquals("2017-03-13T03:14:28", parse("2017-03-13 03:14:28")); assertEquals("2017-03-10T00:00:00", parse("10 March 2017")); assertEquals("2017-03-09T16:47:21", parse("2017-03-09 16:47:21")); assertEquals("2017-03-09T01:00:00", parse("2017-03-09T01:00:00")); assertEquals("2017-03-10T08:24:19", parse("Fri, 10 Mar 2017 13:54:19 +0530")); assertEquals("2016-08-24T06:42:00", parse("Wed Aug 24, 2016 2:42am EDT")); assertEquals("2017-03-10T12:51:00", parse("March 10, 2017, 14:51 IST")); assertEquals("2016-08-22T18:14:26", parse("Mon, 22 Aug 2016 18:14:26 +0000")); assertEquals("2017-04-13T00:00:00", parse("2017/04/13")); }
public static MatchedDate parse(MatchedDate matchedText, HttpSource source) { String value = Strings.nullToEmpty(matchedText.getValue()).trim(); for (String regexp : source.getDateRegexps()) { Pattern pattern = Pattern.compile(regexp); Matcher matcher = pattern.matcher(value); if (matcher.matches() && matcher.groupCount() > 0) { value = matcher.group(1); } } matchedText.setValue(value.replace("ET", "EST")); List<SimpleDateFormat> customFormatters = formatsToFormatters(source.getDateFormats()); MatchedDate md = Stream.concat(customFormatters.stream(), FORMATTERS.stream()) .map(dateFormat -> parse(matchedText, dateFormat)) .filter(matchedDate -> matchedDate.getDate() != null) .findFirst().orElse(matchedText); if (md.getDate() == null && md.getValue() != null) { md = parseWithTimewords(md, source); } return md; }
DateParser { public static MatchedDate parse(MatchedDate matchedText, HttpSource source) { String value = Strings.nullToEmpty(matchedText.getValue()).trim(); for (String regexp : source.getDateRegexps()) { Pattern pattern = Pattern.compile(regexp); Matcher matcher = pattern.matcher(value); if (matcher.matches() && matcher.groupCount() > 0) { value = matcher.group(1); } } matchedText.setValue(value.replace("ET", "EST")); List<SimpleDateFormat> customFormatters = formatsToFormatters(source.getDateFormats()); MatchedDate md = Stream.concat(customFormatters.stream(), FORMATTERS.stream()) .map(dateFormat -> parse(matchedText, dateFormat)) .filter(matchedDate -> matchedDate.getDate() != null) .findFirst().orElse(matchedText); if (md.getDate() == null && md.getValue() != null) { md = parseWithTimewords(md, source); } return md; } }
DateParser { public static MatchedDate parse(MatchedDate matchedText, HttpSource source) { String value = Strings.nullToEmpty(matchedText.getValue()).trim(); for (String regexp : source.getDateRegexps()) { Pattern pattern = Pattern.compile(regexp); Matcher matcher = pattern.matcher(value); if (matcher.matches() && matcher.groupCount() > 0) { value = matcher.group(1); } } matchedText.setValue(value.replace("ET", "EST")); List<SimpleDateFormat> customFormatters = formatsToFormatters(source.getDateFormats()); MatchedDate md = Stream.concat(customFormatters.stream(), FORMATTERS.stream()) .map(dateFormat -> parse(matchedText, dateFormat)) .filter(matchedDate -> matchedDate.getDate() != null) .findFirst().orElse(matchedText); if (md.getDate() == null && md.getValue() != null) { md = parseWithTimewords(md, source); } return md; } }
DateParser { public static MatchedDate parse(MatchedDate matchedText, HttpSource source) { String value = Strings.nullToEmpty(matchedText.getValue()).trim(); for (String regexp : source.getDateRegexps()) { Pattern pattern = Pattern.compile(regexp); Matcher matcher = pattern.matcher(value); if (matcher.matches() && matcher.groupCount() > 0) { value = matcher.group(1); } } matchedText.setValue(value.replace("ET", "EST")); List<SimpleDateFormat> customFormatters = formatsToFormatters(source.getDateFormats()); MatchedDate md = Stream.concat(customFormatters.stream(), FORMATTERS.stream()) .map(dateFormat -> parse(matchedText, dateFormat)) .filter(matchedDate -> matchedDate.getDate() != null) .findFirst().orElse(matchedText); if (md.getDate() == null && md.getValue() != null) { md = parseWithTimewords(md, source); } return md; } static MatchedDate parse(MatchedDate matchedText, HttpSource source); static List<MatchedDate> extractFromMeta(Document document); static List<MatchedDate> extractFromProperties(Document document); }
DateParser { public static MatchedDate parse(MatchedDate matchedText, HttpSource source) { String value = Strings.nullToEmpty(matchedText.getValue()).trim(); for (String regexp : source.getDateRegexps()) { Pattern pattern = Pattern.compile(regexp); Matcher matcher = pattern.matcher(value); if (matcher.matches() && matcher.groupCount() > 0) { value = matcher.group(1); } } matchedText.setValue(value.replace("ET", "EST")); List<SimpleDateFormat> customFormatters = formatsToFormatters(source.getDateFormats()); MatchedDate md = Stream.concat(customFormatters.stream(), FORMATTERS.stream()) .map(dateFormat -> parse(matchedText, dateFormat)) .filter(matchedDate -> matchedDate.getDate() != null) .findFirst().orElse(matchedText); if (md.getDate() == null && md.getValue() != null) { md = parseWithTimewords(md, source); } return md; } static MatchedDate parse(MatchedDate matchedText, HttpSource source); static List<MatchedDate> extractFromMeta(Document document); static List<MatchedDate> extractFromProperties(Document document); }
@Test public void parseWithTimewords() { MatchedDate matchedDate = new MatchedDate("Wed Feb 24 2016 00:01 UTC+1201", null); MatchedDate parse = DateParser.parse(matchedDate, new HttpSource()); assertEquals("2016-02-24T00:01:00", DataUtils.formatInUTC(parse.getDate())); assertEquals("TIMEWORDS", parse.getPattern()); assertEquals("Wed Feb 24 2016 00:01 UTC+1201", parse.getValue()); }
private static MatchedDate parseWithTimewords(MatchedDate matchedText, HttpSource source) { Timewords timewords = new Timewords(); try { Date parse = timewords.parse(matchedText.getValue(), new Date(), source.getLanguage()); if (parse != null) { matchedText.setDate(new DateTime(parse)); matchedText.setPattern("TIMEWORDS"); } return matchedText; } catch (Exception e) { return matchedText; } }
DateParser { private static MatchedDate parseWithTimewords(MatchedDate matchedText, HttpSource source) { Timewords timewords = new Timewords(); try { Date parse = timewords.parse(matchedText.getValue(), new Date(), source.getLanguage()); if (parse != null) { matchedText.setDate(new DateTime(parse)); matchedText.setPattern("TIMEWORDS"); } return matchedText; } catch (Exception e) { return matchedText; } } }
DateParser { private static MatchedDate parseWithTimewords(MatchedDate matchedText, HttpSource source) { Timewords timewords = new Timewords(); try { Date parse = timewords.parse(matchedText.getValue(), new Date(), source.getLanguage()); if (parse != null) { matchedText.setDate(new DateTime(parse)); matchedText.setPattern("TIMEWORDS"); } return matchedText; } catch (Exception e) { return matchedText; } } }
DateParser { private static MatchedDate parseWithTimewords(MatchedDate matchedText, HttpSource source) { Timewords timewords = new Timewords(); try { Date parse = timewords.parse(matchedText.getValue(), new Date(), source.getLanguage()); if (parse != null) { matchedText.setDate(new DateTime(parse)); matchedText.setPattern("TIMEWORDS"); } return matchedText; } catch (Exception e) { return matchedText; } } static MatchedDate parse(MatchedDate matchedText, HttpSource source); static List<MatchedDate> extractFromMeta(Document document); static List<MatchedDate> extractFromProperties(Document document); }
DateParser { private static MatchedDate parseWithTimewords(MatchedDate matchedText, HttpSource source) { Timewords timewords = new Timewords(); try { Date parse = timewords.parse(matchedText.getValue(), new Date(), source.getLanguage()); if (parse != null) { matchedText.setDate(new DateTime(parse)); matchedText.setPattern("TIMEWORDS"); } return matchedText; } catch (Exception e) { return matchedText; } } static MatchedDate parse(MatchedDate matchedText, HttpSource source); static List<MatchedDate> extractFromMeta(Document document); static List<MatchedDate> extractFromProperties(Document document); }
@Test public void testHttpSourceDateRegexpPattern000() throws ParseException { String dateRegexp = "By.*on (.*) Tweet"; String dateString = "By Scott Simkin on February 14, 2017 Tweet"; String expectedDateString = "2017-02-14T00:00:00"; MatchedDate matchedDate = new MatchedDate(dateString, null); HttpSource httpSource = new HttpSource(); httpSource.setDateRegexps(Arrays.asList(dateRegexp)); MatchedDate parse = DateParser.parse(matchedDate, httpSource); assertNotNull(parse.getDate()); assertEquals(expectedDateString, DataUtils.formatInUTC(matchedDate.getDate())); }
public static MatchedDate parse(MatchedDate matchedText, HttpSource source) { String value = Strings.nullToEmpty(matchedText.getValue()).trim(); for (String regexp : source.getDateRegexps()) { Pattern pattern = Pattern.compile(regexp); Matcher matcher = pattern.matcher(value); if (matcher.matches() && matcher.groupCount() > 0) { value = matcher.group(1); } } matchedText.setValue(value.replace("ET", "EST")); List<SimpleDateFormat> customFormatters = formatsToFormatters(source.getDateFormats()); MatchedDate md = Stream.concat(customFormatters.stream(), FORMATTERS.stream()) .map(dateFormat -> parse(matchedText, dateFormat)) .filter(matchedDate -> matchedDate.getDate() != null) .findFirst().orElse(matchedText); if (md.getDate() == null && md.getValue() != null) { md = parseWithTimewords(md, source); } return md; }
DateParser { public static MatchedDate parse(MatchedDate matchedText, HttpSource source) { String value = Strings.nullToEmpty(matchedText.getValue()).trim(); for (String regexp : source.getDateRegexps()) { Pattern pattern = Pattern.compile(regexp); Matcher matcher = pattern.matcher(value); if (matcher.matches() && matcher.groupCount() > 0) { value = matcher.group(1); } } matchedText.setValue(value.replace("ET", "EST")); List<SimpleDateFormat> customFormatters = formatsToFormatters(source.getDateFormats()); MatchedDate md = Stream.concat(customFormatters.stream(), FORMATTERS.stream()) .map(dateFormat -> parse(matchedText, dateFormat)) .filter(matchedDate -> matchedDate.getDate() != null) .findFirst().orElse(matchedText); if (md.getDate() == null && md.getValue() != null) { md = parseWithTimewords(md, source); } return md; } }
DateParser { public static MatchedDate parse(MatchedDate matchedText, HttpSource source) { String value = Strings.nullToEmpty(matchedText.getValue()).trim(); for (String regexp : source.getDateRegexps()) { Pattern pattern = Pattern.compile(regexp); Matcher matcher = pattern.matcher(value); if (matcher.matches() && matcher.groupCount() > 0) { value = matcher.group(1); } } matchedText.setValue(value.replace("ET", "EST")); List<SimpleDateFormat> customFormatters = formatsToFormatters(source.getDateFormats()); MatchedDate md = Stream.concat(customFormatters.stream(), FORMATTERS.stream()) .map(dateFormat -> parse(matchedText, dateFormat)) .filter(matchedDate -> matchedDate.getDate() != null) .findFirst().orElse(matchedText); if (md.getDate() == null && md.getValue() != null) { md = parseWithTimewords(md, source); } return md; } }
DateParser { public static MatchedDate parse(MatchedDate matchedText, HttpSource source) { String value = Strings.nullToEmpty(matchedText.getValue()).trim(); for (String regexp : source.getDateRegexps()) { Pattern pattern = Pattern.compile(regexp); Matcher matcher = pattern.matcher(value); if (matcher.matches() && matcher.groupCount() > 0) { value = matcher.group(1); } } matchedText.setValue(value.replace("ET", "EST")); List<SimpleDateFormat> customFormatters = formatsToFormatters(source.getDateFormats()); MatchedDate md = Stream.concat(customFormatters.stream(), FORMATTERS.stream()) .map(dateFormat -> parse(matchedText, dateFormat)) .filter(matchedDate -> matchedDate.getDate() != null) .findFirst().orElse(matchedText); if (md.getDate() == null && md.getValue() != null) { md = parseWithTimewords(md, source); } return md; } static MatchedDate parse(MatchedDate matchedText, HttpSource source); static List<MatchedDate> extractFromMeta(Document document); static List<MatchedDate> extractFromProperties(Document document); }
DateParser { public static MatchedDate parse(MatchedDate matchedText, HttpSource source) { String value = Strings.nullToEmpty(matchedText.getValue()).trim(); for (String regexp : source.getDateRegexps()) { Pattern pattern = Pattern.compile(regexp); Matcher matcher = pattern.matcher(value); if (matcher.matches() && matcher.groupCount() > 0) { value = matcher.group(1); } } matchedText.setValue(value.replace("ET", "EST")); List<SimpleDateFormat> customFormatters = formatsToFormatters(source.getDateFormats()); MatchedDate md = Stream.concat(customFormatters.stream(), FORMATTERS.stream()) .map(dateFormat -> parse(matchedText, dateFormat)) .filter(matchedDate -> matchedDate.getDate() != null) .findFirst().orElse(matchedText); if (md.getDate() == null && md.getValue() != null) { md = parseWithTimewords(md, source); } return md; } static MatchedDate parse(MatchedDate matchedText, HttpSource source); static List<MatchedDate> extractFromMeta(Document document); static List<MatchedDate> extractFromProperties(Document document); }
@Test public void normalizerSplitter() { assertEquals(Lists.newArrayList("\\?.*$-->>", "a-->>b"), DataUtils.parseStringList("\\?.*$-->>\na-->>b\r\r\n\n")); }
public static List<String> parseStringList(Object object) { if (object == null) { return null; } return Splitter.onPattern("(?:\r?\n)+") .splitToList(object.toString()) .stream() .map(String::trim) .filter(s -> !s.isEmpty()) .collect(Collectors.toList()); }
DataUtils implements Serializable { public static List<String> parseStringList(Object object) { if (object == null) { return null; } return Splitter.onPattern("(?:\r?\n)+") .splitToList(object.toString()) .stream() .map(String::trim) .filter(s -> !s.isEmpty()) .collect(Collectors.toList()); } }
DataUtils implements Serializable { public static List<String> parseStringList(Object object) { if (object == null) { return null; } return Splitter.onPattern("(?:\r?\n)+") .splitToList(object.toString()) .stream() .map(String::trim) .filter(s -> !s.isEmpty()) .collect(Collectors.toList()); } }
DataUtils implements Serializable { public static List<String> parseStringList(Object object) { if (object == null) { return null; } return Splitter.onPattern("(?:\r?\n)+") .splitToList(object.toString()) .stream() .map(String::trim) .filter(s -> !s.isEmpty()) .collect(Collectors.toList()); } static Integer tryParseInteger(Object object); static Long tryParseLong(Object object); static List<String> parseStringList(Object object); static String formatInUTC(DateTime date); static DateTime parseFromUTC(String date); }
DataUtils implements Serializable { public static List<String> parseStringList(Object object) { if (object == null) { return null; } return Splitter.onPattern("(?:\r?\n)+") .splitToList(object.toString()) .stream() .map(String::trim) .filter(s -> !s.isEmpty()) .collect(Collectors.toList()); } static Integer tryParseInteger(Object object); static Long tryParseLong(Object object); static List<String> parseStringList(Object object); static String formatInUTC(DateTime date); static DateTime parseFromUTC(String date); }
@Test public void dateFormatInUTC() { Long DATE_2017_01_04_12_26_00 = 1483532760805L; assertEquals("2017-01-04T12:26:00", DataUtils.formatInUTC(new DateTime(DATE_2017_01_04_12_26_00))); }
public static String formatInUTC(DateTime date) { return date != null ? FORMATTER.print(date.toDateTime(DateTimeZone.UTC)) : null; }
DataUtils implements Serializable { public static String formatInUTC(DateTime date) { return date != null ? FORMATTER.print(date.toDateTime(DateTimeZone.UTC)) : null; } }
DataUtils implements Serializable { public static String formatInUTC(DateTime date) { return date != null ? FORMATTER.print(date.toDateTime(DateTimeZone.UTC)) : null; } }
DataUtils implements Serializable { public static String formatInUTC(DateTime date) { return date != null ? FORMATTER.print(date.toDateTime(DateTimeZone.UTC)) : null; } static Integer tryParseInteger(Object object); static Long tryParseLong(Object object); static List<String> parseStringList(Object object); static String formatInUTC(DateTime date); static DateTime parseFromUTC(String date); }
DataUtils implements Serializable { public static String formatInUTC(DateTime date) { return date != null ? FORMATTER.print(date.toDateTime(DateTimeZone.UTC)) : null; } static Integer tryParseInteger(Object object); static Long tryParseLong(Object object); static List<String> parseStringList(Object object); static String formatInUTC(DateTime date); static DateTime parseFromUTC(String date); }
@Test public void htmlParsing() { HashMap<String, String> config = Maps.newHashMap(); HtmlAnalysisResult result = PageAnalyzer.analyze(config, "https: assertEquals("Bloomberg.com", result.getTitle()); assertEquals(33, result.getMetaValues().size()); assertTrue(result.getMetaValues().contains("<meta property=\"og:url\" content=\"https: assertEquals(361, result.getLinks().size()); assertTrue(result.getLinks().contains("https: }
public static HtmlAnalysisResult analyze(Map<String, String> config, String url) { try { String userAgent = config.getOrDefault(CONFIG_USER_AGENT, DEFAULT_USER_AGENT); HttpResponse<String> response = Unirest.get(url) .header("User-Agent", userAgent) .asString(); return analyze(config, url, response.getBody(), response.getStatus(), response.getHeaders()); } catch (UnirestException e) { throw new RuntimeException(e); } }
PageAnalyzer { public static HtmlAnalysisResult analyze(Map<String, String> config, String url) { try { String userAgent = config.getOrDefault(CONFIG_USER_AGENT, DEFAULT_USER_AGENT); HttpResponse<String> response = Unirest.get(url) .header("User-Agent", userAgent) .asString(); return analyze(config, url, response.getBody(), response.getStatus(), response.getHeaders()); } catch (UnirestException e) { throw new RuntimeException(e); } } }
PageAnalyzer { public static HtmlAnalysisResult analyze(Map<String, String> config, String url) { try { String userAgent = config.getOrDefault(CONFIG_USER_AGENT, DEFAULT_USER_AGENT); HttpResponse<String> response = Unirest.get(url) .header("User-Agent", userAgent) .asString(); return analyze(config, url, response.getBody(), response.getStatus(), response.getHeaders()); } catch (UnirestException e) { throw new RuntimeException(e); } } }
PageAnalyzer { public static HtmlAnalysisResult analyze(Map<String, String> config, String url) { try { String userAgent = config.getOrDefault(CONFIG_USER_AGENT, DEFAULT_USER_AGENT); HttpResponse<String> response = Unirest.get(url) .header("User-Agent", userAgent) .asString(); return analyze(config, url, response.getBody(), response.getStatus(), response.getHeaders()); } catch (UnirestException e) { throw new RuntimeException(e); } } static HtmlAnalysisResult analyze(Map<String, String> config, String url); static HtmlAnalysisResult analyze(Map<String, String> config, String url, String html); static HtmlAnalysisResult analyze(Map<String, String> config, String url, String html, Integer status, Map<String, List<String>> headers); static void parseRobotsTxt(String userAgent, String robotsUrl, String robotsTxt, HtmlAnalysisResult result); }
PageAnalyzer { public static HtmlAnalysisResult analyze(Map<String, String> config, String url) { try { String userAgent = config.getOrDefault(CONFIG_USER_AGENT, DEFAULT_USER_AGENT); HttpResponse<String> response = Unirest.get(url) .header("User-Agent", userAgent) .asString(); return analyze(config, url, response.getBody(), response.getStatus(), response.getHeaders()); } catch (UnirestException e) { throw new RuntimeException(e); } } static HtmlAnalysisResult analyze(Map<String, String> config, String url); static HtmlAnalysisResult analyze(Map<String, String> config, String url, String html); static HtmlAnalysisResult analyze(Map<String, String> config, String url, String html, Integer status, Map<String, List<String>> headers); static void parseRobotsTxt(String userAgent, String robotsUrl, String robotsTxt, HtmlAnalysisResult result); static final String CONFIG_USER_AGENT; static final String CONFIG_ANALYZE_ROBOTS_TXT; }
@Test @Ignore public void fetchAndParse() { HashMap<String, String> config = Maps.newHashMap(); config.put(PageAnalyzer.CONFIG_ANALYZE_ROBOTS_TXT, "true"); HtmlAnalysisResult result = PageAnalyzer.analyze(config, "http: assertEquals("TokenMill - Natural Language Processing", result.getTitle()); assertEquals(10, result.getMetaValues().size()); assertEquals(42, result.getLinks().size()); assertTrue(result.getLinks().contains("http: assertTrue(result.getRobotsAllowedAll()); assertFalse(result.getRobotsAllowedNone()); assertTrue(result.getRobotsAllowedHome()); assertEquals(Lists.newArrayList(), result.getRobotsSitemaps()); assertEquals(Long.MIN_VALUE, (long) result.getRobotsCrawlDelay()); }
public static HtmlAnalysisResult analyze(Map<String, String> config, String url) { try { String userAgent = config.getOrDefault(CONFIG_USER_AGENT, DEFAULT_USER_AGENT); HttpResponse<String> response = Unirest.get(url) .header("User-Agent", userAgent) .asString(); return analyze(config, url, response.getBody(), response.getStatus(), response.getHeaders()); } catch (UnirestException e) { throw new RuntimeException(e); } }
PageAnalyzer { public static HtmlAnalysisResult analyze(Map<String, String> config, String url) { try { String userAgent = config.getOrDefault(CONFIG_USER_AGENT, DEFAULT_USER_AGENT); HttpResponse<String> response = Unirest.get(url) .header("User-Agent", userAgent) .asString(); return analyze(config, url, response.getBody(), response.getStatus(), response.getHeaders()); } catch (UnirestException e) { throw new RuntimeException(e); } } }
PageAnalyzer { public static HtmlAnalysisResult analyze(Map<String, String> config, String url) { try { String userAgent = config.getOrDefault(CONFIG_USER_AGENT, DEFAULT_USER_AGENT); HttpResponse<String> response = Unirest.get(url) .header("User-Agent", userAgent) .asString(); return analyze(config, url, response.getBody(), response.getStatus(), response.getHeaders()); } catch (UnirestException e) { throw new RuntimeException(e); } } }
PageAnalyzer { public static HtmlAnalysisResult analyze(Map<String, String> config, String url) { try { String userAgent = config.getOrDefault(CONFIG_USER_AGENT, DEFAULT_USER_AGENT); HttpResponse<String> response = Unirest.get(url) .header("User-Agent", userAgent) .asString(); return analyze(config, url, response.getBody(), response.getStatus(), response.getHeaders()); } catch (UnirestException e) { throw new RuntimeException(e); } } static HtmlAnalysisResult analyze(Map<String, String> config, String url); static HtmlAnalysisResult analyze(Map<String, String> config, String url, String html); static HtmlAnalysisResult analyze(Map<String, String> config, String url, String html, Integer status, Map<String, List<String>> headers); static void parseRobotsTxt(String userAgent, String robotsUrl, String robotsTxt, HtmlAnalysisResult result); }
PageAnalyzer { public static HtmlAnalysisResult analyze(Map<String, String> config, String url) { try { String userAgent = config.getOrDefault(CONFIG_USER_AGENT, DEFAULT_USER_AGENT); HttpResponse<String> response = Unirest.get(url) .header("User-Agent", userAgent) .asString(); return analyze(config, url, response.getBody(), response.getStatus(), response.getHeaders()); } catch (UnirestException e) { throw new RuntimeException(e); } } static HtmlAnalysisResult analyze(Map<String, String> config, String url); static HtmlAnalysisResult analyze(Map<String, String> config, String url, String html); static HtmlAnalysisResult analyze(Map<String, String> config, String url, String html, Integer status, Map<String, List<String>> headers); static void parseRobotsTxt(String userAgent, String robotsUrl, String robotsTxt, HtmlAnalysisResult result); static final String CONFIG_USER_AGENT; static final String CONFIG_ANALYZE_ROBOTS_TXT; }
@Test @Ignore public void fetchAndParseRobotsTxt() { HashMap<String, String> config = Maps.newHashMap(); config.put(PageAnalyzer.CONFIG_ANALYZE_ROBOTS_TXT, "true"); HtmlAnalysisResult result = PageAnalyzer.analyze(config, "https: assertFalse(result.getRobotsAllowedAll()); assertFalse(result.getRobotsAllowedNone()); assertTrue(result.getRobotsAllowedHome()); assertTrue(result.getRobotsSitemaps().contains("http: assertEquals(Long.MIN_VALUE, (long) result.getRobotsCrawlDelay()); }
public static HtmlAnalysisResult analyze(Map<String, String> config, String url) { try { String userAgent = config.getOrDefault(CONFIG_USER_AGENT, DEFAULT_USER_AGENT); HttpResponse<String> response = Unirest.get(url) .header("User-Agent", userAgent) .asString(); return analyze(config, url, response.getBody(), response.getStatus(), response.getHeaders()); } catch (UnirestException e) { throw new RuntimeException(e); } }
PageAnalyzer { public static HtmlAnalysisResult analyze(Map<String, String> config, String url) { try { String userAgent = config.getOrDefault(CONFIG_USER_AGENT, DEFAULT_USER_AGENT); HttpResponse<String> response = Unirest.get(url) .header("User-Agent", userAgent) .asString(); return analyze(config, url, response.getBody(), response.getStatus(), response.getHeaders()); } catch (UnirestException e) { throw new RuntimeException(e); } } }
PageAnalyzer { public static HtmlAnalysisResult analyze(Map<String, String> config, String url) { try { String userAgent = config.getOrDefault(CONFIG_USER_AGENT, DEFAULT_USER_AGENT); HttpResponse<String> response = Unirest.get(url) .header("User-Agent", userAgent) .asString(); return analyze(config, url, response.getBody(), response.getStatus(), response.getHeaders()); } catch (UnirestException e) { throw new RuntimeException(e); } } }
PageAnalyzer { public static HtmlAnalysisResult analyze(Map<String, String> config, String url) { try { String userAgent = config.getOrDefault(CONFIG_USER_AGENT, DEFAULT_USER_AGENT); HttpResponse<String> response = Unirest.get(url) .header("User-Agent", userAgent) .asString(); return analyze(config, url, response.getBody(), response.getStatus(), response.getHeaders()); } catch (UnirestException e) { throw new RuntimeException(e); } } static HtmlAnalysisResult analyze(Map<String, String> config, String url); static HtmlAnalysisResult analyze(Map<String, String> config, String url, String html); static HtmlAnalysisResult analyze(Map<String, String> config, String url, String html, Integer status, Map<String, List<String>> headers); static void parseRobotsTxt(String userAgent, String robotsUrl, String robotsTxt, HtmlAnalysisResult result); }
PageAnalyzer { public static HtmlAnalysisResult analyze(Map<String, String> config, String url) { try { String userAgent = config.getOrDefault(CONFIG_USER_AGENT, DEFAULT_USER_AGENT); HttpResponse<String> response = Unirest.get(url) .header("User-Agent", userAgent) .asString(); return analyze(config, url, response.getBody(), response.getStatus(), response.getHeaders()); } catch (UnirestException e) { throw new RuntimeException(e); } } static HtmlAnalysisResult analyze(Map<String, String> config, String url); static HtmlAnalysisResult analyze(Map<String, String> config, String url, String html); static HtmlAnalysisResult analyze(Map<String, String> config, String url, String html, Integer status, Map<String, List<String>> headers); static void parseRobotsTxt(String userAgent, String robotsUrl, String robotsTxt, HtmlAnalysisResult result); static final String CONFIG_USER_AGENT; static final String CONFIG_ANALYZE_ROBOTS_TXT; }
@Test @Ignore public void test() { ElasticConnection connection = ElasticConnection.getConnection("localhost", 9200, "http"); EsHttpSourceOperations esHttpSourceOperations = new EsHttpSourceOperations(connection, "demo-http_sources", "http_source"); PageableList<HttpSource> data = esHttpSourceOperations.filter(null); for (HttpSource source : data.getItems()) { System.out.println(">>" + source); } }
public PageableList<HttpSource> filter(String text) { return filter(text, 0); }
EsHttpSourceOperations extends BaseElasticOps { public PageableList<HttpSource> filter(String text) { return filter(text, 0); } }
EsHttpSourceOperations extends BaseElasticOps { public PageableList<HttpSource> filter(String text) { return filter(text, 0); } protected EsHttpSourceOperations(ElasticConnection connection, String index, String type); }
EsHttpSourceOperations extends BaseElasticOps { public PageableList<HttpSource> filter(String text) { return filter(text, 0); } protected EsHttpSourceOperations(ElasticConnection connection, String index, String type); static EsHttpSourceOperations getInstance(ElasticConnection connection, String index, String type); List<HttpSource> findEnabledSources(); HttpSource get(String url); PageableList<HttpSource> filter(String text); PageableList<HttpSource> filter(String text, int offset); List<HttpSource> all(); void save(HttpSource source); void delete(String url); void deleteAll(); }
EsHttpSourceOperations extends BaseElasticOps { public PageableList<HttpSource> filter(String text) { return filter(text, 0); } protected EsHttpSourceOperations(ElasticConnection connection, String index, String type); static EsHttpSourceOperations getInstance(ElasticConnection connection, String index, String type); List<HttpSource> findEnabledSources(); HttpSource get(String url); PageableList<HttpSource> filter(String text); PageableList<HttpSource> filter(String text, int offset); List<HttpSource> all(); void save(HttpSource source); void delete(String url); void deleteAll(); }
@Test public void testBuilder() { BulkProcessor.Listener listener = new BulkProcessor.Listener() { @Override public void afterBulk(long executionId, BulkRequest request, BulkResponse response) { for (BulkItemResponse item : response.getItems()) { if (item.isFailed()) { LOG.error("Bulk item failure: '{}' for request '{}'", item.getFailure(), request.requests().get(item.getItemId())); } } } @Override public void afterBulk(long executionId, BulkRequest request, Throwable response) { LOG.error("Bulk failed:" + response); } @Override public void beforeBulk(long executionId, BulkRequest request) { for (DocWriteRequest r :request.requests()) { try { if (r instanceof IndexRequest) { IndexRequest indexRequest = (IndexRequest) r; indexRequest.id(URLDecoder.decode(indexRequest.id(), "utf-8")); } else if (r instanceof UpdateRequest) { UpdateRequest updateRequest = (UpdateRequest) r; updateRequest.id(URLDecoder.decode(updateRequest.id(), "utf-8")); } } catch (UnsupportedEncodingException e) { e.printStackTrace(); } } } }; ElasticConnection connection = ElasticConnection.builder() .hostname("0.0.0.0") .restPort(443) .restScheme("https") .bulkActions(1) .flushIntervalString("1s") .listener(listener) .build(); assertNotNull(connection); }
public static Builder builder() { return new Builder(); }
ElasticConnection { public static Builder builder() { return new Builder(); } }
ElasticConnection { public static Builder builder() { return new Builder(); } private ElasticConnection(BulkProcessor processor, RestHighLevelClient restHighLevelClient, RestClientBuilder restClient); }
ElasticConnection { public static Builder builder() { return new Builder(); } private ElasticConnection(BulkProcessor processor, RestHighLevelClient restHighLevelClient, RestClientBuilder restClient); static Builder builder(); RestHighLevelClient getRestHighLevelClient(); BulkProcessor getProcessor(); static ElasticConnection getConnection(String hostname); static ElasticConnection getConnection(String hostname, int restPort, String restScheme); void close(); }
ElasticConnection { public static Builder builder() { return new Builder(); } private ElasticConnection(BulkProcessor processor, RestHighLevelClient restHighLevelClient, RestClientBuilder restClient); static Builder builder(); RestHighLevelClient getRestHighLevelClient(); BulkProcessor getProcessor(); static ElasticConnection getConnection(String hostname); static ElasticConnection getConnection(String hostname, int restPort, String restScheme); void close(); }
@Test public void testTextProfileSignature() { TextProfileSignature textProfileSignature = new TextProfileSignature(); String text1 = "This is a test"; String text2 = "This is e test"; String text3 = "This is a very test"; assertEquals(text1, text1); assertTrue(textProfileSignature.getSignature(text1) .equalsIgnoreCase(textProfileSignature.getSignature(text1))); assertNotEquals(text1, text2); assertTrue(textProfileSignature.getSignature(text1) .equalsIgnoreCase(textProfileSignature.getSignature(text2))); assertNotEquals(text1, text3); assertFalse(textProfileSignature.getSignature(text1) .equalsIgnoreCase(textProfileSignature.getSignature(text3))); assertTrue(textProfileSignature.getSignature("very very text") .equalsIgnoreCase(textProfileSignature.getSignature("very very very text"))); String a = "Updated: 2.4 million hit by Carphone Warehouse breach On Saturday Carphone Warehouse (CW) announced that the names, addresses, dates of birth and bank details of up to 2.4 million customers may have been accessed in a cyber-attack discovered on Wednesday, believed to have occurred during the two weeks prior. Encrypted credit card details of up to 90,000 people may have been accessed. Check Point's technical director, Thierry Karsenti, emailed SC to warn that the stolen data is likely to be used as bait for targeted phishing attacks against customers, especially in emails claiming to be from Carphone Warehouse or one of its subsidiaries. Karsenti said: “Armed with the data they already have, attackers are likely to try and trick those affected by the breach into revealing further details, such as account numbers and passwords. “For the attackers, it's just a numbers game, but it could have serious consequences for customers. Phishing emails continue to be the most common source for social engineering attacks, so customers should be suspicious of any emails, or even phone calls, that relate to the breach, and should not give away more information.” Carphone Warehouse is clearly aware of the danger and on Saturday sent an email to customers telling them to notify their bank and credit card company, so they can monitor account activity, as well as advising them to change the password for their online accounts. They also advised checking credit rating on Experian, Equifax or Noddle to ensure they have not been made a victim of fraud. Some commentators suggest the details where obtained, will already have been sold on. Staff at Haymarket were among those affected. After receiving warning emails from Carphone Warehouse, at 3pm and 9pm on Saturday, one member told SC how they rang their bank, and were immediately asked whether their password for the bank was the same as for the phone contract – as the password would have needed to be changed had that been the case. Plus they were advised to keep an eye out for any unusual transactions on their account, clearly concerned that identity theft may be attempted. They were also advised to contact Action Fraud, the UK's national fraud and internet crime reporting centre, if they were concerned they might be a victim of fraud. However, both the Information Commissioner's Office (ICO) and The Metropolitan Police Cyber Crime Unit have reported being aware of the attack and the ICO is investigating the issue while the Met says no reports of related fraud have yet been made. Sebastian James, chief executive of Dixons Carphone, was reported by the Guardian newspaper as saying: “We take the security of customer data extremely seriously, and we are very sorry people have been affected by this attack. We are, of course, informing anyone that may have been affected, and have put in place additional security measures.” In an email to SCMagazineUK.com data security expert Jason du Preez, CEO of Privitar said: “This data breach is yet another high-profile reminder that it is impossible for companies to protect their customer's data with traditional perimeter security. “Companies need to embrace the irrefutable fact that the way they manage and process data will have a direct impact on brand and customer loyalty. Embracing a data-centric approach to security and a process that ensures no sensitive data is visible in any given process – privacy-by-default – will enable organisations to confidently use consumer's precious data safely.” “Most organisations have entirely valid reasons for wanting customer data. It allows them to provide the personalised, relevant product and services consumers demand. But there's no reason, from a technical point of view, even financial data can't be anonymised to protect both the individual and the organisation itself.” Carphone Warehouse says the hack was stopped \"straight away\" after it was discovered on Wednesday afternoon, and that the company has launched a forensic investigation with a ‘leading cyber security firm'. Carphone Warehouse is responsible for the websites of OneStopPhoneShop.com, e2save.com and Mobiles.co.uk, as well as services for its own recently launched iD Mobile network, as well as TalkTalk Mobile, and Talk Mobile. About 1.9 million of those affected are reportedly directly signed up to Carphone Warehouse, while about 480,000 are customers of TalkTalk Mobile, whose registration process is handled by Carphone Warehouse. Phil Barnett, EMEA VP and GM of Good Technology, noted in an email that: “Many companies are still flying blind when it comes to security, because 60 per cent think it doesn't affect them. The truth is that it's not just a conversation for banks or governments anymore - anyone and everyone is a potential victim of hacks and data leaks. Data is a company's biggest asset, but many organisations haven't yet got to grips with how to protect it in the new world order of mobile devices and cloud-based access. The security challenge won't go away and companies need to change their mindset in order to solve it.”"; String b = "Updated: 2.4 million hit by Carphone Warehouse breach On Saturday Carphone Warehouse (CW) announced that the names, addresses, dates of birth and bank details of up to 2.4 million customers may have been accessed in a cyber-attack discovered on Wednesday, believed to have occurred during the two weeks prior. Encrypted credit card details of up to 90,000 people may have been accessed. Check Point's technical director, Thierry Karsenti, emailed SC to warn that the stolen data is likely to be used as bait for targeted phishing attacks against customers, especially in emails claiming to be from Carphone Warehouse or one of its subsidiaries. Karsenti said: “Armed with the data they already have, attackers are likely to try and trick those affected by the breach into revealing further details, such as account numbers and passwords. “For the attackers, it's just a numbers game, but it could have serious consequences for customers. Phishing emails continue to be the most common source for social engineering attacks, so customers should be suspicious of any emails, or even phone calls, that relate to the breach, and should not give away more information.” Carphone Warehouse is clearly aware of the danger and on Saturday sent an email to customers telling them to notify their bank and credit card company, so they can monitor account activity, as well as advising them to change the password for their online accounts. They also advised checking credit rating on Experian, Equifax or Noddle to ensure they have not been made a victim of fraud. Some commentators suggest the details where obtained, will already have been sold on. Staff at Haymarket were among those affected. After receiving warning emails from Carphone Warehouse, at 3pm and 9pm on Saturday, one member told SC how they rang their bank, and were immediately asked whether their password for the bank was the same as for the phone contract – as the password would have needed to be changed had that been the case. Plus they were advised to keep an eye out for any unusual transactions on their account, clearly concerned that identity theft may be attempted. They were also advised to contact Action Fraud, the UK's national fraud and internet crime reporting centre, if they were concerned they might be a victim of fraud. However, both the Information Commissioner's Office (ICO) and The Metropolitan Police Cyber Crime Unit have reported being aware of the attack and the ICO is investigating the issue while the Met says no reports of related fraud have yet been made. Sebastian James, chief executive of Dixons Carphone, was reported by the Guardian newspaper as saying: “We take the security of customer data extremely seriously, and we are very sorry people have been affected by this attack. We are, of course, informing anyone that may have been affected, and have put in place additional security measures.” In an email to SCMagazineUK.com data security expert Jason du Preez, CEO of Privitar said: “This data breach is yet another high-profile reminder that it is impossible for companies to protect their customer's data with traditional perimeter security. “Companies need to embrace the irrefutable fact that the way they manage and process data will have a direct impact on brand and customer loyalty. Embracing a data-centric approach to security and a process that ensures no sensitive data is visible in any given process – privacy-by-default – will enable organisations to confidently use consumer's precious data safely.” “Most organisations have entirely valid reasons for wanting customer data. It allows them to provide the personalised, relevant product and services consumers demand. But there's no reason, from a technical point of view, even financial data can't be anonymised to protect both the individual and the organisation itself.” Carphone Warehouse says the hack was stopped \"straight away\" after it was discovered on Wednesday afternoon, and that the company has launched a forensic investigation with a ‘leading cyber security firm'. Carphone Warehouse is responsible for the websites of OneStopPhoneShop.com, e2save.com and Mobiles.co.uk, as well as services for its own recently launched iD Mobile network, as well as TalkTalk Mobile, and Talk Mobile. About 1.9 million of those affected are reportedly directly signed up to Carphone Warehouse, while about 480,000 are customers of TalkTalk Mobile, whose registration process is handled by Carphone Warehouse. Phil Barnett, EMEA VP and GM of Good Technology, noted in an email that: “Many companies are still flying blind when it comes to security, because 60 per cent think it doesn't affect them. The truth is that it's not just a conversation for banks or governments anymore - anyone and everyone is a potential victim of hacks and data leaks. Data is a company's biggest asset, but many organisations haven't yet got to grips with how to protect it in the new world order of mobile devices and cloud-based access. The security challenge won't go away and companies need to change their mindset in order to solve its.”"; assertNotEquals(a, b); assertTrue(textProfileSignature.getSignature(a) .equalsIgnoreCase(textProfileSignature.getSignature(b))); }
public TextProfileSignature() { this.quantRate = 0.01f; this.minTokenLen = 2; try { this.digester = MessageDigest.getInstance("MD5"); } catch (Exception e) { LOG.error("Failed to initialize Media digest algorithm"); throw new RuntimeException("Failed to initialize Media digest algorithm", e); } }
TextProfileSignature { public TextProfileSignature() { this.quantRate = 0.01f; this.minTokenLen = 2; try { this.digester = MessageDigest.getInstance("MD5"); } catch (Exception e) { LOG.error("Failed to initialize Media digest algorithm"); throw new RuntimeException("Failed to initialize Media digest algorithm", e); } } }
TextProfileSignature { public TextProfileSignature() { this.quantRate = 0.01f; this.minTokenLen = 2; try { this.digester = MessageDigest.getInstance("MD5"); } catch (Exception e) { LOG.error("Failed to initialize Media digest algorithm"); throw new RuntimeException("Failed to initialize Media digest algorithm", e); } } TextProfileSignature(); }
TextProfileSignature { public TextProfileSignature() { this.quantRate = 0.01f; this.minTokenLen = 2; try { this.digester = MessageDigest.getInstance("MD5"); } catch (Exception e) { LOG.error("Failed to initialize Media digest algorithm"); throw new RuntimeException("Failed to initialize Media digest algorithm", e); } } TextProfileSignature(); String getSignature(String text); void add(String content); }
TextProfileSignature { public TextProfileSignature() { this.quantRate = 0.01f; this.minTokenLen = 2; try { this.digester = MessageDigest.getInstance("MD5"); } catch (Exception e) { LOG.error("Failed to initialize Media digest algorithm"); throw new RuntimeException("Failed to initialize Media digest algorithm", e); } } TextProfileSignature(); String getSignature(String text); void add(String content); }
@Test public void parseQuery() { List<String> parts = QueryParser.parseQuery("+Turkey-Inflation"); assertEquals(Lists.newArrayList("+Turkey", "-Inflation"), parts); parts = QueryParser.parseQuery("+Turkey -Inflation"); assertEquals(Lists.newArrayList("+Turkey", "-Inflation"), parts); parts = QueryParser.parseQuery("Turkey -Inflation"); assertEquals(Lists.newArrayList("Turkey", "-Inflation"), parts); parts = QueryParser.parseQuery("+Turkey attack"); assertEquals(Lists.newArrayList("+Turkey", "attack"), parts); }
public static List<String> parseQuery(String query) { List<String> result = Lists.newArrayList(); if (!Strings.isNullOrEmpty(query)) { query = query.replaceAll("(\\s*[+-]\\s*)", "#SPLIT#$1"); return Arrays.stream(query.split("(#SPLIT#| )")) .map(String::trim) .filter(s -> !s.isEmpty()) .collect(Collectors.toList()); } return result; }
QueryParser { public static List<String> parseQuery(String query) { List<String> result = Lists.newArrayList(); if (!Strings.isNullOrEmpty(query)) { query = query.replaceAll("(\\s*[+-]\\s*)", "#SPLIT#$1"); return Arrays.stream(query.split("(#SPLIT#| )")) .map(String::trim) .filter(s -> !s.isEmpty()) .collect(Collectors.toList()); } return result; } }
QueryParser { public static List<String> parseQuery(String query) { List<String> result = Lists.newArrayList(); if (!Strings.isNullOrEmpty(query)) { query = query.replaceAll("(\\s*[+-]\\s*)", "#SPLIT#$1"); return Arrays.stream(query.split("(#SPLIT#| )")) .map(String::trim) .filter(s -> !s.isEmpty()) .collect(Collectors.toList()); } return result; } }
QueryParser { public static List<String> parseQuery(String query) { List<String> result = Lists.newArrayList(); if (!Strings.isNullOrEmpty(query)) { query = query.replaceAll("(\\s*[+-]\\s*)", "#SPLIT#$1"); return Arrays.stream(query.split("(#SPLIT#| )")) .map(String::trim) .filter(s -> !s.isEmpty()) .collect(Collectors.toList()); } return result; } static List<String> parseQuery(String query); }
QueryParser { public static List<String> parseQuery(String query) { List<String> result = Lists.newArrayList(); if (!Strings.isNullOrEmpty(query)) { query = query.replaceAll("(\\s*[+-]\\s*)", "#SPLIT#$1"); return Arrays.stream(query.split("(#SPLIT#| )")) .map(String::trim) .filter(s -> !s.isEmpty()) .collect(Collectors.toList()); } return result; } static List<String> parseQuery(String query); }
@Test public void testExtraction00() throws Exception { String html = loadArticle("aljazeera1"); String url = "https: Document document = Jsoup.parse(html); assertEquals(url, UrlExtractor.extract(url, document)); assertEquals("https: }
private static Set<String> extract(Document document) { Set<String> canonicalUrls = new HashSet<>(); if (document == null) { return canonicalUrls; } Elements elements = document.select("meta[property=og:url]"); elements.forEach(element -> { String attr = element.attr("content"); if (attr != null) { canonicalUrls.add(attr); } }); elements = document.select("link[rel=canonical]"); elements.forEach(element -> { String attr = element.attr("href"); if (attr != null) { canonicalUrls.add(attr); } }); return canonicalUrls.stream() .filter(UrlExtractor::isAbsolute) .collect(Collectors.toSet()); }
UrlExtractor { private static Set<String> extract(Document document) { Set<String> canonicalUrls = new HashSet<>(); if (document == null) { return canonicalUrls; } Elements elements = document.select("meta[property=og:url]"); elements.forEach(element -> { String attr = element.attr("content"); if (attr != null) { canonicalUrls.add(attr); } }); elements = document.select("link[rel=canonical]"); elements.forEach(element -> { String attr = element.attr("href"); if (attr != null) { canonicalUrls.add(attr); } }); return canonicalUrls.stream() .filter(UrlExtractor::isAbsolute) .collect(Collectors.toSet()); } }
UrlExtractor { private static Set<String> extract(Document document) { Set<String> canonicalUrls = new HashSet<>(); if (document == null) { return canonicalUrls; } Elements elements = document.select("meta[property=og:url]"); elements.forEach(element -> { String attr = element.attr("content"); if (attr != null) { canonicalUrls.add(attr); } }); elements = document.select("link[rel=canonical]"); elements.forEach(element -> { String attr = element.attr("href"); if (attr != null) { canonicalUrls.add(attr); } }); return canonicalUrls.stream() .filter(UrlExtractor::isAbsolute) .collect(Collectors.toSet()); } }
UrlExtractor { private static Set<String> extract(Document document) { Set<String> canonicalUrls = new HashSet<>(); if (document == null) { return canonicalUrls; } Elements elements = document.select("meta[property=og:url]"); elements.forEach(element -> { String attr = element.attr("content"); if (attr != null) { canonicalUrls.add(attr); } }); elements = document.select("link[rel=canonical]"); elements.forEach(element -> { String attr = element.attr("href"); if (attr != null) { canonicalUrls.add(attr); } }); return canonicalUrls.stream() .filter(UrlExtractor::isAbsolute) .collect(Collectors.toSet()); } static String extract(String url, Document document); }
UrlExtractor { private static Set<String> extract(Document document) { Set<String> canonicalUrls = new HashSet<>(); if (document == null) { return canonicalUrls; } Elements elements = document.select("meta[property=og:url]"); elements.forEach(element -> { String attr = element.attr("content"); if (attr != null) { canonicalUrls.add(attr); } }); elements = document.select("link[rel=canonical]"); elements.forEach(element -> { String attr = element.attr("href"); if (attr != null) { canonicalUrls.add(attr); } }); return canonicalUrls.stream() .filter(UrlExtractor::isAbsolute) .collect(Collectors.toSet()); } static String extract(String url, Document document); }
@Test public void testExtraction01() throws Exception { String html = loadArticle("kedainietis"); String url = "url"; Document document = Jsoup.parse(html); assertEquals(url, UrlExtractor.extract(url, document)); }
private static Set<String> extract(Document document) { Set<String> canonicalUrls = new HashSet<>(); if (document == null) { return canonicalUrls; } Elements elements = document.select("meta[property=og:url]"); elements.forEach(element -> { String attr = element.attr("content"); if (attr != null) { canonicalUrls.add(attr); } }); elements = document.select("link[rel=canonical]"); elements.forEach(element -> { String attr = element.attr("href"); if (attr != null) { canonicalUrls.add(attr); } }); return canonicalUrls.stream() .filter(UrlExtractor::isAbsolute) .collect(Collectors.toSet()); }
UrlExtractor { private static Set<String> extract(Document document) { Set<String> canonicalUrls = new HashSet<>(); if (document == null) { return canonicalUrls; } Elements elements = document.select("meta[property=og:url]"); elements.forEach(element -> { String attr = element.attr("content"); if (attr != null) { canonicalUrls.add(attr); } }); elements = document.select("link[rel=canonical]"); elements.forEach(element -> { String attr = element.attr("href"); if (attr != null) { canonicalUrls.add(attr); } }); return canonicalUrls.stream() .filter(UrlExtractor::isAbsolute) .collect(Collectors.toSet()); } }
UrlExtractor { private static Set<String> extract(Document document) { Set<String> canonicalUrls = new HashSet<>(); if (document == null) { return canonicalUrls; } Elements elements = document.select("meta[property=og:url]"); elements.forEach(element -> { String attr = element.attr("content"); if (attr != null) { canonicalUrls.add(attr); } }); elements = document.select("link[rel=canonical]"); elements.forEach(element -> { String attr = element.attr("href"); if (attr != null) { canonicalUrls.add(attr); } }); return canonicalUrls.stream() .filter(UrlExtractor::isAbsolute) .collect(Collectors.toSet()); } }
UrlExtractor { private static Set<String> extract(Document document) { Set<String> canonicalUrls = new HashSet<>(); if (document == null) { return canonicalUrls; } Elements elements = document.select("meta[property=og:url]"); elements.forEach(element -> { String attr = element.attr("content"); if (attr != null) { canonicalUrls.add(attr); } }); elements = document.select("link[rel=canonical]"); elements.forEach(element -> { String attr = element.attr("href"); if (attr != null) { canonicalUrls.add(attr); } }); return canonicalUrls.stream() .filter(UrlExtractor::isAbsolute) .collect(Collectors.toSet()); } static String extract(String url, Document document); }
UrlExtractor { private static Set<String> extract(Document document) { Set<String> canonicalUrls = new HashSet<>(); if (document == null) { return canonicalUrls; } Elements elements = document.select("meta[property=og:url]"); elements.forEach(element -> { String attr = element.attr("content"); if (attr != null) { canonicalUrls.add(attr); } }); elements = document.select("link[rel=canonical]"); elements.forEach(element -> { String attr = element.attr("href"); if (attr != null) { canonicalUrls.add(attr); } }); return canonicalUrls.stream() .filter(UrlExtractor::isAbsolute) .collect(Collectors.toSet()); } static String extract(String url, Document document); }
@Test public void simple_shallow() { String template = "{ \"a\" : \"{{value}}\", \"b\": \"b\"}"; JsonObject document = (JsonObject) new JsonParser().parse(template); Map<String, String> paths = JsonUtil.getJsonPathsForTemplating(document); assertEquals(1, paths.size()); Object value = paths.get("$.a"); assertNotNull(value); assertEquals("{{value}}", value.toString()); }
public static Map<String, String> getJsonPathsForTemplating(Set<Map.Entry<String, JsonElement>> root) { Map<String, String> paths = new HashMap<>(); searchJsonForTemplate(root, paths, "$"); return paths; }
JsonUtil { public static Map<String, String> getJsonPathsForTemplating(Set<Map.Entry<String, JsonElement>> root) { Map<String, String> paths = new HashMap<>(); searchJsonForTemplate(root, paths, "$"); return paths; } }
JsonUtil { public static Map<String, String> getJsonPathsForTemplating(Set<Map.Entry<String, JsonElement>> root) { Map<String, String> paths = new HashMap<>(); searchJsonForTemplate(root, paths, "$"); return paths; } private JsonUtil(/* empty */); }
JsonUtil { public static Map<String, String> getJsonPathsForTemplating(Set<Map.Entry<String, JsonElement>> root) { Map<String, String> paths = new HashMap<>(); searchJsonForTemplate(root, paths, "$"); return paths; } private JsonUtil(/* empty */); static boolean updateField(JsonElement json, String field, JsonElement value); static boolean updateField(JsonElement json, String field, String value); static Map<String, String> getJsonPathsForTemplating(Set<Map.Entry<String, JsonElement>> root); static Map<String, String> getJsonPathsForTemplating(JsonObject json); }
JsonUtil { public static Map<String, String> getJsonPathsForTemplating(Set<Map.Entry<String, JsonElement>> root) { Map<String, String> paths = new HashMap<>(); searchJsonForTemplate(root, paths, "$"); return paths; } private JsonUtil(/* empty */); static boolean updateField(JsonElement json, String field, JsonElement value); static boolean updateField(JsonElement json, String field, String value); static Map<String, String> getJsonPathsForTemplating(Set<Map.Entry<String, JsonElement>> root); static Map<String, String> getJsonPathsForTemplating(JsonObject json); }
@Test public void double_shallow() { String template = "{ \"a\" : \"{{value}}\", \"b\": \"{{value}}\"}"; JsonObject document = (JsonObject) new JsonParser().parse(template); Map<String, String> paths = JsonUtil.getJsonPathsForTemplating(document); assertEquals(2, paths.size()); Object a = paths.get("$.a"); assertNotNull(a); assertEquals("{{value}}", a.toString()); Object b = paths.get("$.b"); assertNotNull(b); assertEquals("{{value}}", a.toString()); }
public static Map<String, String> getJsonPathsForTemplating(Set<Map.Entry<String, JsonElement>> root) { Map<String, String> paths = new HashMap<>(); searchJsonForTemplate(root, paths, "$"); return paths; }
JsonUtil { public static Map<String, String> getJsonPathsForTemplating(Set<Map.Entry<String, JsonElement>> root) { Map<String, String> paths = new HashMap<>(); searchJsonForTemplate(root, paths, "$"); return paths; } }
JsonUtil { public static Map<String, String> getJsonPathsForTemplating(Set<Map.Entry<String, JsonElement>> root) { Map<String, String> paths = new HashMap<>(); searchJsonForTemplate(root, paths, "$"); return paths; } private JsonUtil(/* empty */); }
JsonUtil { public static Map<String, String> getJsonPathsForTemplating(Set<Map.Entry<String, JsonElement>> root) { Map<String, String> paths = new HashMap<>(); searchJsonForTemplate(root, paths, "$"); return paths; } private JsonUtil(/* empty */); static boolean updateField(JsonElement json, String field, JsonElement value); static boolean updateField(JsonElement json, String field, String value); static Map<String, String> getJsonPathsForTemplating(Set<Map.Entry<String, JsonElement>> root); static Map<String, String> getJsonPathsForTemplating(JsonObject json); }
JsonUtil { public static Map<String, String> getJsonPathsForTemplating(Set<Map.Entry<String, JsonElement>> root) { Map<String, String> paths = new HashMap<>(); searchJsonForTemplate(root, paths, "$"); return paths; } private JsonUtil(/* empty */); static boolean updateField(JsonElement json, String field, JsonElement value); static boolean updateField(JsonElement json, String field, String value); static Map<String, String> getJsonPathsForTemplating(Set<Map.Entry<String, JsonElement>> root); static Map<String, String> getJsonPathsForTemplating(JsonObject json); }
@Test public void simple_deep() { String template = "{ \"a\" : { \"b\": \"{{value}}\"}}"; JsonObject document = (JsonObject) new JsonParser().parse(template); Map<String, String> paths = JsonUtil.getJsonPathsForTemplating(document); assertEquals(1, paths.size()); Object value = paths.get("$.a.b"); assertNotNull(value); assertEquals("{{value}}", value.toString()); }
public static Map<String, String> getJsonPathsForTemplating(Set<Map.Entry<String, JsonElement>> root) { Map<String, String> paths = new HashMap<>(); searchJsonForTemplate(root, paths, "$"); return paths; }
JsonUtil { public static Map<String, String> getJsonPathsForTemplating(Set<Map.Entry<String, JsonElement>> root) { Map<String, String> paths = new HashMap<>(); searchJsonForTemplate(root, paths, "$"); return paths; } }
JsonUtil { public static Map<String, String> getJsonPathsForTemplating(Set<Map.Entry<String, JsonElement>> root) { Map<String, String> paths = new HashMap<>(); searchJsonForTemplate(root, paths, "$"); return paths; } private JsonUtil(/* empty */); }
JsonUtil { public static Map<String, String> getJsonPathsForTemplating(Set<Map.Entry<String, JsonElement>> root) { Map<String, String> paths = new HashMap<>(); searchJsonForTemplate(root, paths, "$"); return paths; } private JsonUtil(/* empty */); static boolean updateField(JsonElement json, String field, JsonElement value); static boolean updateField(JsonElement json, String field, String value); static Map<String, String> getJsonPathsForTemplating(Set<Map.Entry<String, JsonElement>> root); static Map<String, String> getJsonPathsForTemplating(JsonObject json); }
JsonUtil { public static Map<String, String> getJsonPathsForTemplating(Set<Map.Entry<String, JsonElement>> root) { Map<String, String> paths = new HashMap<>(); searchJsonForTemplate(root, paths, "$"); return paths; } private JsonUtil(/* empty */); static boolean updateField(JsonElement json, String field, JsonElement value); static boolean updateField(JsonElement json, String field, String value); static Map<String, String> getJsonPathsForTemplating(Set<Map.Entry<String, JsonElement>> root); static Map<String, String> getJsonPathsForTemplating(JsonObject json); }
@Test public void double_deep() { String template = "{ \"a\" : { \"b\": \"{{value}}\"}, \"c\": { \"b\": \"{{value}}\"}}"; JsonObject document = (JsonObject) new JsonParser().parse(template); Map<String, String> paths = JsonUtil.getJsonPathsForTemplating(document); assertEquals(2, paths.size()); Object a = paths.get("$.a.b"); assertNotNull(a); assertEquals("{{value}}", a.toString()); Object b = paths.get("$.c.b"); assertNotNull(b); assertEquals("{{value}}", a.toString()); }
public static Map<String, String> getJsonPathsForTemplating(Set<Map.Entry<String, JsonElement>> root) { Map<String, String> paths = new HashMap<>(); searchJsonForTemplate(root, paths, "$"); return paths; }
JsonUtil { public static Map<String, String> getJsonPathsForTemplating(Set<Map.Entry<String, JsonElement>> root) { Map<String, String> paths = new HashMap<>(); searchJsonForTemplate(root, paths, "$"); return paths; } }
JsonUtil { public static Map<String, String> getJsonPathsForTemplating(Set<Map.Entry<String, JsonElement>> root) { Map<String, String> paths = new HashMap<>(); searchJsonForTemplate(root, paths, "$"); return paths; } private JsonUtil(/* empty */); }
JsonUtil { public static Map<String, String> getJsonPathsForTemplating(Set<Map.Entry<String, JsonElement>> root) { Map<String, String> paths = new HashMap<>(); searchJsonForTemplate(root, paths, "$"); return paths; } private JsonUtil(/* empty */); static boolean updateField(JsonElement json, String field, JsonElement value); static boolean updateField(JsonElement json, String field, String value); static Map<String, String> getJsonPathsForTemplating(Set<Map.Entry<String, JsonElement>> root); static Map<String, String> getJsonPathsForTemplating(JsonObject json); }
JsonUtil { public static Map<String, String> getJsonPathsForTemplating(Set<Map.Entry<String, JsonElement>> root) { Map<String, String> paths = new HashMap<>(); searchJsonForTemplate(root, paths, "$"); return paths; } private JsonUtil(/* empty */); static boolean updateField(JsonElement json, String field, JsonElement value); static boolean updateField(JsonElement json, String field, String value); static Map<String, String> getJsonPathsForTemplating(Set<Map.Entry<String, JsonElement>> root); static Map<String, String> getJsonPathsForTemplating(JsonObject json); }
@Test public void double_nested_deep() { String template = "{ \"a\" : { \"b\": \"{{value}}\", \"c\": { \"b\": \"{{value}}\"}}, \"c\": { \"b\": \"{{value}}\"}}"; JsonObject document = (JsonObject) new JsonParser().parse(template); Map<String, String> paths = JsonUtil.getJsonPathsForTemplating(document); assertEquals(3, paths.size()); Object a = paths.get("$.a.b"); assertNotNull(a); assertEquals("{{value}}", a.toString()); Object b = paths.get("$.a.c.b"); assertNotNull(b); assertEquals("{{value}}", b.toString()); Object c = paths.get("$.c.b"); assertNotNull(c); assertEquals("{{value}}", c.toString()); }
public static Map<String, String> getJsonPathsForTemplating(Set<Map.Entry<String, JsonElement>> root) { Map<String, String> paths = new HashMap<>(); searchJsonForTemplate(root, paths, "$"); return paths; }
JsonUtil { public static Map<String, String> getJsonPathsForTemplating(Set<Map.Entry<String, JsonElement>> root) { Map<String, String> paths = new HashMap<>(); searchJsonForTemplate(root, paths, "$"); return paths; } }
JsonUtil { public static Map<String, String> getJsonPathsForTemplating(Set<Map.Entry<String, JsonElement>> root) { Map<String, String> paths = new HashMap<>(); searchJsonForTemplate(root, paths, "$"); return paths; } private JsonUtil(/* empty */); }
JsonUtil { public static Map<String, String> getJsonPathsForTemplating(Set<Map.Entry<String, JsonElement>> root) { Map<String, String> paths = new HashMap<>(); searchJsonForTemplate(root, paths, "$"); return paths; } private JsonUtil(/* empty */); static boolean updateField(JsonElement json, String field, JsonElement value); static boolean updateField(JsonElement json, String field, String value); static Map<String, String> getJsonPathsForTemplating(Set<Map.Entry<String, JsonElement>> root); static Map<String, String> getJsonPathsForTemplating(JsonObject json); }
JsonUtil { public static Map<String, String> getJsonPathsForTemplating(Set<Map.Entry<String, JsonElement>> root) { Map<String, String> paths = new HashMap<>(); searchJsonForTemplate(root, paths, "$"); return paths; } private JsonUtil(/* empty */); static boolean updateField(JsonElement json, String field, JsonElement value); static boolean updateField(JsonElement json, String field, String value); static Map<String, String> getJsonPathsForTemplating(Set<Map.Entry<String, JsonElement>> root); static Map<String, String> getJsonPathsForTemplating(JsonObject json); }
@Test public void mixed_data_types() { String template = "{ \"a\" : { \"b\": \"{{value}}\", \"c\": { \"b\": \"{{value}}\"}}, \"c\": { \"b\": \"{{value}}\"}, \"num\": 343, \"bool\": true}"; JsonObject document = (JsonObject) new JsonParser().parse(template); Map<String, String> paths = JsonUtil.getJsonPathsForTemplating(document); assertEquals(3, paths.size()); Object a = paths.get("$.a.b"); assertNotNull(a); assertEquals("{{value}}", a.toString()); Object b = paths.get("$.a.c.b"); assertNotNull(b); assertEquals("{{value}}", b.toString()); Object c = paths.get("$.c.b"); assertNotNull(c); assertEquals("{{value}}", c.toString()); }
public static Map<String, String> getJsonPathsForTemplating(Set<Map.Entry<String, JsonElement>> root) { Map<String, String> paths = new HashMap<>(); searchJsonForTemplate(root, paths, "$"); return paths; }
JsonUtil { public static Map<String, String> getJsonPathsForTemplating(Set<Map.Entry<String, JsonElement>> root) { Map<String, String> paths = new HashMap<>(); searchJsonForTemplate(root, paths, "$"); return paths; } }
JsonUtil { public static Map<String, String> getJsonPathsForTemplating(Set<Map.Entry<String, JsonElement>> root) { Map<String, String> paths = new HashMap<>(); searchJsonForTemplate(root, paths, "$"); return paths; } private JsonUtil(/* empty */); }
JsonUtil { public static Map<String, String> getJsonPathsForTemplating(Set<Map.Entry<String, JsonElement>> root) { Map<String, String> paths = new HashMap<>(); searchJsonForTemplate(root, paths, "$"); return paths; } private JsonUtil(/* empty */); static boolean updateField(JsonElement json, String field, JsonElement value); static boolean updateField(JsonElement json, String field, String value); static Map<String, String> getJsonPathsForTemplating(Set<Map.Entry<String, JsonElement>> root); static Map<String, String> getJsonPathsForTemplating(JsonObject json); }
JsonUtil { public static Map<String, String> getJsonPathsForTemplating(Set<Map.Entry<String, JsonElement>> root) { Map<String, String> paths = new HashMap<>(); searchJsonForTemplate(root, paths, "$"); return paths; } private JsonUtil(/* empty */); static boolean updateField(JsonElement json, String field, JsonElement value); static boolean updateField(JsonElement json, String field, String value); static Map<String, String> getJsonPathsForTemplating(Set<Map.Entry<String, JsonElement>> root); static Map<String, String> getJsonPathsForTemplating(JsonObject json); }
@Test public void testIsValid() throws MalformedObjectNameException { ObjectName o = new ObjectName("domain", "key", "value"); Set<String> mapNames = ImmutableSet.of("foo"); HazelcastMapMetricsReporter hazelcastMapMetricsReporter = new HazelcastMapMetricsReporter(); boolean isValid = hazelcastMapMetricsReporter.isValid(o, mapNames, "cluster"); assertFalse(isValid); String c = "foo"; o = new ObjectName("com.hazelcast", "key", "value"); isValid = hazelcastMapMetricsReporter.isValid(o, mapNames, c); assertFalse(isValid); o = new ObjectName("com.hazelcast", "name", "foo"); isValid = hazelcastMapMetricsReporter.isValid(o, mapNames, c); assertFalse(isValid); Hashtable<String, String> keys = new Hashtable<>(); keys.put("name", "foo"); keys.put("type", "IMap"); o = new ObjectName("com.hazelcast", keys); isValid = hazelcastMapMetricsReporter.isValid(o, mapNames, c); assertFalse(isValid); keys = new Hashtable<>(); keys.put("name", "foo"); keys.put("type", "IMap"); keys.put("instance", "foo"); o = new ObjectName("com.hazelcast", keys); isValid = hazelcastMapMetricsReporter.isValid(o, mapNames, c); assertTrue(isValid); }
boolean isValid(ObjectName name, Set<String> mapNames, String clusterName) { if (!"com.hazelcast".equals(name.getDomain())) { return false; } String propertyName = name.getKeyProperty("name"); if (!mapNames.isEmpty() && !mapNames.contains(propertyName)) { return false; } String typeProperty = name.getKeyProperty("type"); if (StringUtils.isBlank(typeProperty) || !"IMap".equals(name.getKeyProperty("type"))) { return false; } String instanceProperty = name.getKeyProperty("instance"); if (StringUtils.isBlank(instanceProperty) || !instanceProperty.contains(clusterName)) { return false; } return true; }
HazelcastMapMetricsReporter extends AbstractReportingTask { boolean isValid(ObjectName name, Set<String> mapNames, String clusterName) { if (!"com.hazelcast".equals(name.getDomain())) { return false; } String propertyName = name.getKeyProperty("name"); if (!mapNames.isEmpty() && !mapNames.contains(propertyName)) { return false; } String typeProperty = name.getKeyProperty("type"); if (StringUtils.isBlank(typeProperty) || !"IMap".equals(name.getKeyProperty("type"))) { return false; } String instanceProperty = name.getKeyProperty("instance"); if (StringUtils.isBlank(instanceProperty) || !instanceProperty.contains(clusterName)) { return false; } return true; } }
HazelcastMapMetricsReporter extends AbstractReportingTask { boolean isValid(ObjectName name, Set<String> mapNames, String clusterName) { if (!"com.hazelcast".equals(name.getDomain())) { return false; } String propertyName = name.getKeyProperty("name"); if (!mapNames.isEmpty() && !mapNames.contains(propertyName)) { return false; } String typeProperty = name.getKeyProperty("type"); if (StringUtils.isBlank(typeProperty) || !"IMap".equals(name.getKeyProperty("type"))) { return false; } String instanceProperty = name.getKeyProperty("instance"); if (StringUtils.isBlank(instanceProperty) || !instanceProperty.contains(clusterName)) { return false; } return true; } }
HazelcastMapMetricsReporter extends AbstractReportingTask { boolean isValid(ObjectName name, Set<String> mapNames, String clusterName) { if (!"com.hazelcast".equals(name.getDomain())) { return false; } String propertyName = name.getKeyProperty("name"); if (!mapNames.isEmpty() && !mapNames.contains(propertyName)) { return false; } String typeProperty = name.getKeyProperty("type"); if (StringUtils.isBlank(typeProperty) || !"IMap".equals(name.getKeyProperty("type"))) { return false; } String instanceProperty = name.getKeyProperty("instance"); if (StringUtils.isBlank(instanceProperty) || !instanceProperty.contains(clusterName)) { return false; } return true; } @OnScheduled void startup(ConfigurationContext context); @Override void onTrigger(ReportingContext context); @Override final List<PropertyDescriptor> getSupportedPropertyDescriptors(); }
HazelcastMapMetricsReporter extends AbstractReportingTask { boolean isValid(ObjectName name, Set<String> mapNames, String clusterName) { if (!"com.hazelcast".equals(name.getDomain())) { return false; } String propertyName = name.getKeyProperty("name"); if (!mapNames.isEmpty() && !mapNames.contains(propertyName)) { return false; } String typeProperty = name.getKeyProperty("type"); if (StringUtils.isBlank(typeProperty) || !"IMap".equals(name.getKeyProperty("type"))) { return false; } String instanceProperty = name.getKeyProperty("instance"); if (StringUtils.isBlank(instanceProperty) || !instanceProperty.contains(clusterName)) { return false; } return true; } @OnScheduled void startup(ConfigurationContext context); @Override void onTrigger(ReportingContext context); @Override final List<PropertyDescriptor> getSupportedPropertyDescriptors(); }
@Test public void testCollectMeasurements() throws InitializationException { InfluxNiFiClusterMetricsReporter metricsInfluxDbReporter = new InfluxNiFiClusterMetricsReporter(); ProcessGroupStatusMetric processGroupStatusMetric = new ProcessGroupStatusMetric() .setId("id") .setProcessGroupName("root") .setActiveThreadCount(15.0) .setBytesRead(1.4) .setBytesReceived(4.) .setBytesSent(45.) .setBytesWritten(2387.) .setFlowFilesReceived(3425.) .setFlowFilesSent(3425.) .setFlowFilesTransferred(4243.) .setQueued(34521.) .setQueuedContentSize(487652.); Map<String, Object> memory = new HashMap<>(); memory.put("mem", 1.2); Map<String, Object> jvm = new HashMap<>(); jvm.put("free", 1.2); SystemMetricsSnapshot metrics = new SystemMetricsSnapshot() .setClusterNodeIdentifier("clusterId") .setMachineMemory(memory) .setJvmMetrics(jvm) .setRootProcessGroupSnapshot(processGroupStatusMetric) .setProcessGroupSnapshots(Arrays.asList(processGroupStatusMetric)); BatchPoints batchPoints = BatchPoints .database("mock_database") .build(); metricsInfluxDbReporter.collectMeasurements(System.currentTimeMillis(), metrics, batchPoints); List<Point> points = batchPoints.getPoints(); assertEquals(4, points.size()); }
void collectMeasurements(long now, SystemMetricsSnapshot snapshot, BatchPoints points) { collectMemoryMetrics(now, snapshot, points); collectJvmMetrics(now, snapshot, points); collectDiskUsageMetrics(now, snapshot, points); collectProcessGroupMetrics(now, Collections.singletonList(snapshot.getRootProcessGroupSnapshot()), points); collectProcessGroupMetrics(now, snapshot.getProcessGroupSnapshots(), points); collectRemoteProcessGroupMetrics(now, snapshot.getRemoteProcessGroupSnapshots(), points); collectProcessorMetrics(now, snapshot.getProcessorSnapshots(), points); collectConnectionMetrics(now, snapshot.getConnectionSnapshots(), points); collectInputPortMetrics(now, snapshot.getInputPortSnapshots(), points); collectOutputPortMetrics(now, snapshot.getOutputPortSnapshots(), points); }
InfluxNiFiClusterMetricsReporter extends AbstractNiFiClusterMetricsReporter { void collectMeasurements(long now, SystemMetricsSnapshot snapshot, BatchPoints points) { collectMemoryMetrics(now, snapshot, points); collectJvmMetrics(now, snapshot, points); collectDiskUsageMetrics(now, snapshot, points); collectProcessGroupMetrics(now, Collections.singletonList(snapshot.getRootProcessGroupSnapshot()), points); collectProcessGroupMetrics(now, snapshot.getProcessGroupSnapshots(), points); collectRemoteProcessGroupMetrics(now, snapshot.getRemoteProcessGroupSnapshots(), points); collectProcessorMetrics(now, snapshot.getProcessorSnapshots(), points); collectConnectionMetrics(now, snapshot.getConnectionSnapshots(), points); collectInputPortMetrics(now, snapshot.getInputPortSnapshots(), points); collectOutputPortMetrics(now, snapshot.getOutputPortSnapshots(), points); } }
InfluxNiFiClusterMetricsReporter extends AbstractNiFiClusterMetricsReporter { void collectMeasurements(long now, SystemMetricsSnapshot snapshot, BatchPoints points) { collectMemoryMetrics(now, snapshot, points); collectJvmMetrics(now, snapshot, points); collectDiskUsageMetrics(now, snapshot, points); collectProcessGroupMetrics(now, Collections.singletonList(snapshot.getRootProcessGroupSnapshot()), points); collectProcessGroupMetrics(now, snapshot.getProcessGroupSnapshots(), points); collectRemoteProcessGroupMetrics(now, snapshot.getRemoteProcessGroupSnapshots(), points); collectProcessorMetrics(now, snapshot.getProcessorSnapshots(), points); collectConnectionMetrics(now, snapshot.getConnectionSnapshots(), points); collectInputPortMetrics(now, snapshot.getInputPortSnapshots(), points); collectOutputPortMetrics(now, snapshot.getOutputPortSnapshots(), points); } }
InfluxNiFiClusterMetricsReporter extends AbstractNiFiClusterMetricsReporter { void collectMeasurements(long now, SystemMetricsSnapshot snapshot, BatchPoints points) { collectMemoryMetrics(now, snapshot, points); collectJvmMetrics(now, snapshot, points); collectDiskUsageMetrics(now, snapshot, points); collectProcessGroupMetrics(now, Collections.singletonList(snapshot.getRootProcessGroupSnapshot()), points); collectProcessGroupMetrics(now, snapshot.getProcessGroupSnapshots(), points); collectRemoteProcessGroupMetrics(now, snapshot.getRemoteProcessGroupSnapshots(), points); collectProcessorMetrics(now, snapshot.getProcessorSnapshots(), points); collectConnectionMetrics(now, snapshot.getConnectionSnapshots(), points); collectInputPortMetrics(now, snapshot.getInputPortSnapshots(), points); collectOutputPortMetrics(now, snapshot.getOutputPortSnapshots(), points); } @OnScheduled void startup(ConfigurationContext context); @Override final List<PropertyDescriptor> getSupportedPropertyDescriptors(); }
InfluxNiFiClusterMetricsReporter extends AbstractNiFiClusterMetricsReporter { void collectMeasurements(long now, SystemMetricsSnapshot snapshot, BatchPoints points) { collectMemoryMetrics(now, snapshot, points); collectJvmMetrics(now, snapshot, points); collectDiskUsageMetrics(now, snapshot, points); collectProcessGroupMetrics(now, Collections.singletonList(snapshot.getRootProcessGroupSnapshot()), points); collectProcessGroupMetrics(now, snapshot.getProcessGroupSnapshots(), points); collectRemoteProcessGroupMetrics(now, snapshot.getRemoteProcessGroupSnapshots(), points); collectProcessorMetrics(now, snapshot.getProcessorSnapshots(), points); collectConnectionMetrics(now, snapshot.getConnectionSnapshots(), points); collectInputPortMetrics(now, snapshot.getInputPortSnapshots(), points); collectOutputPortMetrics(now, snapshot.getOutputPortSnapshots(), points); } @OnScheduled void startup(ConfigurationContext context); @Override final List<PropertyDescriptor> getSupportedPropertyDescriptors(); }
@Test public void testCollectMeasurements() throws InitializationException { CloudwatchNiFiClusterMetricsReporter metricsCloudwatchReporter = new CloudwatchNiFiClusterMetricsReporter(); ProcessGroupStatusMetric processGroupStatusMetric = new ProcessGroupStatusMetric() .setId("id") .setProcessGroupName("root") .setActiveThreadCount(15.0) .setBytesRead(1.4) .setBytesReceived(4.) .setBytesSent(45.) .setBytesWritten(2387.) .setFlowFilesReceived(3425.) .setFlowFilesSent(3425.) .setFlowFilesTransferred(4243.) .setQueued(34521.) .setQueuedContentSize(487652.); Map<String, Object> memory = new HashMap<>(); memory.put("mem", 1.2); Map<String, Object> jvm = new HashMap<>(); jvm.put("free", 1.2); SystemMetricsSnapshot metrics = new SystemMetricsSnapshot() .setClusterNodeIdentifier("clusterId") .setMachineMemory(memory) .setJvmMetrics(jvm) .setRootProcessGroupSnapshot(processGroupStatusMetric) .setProcessGroupSnapshots(Arrays.asList(processGroupStatusMetric)); List<Dimension> dimensions = new ArrayList<>(); List<MetricDatum> cloudwatchMetrics = metricsCloudwatchReporter.collectMeasurements(new Date(), metrics, dimensions); assertEquals(10, cloudwatchMetrics.size()); metricsCloudwatchReporter.collectsJVMMetrics = true; metricsCloudwatchReporter.collectsMemory = true; cloudwatchMetrics = metricsCloudwatchReporter.collectMeasurements(new Date(), metrics, dimensions); assertEquals(12, cloudwatchMetrics.size()); }
List<MetricDatum> collectMeasurements(Date now, SystemMetricsSnapshot snapshot, List<Dimension> dimensions) { List<MetricDatum> toCloudwatch = new ArrayList<>(); if (collectsMemory) { getMetrics("System Memory", snapshot.getMachineMemory(), now, dimensions, toCloudwatch); } if (collectsJVMMetrics) { getMetrics("System JVM", snapshot.getJvmMetrics(), now, dimensions, toCloudwatch); } snapshot.getProcessGroupSnapshots().forEach((groupData) -> getMetrics(groupData.getProcessGroupName(), groupData.valuesAsMap(), now, dimensions, toCloudwatch) ); snapshot.getRemoteProcessGroupSnapshots().forEach((groupData) -> getMetrics(groupData.getRemoteProcessGroupName(), groupData.valuesAsMap(), now, dimensions, toCloudwatch) ); snapshot.getProcessorSnapshots().forEach((processorData) -> getMetrics(processorData.getProcessorName(), processorData.valuesAsMap(), now, dimensions, toCloudwatch) ); snapshot.getConnectionSnapshots().forEach((connectionData) -> getMetrics(connectionData.getConnectionName(), connectionData.valuesAsMap(), now, dimensions, toCloudwatch) ); snapshot.getInputPortSnapshots().forEach((portData) -> getMetrics(portData.getInputPortName(), portData.valuesAsMap(), now, dimensions, toCloudwatch) ); snapshot.getOutputPortSnapshots().forEach((portData) -> getMetrics(portData.getInputPortName(), portData.valuesAsMap(), now, dimensions, toCloudwatch) ); snapshot.getDiskMetrics().entrySet().forEach((fileData) -> getMetrics(fileData.getKey().getAbsolutePath(), fileData.getValue(), now, dimensions, toCloudwatch) ); return toCloudwatch; }
CloudwatchNiFiClusterMetricsReporter extends AbstractNiFiClusterMetricsReporter { List<MetricDatum> collectMeasurements(Date now, SystemMetricsSnapshot snapshot, List<Dimension> dimensions) { List<MetricDatum> toCloudwatch = new ArrayList<>(); if (collectsMemory) { getMetrics("System Memory", snapshot.getMachineMemory(), now, dimensions, toCloudwatch); } if (collectsJVMMetrics) { getMetrics("System JVM", snapshot.getJvmMetrics(), now, dimensions, toCloudwatch); } snapshot.getProcessGroupSnapshots().forEach((groupData) -> getMetrics(groupData.getProcessGroupName(), groupData.valuesAsMap(), now, dimensions, toCloudwatch) ); snapshot.getRemoteProcessGroupSnapshots().forEach((groupData) -> getMetrics(groupData.getRemoteProcessGroupName(), groupData.valuesAsMap(), now, dimensions, toCloudwatch) ); snapshot.getProcessorSnapshots().forEach((processorData) -> getMetrics(processorData.getProcessorName(), processorData.valuesAsMap(), now, dimensions, toCloudwatch) ); snapshot.getConnectionSnapshots().forEach((connectionData) -> getMetrics(connectionData.getConnectionName(), connectionData.valuesAsMap(), now, dimensions, toCloudwatch) ); snapshot.getInputPortSnapshots().forEach((portData) -> getMetrics(portData.getInputPortName(), portData.valuesAsMap(), now, dimensions, toCloudwatch) ); snapshot.getOutputPortSnapshots().forEach((portData) -> getMetrics(portData.getInputPortName(), portData.valuesAsMap(), now, dimensions, toCloudwatch) ); snapshot.getDiskMetrics().entrySet().forEach((fileData) -> getMetrics(fileData.getKey().getAbsolutePath(), fileData.getValue(), now, dimensions, toCloudwatch) ); return toCloudwatch; } }
CloudwatchNiFiClusterMetricsReporter extends AbstractNiFiClusterMetricsReporter { List<MetricDatum> collectMeasurements(Date now, SystemMetricsSnapshot snapshot, List<Dimension> dimensions) { List<MetricDatum> toCloudwatch = new ArrayList<>(); if (collectsMemory) { getMetrics("System Memory", snapshot.getMachineMemory(), now, dimensions, toCloudwatch); } if (collectsJVMMetrics) { getMetrics("System JVM", snapshot.getJvmMetrics(), now, dimensions, toCloudwatch); } snapshot.getProcessGroupSnapshots().forEach((groupData) -> getMetrics(groupData.getProcessGroupName(), groupData.valuesAsMap(), now, dimensions, toCloudwatch) ); snapshot.getRemoteProcessGroupSnapshots().forEach((groupData) -> getMetrics(groupData.getRemoteProcessGroupName(), groupData.valuesAsMap(), now, dimensions, toCloudwatch) ); snapshot.getProcessorSnapshots().forEach((processorData) -> getMetrics(processorData.getProcessorName(), processorData.valuesAsMap(), now, dimensions, toCloudwatch) ); snapshot.getConnectionSnapshots().forEach((connectionData) -> getMetrics(connectionData.getConnectionName(), connectionData.valuesAsMap(), now, dimensions, toCloudwatch) ); snapshot.getInputPortSnapshots().forEach((portData) -> getMetrics(portData.getInputPortName(), portData.valuesAsMap(), now, dimensions, toCloudwatch) ); snapshot.getOutputPortSnapshots().forEach((portData) -> getMetrics(portData.getInputPortName(), portData.valuesAsMap(), now, dimensions, toCloudwatch) ); snapshot.getDiskMetrics().entrySet().forEach((fileData) -> getMetrics(fileData.getKey().getAbsolutePath(), fileData.getValue(), now, dimensions, toCloudwatch) ); return toCloudwatch; } }
CloudwatchNiFiClusterMetricsReporter extends AbstractNiFiClusterMetricsReporter { List<MetricDatum> collectMeasurements(Date now, SystemMetricsSnapshot snapshot, List<Dimension> dimensions) { List<MetricDatum> toCloudwatch = new ArrayList<>(); if (collectsMemory) { getMetrics("System Memory", snapshot.getMachineMemory(), now, dimensions, toCloudwatch); } if (collectsJVMMetrics) { getMetrics("System JVM", snapshot.getJvmMetrics(), now, dimensions, toCloudwatch); } snapshot.getProcessGroupSnapshots().forEach((groupData) -> getMetrics(groupData.getProcessGroupName(), groupData.valuesAsMap(), now, dimensions, toCloudwatch) ); snapshot.getRemoteProcessGroupSnapshots().forEach((groupData) -> getMetrics(groupData.getRemoteProcessGroupName(), groupData.valuesAsMap(), now, dimensions, toCloudwatch) ); snapshot.getProcessorSnapshots().forEach((processorData) -> getMetrics(processorData.getProcessorName(), processorData.valuesAsMap(), now, dimensions, toCloudwatch) ); snapshot.getConnectionSnapshots().forEach((connectionData) -> getMetrics(connectionData.getConnectionName(), connectionData.valuesAsMap(), now, dimensions, toCloudwatch) ); snapshot.getInputPortSnapshots().forEach((portData) -> getMetrics(portData.getInputPortName(), portData.valuesAsMap(), now, dimensions, toCloudwatch) ); snapshot.getOutputPortSnapshots().forEach((portData) -> getMetrics(portData.getInputPortName(), portData.valuesAsMap(), now, dimensions, toCloudwatch) ); snapshot.getDiskMetrics().entrySet().forEach((fileData) -> getMetrics(fileData.getKey().getAbsolutePath(), fileData.getValue(), now, dimensions, toCloudwatch) ); return toCloudwatch; } @Override final List<PropertyDescriptor> getSupportedPropertyDescriptors(); @OnScheduled void startup(ConfigurationContext context); }
CloudwatchNiFiClusterMetricsReporter extends AbstractNiFiClusterMetricsReporter { List<MetricDatum> collectMeasurements(Date now, SystemMetricsSnapshot snapshot, List<Dimension> dimensions) { List<MetricDatum> toCloudwatch = new ArrayList<>(); if (collectsMemory) { getMetrics("System Memory", snapshot.getMachineMemory(), now, dimensions, toCloudwatch); } if (collectsJVMMetrics) { getMetrics("System JVM", snapshot.getJvmMetrics(), now, dimensions, toCloudwatch); } snapshot.getProcessGroupSnapshots().forEach((groupData) -> getMetrics(groupData.getProcessGroupName(), groupData.valuesAsMap(), now, dimensions, toCloudwatch) ); snapshot.getRemoteProcessGroupSnapshots().forEach((groupData) -> getMetrics(groupData.getRemoteProcessGroupName(), groupData.valuesAsMap(), now, dimensions, toCloudwatch) ); snapshot.getProcessorSnapshots().forEach((processorData) -> getMetrics(processorData.getProcessorName(), processorData.valuesAsMap(), now, dimensions, toCloudwatch) ); snapshot.getConnectionSnapshots().forEach((connectionData) -> getMetrics(connectionData.getConnectionName(), connectionData.valuesAsMap(), now, dimensions, toCloudwatch) ); snapshot.getInputPortSnapshots().forEach((portData) -> getMetrics(portData.getInputPortName(), portData.valuesAsMap(), now, dimensions, toCloudwatch) ); snapshot.getOutputPortSnapshots().forEach((portData) -> getMetrics(portData.getInputPortName(), portData.valuesAsMap(), now, dimensions, toCloudwatch) ); snapshot.getDiskMetrics().entrySet().forEach((fileData) -> getMetrics(fileData.getKey().getAbsolutePath(), fileData.getValue(), now, dimensions, toCloudwatch) ); return toCloudwatch; } @Override final List<PropertyDescriptor> getSupportedPropertyDescriptors(); @OnScheduled void startup(ConfigurationContext context); static final PropertyDescriptor CREDENTIALS_FILE; static final PropertyDescriptor ACCESS_KEY; static final PropertyDescriptor SECRET_KEY; }
@Test public void probeByteCodeDebug() { PrintStream sysOut = mock(PrintStream.class); System.out.println("Sysout hijack!"); PrintStream oldPrintStream = System.out; try { System.setOut(sysOut); InvokeInstruction ins = mock(InvokeInstruction.class); ConstantPoolGen cpg = mock(ConstantPoolGen.class); when(ins.getClassName(Matchers.<ConstantPoolGen>any())).thenReturn("ClassTest"); when(ins.getMethodName(Matchers.<ConstantPoolGen>any())).thenReturn("method"); when(ins.getSignature(Matchers.<ConstantPoolGen>any())).thenReturn("(Lsignature)Lblah"); ByteCode.printOpCode(ins, cpg); verify(sysOut, atLeastOnce()).println(contains("ClassTest.method")); } finally { System.setOut(oldPrintStream); System.out.println("Sysout is back!"); } }
public static void printOpCode(InstructionHandle insHandle, ConstantPoolGen cpg) { System.out.print("[" + String.format("%02d", insHandle.getPosition()) + "] "); printOpCode(insHandle.getInstruction(),cpg); }
ByteCode { public static void printOpCode(InstructionHandle insHandle, ConstantPoolGen cpg) { System.out.print("[" + String.format("%02d", insHandle.getPosition()) + "] "); printOpCode(insHandle.getInstruction(),cpg); } }
ByteCode { public static void printOpCode(InstructionHandle insHandle, ConstantPoolGen cpg) { System.out.print("[" + String.format("%02d", insHandle.getPosition()) + "] "); printOpCode(insHandle.getInstruction(),cpg); } }
ByteCode { public static void printOpCode(InstructionHandle insHandle, ConstantPoolGen cpg) { System.out.print("[" + String.format("%02d", insHandle.getPosition()) + "] "); printOpCode(insHandle.getInstruction(),cpg); } static void printOpCode(InstructionHandle insHandle, ConstantPoolGen cpg); static void printOpCode(Instruction ins, ConstantPoolGen cpg); static T getConstantLDC(InstructionHandle h, ConstantPoolGen cpg, Class<T> clazz); static Integer getConstantInt(InstructionHandle h); static Number getPushNumber(InstructionHandle h); static T getPrevInstruction(InstructionHandle startHandle, Class<T> clazz); }
ByteCode { public static void printOpCode(InstructionHandle insHandle, ConstantPoolGen cpg) { System.out.print("[" + String.format("%02d", insHandle.getPosition()) + "] "); printOpCode(insHandle.getInstruction(),cpg); } static void printOpCode(InstructionHandle insHandle, ConstantPoolGen cpg); static void printOpCode(Instruction ins, ConstantPoolGen cpg); static T getConstantLDC(InstructionHandle h, ConstantPoolGen cpg, Class<T> clazz); static Integer getConstantInt(InstructionHandle h); static Number getPushNumber(InstructionHandle h); static T getPrevInstruction(InstructionHandle startHandle, Class<T> clazz); }
@Test public void testSimple() { DoubleLinkedCountingSet s = new DoubleLinkedCountingSet(10, 5); assertEquals(0, s.elementsCount); s.increment(3); assertEquals(1, s.elementsCount); assertEquals(1, s.counts[0]); assertEquals(3, s.dense[0]); s.increment(10); assertEquals(2, s.elementsCount); assertEquals(1, s.counts[1]); assertEquals(10, s.dense[1]); s.increment(3); assertEquals(2, s.elementsCount); assertEquals(2, s.counts[0]); }
public void increment(int key) { int index = sparse[key]; if (index < elementsCount && dense[index] == key) { counts[index]++; } else { index = elementsCount++; sparse[key] = index; dense[index] = key; counts[index] = 1; } }
DoubleLinkedCountingSet { public void increment(int key) { int index = sparse[key]; if (index < elementsCount && dense[index] == key) { counts[index]++; } else { index = elementsCount++; sparse[key] = index; dense[index] = key; counts[index] = 1; } } }
DoubleLinkedCountingSet { public void increment(int key) { int index = sparse[key]; if (index < elementsCount && dense[index] == key) { counts[index]++; } else { index = elementsCount++; sparse[key] = index; dense[index] = key; counts[index] = 1; } } DoubleLinkedCountingSet(int maxValue, int maxValues); }
DoubleLinkedCountingSet { public void increment(int key) { int index = sparse[key]; if (index < elementsCount && dense[index] == key) { counts[index]++; } else { index = elementsCount++; sparse[key] = index; dense[index] = key; counts[index] = 1; } } DoubleLinkedCountingSet(int maxValue, int maxValues); void increment(int key); void clear(); }
DoubleLinkedCountingSet { public void increment(int key) { int index = sparse[key]; if (index < elementsCount && dense[index] == key) { counts[index]++; } else { index = elementsCount++; sparse[key] = index; dense[index] = key; counts[index] = 1; } } DoubleLinkedCountingSet(int maxValue, int maxValues); void increment(int key); void clear(); final int[] sparse; final int[] dense; final int[] counts; public int elementsCount; }
@Test @Repeat(iterations = 20) public void testRandomized() { int maxValue = randomIntBetween(0, 1000); int maxValues = randomIntBetween(0, maxValue); int [] values = new int [maxValues]; for (int i = 0; i < values.length; i++) { values[i] = randomIntBetween(0, maxValue); } DoubleLinkedCountingSet s = new DoubleLinkedCountingSet(maxValue, maxValues); IntIntOpenHashMap ref = IntIntOpenHashMap.newInstance(); for (int i = 0; i < maxValues * 10; i++) { int r = values[randomIntBetween(0, values.length - 1)]; ref.addTo(r, 1); s.increment(r); } IntIntOpenHashMap result = IntIntOpenHashMap.newInstance(); for (int i = 0; i < s.elementsCount; i++) { int k = s.dense[i]; int v = s.counts[i]; assertTrue(!result.containsKey(k)); result.put(k, v); } assertEquals(ref, result); }
public void increment(int key) { int index = sparse[key]; if (index < elementsCount && dense[index] == key) { counts[index]++; } else { index = elementsCount++; sparse[key] = index; dense[index] = key; counts[index] = 1; } }
DoubleLinkedCountingSet { public void increment(int key) { int index = sparse[key]; if (index < elementsCount && dense[index] == key) { counts[index]++; } else { index = elementsCount++; sparse[key] = index; dense[index] = key; counts[index] = 1; } } }
DoubleLinkedCountingSet { public void increment(int key) { int index = sparse[key]; if (index < elementsCount && dense[index] == key) { counts[index]++; } else { index = elementsCount++; sparse[key] = index; dense[index] = key; counts[index] = 1; } } DoubleLinkedCountingSet(int maxValue, int maxValues); }
DoubleLinkedCountingSet { public void increment(int key) { int index = sparse[key]; if (index < elementsCount && dense[index] == key) { counts[index]++; } else { index = elementsCount++; sparse[key] = index; dense[index] = key; counts[index] = 1; } } DoubleLinkedCountingSet(int maxValue, int maxValues); void increment(int key); void clear(); }
DoubleLinkedCountingSet { public void increment(int key) { int index = sparse[key]; if (index < elementsCount && dense[index] == key) { counts[index]++; } else { index = elementsCount++; sparse[key] = index; dense[index] = key; counts[index] = 1; } } DoubleLinkedCountingSet(int maxValue, int maxValues); void increment(int key); void clear(); final int[] sparse; final int[] dense; final int[] counts; public int elementsCount; }
@Test public void testSanity() { LangIdV3 langid = new LangIdV3(); for (String [] langString : new String [][] { {"en", "Mike McCandless rocks the boat."}, {"pl", "W Szczebrzeszynie chrząszcz brzmi w trzcinie"}, {"it", "Piano italiano per la crescita: negoziato in Europa sugli investimenti «virtuosi»"} }) { DetectedLanguage result = langid.classify(langString[1], true); assertEquals(langString[0], result.langCode); } }
@Override public DetectedLanguage classify(CharSequence str, boolean normalizeConfidence) { reset(); append(str); return classify(normalizeConfidence); }
LangIdV3 implements ILangIdClassifier { @Override public DetectedLanguage classify(CharSequence str, boolean normalizeConfidence) { reset(); append(str); return classify(normalizeConfidence); } }
LangIdV3 implements ILangIdClassifier { @Override public DetectedLanguage classify(CharSequence str, boolean normalizeConfidence) { reset(); append(str); return classify(normalizeConfidence); } LangIdV3(); LangIdV3(Model model); }
LangIdV3 implements ILangIdClassifier { @Override public DetectedLanguage classify(CharSequence str, boolean normalizeConfidence) { reset(); append(str); return classify(normalizeConfidence); } LangIdV3(); LangIdV3(Model model); @Override DetectedLanguage classify(CharSequence str, boolean normalizeConfidence); @Override void reset(); @Override void append(CharSequence str); @Override void append(ByteBuffer buffer); @Override void append(byte [] array, int start, int length); @Override DetectedLanguage classify(boolean normalizeConfidence); @Override List<DetectedLanguage> rank(boolean normalizeConfidence); }
LangIdV3 implements ILangIdClassifier { @Override public DetectedLanguage classify(CharSequence str, boolean normalizeConfidence) { reset(); append(str); return classify(normalizeConfidence); } LangIdV3(); LangIdV3(Model model); @Override DetectedLanguage classify(CharSequence str, boolean normalizeConfidence); @Override void reset(); @Override void append(CharSequence str); @Override void append(ByteBuffer buffer); @Override void append(byte [] array, int start, int length); @Override DetectedLanguage classify(boolean normalizeConfidence); @Override List<DetectedLanguage> rank(boolean normalizeConfidence); }
@Test @Seeds(value = { @Seed, @Seed("deadbeef") }) public void testSameResultWithTrimmedLanguages() { final Set<String> allowed = Sets.newHashSet("en", "de", "es", "fr", "it", "pl"); LangIdV3 v1 = new LangIdV3(); LangIdV3 v2 = new LangIdV3(Model.detectOnly(allowed)); for (int i = 0; i < 10000; i++) { String in = randomRealisticUnicodeOfCodepointLengthBetween(1, 300); DetectedLanguage c1 = v1.classify(in, true); DetectedLanguage c2 = v2.classify(in, true); if (allowed.contains(c1.langCode)) { assertEquals(c1.langCode, c2.langCode); } } }
public static Model detectOnly(Set<String> langCodes) { final Model source = defaultModel(); Set<String> newClasses = new LinkedHashSet<String>(Arrays.asList(source.langClasses)); newClasses.retainAll(langCodes); if (newClasses.size() < 2) { throw new IllegalArgumentException("A model must contain at least two languages."); } String [] trimmed_nb_classes = newClasses.toArray(new String[newClasses.size()]); float[] trimmed_nb_pc = new float [newClasses.size()]; float[] trimmed_nb_ptc = new float [newClasses.size() * source.numFeatures]; for (int i = 0, j = 0; i < source.numClasses; i++) { if (newClasses.contains(source.langClasses[i])) { trimmed_nb_pc[j] = source.nb_pc[i]; for (int f = 0; f < source.numFeatures; f++) { int iFrom = source.numFeatures * i + f; int iTo = source.numFeatures * j + f; trimmed_nb_ptc[iTo] = source.nb_ptc[iFrom]; } j++; } } return new Model( trimmed_nb_classes, trimmed_nb_ptc, trimmed_nb_pc, source.dsa, source.dsaOutput); }
Model { public static Model detectOnly(Set<String> langCodes) { final Model source = defaultModel(); Set<String> newClasses = new LinkedHashSet<String>(Arrays.asList(source.langClasses)); newClasses.retainAll(langCodes); if (newClasses.size() < 2) { throw new IllegalArgumentException("A model must contain at least two languages."); } String [] trimmed_nb_classes = newClasses.toArray(new String[newClasses.size()]); float[] trimmed_nb_pc = new float [newClasses.size()]; float[] trimmed_nb_ptc = new float [newClasses.size() * source.numFeatures]; for (int i = 0, j = 0; i < source.numClasses; i++) { if (newClasses.contains(source.langClasses[i])) { trimmed_nb_pc[j] = source.nb_pc[i]; for (int f = 0; f < source.numFeatures; f++) { int iFrom = source.numFeatures * i + f; int iTo = source.numFeatures * j + f; trimmed_nb_ptc[iTo] = source.nb_ptc[iFrom]; } j++; } } return new Model( trimmed_nb_classes, trimmed_nb_ptc, trimmed_nb_pc, source.dsa, source.dsaOutput); } }
Model { public static Model detectOnly(Set<String> langCodes) { final Model source = defaultModel(); Set<String> newClasses = new LinkedHashSet<String>(Arrays.asList(source.langClasses)); newClasses.retainAll(langCodes); if (newClasses.size() < 2) { throw new IllegalArgumentException("A model must contain at least two languages."); } String [] trimmed_nb_classes = newClasses.toArray(new String[newClasses.size()]); float[] trimmed_nb_pc = new float [newClasses.size()]; float[] trimmed_nb_ptc = new float [newClasses.size() * source.numFeatures]; for (int i = 0, j = 0; i < source.numClasses; i++) { if (newClasses.contains(source.langClasses[i])) { trimmed_nb_pc[j] = source.nb_pc[i]; for (int f = 0; f < source.numFeatures; f++) { int iFrom = source.numFeatures * i + f; int iTo = source.numFeatures * j + f; trimmed_nb_ptc[iTo] = source.nb_ptc[iFrom]; } j++; } } return new Model( trimmed_nb_classes, trimmed_nb_ptc, trimmed_nb_pc, source.dsa, source.dsaOutput); } Model(String [] langClasses, float [] ptc, float [] pc, short [] dsa, int[][] dsaOutput); }
Model { public static Model detectOnly(Set<String> langCodes) { final Model source = defaultModel(); Set<String> newClasses = new LinkedHashSet<String>(Arrays.asList(source.langClasses)); newClasses.retainAll(langCodes); if (newClasses.size() < 2) { throw new IllegalArgumentException("A model must contain at least two languages."); } String [] trimmed_nb_classes = newClasses.toArray(new String[newClasses.size()]); float[] trimmed_nb_pc = new float [newClasses.size()]; float[] trimmed_nb_ptc = new float [newClasses.size() * source.numFeatures]; for (int i = 0, j = 0; i < source.numClasses; i++) { if (newClasses.contains(source.langClasses[i])) { trimmed_nb_pc[j] = source.nb_pc[i]; for (int f = 0; f < source.numFeatures; f++) { int iFrom = source.numFeatures * i + f; int iTo = source.numFeatures * j + f; trimmed_nb_ptc[iTo] = source.nb_ptc[iFrom]; } j++; } } return new Model( trimmed_nb_classes, trimmed_nb_ptc, trimmed_nb_pc, source.dsa, source.dsaOutput); } Model(String [] langClasses, float [] ptc, float [] pc, short [] dsa, int[][] dsaOutput); static Model readExternal(ObjectInput in); static Model detectOnly(Set<String> langCodes); Set<String> getDetectedLanguages(); static synchronized Model defaultModel(); }
Model { public static Model detectOnly(Set<String> langCodes) { final Model source = defaultModel(); Set<String> newClasses = new LinkedHashSet<String>(Arrays.asList(source.langClasses)); newClasses.retainAll(langCodes); if (newClasses.size() < 2) { throw new IllegalArgumentException("A model must contain at least two languages."); } String [] trimmed_nb_classes = newClasses.toArray(new String[newClasses.size()]); float[] trimmed_nb_pc = new float [newClasses.size()]; float[] trimmed_nb_ptc = new float [newClasses.size() * source.numFeatures]; for (int i = 0, j = 0; i < source.numClasses; i++) { if (newClasses.contains(source.langClasses[i])) { trimmed_nb_pc[j] = source.nb_pc[i]; for (int f = 0; f < source.numFeatures; f++) { int iFrom = source.numFeatures * i + f; int iTo = source.numFeatures * j + f; trimmed_nb_ptc[iTo] = source.nb_ptc[iFrom]; } j++; } } return new Model( trimmed_nb_classes, trimmed_nb_ptc, trimmed_nb_pc, source.dsa, source.dsaOutput); } Model(String [] langClasses, float [] ptc, float [] pc, short [] dsa, int[][] dsaOutput); static Model readExternal(ObjectInput in); static Model detectOnly(Set<String> langCodes); Set<String> getDetectedLanguages(); static synchronized Model defaultModel(); }
@Test public void shouldCreateUser() throws Exception { when(userRepositoryMock.save(isA(User.class))).thenAnswer(invocation -> invocation.getArgument(0)); final User user = testSubject.create("Clark", "$"); assertThat(user.getName()).isEqualTo("Clark"); assertThat(user.getCurrency()).isEqualTo("$"); }
public User create(String name, String currency) { final User user = new User(name, currency); return userRepository.save(user); }
UserService { public User create(String name, String currency) { final User user = new User(name, currency); return userRepository.save(user); } }
UserService { public User create(String name, String currency) { final User user = new User(name, currency); return userRepository.save(user); } @Autowired UserService(UserRepository userRepository, UserManagementProperties userManagementProperties); }
UserService { public User create(String name, String currency) { final User user = new User(name, currency); return userRepository.save(user); } @Autowired UserService(UserRepository userRepository, UserManagementProperties userManagementProperties); List<User> list(); User create(String name, String currency); User get(long id); String getTestProperty(); }
UserService { public User create(String name, String currency) { final User user = new User(name, currency); return userRepository.save(user); } @Autowired UserService(UserRepository userRepository, UserManagementProperties userManagementProperties); List<User> list(); User create(String name, String currency); User get(long id); String getTestProperty(); }
@Test public void shouldListAccounts() { User bob = UserTestUtils.createBob(); Account checkings = AccountTestUtils.createCheckingsAccount(bob); Account savings = AccountTestUtils.createSavingsAccount(bob); when(accountRepositoryMock.findByUserId(bob.getId())).thenReturn(asList(checkings, savings)); List<Account> accounts = testSubject.list(bob.getId()); assertThat(accounts).containsExactlyInAnyOrder(checkings, savings); }
public List<Account> list(long userId) { return accountRepository.findByUserId(userId); }
AccountService { public List<Account> list(long userId) { return accountRepository.findByUserId(userId); } }
AccountService { public List<Account> list(long userId) { return accountRepository.findByUserId(userId); } @Autowired AccountService(AccountRepository accountRepository, UserRepository userRepository); }
AccountService { public List<Account> list(long userId) { return accountRepository.findByUserId(userId); } @Autowired AccountService(AccountRepository accountRepository, UserRepository userRepository); List<Account> list(long userId); Account get(long id); Account create(long userId, String description, boolean onBudget); }
AccountService { public List<Account> list(long userId) { return accountRepository.findByUserId(userId); } @Autowired AccountService(AccountRepository accountRepository, UserRepository userRepository); List<Account> list(long userId); Account get(long id); Account create(long userId, String description, boolean onBudget); }
@Test public void shoudlGetAccount() { User bob = UserTestUtils.createBob(); Account checkings = AccountTestUtils.createCheckingsAccount(bob); when(accountRepositoryMock.findOne(isA(Example.class))).thenReturn(Optional.of(checkings)); Account accounts = testSubject.get(checkings.getId()); assertThat(accounts).isEqualTo(checkings); }
public Account get(long id) { return accountRepository.findOne(Example.of(new Account().setId(id))).orElse(null); }
AccountService { public Account get(long id) { return accountRepository.findOne(Example.of(new Account().setId(id))).orElse(null); } }
AccountService { public Account get(long id) { return accountRepository.findOne(Example.of(new Account().setId(id))).orElse(null); } @Autowired AccountService(AccountRepository accountRepository, UserRepository userRepository); }
AccountService { public Account get(long id) { return accountRepository.findOne(Example.of(new Account().setId(id))).orElse(null); } @Autowired AccountService(AccountRepository accountRepository, UserRepository userRepository); List<Account> list(long userId); Account get(long id); Account create(long userId, String description, boolean onBudget); }
AccountService { public Account get(long id) { return accountRepository.findOne(Example.of(new Account().setId(id))).orElse(null); } @Autowired AccountService(AccountRepository accountRepository, UserRepository userRepository); List<Account> list(long userId); Account get(long id); Account create(long userId, String description, boolean onBudget); }
@Test public void shouldCreateAnAccount() { User bob = UserTestUtils.createBob(); when(userRepositoryMock.getOne(bob.getId())).thenReturn(bob); when(accountRepositoryMock.saveAndFlush(isA(Account.class))).thenAnswer(invocation -> invocation.getArgument(0)); Account account = testSubject.create(bob.getId(), "Cash", true); assertThat(account).isNotNull(); assertThat(account.getUser()).isNotNull(); assertThat(account.getUser().getId()).isEqualTo(bob.getId()); assertThat(account.getDescription()).isEqualTo("Cash"); assertThat(account.isOnBudget()).isTrue(); }
public Account create(long userId, String description, boolean onBudget) { User user = userRepository.getOne(userId); Account account = new Account(description, onBudget, user); return accountRepository.saveAndFlush(account); }
AccountService { public Account create(long userId, String description, boolean onBudget) { User user = userRepository.getOne(userId); Account account = new Account(description, onBudget, user); return accountRepository.saveAndFlush(account); } }
AccountService { public Account create(long userId, String description, boolean onBudget) { User user = userRepository.getOne(userId); Account account = new Account(description, onBudget, user); return accountRepository.saveAndFlush(account); } @Autowired AccountService(AccountRepository accountRepository, UserRepository userRepository); }
AccountService { public Account create(long userId, String description, boolean onBudget) { User user = userRepository.getOne(userId); Account account = new Account(description, onBudget, user); return accountRepository.saveAndFlush(account); } @Autowired AccountService(AccountRepository accountRepository, UserRepository userRepository); List<Account> list(long userId); Account get(long id); Account create(long userId, String description, boolean onBudget); }
AccountService { public Account create(long userId, String description, boolean onBudget) { User user = userRepository.getOne(userId); Account account = new Account(description, onBudget, user); return accountRepository.saveAndFlush(account); } @Autowired AccountService(AccountRepository accountRepository, UserRepository userRepository); List<Account> list(long userId); Account get(long id); Account create(long userId, String description, boolean onBudget); }
@Test public void descriptionShouldNotBeEmpty() { final AccountResource resource = new AccountResource("", true); final BeanPropertyBindingResult errors = createBindingResult(resource); testSubject.validate(resource, errors); assertThat(errors.getFieldError("description").getCode()).isEqualTo("description.empty"); }
@Override public void validate(Object target, Errors errors) { ValidationUtils.rejectIfEmptyOrWhitespace(errors, "description", "description.empty"); ValidationUtils.rejectIfEmptyOrWhitespace(errors, "onBudget", "onBudget.empty"); }
AccountResourceValidator implements Validator { @Override public void validate(Object target, Errors errors) { ValidationUtils.rejectIfEmptyOrWhitespace(errors, "description", "description.empty"); ValidationUtils.rejectIfEmptyOrWhitespace(errors, "onBudget", "onBudget.empty"); } }
AccountResourceValidator implements Validator { @Override public void validate(Object target, Errors errors) { ValidationUtils.rejectIfEmptyOrWhitespace(errors, "description", "description.empty"); ValidationUtils.rejectIfEmptyOrWhitespace(errors, "onBudget", "onBudget.empty"); } }
AccountResourceValidator implements Validator { @Override public void validate(Object target, Errors errors) { ValidationUtils.rejectIfEmptyOrWhitespace(errors, "description", "description.empty"); ValidationUtils.rejectIfEmptyOrWhitespace(errors, "onBudget", "onBudget.empty"); } @Override boolean supports(Class<?> clazz); @Override void validate(Object target, Errors errors); }
AccountResourceValidator implements Validator { @Override public void validate(Object target, Errors errors) { ValidationUtils.rejectIfEmptyOrWhitespace(errors, "description", "description.empty"); ValidationUtils.rejectIfEmptyOrWhitespace(errors, "onBudget", "onBudget.empty"); } @Override boolean supports(Class<?> clazz); @Override void validate(Object target, Errors errors); }
@Test public void onBudgetShouldNotBeEmpty() { final AccountResource resource = new AccountResource("Cash", null); final BeanPropertyBindingResult errors = createBindingResult(resource); testSubject.validate(resource, errors); assertThat(errors.getFieldError("onBudget").getCode()).isEqualTo("onBudget.empty"); }
@Override public void validate(Object target, Errors errors) { ValidationUtils.rejectIfEmptyOrWhitespace(errors, "description", "description.empty"); ValidationUtils.rejectIfEmptyOrWhitespace(errors, "onBudget", "onBudget.empty"); }
AccountResourceValidator implements Validator { @Override public void validate(Object target, Errors errors) { ValidationUtils.rejectIfEmptyOrWhitespace(errors, "description", "description.empty"); ValidationUtils.rejectIfEmptyOrWhitespace(errors, "onBudget", "onBudget.empty"); } }
AccountResourceValidator implements Validator { @Override public void validate(Object target, Errors errors) { ValidationUtils.rejectIfEmptyOrWhitespace(errors, "description", "description.empty"); ValidationUtils.rejectIfEmptyOrWhitespace(errors, "onBudget", "onBudget.empty"); } }
AccountResourceValidator implements Validator { @Override public void validate(Object target, Errors errors) { ValidationUtils.rejectIfEmptyOrWhitespace(errors, "description", "description.empty"); ValidationUtils.rejectIfEmptyOrWhitespace(errors, "onBudget", "onBudget.empty"); } @Override boolean supports(Class<?> clazz); @Override void validate(Object target, Errors errors); }
AccountResourceValidator implements Validator { @Override public void validate(Object target, Errors errors) { ValidationUtils.rejectIfEmptyOrWhitespace(errors, "description", "description.empty"); ValidationUtils.rejectIfEmptyOrWhitespace(errors, "onBudget", "onBudget.empty"); } @Override boolean supports(Class<?> clazz); @Override void validate(Object target, Errors errors); }
@Test public void shouldGetOneAccount() throws Exception { User bob = UserTestUtils.createBob(); Account savingsAccount = AccountTestUtils.createSavingsAccount(bob); when(accountServiceMock.get(savingsAccount.getId())).thenReturn(savingsAccount); final MockHttpServletRequestBuilder requestBuilder = get("/users/{userId}/accounts/{id}", bob.getId(), savingsAccount.getId()).accept(MediaType.APPLICATION_JSON); final MvcResult mvcResult = mockMvc.perform(requestBuilder).andReturn(); final MockHttpServletResponse response = mvcResult.getResponse(); assertThat(response.getStatus()).isEqualTo(HttpStatus.OK.value()); final AccountResource userResource = JsonHelper.fromJson(response.getContentAsString(), AccountResource.class); assertThat(userResource.getDescription()).isEqualTo(savingsAccount.getDescription()); assertThat(userResource.getOnBudget()).isEqualTo(savingsAccount.isOnBudget()); }
@GetMapping("/{accountId}") public Resource<AccountResource> get(@PathVariable("userId") long userId, @PathVariable("accountId") long accountId) { Account account = accountService.get(accountId); final AccountResource accountResource = accountResourceAssembler.toResource(account); return new Resource<>(accountResource); }
AccountController { @GetMapping("/{accountId}") public Resource<AccountResource> get(@PathVariable("userId") long userId, @PathVariable("accountId") long accountId) { Account account = accountService.get(accountId); final AccountResource accountResource = accountResourceAssembler.toResource(account); return new Resource<>(accountResource); } }
AccountController { @GetMapping("/{accountId}") public Resource<AccountResource> get(@PathVariable("userId") long userId, @PathVariable("accountId") long accountId) { Account account = accountService.get(accountId); final AccountResource accountResource = accountResourceAssembler.toResource(account); return new Resource<>(accountResource); } @Autowired AccountController(AccountService accountService, AccountResourceAssembler accountResourceAssembler); }
AccountController { @GetMapping("/{accountId}") public Resource<AccountResource> get(@PathVariable("userId") long userId, @PathVariable("accountId") long accountId) { Account account = accountService.get(accountId); final AccountResource accountResource = accountResourceAssembler.toResource(account); return new Resource<>(accountResource); } @Autowired AccountController(AccountService accountService, AccountResourceAssembler accountResourceAssembler); @GetMapping Resources<AccountResource> list(@PathVariable("userId") long userId); @GetMapping("/{accountId}") Resource<AccountResource> get(@PathVariable("userId") long userId, @PathVariable("accountId") long accountId); @PostMapping(consumes = MediaType.APPLICATION_JSON_VALUE) ResponseEntity<AccountResource> create(@PathVariable("userId") long userId, @RequestBody @Valid AccountResource accountResource); }
AccountController { @GetMapping("/{accountId}") public Resource<AccountResource> get(@PathVariable("userId") long userId, @PathVariable("accountId") long accountId) { Account account = accountService.get(accountId); final AccountResource accountResource = accountResourceAssembler.toResource(account); return new Resource<>(accountResource); } @Autowired AccountController(AccountService accountService, AccountResourceAssembler accountResourceAssembler); @GetMapping Resources<AccountResource> list(@PathVariable("userId") long userId); @GetMapping("/{accountId}") Resource<AccountResource> get(@PathVariable("userId") long userId, @PathVariable("accountId") long accountId); @PostMapping(consumes = MediaType.APPLICATION_JSON_VALUE) ResponseEntity<AccountResource> create(@PathVariable("userId") long userId, @RequestBody @Valid AccountResource accountResource); }
@Test public void shouldCreateAccount() throws Exception { String description = "Cash"; boolean onBudget = true; long userId = 42L; AccountResource accountResource = new AccountResource(description, onBudget); when(accountServiceMock.create(anyLong(), anyString(), anyBoolean())).thenAnswer(invocation -> new Account(invocation.getArgument(1), invocation.getArgument(2), new User().setId(invocation.getArgument(0))).setId(1L)); final MockHttpServletRequestBuilder requestBuilder = post("/users/{userId}/accounts", userId).accept(MediaType.APPLICATION_JSON) .content(JsonHelper.toJson(accountResource)).contentType(MediaType.APPLICATION_JSON); final MvcResult mvcResult = mockMvc.perform(requestBuilder).andReturn(); final MockHttpServletResponse response = mvcResult.getResponse(); assertThat(response.getStatus()).isEqualTo(HttpStatus.OK.value()); AccountResource result = JsonHelper.fromJson(response.getContentAsString(), AccountResource.class); assertThat(result.getDescription()).isEqualTo(description); assertThat(result.getOnBudget()).isEqualTo(onBudget); verify(accountServiceMock).create(userId, description, onBudget); }
@PostMapping(consumes = MediaType.APPLICATION_JSON_VALUE) public ResponseEntity<AccountResource> create(@PathVariable("userId") long userId, @RequestBody @Valid AccountResource accountResource) { Account account = accountService.create(userId, accountResource.getDescription(), accountResource.getOnBudget()); final AccountResource createdAccountResource = accountResourceAssembler.toResource(account); return new ResponseEntity<>(createdAccountResource, HttpStatus.OK); }
AccountController { @PostMapping(consumes = MediaType.APPLICATION_JSON_VALUE) public ResponseEntity<AccountResource> create(@PathVariable("userId") long userId, @RequestBody @Valid AccountResource accountResource) { Account account = accountService.create(userId, accountResource.getDescription(), accountResource.getOnBudget()); final AccountResource createdAccountResource = accountResourceAssembler.toResource(account); return new ResponseEntity<>(createdAccountResource, HttpStatus.OK); } }
AccountController { @PostMapping(consumes = MediaType.APPLICATION_JSON_VALUE) public ResponseEntity<AccountResource> create(@PathVariable("userId") long userId, @RequestBody @Valid AccountResource accountResource) { Account account = accountService.create(userId, accountResource.getDescription(), accountResource.getOnBudget()); final AccountResource createdAccountResource = accountResourceAssembler.toResource(account); return new ResponseEntity<>(createdAccountResource, HttpStatus.OK); } @Autowired AccountController(AccountService accountService, AccountResourceAssembler accountResourceAssembler); }
AccountController { @PostMapping(consumes = MediaType.APPLICATION_JSON_VALUE) public ResponseEntity<AccountResource> create(@PathVariable("userId") long userId, @RequestBody @Valid AccountResource accountResource) { Account account = accountService.create(userId, accountResource.getDescription(), accountResource.getOnBudget()); final AccountResource createdAccountResource = accountResourceAssembler.toResource(account); return new ResponseEntity<>(createdAccountResource, HttpStatus.OK); } @Autowired AccountController(AccountService accountService, AccountResourceAssembler accountResourceAssembler); @GetMapping Resources<AccountResource> list(@PathVariable("userId") long userId); @GetMapping("/{accountId}") Resource<AccountResource> get(@PathVariable("userId") long userId, @PathVariable("accountId") long accountId); @PostMapping(consumes = MediaType.APPLICATION_JSON_VALUE) ResponseEntity<AccountResource> create(@PathVariable("userId") long userId, @RequestBody @Valid AccountResource accountResource); }
AccountController { @PostMapping(consumes = MediaType.APPLICATION_JSON_VALUE) public ResponseEntity<AccountResource> create(@PathVariable("userId") long userId, @RequestBody @Valid AccountResource accountResource) { Account account = accountService.create(userId, accountResource.getDescription(), accountResource.getOnBudget()); final AccountResource createdAccountResource = accountResourceAssembler.toResource(account); return new ResponseEntity<>(createdAccountResource, HttpStatus.OK); } @Autowired AccountController(AccountService accountService, AccountResourceAssembler accountResourceAssembler); @GetMapping Resources<AccountResource> list(@PathVariable("userId") long userId); @GetMapping("/{accountId}") Resource<AccountResource> get(@PathVariable("userId") long userId, @PathVariable("accountId") long accountId); @PostMapping(consumes = MediaType.APPLICATION_JSON_VALUE) ResponseEntity<AccountResource> create(@PathVariable("userId") long userId, @RequestBody @Valid AccountResource accountResource); }
@Test public void shouldCreateResource() { Account entity = AccountTestUtils.createCheckingsAccount(UserTestUtils.createBob()); AccountResource resource = testSubject.toResource(entity); assertThat(resource.getDescription()).isEqualTo(entity.getDescription()); assertThat(resource.getOnBudget()).isEqualTo(entity.isOnBudget()); }
@Override public AccountResource toResource(Account entity) { final AccountResource accountResource = new AccountResource(entity.getDescription(), entity.isOnBudget()); accountResource.add(linkTo(methodOn(AccountController.class).get(entity.getUser().getId(), entity.getId())).withSelfRel()); accountResource.add(linkTo(methodOn(UserController.class).get(entity.getUser().getId())).withRel("user")); return accountResource; }
AccountResourceAssembler extends ResourceAssemblerSupport<Account, AccountResource> { @Override public AccountResource toResource(Account entity) { final AccountResource accountResource = new AccountResource(entity.getDescription(), entity.isOnBudget()); accountResource.add(linkTo(methodOn(AccountController.class).get(entity.getUser().getId(), entity.getId())).withSelfRel()); accountResource.add(linkTo(methodOn(UserController.class).get(entity.getUser().getId())).withRel("user")); return accountResource; } }
AccountResourceAssembler extends ResourceAssemblerSupport<Account, AccountResource> { @Override public AccountResource toResource(Account entity) { final AccountResource accountResource = new AccountResource(entity.getDescription(), entity.isOnBudget()); accountResource.add(linkTo(methodOn(AccountController.class).get(entity.getUser().getId(), entity.getId())).withSelfRel()); accountResource.add(linkTo(methodOn(UserController.class).get(entity.getUser().getId())).withRel("user")); return accountResource; } AccountResourceAssembler(); }
AccountResourceAssembler extends ResourceAssemblerSupport<Account, AccountResource> { @Override public AccountResource toResource(Account entity) { final AccountResource accountResource = new AccountResource(entity.getDescription(), entity.isOnBudget()); accountResource.add(linkTo(methodOn(AccountController.class).get(entity.getUser().getId(), entity.getId())).withSelfRel()); accountResource.add(linkTo(methodOn(UserController.class).get(entity.getUser().getId())).withRel("user")); return accountResource; } AccountResourceAssembler(); @Override AccountResource toResource(Account entity); }
AccountResourceAssembler extends ResourceAssemblerSupport<Account, AccountResource> { @Override public AccountResource toResource(Account entity) { final AccountResource accountResource = new AccountResource(entity.getDescription(), entity.isOnBudget()); accountResource.add(linkTo(methodOn(AccountController.class).get(entity.getUser().getId(), entity.getId())).withSelfRel()); accountResource.add(linkTo(methodOn(UserController.class).get(entity.getUser().getId())).withRel("user")); return accountResource; } AccountResourceAssembler(); @Override AccountResource toResource(Account entity); }
@Test public void byUser() { User user = userRepository.save(new User("Bob", "€")); MasterCategory mcMonthly = masterCategoryRepository.save(new MasterCategory().setName("Monthly").setUser(user)); MasterCategory mcSavings = masterCategoryRepository.save(new MasterCategory().setName("Savings").setUser(user)); categoryRepository.saveAll(asList( new Category().setName("Rent").setMasterCategory(mcMonthly), new Category().setName("Internet").setMasterCategory(mcMonthly), new Category().setName("Rainy Day Funds").setMasterCategory(mcSavings), new Category().setName("Christmas").setMasterCategory(mcSavings) )); Specification<Category> specification = testSubject.byUser(user); List<Category> categories = categoryRepository.findAll(specification); assertThat(categories).extracting("name").containsExactlyInAnyOrder("Rent", "Internet", "Rainy Day Funds", "Christmas"); }
public Specification<Category> byUser(User user) { return (root, query, criteriaBuilder) -> criteriaBuilder.equal(root.get(Category_.masterCategory).get(MasterCategory_.user), user); }
CategorySpecifications { public Specification<Category> byUser(User user) { return (root, query, criteriaBuilder) -> criteriaBuilder.equal(root.get(Category_.masterCategory).get(MasterCategory_.user), user); } }
CategorySpecifications { public Specification<Category> byUser(User user) { return (root, query, criteriaBuilder) -> criteriaBuilder.equal(root.get(Category_.masterCategory).get(MasterCategory_.user), user); } }
CategorySpecifications { public Specification<Category> byUser(User user) { return (root, query, criteriaBuilder) -> criteriaBuilder.equal(root.get(Category_.masterCategory).get(MasterCategory_.user), user); } Specification<Category> byUser(User user); }
CategorySpecifications { public Specification<Category> byUser(User user) { return (root, query, criteriaBuilder) -> criteriaBuilder.equal(root.get(Category_.masterCategory).get(MasterCategory_.user), user); } Specification<Category> byUser(User user); }
@Test public void shouldReturnAllUser() throws Exception { final List<User> bobAndJane = UserTestUtils.createBobAndJane(); when(userRepositoryMock.findAll()).thenReturn(bobAndJane); final List<User> list = testSubject.list(); assertThat(list).isEqualTo(bobAndJane); }
public List<User> list() { return userRepository.findAll(); }
UserService { public List<User> list() { return userRepository.findAll(); } }
UserService { public List<User> list() { return userRepository.findAll(); } @Autowired UserService(UserRepository userRepository, UserManagementProperties userManagementProperties); }
UserService { public List<User> list() { return userRepository.findAll(); } @Autowired UserService(UserRepository userRepository, UserManagementProperties userManagementProperties); List<User> list(); User create(String name, String currency); User get(long id); String getTestProperty(); }
UserService { public List<User> list() { return userRepository.findAll(); } @Autowired UserService(UserRepository userRepository, UserManagementProperties userManagementProperties); List<User> list(); User create(String name, String currency); User get(long id); String getTestProperty(); }
@Test public void shouldFindOneUser() { final User bob = UserTestUtils.createBob(); when(userRepositoryMock.findOne(isA(Example.class))).thenReturn(Optional.of(bob)); final User user = testSubject.get(bob.getId()); assertThat(user).isEqualToComparingFieldByField(bob); }
public User get(long id) { return userRepository.findOne(Example.of(new User().setId(id))).orElse(null); }
UserService { public User get(long id) { return userRepository.findOne(Example.of(new User().setId(id))).orElse(null); } }
UserService { public User get(long id) { return userRepository.findOne(Example.of(new User().setId(id))).orElse(null); } @Autowired UserService(UserRepository userRepository, UserManagementProperties userManagementProperties); }
UserService { public User get(long id) { return userRepository.findOne(Example.of(new User().setId(id))).orElse(null); } @Autowired UserService(UserRepository userRepository, UserManagementProperties userManagementProperties); List<User> list(); User create(String name, String currency); User get(long id); String getTestProperty(); }
UserService { public User get(long id) { return userRepository.findOne(Example.of(new User().setId(id))).orElse(null); } @Autowired UserService(UserRepository userRepository, UserManagementProperties userManagementProperties); List<User> list(); User create(String name, String currency); User get(long id); String getTestProperty(); }
@Test public void shouldReadTestProperty() { assertThat(testSubject.getTestProperty()).isEqualTo("mockedTestProperty"); }
public String getTestProperty() { return userManagementProperties.getTestProperty(); }
UserService { public String getTestProperty() { return userManagementProperties.getTestProperty(); } }
UserService { public String getTestProperty() { return userManagementProperties.getTestProperty(); } @Autowired UserService(UserRepository userRepository, UserManagementProperties userManagementProperties); }
UserService { public String getTestProperty() { return userManagementProperties.getTestProperty(); } @Autowired UserService(UserRepository userRepository, UserManagementProperties userManagementProperties); List<User> list(); User create(String name, String currency); User get(long id); String getTestProperty(); }
UserService { public String getTestProperty() { return userManagementProperties.getTestProperty(); } @Autowired UserService(UserRepository userRepository, UserManagementProperties userManagementProperties); List<User> list(); User create(String name, String currency); User get(long id); String getTestProperty(); }
@Test public void createResource() throws Exception { UserResource userResource = testSubject.createResource(new User(NAME, CURRENCY)); assertThat(userResource.getName()).isEqualTo(NAME); assertThat(userResource.getCurrency()).isEqualTo(CURRENCY); }
@Override protected UserResource createResource(User user) { return new UserResource(user.getName(), user.getCurrency()); }
UserResourceAssembler extends ResourceAssembler<User, UserResource> { @Override protected UserResource createResource(User user) { return new UserResource(user.getName(), user.getCurrency()); } }
UserResourceAssembler extends ResourceAssembler<User, UserResource> { @Override protected UserResource createResource(User user) { return new UserResource(user.getName(), user.getCurrency()); } @Autowired UserResourceAssembler(List<ResourceLinks<User>> resourceLinks); }
UserResourceAssembler extends ResourceAssembler<User, UserResource> { @Override protected UserResource createResource(User user) { return new UserResource(user.getName(), user.getCurrency()); } @Autowired UserResourceAssembler(List<ResourceLinks<User>> resourceLinks); }
UserResourceAssembler extends ResourceAssembler<User, UserResource> { @Override protected UserResource createResource(User user) { return new UserResource(user.getName(), user.getCurrency()); } @Autowired UserResourceAssembler(List<ResourceLinks<User>> resourceLinks); }
@Test public void nameShouldNotBeEmpty() { final UserResource userResource = new UserResource("", "€"); final BeanPropertyBindingResult errors = createBindingResult(userResource); testSubject.validate(userResource, errors); assertThat(errors.getFieldError("name").getCode()).isEqualTo("name.empty"); }
@Override public void validate(Object target, Errors errors) { ValidationUtils.rejectIfEmptyOrWhitespace(errors, "name", "name.empty"); ValidationUtils.rejectIfEmptyOrWhitespace(errors, "currency", "currency.empty"); }
UserResourceValidator implements Validator { @Override public void validate(Object target, Errors errors) { ValidationUtils.rejectIfEmptyOrWhitespace(errors, "name", "name.empty"); ValidationUtils.rejectIfEmptyOrWhitespace(errors, "currency", "currency.empty"); } }
UserResourceValidator implements Validator { @Override public void validate(Object target, Errors errors) { ValidationUtils.rejectIfEmptyOrWhitespace(errors, "name", "name.empty"); ValidationUtils.rejectIfEmptyOrWhitespace(errors, "currency", "currency.empty"); } }
UserResourceValidator implements Validator { @Override public void validate(Object target, Errors errors) { ValidationUtils.rejectIfEmptyOrWhitespace(errors, "name", "name.empty"); ValidationUtils.rejectIfEmptyOrWhitespace(errors, "currency", "currency.empty"); } @Override boolean supports(Class<?> clazz); @Override void validate(Object target, Errors errors); }
UserResourceValidator implements Validator { @Override public void validate(Object target, Errors errors) { ValidationUtils.rejectIfEmptyOrWhitespace(errors, "name", "name.empty"); ValidationUtils.rejectIfEmptyOrWhitespace(errors, "currency", "currency.empty"); } @Override boolean supports(Class<?> clazz); @Override void validate(Object target, Errors errors); }
@Test public void currencyShouldNotBeEmpty() { final UserResource userResource = new UserResource("Foo", ""); final BeanPropertyBindingResult errors = createBindingResult(userResource); testSubject.validate(userResource, errors); assertThat(errors.getFieldError("currency").getCode()).isEqualTo("currency.empty"); }
@Override public void validate(Object target, Errors errors) { ValidationUtils.rejectIfEmptyOrWhitespace(errors, "name", "name.empty"); ValidationUtils.rejectIfEmptyOrWhitespace(errors, "currency", "currency.empty"); }
UserResourceValidator implements Validator { @Override public void validate(Object target, Errors errors) { ValidationUtils.rejectIfEmptyOrWhitespace(errors, "name", "name.empty"); ValidationUtils.rejectIfEmptyOrWhitespace(errors, "currency", "currency.empty"); } }
UserResourceValidator implements Validator { @Override public void validate(Object target, Errors errors) { ValidationUtils.rejectIfEmptyOrWhitespace(errors, "name", "name.empty"); ValidationUtils.rejectIfEmptyOrWhitespace(errors, "currency", "currency.empty"); } }
UserResourceValidator implements Validator { @Override public void validate(Object target, Errors errors) { ValidationUtils.rejectIfEmptyOrWhitespace(errors, "name", "name.empty"); ValidationUtils.rejectIfEmptyOrWhitespace(errors, "currency", "currency.empty"); } @Override boolean supports(Class<?> clazz); @Override void validate(Object target, Errors errors); }
UserResourceValidator implements Validator { @Override public void validate(Object target, Errors errors) { ValidationUtils.rejectIfEmptyOrWhitespace(errors, "name", "name.empty"); ValidationUtils.rejectIfEmptyOrWhitespace(errors, "currency", "currency.empty"); } @Override boolean supports(Class<?> clazz); @Override void validate(Object target, Errors errors); }
@Test public void generateLinks() { List<Link> links = new ArrayList<>(testSubject.generateLinks(createUser())); assertThat(links.size()).isEqualTo(2); assertThat(links.get(0).getRel()).isEqualTo("self"); assertThat(links.get(0).getHref()).isEqualTo("/users/1"); assertThat(links.get(1).getRel()).isEqualTo("users"); assertThat(links.get(1).getHref()).isEqualTo("/users"); }
@Override public Collection<Link> generateLinks(User entity) { Link self = linkTo(methodOn(UserController.class).get(entity.getId())).withSelfRel(); Link users = linkTo(methodOn(UserController.class).list()).withRel("users"); return Arrays.asList(self, users); }
UserControllerUserLinks extends ResourceLinks<User> { @Override public Collection<Link> generateLinks(User entity) { Link self = linkTo(methodOn(UserController.class).get(entity.getId())).withSelfRel(); Link users = linkTo(methodOn(UserController.class).list()).withRel("users"); return Arrays.asList(self, users); } }
UserControllerUserLinks extends ResourceLinks<User> { @Override public Collection<Link> generateLinks(User entity) { Link self = linkTo(methodOn(UserController.class).get(entity.getId())).withSelfRel(); Link users = linkTo(methodOn(UserController.class).list()).withRel("users"); return Arrays.asList(self, users); } UserControllerUserLinks(); }
UserControllerUserLinks extends ResourceLinks<User> { @Override public Collection<Link> generateLinks(User entity) { Link self = linkTo(methodOn(UserController.class).get(entity.getId())).withSelfRel(); Link users = linkTo(methodOn(UserController.class).list()).withRel("users"); return Arrays.asList(self, users); } UserControllerUserLinks(); @Override Collection<Link> generateLinks(User entity); }
UserControllerUserLinks extends ResourceLinks<User> { @Override public Collection<Link> generateLinks(User entity) { Link self = linkTo(methodOn(UserController.class).get(entity.getId())).withSelfRel(); Link users = linkTo(methodOn(UserController.class).list()).withRel("users"); return Arrays.asList(self, users); } UserControllerUserLinks(); @Override Collection<Link> generateLinks(User entity); }
@Test public void shouldGetOneUser() throws Exception { when(userServiceMock.get(anyLong())).thenReturn(UserTestUtils.createBob()); final MockHttpServletRequestBuilder requestBuilder = get("/users/{id}", 1L).accept(MediaType.APPLICATION_JSON); final MvcResult mvcResult = mockMvc.perform(requestBuilder).andReturn(); final MockHttpServletResponse response = mvcResult.getResponse(); assertThat(response.getStatus()).isEqualTo(HttpStatus.OK.value()); final UserResource userResource = JsonHelper.fromJson(response.getContentAsString(), UserResource.class); assertThat(userResource.getName()).isEqualTo("Bob"); assertThat(userResource.getCurrency()).isEqualTo("€"); }
@GetMapping("/{userId}") public Resource<UserResource> get(@PathVariable("userId") long userId) { User user = userService.get(userId); final UserResource userResource = userResourceAssembler.toResource(user); return new Resource<>(userResource); }
UserController { @GetMapping("/{userId}") public Resource<UserResource> get(@PathVariable("userId") long userId) { User user = userService.get(userId); final UserResource userResource = userResourceAssembler.toResource(user); return new Resource<>(userResource); } }
UserController { @GetMapping("/{userId}") public Resource<UserResource> get(@PathVariable("userId") long userId) { User user = userService.get(userId); final UserResource userResource = userResourceAssembler.toResource(user); return new Resource<>(userResource); } @Autowired UserController(UserService userService, UserResourceAssembler userResourceAssembler); }
UserController { @GetMapping("/{userId}") public Resource<UserResource> get(@PathVariable("userId") long userId) { User user = userService.get(userId); final UserResource userResource = userResourceAssembler.toResource(user); return new Resource<>(userResource); } @Autowired UserController(UserService userService, UserResourceAssembler userResourceAssembler); @GetMapping Resources<UserResource> list(); @GetMapping("/{userId}") Resource<UserResource> get(@PathVariable("userId") long userId); @PostMapping(consumes = MediaType.APPLICATION_JSON_VALUE) ResponseEntity<UserResource> create(@RequestBody @Valid UserResource userResource); }
UserController { @GetMapping("/{userId}") public Resource<UserResource> get(@PathVariable("userId") long userId) { User user = userService.get(userId); final UserResource userResource = userResourceAssembler.toResource(user); return new Resource<>(userResource); } @Autowired UserController(UserService userService, UserResourceAssembler userResourceAssembler); @GetMapping Resources<UserResource> list(); @GetMapping("/{userId}") Resource<UserResource> get(@PathVariable("userId") long userId); @PostMapping(consumes = MediaType.APPLICATION_JSON_VALUE) ResponseEntity<UserResource> create(@RequestBody @Valid UserResource userResource); }
@Test public void shouldCreateUser() throws Exception { final String name = "Martha"; final String currency = "€"; final UserResource userResource = new UserResource(name, currency); when(userServiceMock.create(anyString(), anyString())).thenAnswer(invocation -> new User().setId(1L) .setName(invocation.getArgument(0)) .setCurrency(invocation.getArgument(1)) ); final MockHttpServletRequestBuilder requestBuilder = post("/users").accept(MediaType.APPLICATION_JSON) .content(JsonHelper.toJson(userResource)).contentType(MediaType.APPLICATION_JSON); final MvcResult mvcResult = mockMvc.perform(requestBuilder).andReturn(); final MockHttpServletResponse response = mvcResult.getResponse(); assertThat(response.getStatus()).isEqualTo(HttpStatus.OK.value()); final UserResource result = JsonHelper.fromJson(response.getContentAsString(), UserResource.class); assertThat(result.getName()).isEqualTo(name); assertThat(result.getCurrency()).isEqualTo(currency); verify(userServiceMock).create(name, currency); }
@PostMapping(consumes = MediaType.APPLICATION_JSON_VALUE) public ResponseEntity<UserResource> create(@RequestBody @Valid UserResource userResource) { User user = userService.create(userResource.getName(), userResource.getCurrency()); final UserResource createdUserResource = userResourceAssembler.toResource(user); return new ResponseEntity<>(createdUserResource, HttpStatus.OK); }
UserController { @PostMapping(consumes = MediaType.APPLICATION_JSON_VALUE) public ResponseEntity<UserResource> create(@RequestBody @Valid UserResource userResource) { User user = userService.create(userResource.getName(), userResource.getCurrency()); final UserResource createdUserResource = userResourceAssembler.toResource(user); return new ResponseEntity<>(createdUserResource, HttpStatus.OK); } }
UserController { @PostMapping(consumes = MediaType.APPLICATION_JSON_VALUE) public ResponseEntity<UserResource> create(@RequestBody @Valid UserResource userResource) { User user = userService.create(userResource.getName(), userResource.getCurrency()); final UserResource createdUserResource = userResourceAssembler.toResource(user); return new ResponseEntity<>(createdUserResource, HttpStatus.OK); } @Autowired UserController(UserService userService, UserResourceAssembler userResourceAssembler); }
UserController { @PostMapping(consumes = MediaType.APPLICATION_JSON_VALUE) public ResponseEntity<UserResource> create(@RequestBody @Valid UserResource userResource) { User user = userService.create(userResource.getName(), userResource.getCurrency()); final UserResource createdUserResource = userResourceAssembler.toResource(user); return new ResponseEntity<>(createdUserResource, HttpStatus.OK); } @Autowired UserController(UserService userService, UserResourceAssembler userResourceAssembler); @GetMapping Resources<UserResource> list(); @GetMapping("/{userId}") Resource<UserResource> get(@PathVariable("userId") long userId); @PostMapping(consumes = MediaType.APPLICATION_JSON_VALUE) ResponseEntity<UserResource> create(@RequestBody @Valid UserResource userResource); }
UserController { @PostMapping(consumes = MediaType.APPLICATION_JSON_VALUE) public ResponseEntity<UserResource> create(@RequestBody @Valid UserResource userResource) { User user = userService.create(userResource.getName(), userResource.getCurrency()); final UserResource createdUserResource = userResourceAssembler.toResource(user); return new ResponseEntity<>(createdUserResource, HttpStatus.OK); } @Autowired UserController(UserService userService, UserResourceAssembler userResourceAssembler); @GetMapping Resources<UserResource> list(); @GetMapping("/{userId}") Resource<UserResource> get(@PathVariable("userId") long userId); @PostMapping(consumes = MediaType.APPLICATION_JSON_VALUE) ResponseEntity<UserResource> create(@RequestBody @Valid UserResource userResource); }
@Test public void overrideToString() { assertEquals(opEquals1.toString(), opEquals2.toString()); assertNotEquals(opEquals1.toString(), opNotEquals1.toString()); assertNotEquals(opEquals1.toString(), opNotEquals2.toString()); }
@Override public String toString() { return "Order{" + "type=" + type + ", index=" + index + ", price=" + pricePerAsset + ", amount=" + amount + '}'; }
Order implements Serializable { @Override public String toString() { return "Order{" + "type=" + type + ", index=" + index + ", price=" + pricePerAsset + ", amount=" + amount + '}'; } }
Order implements Serializable { @Override public String toString() { return "Order{" + "type=" + type + ", index=" + index + ", price=" + pricePerAsset + ", amount=" + amount + '}'; } protected Order(int index, BarSeries series, OrderType type); protected Order(int index, BarSeries series, OrderType type, Num amount); protected Order(int index, BarSeries series, OrderType type, Num amount, CostModel transactionCostModel); protected Order(int index, OrderType type, Num pricePerAsset); protected Order(int index, OrderType type, Num pricePerAsset, Num amount); protected Order(int index, OrderType type, Num pricePerAsset, Num amount, CostModel transactionCostModel); }
Order implements Serializable { @Override public String toString() { return "Order{" + "type=" + type + ", index=" + index + ", price=" + pricePerAsset + ", amount=" + amount + '}'; } protected Order(int index, BarSeries series, OrderType type); protected Order(int index, BarSeries series, OrderType type, Num amount); protected Order(int index, BarSeries series, OrderType type, Num amount, CostModel transactionCostModel); protected Order(int index, OrderType type, Num pricePerAsset); protected Order(int index, OrderType type, Num pricePerAsset, Num amount); protected Order(int index, OrderType type, Num pricePerAsset, Num amount, CostModel transactionCostModel); OrderType getType(); Num getCost(); int getIndex(); Num getPricePerAsset(); Num getNetPrice(); Num getAmount(); CostModel getCostModel(); boolean isBuy(); boolean isSell(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); static Order buyAt(int index, BarSeries series); static Order buyAt(int index, Num price, Num amount, CostModel transactionCostModel); static Order buyAt(int index, Num price, Num amount); static Order buyAt(int index, BarSeries series, Num amount); static Order buyAt(int index, BarSeries series, Num amount, CostModel transactionCostModel); static Order sellAt(int index, BarSeries series); static Order sellAt(int index, Num price, Num amount); static Order sellAt(int index, Num price, Num amount, CostModel transactionCostModel); static Order sellAt(int index, BarSeries series, Num amount); static Order sellAt(int index, BarSeries series, Num amount, CostModel transactionCostModel); Num getValue(); }
Order implements Serializable { @Override public String toString() { return "Order{" + "type=" + type + ", index=" + index + ", price=" + pricePerAsset + ", amount=" + amount + '}'; } protected Order(int index, BarSeries series, OrderType type); protected Order(int index, BarSeries series, OrderType type, Num amount); protected Order(int index, BarSeries series, OrderType type, Num amount, CostModel transactionCostModel); protected Order(int index, OrderType type, Num pricePerAsset); protected Order(int index, OrderType type, Num pricePerAsset, Num amount); protected Order(int index, OrderType type, Num pricePerAsset, Num amount, CostModel transactionCostModel); OrderType getType(); Num getCost(); int getIndex(); Num getPricePerAsset(); Num getNetPrice(); Num getAmount(); CostModel getCostModel(); boolean isBuy(); boolean isSell(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); static Order buyAt(int index, BarSeries series); static Order buyAt(int index, Num price, Num amount, CostModel transactionCostModel); static Order buyAt(int index, Num price, Num amount); static Order buyAt(int index, BarSeries series, Num amount); static Order buyAt(int index, BarSeries series, Num amount, CostModel transactionCostModel); static Order sellAt(int index, BarSeries series); static Order sellAt(int index, Num price, Num amount); static Order sellAt(int index, Num price, Num amount, CostModel transactionCostModel); static Order sellAt(int index, BarSeries series, Num amount); static Order sellAt(int index, BarSeries series, Num amount, CostModel transactionCostModel); Num getValue(); }
@Test public void betterThan() { AnalysisCriterion criterion = getCriterion(); assertTrue(criterion.betterThan(numOf(3), numOf(6))); assertFalse(criterion.betterThan(numOf(6), numOf(2))); }
@Override public boolean betterThan(Num criterionValue1, Num criterionValue2) { return criterionValue1.isLessThan(criterionValue2); }
NumberOfBarsCriterion extends AbstractAnalysisCriterion { @Override public boolean betterThan(Num criterionValue1, Num criterionValue2) { return criterionValue1.isLessThan(criterionValue2); } }
NumberOfBarsCriterion extends AbstractAnalysisCriterion { @Override public boolean betterThan(Num criterionValue1, Num criterionValue2) { return criterionValue1.isLessThan(criterionValue2); } }
NumberOfBarsCriterion extends AbstractAnalysisCriterion { @Override public boolean betterThan(Num criterionValue1, Num criterionValue2) { return criterionValue1.isLessThan(criterionValue2); } @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override Num calculate(BarSeries series, Trade trade); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); }
NumberOfBarsCriterion extends AbstractAnalysisCriterion { @Override public boolean betterThan(Num criterionValue1, Num criterionValue2) { return criterionValue1.isLessThan(criterionValue2); } @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override Num calculate(BarSeries series, Trade trade); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); }
@Test public void calculateOnlyWithGainTrades() { series = new MockBarSeries(numFunction, 100d, 105d, 110d, 100d, 95d, 105d); TradingRecord tradingRecord = new BaseTradingRecord(Order.buyAt(0, series), Order.sellAt(2, series), Order.buyAt(3, series), Order.sellAt(5, series)); AnalysisCriterion averageProfit = getCriterion(); assertNumEquals(1.0243, averageProfit.calculate(series, tradingRecord)); }
@Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { Num bars = numberOfBars.calculate(series, tradingRecord); if (bars.isEqual(series.numOf(0))) { return series.numOf(1); } return totalProfit.calculate(series, tradingRecord).pow(series.numOf(1).dividedBy(bars)); }
AverageProfitCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { Num bars = numberOfBars.calculate(series, tradingRecord); if (bars.isEqual(series.numOf(0))) { return series.numOf(1); } return totalProfit.calculate(series, tradingRecord).pow(series.numOf(1).dividedBy(bars)); } }
AverageProfitCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { Num bars = numberOfBars.calculate(series, tradingRecord); if (bars.isEqual(series.numOf(0))) { return series.numOf(1); } return totalProfit.calculate(series, tradingRecord).pow(series.numOf(1).dividedBy(bars)); } }
AverageProfitCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { Num bars = numberOfBars.calculate(series, tradingRecord); if (bars.isEqual(series.numOf(0))) { return series.numOf(1); } return totalProfit.calculate(series, tradingRecord).pow(series.numOf(1).dividedBy(bars)); } @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override Num calculate(BarSeries series, Trade trade); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); }
AverageProfitCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { Num bars = numberOfBars.calculate(series, tradingRecord); if (bars.isEqual(series.numOf(0))) { return series.numOf(1); } return totalProfit.calculate(series, tradingRecord).pow(series.numOf(1).dividedBy(bars)); } @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override Num calculate(BarSeries series, Trade trade); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); }
@Test public void calculateWithASimpleTrade() { series = new MockBarSeries(numFunction, 100d, 105d, 110d, 100d, 95d, 105d); TradingRecord tradingRecord = new BaseTradingRecord(Order.buyAt(0, series), Order.sellAt(2, series)); AnalysisCriterion averageProfit = getCriterion(); assertNumEquals(numOf(110d / 100).pow(numOf(1d / 3)), averageProfit.calculate(series, tradingRecord)); }
@Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { Num bars = numberOfBars.calculate(series, tradingRecord); if (bars.isEqual(series.numOf(0))) { return series.numOf(1); } return totalProfit.calculate(series, tradingRecord).pow(series.numOf(1).dividedBy(bars)); }
AverageProfitCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { Num bars = numberOfBars.calculate(series, tradingRecord); if (bars.isEqual(series.numOf(0))) { return series.numOf(1); } return totalProfit.calculate(series, tradingRecord).pow(series.numOf(1).dividedBy(bars)); } }
AverageProfitCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { Num bars = numberOfBars.calculate(series, tradingRecord); if (bars.isEqual(series.numOf(0))) { return series.numOf(1); } return totalProfit.calculate(series, tradingRecord).pow(series.numOf(1).dividedBy(bars)); } }
AverageProfitCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { Num bars = numberOfBars.calculate(series, tradingRecord); if (bars.isEqual(series.numOf(0))) { return series.numOf(1); } return totalProfit.calculate(series, tradingRecord).pow(series.numOf(1).dividedBy(bars)); } @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override Num calculate(BarSeries series, Trade trade); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); }
AverageProfitCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { Num bars = numberOfBars.calculate(series, tradingRecord); if (bars.isEqual(series.numOf(0))) { return series.numOf(1); } return totalProfit.calculate(series, tradingRecord).pow(series.numOf(1).dividedBy(bars)); } @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override Num calculate(BarSeries series, Trade trade); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); }
@Test public void calculateOnlyWithLossTrades() { series = new MockBarSeries(numFunction, 100, 95, 100, 80, 85, 70); TradingRecord tradingRecord = new BaseTradingRecord(Order.buyAt(0, series), Order.sellAt(1, series), Order.buyAt(2, series), Order.sellAt(5, series)); AnalysisCriterion averageProfit = getCriterion(); assertNumEquals(numOf(95d / 100 * 70d / 100).pow(numOf(1d / 6)), averageProfit.calculate(series, tradingRecord)); }
@Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { Num bars = numberOfBars.calculate(series, tradingRecord); if (bars.isEqual(series.numOf(0))) { return series.numOf(1); } return totalProfit.calculate(series, tradingRecord).pow(series.numOf(1).dividedBy(bars)); }
AverageProfitCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { Num bars = numberOfBars.calculate(series, tradingRecord); if (bars.isEqual(series.numOf(0))) { return series.numOf(1); } return totalProfit.calculate(series, tradingRecord).pow(series.numOf(1).dividedBy(bars)); } }
AverageProfitCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { Num bars = numberOfBars.calculate(series, tradingRecord); if (bars.isEqual(series.numOf(0))) { return series.numOf(1); } return totalProfit.calculate(series, tradingRecord).pow(series.numOf(1).dividedBy(bars)); } }
AverageProfitCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { Num bars = numberOfBars.calculate(series, tradingRecord); if (bars.isEqual(series.numOf(0))) { return series.numOf(1); } return totalProfit.calculate(series, tradingRecord).pow(series.numOf(1).dividedBy(bars)); } @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override Num calculate(BarSeries series, Trade trade); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); }
AverageProfitCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { Num bars = numberOfBars.calculate(series, tradingRecord); if (bars.isEqual(series.numOf(0))) { return series.numOf(1); } return totalProfit.calculate(series, tradingRecord).pow(series.numOf(1).dividedBy(bars)); } @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override Num calculate(BarSeries series, Trade trade); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); }
@Test public void calculateWithNoBarsShouldReturn1() { series = new MockBarSeries(numFunction, 100, 95, 100, 80, 85, 70); AnalysisCriterion averageProfit = getCriterion(); assertNumEquals(1, averageProfit.calculate(series, new BaseTradingRecord())); }
@Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { Num bars = numberOfBars.calculate(series, tradingRecord); if (bars.isEqual(series.numOf(0))) { return series.numOf(1); } return totalProfit.calculate(series, tradingRecord).pow(series.numOf(1).dividedBy(bars)); }
AverageProfitCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { Num bars = numberOfBars.calculate(series, tradingRecord); if (bars.isEqual(series.numOf(0))) { return series.numOf(1); } return totalProfit.calculate(series, tradingRecord).pow(series.numOf(1).dividedBy(bars)); } }
AverageProfitCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { Num bars = numberOfBars.calculate(series, tradingRecord); if (bars.isEqual(series.numOf(0))) { return series.numOf(1); } return totalProfit.calculate(series, tradingRecord).pow(series.numOf(1).dividedBy(bars)); } }
AverageProfitCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { Num bars = numberOfBars.calculate(series, tradingRecord); if (bars.isEqual(series.numOf(0))) { return series.numOf(1); } return totalProfit.calculate(series, tradingRecord).pow(series.numOf(1).dividedBy(bars)); } @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override Num calculate(BarSeries series, Trade trade); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); }
AverageProfitCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { Num bars = numberOfBars.calculate(series, tradingRecord); if (bars.isEqual(series.numOf(0))) { return series.numOf(1); } return totalProfit.calculate(series, tradingRecord).pow(series.numOf(1).dividedBy(bars)); } @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override Num calculate(BarSeries series, Trade trade); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); }
@Test public void calculateWithOneTrade() { series = new MockBarSeries(numFunction, 100, 105); Trade trade = new Trade(Order.buyAt(0, series), Order.sellAt(1, series)); AnalysisCriterion average = getCriterion(); assertNumEquals(numOf(105d / 100).pow(numOf(0.5)), average.calculate(series, trade)); }
@Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { Num bars = numberOfBars.calculate(series, tradingRecord); if (bars.isEqual(series.numOf(0))) { return series.numOf(1); } return totalProfit.calculate(series, tradingRecord).pow(series.numOf(1).dividedBy(bars)); }
AverageProfitCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { Num bars = numberOfBars.calculate(series, tradingRecord); if (bars.isEqual(series.numOf(0))) { return series.numOf(1); } return totalProfit.calculate(series, tradingRecord).pow(series.numOf(1).dividedBy(bars)); } }
AverageProfitCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { Num bars = numberOfBars.calculate(series, tradingRecord); if (bars.isEqual(series.numOf(0))) { return series.numOf(1); } return totalProfit.calculate(series, tradingRecord).pow(series.numOf(1).dividedBy(bars)); } }
AverageProfitCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { Num bars = numberOfBars.calculate(series, tradingRecord); if (bars.isEqual(series.numOf(0))) { return series.numOf(1); } return totalProfit.calculate(series, tradingRecord).pow(series.numOf(1).dividedBy(bars)); } @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override Num calculate(BarSeries series, Trade trade); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); }
AverageProfitCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { Num bars = numberOfBars.calculate(series, tradingRecord); if (bars.isEqual(series.numOf(0))) { return series.numOf(1); } return totalProfit.calculate(series, tradingRecord).pow(series.numOf(1).dividedBy(bars)); } @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override Num calculate(BarSeries series, Trade trade); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); }
@Test public void betterThan() { AnalysisCriterion criterion = getCriterion(); assertTrue(criterion.betterThan(numOf(2.0), numOf(1.5))); assertFalse(criterion.betterThan(numOf(1.5), numOf(2.0))); }
@Override public boolean betterThan(Num criterionValue1, Num criterionValue2) { return criterionValue1.isGreaterThan(criterionValue2); }
AverageProfitCriterion extends AbstractAnalysisCriterion { @Override public boolean betterThan(Num criterionValue1, Num criterionValue2) { return criterionValue1.isGreaterThan(criterionValue2); } }
AverageProfitCriterion extends AbstractAnalysisCriterion { @Override public boolean betterThan(Num criterionValue1, Num criterionValue2) { return criterionValue1.isGreaterThan(criterionValue2); } }
AverageProfitCriterion extends AbstractAnalysisCriterion { @Override public boolean betterThan(Num criterionValue1, Num criterionValue2) { return criterionValue1.isGreaterThan(criterionValue2); } @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override Num calculate(BarSeries series, Trade trade); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); }
AverageProfitCriterion extends AbstractAnalysisCriterion { @Override public boolean betterThan(Num criterionValue1, Num criterionValue2) { return criterionValue1.isGreaterThan(criterionValue2); } @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override Num calculate(BarSeries series, Trade trade); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); }
@Test public void rewardRiskRatioCriterion() { MockBarSeries series = new MockBarSeries(numFunction, 100, 105, 95, 100, 90, 95, 80, 120); TradingRecord tradingRecord = new BaseTradingRecord(Order.buyAt(0, series), Order.sellAt(1, series), Order.buyAt(2, series), Order.sellAt(4, series), Order.buyAt(5, series), Order.sellAt(7, series)); double totalProfit = (105d / 100) * (90d / 95d) * (120d / 95); double peak = (105d / 100) * (100d / 95); double low = (105d / 100) * (90d / 95) * (80d / 95); assertNumEquals(totalProfit / ((peak - low) / peak), rrc.calculate(series, tradingRecord)); }
@Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { return totalProfit.calculate(series, tradingRecord).dividedBy(maxDrawdown.calculate(series, tradingRecord)); }
RewardRiskRatioCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { return totalProfit.calculate(series, tradingRecord).dividedBy(maxDrawdown.calculate(series, tradingRecord)); } }
RewardRiskRatioCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { return totalProfit.calculate(series, tradingRecord).dividedBy(maxDrawdown.calculate(series, tradingRecord)); } }
RewardRiskRatioCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { return totalProfit.calculate(series, tradingRecord).dividedBy(maxDrawdown.calculate(series, tradingRecord)); } @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); @Override Num calculate(BarSeries series, Trade trade); }
RewardRiskRatioCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { return totalProfit.calculate(series, tradingRecord).dividedBy(maxDrawdown.calculate(series, tradingRecord)); } @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); @Override Num calculate(BarSeries series, Trade trade); }
@Test public void rewardRiskRatioCriterionOnlyWithGain() { MockBarSeries series = new MockBarSeries(numFunction, 1, 2, 3, 6, 8, 20, 3); TradingRecord tradingRecord = new BaseTradingRecord(Order.buyAt(0, series), Order.sellAt(1, series), Order.buyAt(2, series), Order.sellAt(5, series)); assertTrue(rrc.calculate(series, tradingRecord).isNaN()); }
@Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { return totalProfit.calculate(series, tradingRecord).dividedBy(maxDrawdown.calculate(series, tradingRecord)); }
RewardRiskRatioCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { return totalProfit.calculate(series, tradingRecord).dividedBy(maxDrawdown.calculate(series, tradingRecord)); } }
RewardRiskRatioCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { return totalProfit.calculate(series, tradingRecord).dividedBy(maxDrawdown.calculate(series, tradingRecord)); } }
RewardRiskRatioCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { return totalProfit.calculate(series, tradingRecord).dividedBy(maxDrawdown.calculate(series, tradingRecord)); } @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); @Override Num calculate(BarSeries series, Trade trade); }
RewardRiskRatioCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { return totalProfit.calculate(series, tradingRecord).dividedBy(maxDrawdown.calculate(series, tradingRecord)); } @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); @Override Num calculate(BarSeries series, Trade trade); }
@Test public void isSatisfied() { assertFalse(rule.isSatisfied(0)); assertFalse(rule.isSatisfied(1)); assertFalse(rule.isSatisfied(2)); assertTrue(rule.isSatisfied(3)); assertFalse(rule.isSatisfied(4)); assertTrue(rule.isSatisfied(5)); assertFalse(rule.isSatisfied(6)); assertFalse(rule.isSatisfied(7)); }
@Override public boolean isSatisfied(int index, TradingRecord tradingRecord) { final boolean satisfied = cross.getValue(index); traceIsSatisfied(index, satisfied); return satisfied; }
CrossedDownIndicatorRule extends AbstractRule { @Override public boolean isSatisfied(int index, TradingRecord tradingRecord) { final boolean satisfied = cross.getValue(index); traceIsSatisfied(index, satisfied); return satisfied; } }
CrossedDownIndicatorRule extends AbstractRule { @Override public boolean isSatisfied(int index, TradingRecord tradingRecord) { final boolean satisfied = cross.getValue(index); traceIsSatisfied(index, satisfied); return satisfied; } CrossedDownIndicatorRule(Indicator<Num> indicator, Number threshold); CrossedDownIndicatorRule(Indicator<Num> indicator, Num threshold); CrossedDownIndicatorRule(Indicator<Num> first, Indicator<Num> second); }
CrossedDownIndicatorRule extends AbstractRule { @Override public boolean isSatisfied(int index, TradingRecord tradingRecord) { final boolean satisfied = cross.getValue(index); traceIsSatisfied(index, satisfied); return satisfied; } CrossedDownIndicatorRule(Indicator<Num> indicator, Number threshold); CrossedDownIndicatorRule(Indicator<Num> indicator, Num threshold); CrossedDownIndicatorRule(Indicator<Num> first, Indicator<Num> second); @Override boolean isSatisfied(int index, TradingRecord tradingRecord); }
CrossedDownIndicatorRule extends AbstractRule { @Override public boolean isSatisfied(int index, TradingRecord tradingRecord) { final boolean satisfied = cross.getValue(index); traceIsSatisfied(index, satisfied); return satisfied; } CrossedDownIndicatorRule(Indicator<Num> indicator, Number threshold); CrossedDownIndicatorRule(Indicator<Num> indicator, Num threshold); CrossedDownIndicatorRule(Indicator<Num> first, Indicator<Num> second); @Override boolean isSatisfied(int index, TradingRecord tradingRecord); }
@Test public void rewardRiskRatioCriterionWithNoTrades() { MockBarSeries series = new MockBarSeries(numFunction, 1, 2, 3, 6, 8, 20, 3); assertTrue(rrc.calculate(series, new BaseTradingRecord()).isNaN()); }
@Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { return totalProfit.calculate(series, tradingRecord).dividedBy(maxDrawdown.calculate(series, tradingRecord)); }
RewardRiskRatioCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { return totalProfit.calculate(series, tradingRecord).dividedBy(maxDrawdown.calculate(series, tradingRecord)); } }
RewardRiskRatioCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { return totalProfit.calculate(series, tradingRecord).dividedBy(maxDrawdown.calculate(series, tradingRecord)); } }
RewardRiskRatioCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { return totalProfit.calculate(series, tradingRecord).dividedBy(maxDrawdown.calculate(series, tradingRecord)); } @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); @Override Num calculate(BarSeries series, Trade trade); }
RewardRiskRatioCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { return totalProfit.calculate(series, tradingRecord).dividedBy(maxDrawdown.calculate(series, tradingRecord)); } @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); @Override Num calculate(BarSeries series, Trade trade); }
@Test public void withOneTrade() { MockBarSeries series = new MockBarSeries(numFunction, 100, 95, 95, 100, 90, 95, 80, 120); Trade trade = new Trade(Order.buyAt(0, series), Order.sellAt(1, series)); AnalysisCriterion ratioCriterion = getCriterion(); assertNumEquals((95d / 100) / ((1d - 0.95d)), ratioCriterion.calculate(series, trade)); }
@Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { return totalProfit.calculate(series, tradingRecord).dividedBy(maxDrawdown.calculate(series, tradingRecord)); }
RewardRiskRatioCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { return totalProfit.calculate(series, tradingRecord).dividedBy(maxDrawdown.calculate(series, tradingRecord)); } }
RewardRiskRatioCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { return totalProfit.calculate(series, tradingRecord).dividedBy(maxDrawdown.calculate(series, tradingRecord)); } }
RewardRiskRatioCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { return totalProfit.calculate(series, tradingRecord).dividedBy(maxDrawdown.calculate(series, tradingRecord)); } @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); @Override Num calculate(BarSeries series, Trade trade); }
RewardRiskRatioCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { return totalProfit.calculate(series, tradingRecord).dividedBy(maxDrawdown.calculate(series, tradingRecord)); } @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); @Override Num calculate(BarSeries series, Trade trade); }
@Test public void betterThan() { AnalysisCriterion criterion = getCriterion(); assertTrue(criterion.betterThan(numOf(3.5), numOf(2.2))); assertFalse(criterion.betterThan(numOf(1.5), numOf(2.7))); }
@Override public boolean betterThan(Num criterionValue1, Num criterionValue2) { return criterionValue1.isGreaterThan(criterionValue2); }
RewardRiskRatioCriterion extends AbstractAnalysisCriterion { @Override public boolean betterThan(Num criterionValue1, Num criterionValue2) { return criterionValue1.isGreaterThan(criterionValue2); } }
RewardRiskRatioCriterion extends AbstractAnalysisCriterion { @Override public boolean betterThan(Num criterionValue1, Num criterionValue2) { return criterionValue1.isGreaterThan(criterionValue2); } }
RewardRiskRatioCriterion extends AbstractAnalysisCriterion { @Override public boolean betterThan(Num criterionValue1, Num criterionValue2) { return criterionValue1.isGreaterThan(criterionValue2); } @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); @Override Num calculate(BarSeries series, Trade trade); }
RewardRiskRatioCriterion extends AbstractAnalysisCriterion { @Override public boolean betterThan(Num criterionValue1, Num criterionValue2) { return criterionValue1.isGreaterThan(criterionValue2); } @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); @Override Num calculate(BarSeries series, Trade trade); }
@Test public void calculateOnlyWithGainTrades() { series = new MockBarSeries(numFunction, 100d, 105d, 106d, 107d, 108d, 115d); TradingRecord tradingRecord = new BaseTradingRecord(Order.buyAt(0, series), Order.sellAt(2, series), Order.buyAt(3, series), Order.sellAt(5, series)); AnalysisCriterion varCriterion = getCriterion(); assertNumEquals(numOf(0.0), varCriterion.calculate(series, tradingRecord)); }
@Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { Returns returns = new Returns(series, tradingRecord, Returns.ReturnType.LOG); return calculateES(returns, confidence); }
ExpectedShortfallCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { Returns returns = new Returns(series, tradingRecord, Returns.ReturnType.LOG); return calculateES(returns, confidence); } }
ExpectedShortfallCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { Returns returns = new Returns(series, tradingRecord, Returns.ReturnType.LOG); return calculateES(returns, confidence); } ExpectedShortfallCriterion(Double confidence); }
ExpectedShortfallCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { Returns returns = new Returns(series, tradingRecord, Returns.ReturnType.LOG); return calculateES(returns, confidence); } ExpectedShortfallCriterion(Double confidence); @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override Num calculate(BarSeries series, Trade trade); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); }
ExpectedShortfallCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { Returns returns = new Returns(series, tradingRecord, Returns.ReturnType.LOG); return calculateES(returns, confidence); } ExpectedShortfallCriterion(Double confidence); @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override Num calculate(BarSeries series, Trade trade); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); }
@Test public void calculateWithASimpleTrade() { series = new MockBarSeries(numFunction, 100d, 104d, 90d, 100d, 95d, 105d); TradingRecord tradingRecord = new BaseTradingRecord(Order.buyAt(0, series), Order.sellAt(2, series)); AnalysisCriterion esCriterion = getCriterion(); assertNumEquals(numOf(Math.log(90d / 104)), esCriterion.calculate(series, tradingRecord)); }
@Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { Returns returns = new Returns(series, tradingRecord, Returns.ReturnType.LOG); return calculateES(returns, confidence); }
ExpectedShortfallCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { Returns returns = new Returns(series, tradingRecord, Returns.ReturnType.LOG); return calculateES(returns, confidence); } }
ExpectedShortfallCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { Returns returns = new Returns(series, tradingRecord, Returns.ReturnType.LOG); return calculateES(returns, confidence); } ExpectedShortfallCriterion(Double confidence); }
ExpectedShortfallCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { Returns returns = new Returns(series, tradingRecord, Returns.ReturnType.LOG); return calculateES(returns, confidence); } ExpectedShortfallCriterion(Double confidence); @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override Num calculate(BarSeries series, Trade trade); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); }
ExpectedShortfallCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { Returns returns = new Returns(series, tradingRecord, Returns.ReturnType.LOG); return calculateES(returns, confidence); } ExpectedShortfallCriterion(Double confidence); @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override Num calculate(BarSeries series, Trade trade); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); }
@Test public void calculateOnlyWithLossTrade() { List<Double> prices = IntStream.rangeClosed(1, 100).asDoubleStream().boxed().sorted(Collections.reverseOrder()) .collect(Collectors.toList()); series = new MockBarSeries(numFunction, prices); Trade trade = new Trade(Order.buyAt(series.getBeginIndex(), series), Order.sellAt(series.getEndIndex(), series)); AnalysisCriterion esCriterion = getCriterion(); assertNumEquals(numOf(-0.35835189384561106), esCriterion.calculate(series, trade)); }
@Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { Returns returns = new Returns(series, tradingRecord, Returns.ReturnType.LOG); return calculateES(returns, confidence); }
ExpectedShortfallCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { Returns returns = new Returns(series, tradingRecord, Returns.ReturnType.LOG); return calculateES(returns, confidence); } }
ExpectedShortfallCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { Returns returns = new Returns(series, tradingRecord, Returns.ReturnType.LOG); return calculateES(returns, confidence); } ExpectedShortfallCriterion(Double confidence); }
ExpectedShortfallCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { Returns returns = new Returns(series, tradingRecord, Returns.ReturnType.LOG); return calculateES(returns, confidence); } ExpectedShortfallCriterion(Double confidence); @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override Num calculate(BarSeries series, Trade trade); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); }
ExpectedShortfallCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { Returns returns = new Returns(series, tradingRecord, Returns.ReturnType.LOG); return calculateES(returns, confidence); } ExpectedShortfallCriterion(Double confidence); @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override Num calculate(BarSeries series, Trade trade); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); }
@Test public void calculateWithNoBarsShouldReturn0() { series = new MockBarSeries(numFunction, 100d, 95d, 100d, 80d, 85d, 70d); AnalysisCriterion varCriterion = getCriterion(); assertNumEquals(numOf(0), varCriterion.calculate(series, new BaseTradingRecord())); }
@Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { Returns returns = new Returns(series, tradingRecord, Returns.ReturnType.LOG); return calculateES(returns, confidence); }
ExpectedShortfallCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { Returns returns = new Returns(series, tradingRecord, Returns.ReturnType.LOG); return calculateES(returns, confidence); } }
ExpectedShortfallCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { Returns returns = new Returns(series, tradingRecord, Returns.ReturnType.LOG); return calculateES(returns, confidence); } ExpectedShortfallCriterion(Double confidence); }
ExpectedShortfallCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { Returns returns = new Returns(series, tradingRecord, Returns.ReturnType.LOG); return calculateES(returns, confidence); } ExpectedShortfallCriterion(Double confidence); @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override Num calculate(BarSeries series, Trade trade); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); }
ExpectedShortfallCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { Returns returns = new Returns(series, tradingRecord, Returns.ReturnType.LOG); return calculateES(returns, confidence); } ExpectedShortfallCriterion(Double confidence); @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override Num calculate(BarSeries series, Trade trade); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); }
@Test public void calculateWithBuyAndHold() { series = new MockBarSeries(numFunction, 100d, 99d); Trade trade = new Trade(Order.buyAt(0, series), Order.sellAt(1, series)); AnalysisCriterion varCriterion = getCriterion(); assertNumEquals(numOf(Math.log(99d / 100)), varCriterion.calculate(series, trade)); }
@Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { Returns returns = new Returns(series, tradingRecord, Returns.ReturnType.LOG); return calculateES(returns, confidence); }
ExpectedShortfallCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { Returns returns = new Returns(series, tradingRecord, Returns.ReturnType.LOG); return calculateES(returns, confidence); } }
ExpectedShortfallCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { Returns returns = new Returns(series, tradingRecord, Returns.ReturnType.LOG); return calculateES(returns, confidence); } ExpectedShortfallCriterion(Double confidence); }
ExpectedShortfallCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { Returns returns = new Returns(series, tradingRecord, Returns.ReturnType.LOG); return calculateES(returns, confidence); } ExpectedShortfallCriterion(Double confidence); @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override Num calculate(BarSeries series, Trade trade); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); }
ExpectedShortfallCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { Returns returns = new Returns(series, tradingRecord, Returns.ReturnType.LOG); return calculateES(returns, confidence); } ExpectedShortfallCriterion(Double confidence); @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override Num calculate(BarSeries series, Trade trade); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); }
@Test public void betterThan() { AnalysisCriterion criterion = getCriterion(); assertTrue(criterion.betterThan(numOf(-0.1), numOf(-0.2))); assertFalse(criterion.betterThan(numOf(-0.1), numOf(0.0))); }
@Override public boolean betterThan(Num criterionValue1, Num criterionValue2) { return criterionValue1.isGreaterThan(criterionValue2); }
ExpectedShortfallCriterion extends AbstractAnalysisCriterion { @Override public boolean betterThan(Num criterionValue1, Num criterionValue2) { return criterionValue1.isGreaterThan(criterionValue2); } }
ExpectedShortfallCriterion extends AbstractAnalysisCriterion { @Override public boolean betterThan(Num criterionValue1, Num criterionValue2) { return criterionValue1.isGreaterThan(criterionValue2); } ExpectedShortfallCriterion(Double confidence); }
ExpectedShortfallCriterion extends AbstractAnalysisCriterion { @Override public boolean betterThan(Num criterionValue1, Num criterionValue2) { return criterionValue1.isGreaterThan(criterionValue2); } ExpectedShortfallCriterion(Double confidence); @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override Num calculate(BarSeries series, Trade trade); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); }
ExpectedShortfallCriterion extends AbstractAnalysisCriterion { @Override public boolean betterThan(Num criterionValue1, Num criterionValue2) { return criterionValue1.isGreaterThan(criterionValue2); } ExpectedShortfallCriterion(Double confidence); @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override Num calculate(BarSeries series, Trade trade); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); }
@Test public void calculate() { BarSeries series = new MockBarSeries(numFunction, 100d, 95d, 102d, 105d, 97d, 113d); TradingRecord tradingRecord = new BaseTradingRecord(Order.buyAt(0, series), Order.sellAt(1, series), Order.buyAt(2, series), Order.sellAt(3, series), Order.buyAt(4, series), Order.sellAt(5, series)); AnalysisCriterion average = getCriterion(); assertNumEquals(2d / 3, average.calculate(series, tradingRecord)); }
@Override public Num calculate(BarSeries series, Trade trade) { return isProfitableTrade(series, trade) ? series.numOf(1) : series.numOf(0); }
AverageProfitableTradesCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, Trade trade) { return isProfitableTrade(series, trade) ? series.numOf(1) : series.numOf(0); } }
AverageProfitableTradesCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, Trade trade) { return isProfitableTrade(series, trade) ? series.numOf(1) : series.numOf(0); } }
AverageProfitableTradesCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, Trade trade) { return isProfitableTrade(series, trade) ? series.numOf(1) : series.numOf(0); } @Override Num calculate(BarSeries series, Trade trade); @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); }
AverageProfitableTradesCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, Trade trade) { return isProfitableTrade(series, trade) ? series.numOf(1) : series.numOf(0); } @Override Num calculate(BarSeries series, Trade trade); @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); }
@Test public void isSatisfied() { assertTrue(rule.isSatisfied(0)); assertFalse(rule.isSatisfied(1)); assertFalse(rule.isSatisfied(2)); assertFalse(rule.isSatisfied(3)); }
@Override public boolean isSatisfied(int index, TradingRecord tradingRecord) { final boolean satisfied = first.getValue(index).isEqual(second.getValue(index)); traceIsSatisfied(index, satisfied); return satisfied; }
IsEqualRule extends AbstractRule { @Override public boolean isSatisfied(int index, TradingRecord tradingRecord) { final boolean satisfied = first.getValue(index).isEqual(second.getValue(index)); traceIsSatisfied(index, satisfied); return satisfied; } }
IsEqualRule extends AbstractRule { @Override public boolean isSatisfied(int index, TradingRecord tradingRecord) { final boolean satisfied = first.getValue(index).isEqual(second.getValue(index)); traceIsSatisfied(index, satisfied); return satisfied; } IsEqualRule(Indicator<Num> indicator, Number value); IsEqualRule(Indicator<Num> indicator, Num value); IsEqualRule(Indicator<Num> first, Indicator<Num> second); }
IsEqualRule extends AbstractRule { @Override public boolean isSatisfied(int index, TradingRecord tradingRecord) { final boolean satisfied = first.getValue(index).isEqual(second.getValue(index)); traceIsSatisfied(index, satisfied); return satisfied; } IsEqualRule(Indicator<Num> indicator, Number value); IsEqualRule(Indicator<Num> indicator, Num value); IsEqualRule(Indicator<Num> first, Indicator<Num> second); @Override boolean isSatisfied(int index, TradingRecord tradingRecord); }
IsEqualRule extends AbstractRule { @Override public boolean isSatisfied(int index, TradingRecord tradingRecord) { final boolean satisfied = first.getValue(index).isEqual(second.getValue(index)); traceIsSatisfied(index, satisfied); return satisfied; } IsEqualRule(Indicator<Num> indicator, Number value); IsEqualRule(Indicator<Num> indicator, Num value); IsEqualRule(Indicator<Num> first, Indicator<Num> second); @Override boolean isSatisfied(int index, TradingRecord tradingRecord); }
@Test public void calculateWithOneTrade() { BarSeries series = new MockBarSeries(numFunction, 100d, 95d, 102d, 105d, 97d, 113d); Trade trade = new Trade(Order.buyAt(0, series), Order.sellAt(1, series)); AnalysisCriterion average = getCriterion(); assertNumEquals(numOf(0), average.calculate(series, trade)); trade = new Trade(Order.buyAt(1, series), Order.sellAt(2, series)); assertNumEquals(1, average.calculate(series, trade)); }
@Override public Num calculate(BarSeries series, Trade trade) { return isProfitableTrade(series, trade) ? series.numOf(1) : series.numOf(0); }
AverageProfitableTradesCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, Trade trade) { return isProfitableTrade(series, trade) ? series.numOf(1) : series.numOf(0); } }
AverageProfitableTradesCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, Trade trade) { return isProfitableTrade(series, trade) ? series.numOf(1) : series.numOf(0); } }
AverageProfitableTradesCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, Trade trade) { return isProfitableTrade(series, trade) ? series.numOf(1) : series.numOf(0); } @Override Num calculate(BarSeries series, Trade trade); @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); }
AverageProfitableTradesCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, Trade trade) { return isProfitableTrade(series, trade) ? series.numOf(1) : series.numOf(0); } @Override Num calculate(BarSeries series, Trade trade); @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); }
@Test public void betterThan() { AnalysisCriterion criterion = getCriterion(); assertTrue(criterion.betterThan(numOf(12), numOf(8))); assertFalse(criterion.betterThan(numOf(8), numOf(12))); }
@Override public boolean betterThan(Num criterionValue1, Num criterionValue2) { return criterionValue1.isGreaterThan(criterionValue2); }
AverageProfitableTradesCriterion extends AbstractAnalysisCriterion { @Override public boolean betterThan(Num criterionValue1, Num criterionValue2) { return criterionValue1.isGreaterThan(criterionValue2); } }
AverageProfitableTradesCriterion extends AbstractAnalysisCriterion { @Override public boolean betterThan(Num criterionValue1, Num criterionValue2) { return criterionValue1.isGreaterThan(criterionValue2); } }
AverageProfitableTradesCriterion extends AbstractAnalysisCriterion { @Override public boolean betterThan(Num criterionValue1, Num criterionValue2) { return criterionValue1.isGreaterThan(criterionValue2); } @Override Num calculate(BarSeries series, Trade trade); @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); }
AverageProfitableTradesCriterion extends AbstractAnalysisCriterion { @Override public boolean betterThan(Num criterionValue1, Num criterionValue2) { return criterionValue1.isGreaterThan(criterionValue2); } @Override Num calculate(BarSeries series, Trade trade); @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); }
@Test public void calculateWithNoTrades() { MockBarSeries series = new MockBarSeries(numFunction, 100, 105, 110, 100, 95, 105); assertNumEquals(0, getCriterion().calculate(series, new BaseTradingRecord())); }
@Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { long numberOfLosingTrades = tradingRecord.getTrades().stream().filter(Trade::isClosed) .filter(trade -> isBreakEvenTrade(series, trade)).count(); return series.numOf(numberOfLosingTrades); }
NumberOfBreakEvenTradesCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { long numberOfLosingTrades = tradingRecord.getTrades().stream().filter(Trade::isClosed) .filter(trade -> isBreakEvenTrade(series, trade)).count(); return series.numOf(numberOfLosingTrades); } }
NumberOfBreakEvenTradesCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { long numberOfLosingTrades = tradingRecord.getTrades().stream().filter(Trade::isClosed) .filter(trade -> isBreakEvenTrade(series, trade)).count(); return series.numOf(numberOfLosingTrades); } }
NumberOfBreakEvenTradesCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { long numberOfLosingTrades = tradingRecord.getTrades().stream().filter(Trade::isClosed) .filter(trade -> isBreakEvenTrade(series, trade)).count(); return series.numOf(numberOfLosingTrades); } @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override Num calculate(BarSeries series, Trade trade); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); }
NumberOfBreakEvenTradesCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { long numberOfLosingTrades = tradingRecord.getTrades().stream().filter(Trade::isClosed) .filter(trade -> isBreakEvenTrade(series, trade)).count(); return series.numOf(numberOfLosingTrades); } @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override Num calculate(BarSeries series, Trade trade); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); }
@Test public void calculateWithTwoTrades() { MockBarSeries series = new MockBarSeries(numFunction, 100, 105, 110, 100, 95, 105); TradingRecord tradingRecord = new BaseTradingRecord(Order.buyAt(0, series), Order.sellAt(3, series), Order.buyAt(1, series), Order.sellAt(5, series)); assertNumEquals(2, getCriterion().calculate(series, tradingRecord)); }
@Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { long numberOfLosingTrades = tradingRecord.getTrades().stream().filter(Trade::isClosed) .filter(trade -> isBreakEvenTrade(series, trade)).count(); return series.numOf(numberOfLosingTrades); }
NumberOfBreakEvenTradesCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { long numberOfLosingTrades = tradingRecord.getTrades().stream().filter(Trade::isClosed) .filter(trade -> isBreakEvenTrade(series, trade)).count(); return series.numOf(numberOfLosingTrades); } }
NumberOfBreakEvenTradesCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { long numberOfLosingTrades = tradingRecord.getTrades().stream().filter(Trade::isClosed) .filter(trade -> isBreakEvenTrade(series, trade)).count(); return series.numOf(numberOfLosingTrades); } }
NumberOfBreakEvenTradesCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { long numberOfLosingTrades = tradingRecord.getTrades().stream().filter(Trade::isClosed) .filter(trade -> isBreakEvenTrade(series, trade)).count(); return series.numOf(numberOfLosingTrades); } @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override Num calculate(BarSeries series, Trade trade); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); }
NumberOfBreakEvenTradesCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { long numberOfLosingTrades = tradingRecord.getTrades().stream().filter(Trade::isClosed) .filter(trade -> isBreakEvenTrade(series, trade)).count(); return series.numOf(numberOfLosingTrades); } @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override Num calculate(BarSeries series, Trade trade); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); }
@Test public void calculateWithOneTrade() { MockBarSeries series = new MockBarSeries(numFunction, 100, 105, 110, 100, 95, 105); Trade trade = new Trade(Order.buyAt(0, series), Order.sellAt(3, series)); assertNumEquals(1, getCriterion().calculate(series, trade)); }
@Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { long numberOfLosingTrades = tradingRecord.getTrades().stream().filter(Trade::isClosed) .filter(trade -> isBreakEvenTrade(series, trade)).count(); return series.numOf(numberOfLosingTrades); }
NumberOfBreakEvenTradesCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { long numberOfLosingTrades = tradingRecord.getTrades().stream().filter(Trade::isClosed) .filter(trade -> isBreakEvenTrade(series, trade)).count(); return series.numOf(numberOfLosingTrades); } }
NumberOfBreakEvenTradesCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { long numberOfLosingTrades = tradingRecord.getTrades().stream().filter(Trade::isClosed) .filter(trade -> isBreakEvenTrade(series, trade)).count(); return series.numOf(numberOfLosingTrades); } }
NumberOfBreakEvenTradesCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { long numberOfLosingTrades = tradingRecord.getTrades().stream().filter(Trade::isClosed) .filter(trade -> isBreakEvenTrade(series, trade)).count(); return series.numOf(numberOfLosingTrades); } @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override Num calculate(BarSeries series, Trade trade); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); }
NumberOfBreakEvenTradesCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { long numberOfLosingTrades = tradingRecord.getTrades().stream().filter(Trade::isClosed) .filter(trade -> isBreakEvenTrade(series, trade)).count(); return series.numOf(numberOfLosingTrades); } @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override Num calculate(BarSeries series, Trade trade); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); }
@Test public void betterThan() { AnalysisCriterion criterion = getCriterion(); assertTrue(criterion.betterThan(numOf(3), numOf(6))); assertFalse(criterion.betterThan(numOf(7), numOf(4))); }
@Override public boolean betterThan(Num criterionValue1, Num criterionValue2) { return criterionValue1.isLessThan(criterionValue2); }
NumberOfBreakEvenTradesCriterion extends AbstractAnalysisCriterion { @Override public boolean betterThan(Num criterionValue1, Num criterionValue2) { return criterionValue1.isLessThan(criterionValue2); } }
NumberOfBreakEvenTradesCriterion extends AbstractAnalysisCriterion { @Override public boolean betterThan(Num criterionValue1, Num criterionValue2) { return criterionValue1.isLessThan(criterionValue2); } }
NumberOfBreakEvenTradesCriterion extends AbstractAnalysisCriterion { @Override public boolean betterThan(Num criterionValue1, Num criterionValue2) { return criterionValue1.isLessThan(criterionValue2); } @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override Num calculate(BarSeries series, Trade trade); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); }
NumberOfBreakEvenTradesCriterion extends AbstractAnalysisCriterion { @Override public boolean betterThan(Num criterionValue1, Num criterionValue2) { return criterionValue1.isLessThan(criterionValue2); } @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override Num calculate(BarSeries series, Trade trade); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); }
@Test public void calculateOnlyWithGainTrades() { MockBarSeries series = new MockBarSeries(numFunction, 100, 105, 110, 100, 95, 105); TradingRecord tradingRecord = new BaseTradingRecord(Order.buyAt(0, series), Order.sellAt(2, series), Order.buyAt(3, series), Order.sellAt(5, series)); AnalysisCriterion profit = getCriterion(); assertNumEquals(10 + 5, profit.calculate(series, tradingRecord)); }
@Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { return tradingRecord.getTrades().stream().filter(Trade::isClosed).map(trade -> calculate(series, trade)) .reduce(series.numOf(0), Num::plus); }
ProfitLossPercentageCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { return tradingRecord.getTrades().stream().filter(Trade::isClosed).map(trade -> calculate(series, trade)) .reduce(series.numOf(0), Num::plus); } }
ProfitLossPercentageCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { return tradingRecord.getTrades().stream().filter(Trade::isClosed).map(trade -> calculate(series, trade)) .reduce(series.numOf(0), Num::plus); } }
ProfitLossPercentageCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { return tradingRecord.getTrades().stream().filter(Trade::isClosed).map(trade -> calculate(series, trade)) .reduce(series.numOf(0), Num::plus); } @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override Num calculate(BarSeries series, Trade trade); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); }
ProfitLossPercentageCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { return tradingRecord.getTrades().stream().filter(Trade::isClosed).map(trade -> calculate(series, trade)) .reduce(series.numOf(0), Num::plus); } @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override Num calculate(BarSeries series, Trade trade); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); }
@Test public void calculateOnlyWithLossTrades() { MockBarSeries series = new MockBarSeries(numFunction, 100, 95, 100, 80, 85, 70); TradingRecord tradingRecord = new BaseTradingRecord(Order.buyAt(0, series), Order.sellAt(1, series), Order.buyAt(2, series), Order.sellAt(5, series)); AnalysisCriterion profit = getCriterion(); assertNumEquals(-5 + -30, profit.calculate(series, tradingRecord)); }
@Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { return tradingRecord.getTrades().stream().filter(Trade::isClosed).map(trade -> calculate(series, trade)) .reduce(series.numOf(0), Num::plus); }
ProfitLossPercentageCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { return tradingRecord.getTrades().stream().filter(Trade::isClosed).map(trade -> calculate(series, trade)) .reduce(series.numOf(0), Num::plus); } }
ProfitLossPercentageCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { return tradingRecord.getTrades().stream().filter(Trade::isClosed).map(trade -> calculate(series, trade)) .reduce(series.numOf(0), Num::plus); } }
ProfitLossPercentageCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { return tradingRecord.getTrades().stream().filter(Trade::isClosed).map(trade -> calculate(series, trade)) .reduce(series.numOf(0), Num::plus); } @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override Num calculate(BarSeries series, Trade trade); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); }
ProfitLossPercentageCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { return tradingRecord.getTrades().stream().filter(Trade::isClosed).map(trade -> calculate(series, trade)) .reduce(series.numOf(0), Num::plus); } @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override Num calculate(BarSeries series, Trade trade); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); }