method2testcases
stringlengths 118
6.63k
|
|---|
### Question:
CorpusDb { public CorpusDocument loadDocumentByKey(int key) { String sql = "SELECT ID, DOC_ID, SOURCE_ID, SOURCE_DATE, PROCESS_DATE, CONTENT FROM DOCUMENT_TABLE " + "WHERE ID = " + key; return getDocument(sql); } CorpusDb(Path dbRoot); private CorpusDb(JdbcConnectionPool connectionPool); void addAll(List<CorpusDocument> docs); void generateTables(); void saveSentences(int docKey, List<String> sentences); List<SentenceSearchResult> search(String text); CorpusDocument loadDocumentByKey(int key); void addDocs(Path corpusFile); }### Answer:
@Test public void saveLoadDocument() throws IOException, SQLException { Path tempDir = Files.createTempDirectory("foo"); CorpusDb storage = new CorpusDb(tempDir); Map<Integer, CorpusDocument> docMap = saveDocuments(storage); for (Integer key : docMap.keySet()) { CorpusDocument expected = docMap.get(key); CorpusDocument actual = storage.loadDocumentByKey(key); Assert.assertEquals(expected.id, actual.id); Assert.assertEquals(expected.content, actual.content); } IOUtil.deleteTempDir(tempDir); } |
### Question:
CorpusDb { public List<SentenceSearchResult> search(String text) { try (Connection connection = connectionPool.getConnection()) { String sql = "SELECT T.* FROM FT_SEARCH_DATA('" + text + "', 0, 0) FT, SENTENCE_TABLE T " + "WHERE FT.TABLE='SENTENCE_TABLE' AND T.ID=FT.KEYS[0];"; Statement stat = connection.createStatement(); ResultSet set = stat.executeQuery(sql); List<SentenceSearchResult> result = new ArrayList<>(); while (set.next()) { result.add(new SentenceSearchResult(set.getInt(1), set.getInt(2), set.getString(3))); } return result; } catch (Exception e) { e.printStackTrace(); throw new RuntimeException(e); } } CorpusDb(Path dbRoot); private CorpusDb(JdbcConnectionPool connectionPool); void addAll(List<CorpusDocument> docs); void generateTables(); void saveSentences(int docKey, List<String> sentences); List<SentenceSearchResult> search(String text); CorpusDocument loadDocumentByKey(int key); void addDocs(Path corpusFile); }### Answer:
@Test public void search() throws IOException, SQLException { Path tempDir = Files.createTempDirectory("foo"); CorpusDb storage = new CorpusDb(tempDir); Map<Integer, CorpusDocument> docMap = saveDocuments(storage); for (Integer key : docMap.keySet()) { CorpusDocument doc = docMap.get(key); List<String> paragraphs = Splitter.on("\n").splitToList(doc.content); List<String> sentences = TurkishSentenceExtractor.DEFAULT.fromParagraphs(paragraphs); storage.saveSentences(key, sentences); } List<SentenceSearchResult> searchResults = storage.search("milyar"); for (SentenceSearchResult searchResult : searchResults) { System.out.println(searchResult); } IOUtil.deleteTempDir(tempDir); } |
### Question:
SimpleTextWriter implements AutoCloseable { public SimpleTextWriter write(String s) throws IOException { try { if (s == null || s.length() == 0) { return this; } writer.write(s); return this; } finally { if (!keepOpen) { close(); } } } private SimpleTextWriter(
BufferedWriter writer,
OutputStream os,
String encoding,
boolean keepOpen,
boolean addNewLineBeforeClose); SimpleTextWriter(String fileName); SimpleTextWriter(String fileName, String encoding); SimpleTextWriter(File file, String encoding); SimpleTextWriter(File file); static Builder builder(File file); static Builder utf8Builder(File file); static SimpleTextWriter oneShotUTF8Writer(File file); static SimpleTextWriter keepOpenUTF8Writer(File file); static SimpleTextWriter keepOpenWriter(OutputStream os, String encoding); static SimpleTextWriter oneShotWriter(OutputStream os, String encoding); static SimpleTextWriter keepOpenWriter(OutputStream os); String getEncoding(); boolean isKeepOpen(); SimpleTextWriter writeLines(Collection<String> lines); SimpleTextWriter writeLines(String... lines); SimpleTextWriter writeToStringLines(Collection<?> objects); SimpleTextWriter write(String s); SimpleTextWriter writeLine(String s); SimpleTextWriter writeLine(); SimpleTextWriter writeLine(Object obj); SimpleTextWriter copyFromStream(InputStream is); SimpleTextWriter copyFromURL(String urlStr); void close(); }### Answer:
@Test public void WriteStringTest() throws IOException { new SimpleTextWriter(tmpFile).write("Hello World!"); Assert.assertEquals(new SimpleTextReader(tmpFile).asString(), "Hello World!"); new SimpleTextWriter(tmpFile).write(null); Assert.assertEquals(new SimpleTextReader(tmpFile).asString(), ""); new SimpleTextWriter(tmpFile).write(""); Assert.assertEquals(new SimpleTextReader(tmpFile).asString(), ""); }
@Test public void WriteStringKeepOpenTest() throws IOException { try (SimpleTextWriter sfw = new SimpleTextWriter .Builder(tmpFile) .keepOpen() .build()) { sfw.write("Hello"); sfw.write("Merhaba"); sfw.write(""); sfw.write(null); } Assert.assertEquals("HelloMerhaba", new SimpleTextReader(tmpFile).asString()); }
@Test(expected = IOException.class) public void keepOpenExcepionTest() throws IOException { SimpleTextWriter sfw = new SimpleTextWriter .Builder(tmpFile) .build(); sfw.write("Hello"); sfw.write("Now it will throw an exception.."); } |
### Question:
SimpleTextWriter implements AutoCloseable { public SimpleTextWriter writeLines(Collection<String> lines) throws IOException { try { IOs.writeLines(lines, writer); return this; } finally { if (!keepOpen) { close(); } } } private SimpleTextWriter(
BufferedWriter writer,
OutputStream os,
String encoding,
boolean keepOpen,
boolean addNewLineBeforeClose); SimpleTextWriter(String fileName); SimpleTextWriter(String fileName, String encoding); SimpleTextWriter(File file, String encoding); SimpleTextWriter(File file); static Builder builder(File file); static Builder utf8Builder(File file); static SimpleTextWriter oneShotUTF8Writer(File file); static SimpleTextWriter keepOpenUTF8Writer(File file); static SimpleTextWriter keepOpenWriter(OutputStream os, String encoding); static SimpleTextWriter oneShotWriter(OutputStream os, String encoding); static SimpleTextWriter keepOpenWriter(OutputStream os); String getEncoding(); boolean isKeepOpen(); SimpleTextWriter writeLines(Collection<String> lines); SimpleTextWriter writeLines(String... lines); SimpleTextWriter writeToStringLines(Collection<?> objects); SimpleTextWriter write(String s); SimpleTextWriter writeLine(String s); SimpleTextWriter writeLine(); SimpleTextWriter writeLine(Object obj); SimpleTextWriter copyFromStream(InputStream is); SimpleTextWriter copyFromURL(String urlStr); void close(); }### Answer:
@Test public void WriteMultiLineStringTest() throws IOException { List<String> strs = new ArrayList<>(Arrays.asList("Merhaba", "Dunya", "")); new SimpleTextWriter(tmpFile).writeLines(strs); List<String> read = new SimpleTextReader(tmpFile).asStringList(); for (int i = 0; i < read.size(); i++) { Assert.assertEquals(read.get(i), strs.get(i)); } } |
### Question:
KeyValueReader { public Map<String, String> loadFromFile(File file) throws IOException { return loadFromFile(new SimpleTextReader. Builder(file) .trim() .ignoreIfStartsWith(ignorePrefix) .ignoreWhiteSpaceLines() .build()); } KeyValueReader(String seperator); KeyValueReader(String seperator, String ignorePrefix); Map<String, String> loadFromFile(File file); Map<String, String> loadFromFile(File file, String encoding); Map<String, String> loadFromStream(InputStream is); Map<String, String> loadFromStream(InputStream is, String encoding); Map<String, String> loadFromFile(SimpleTextReader sfr); }### Answer:
@Test public void testReader() throws IOException { Map<String, String> map = new KeyValueReader(":") .loadFromFile(new File(key_value_colon_separator.getFile())); Assert.assertEquals(map.size(), 4); Assert.assertTrue(TestUtil.containsAllKeys(map, "1", "2", "3", "4")); Assert.assertTrue(TestUtil.containsAllValues(map, "bir", "iki", "uc", "dort")); } |
### Question:
Strings { public static boolean isNullOrEmpty(String str) { return str == null || str.length() == 0; } private Strings(); static boolean isNullOrEmpty(String str); static boolean hasText(String s); static boolean allHasText(String... strings); static boolean allNullOrEmpty(String... strings); static String leftTrim(String s); static String rightTrim(String str); static boolean containsNone(String str, String invalidCharsStr); static boolean containsOnly(String str, String allowedChars); static String repeat(char c, int count); static String repeat(String str, int count); static String reverse(String str); static String insertFromLeft(String str, int interval, String stringToInsert); static String insertFromRight(String str, int interval, String stringToInsert); static String rightPad(String str, int size); static String rightPad(String str, int size, char padChar); static String rightPad(String str, int size, String padStr); static String leftPad(String str, int size); static String leftPad(String str, int size, char padChar); static String subStringUntilFirst(String str, String s); static String subStringUntilLast(String str, String s); static String subStringAfterFirst(String str, String s); static String subStringAfterLast(String str, String s); static String leftPad(String str, int size, String padStr); static String whiteSpacesToSingleSpace(String str); static String eliminateWhiteSpaces(String str); static String[] separateGrams(String word, int gramSize); static final String EMPTY_STRING; static final String[] EMPTY_STRING_ARRAY; }### Answer:
@Test public void isEmptyTest() { assertTrue(isNullOrEmpty(null)); assertTrue(isNullOrEmpty("")); assertFalse(isNullOrEmpty("\n")); assertFalse(isNullOrEmpty("\t")); assertFalse(isNullOrEmpty(" ")); assertFalse(isNullOrEmpty("a")); assertFalse(isNullOrEmpty("as")); } |
### Question:
Strings { public static boolean hasText(String s) { return s != null && s.length() > 0 && s.trim().length() > 0; } private Strings(); static boolean isNullOrEmpty(String str); static boolean hasText(String s); static boolean allHasText(String... strings); static boolean allNullOrEmpty(String... strings); static String leftTrim(String s); static String rightTrim(String str); static boolean containsNone(String str, String invalidCharsStr); static boolean containsOnly(String str, String allowedChars); static String repeat(char c, int count); static String repeat(String str, int count); static String reverse(String str); static String insertFromLeft(String str, int interval, String stringToInsert); static String insertFromRight(String str, int interval, String stringToInsert); static String rightPad(String str, int size); static String rightPad(String str, int size, char padChar); static String rightPad(String str, int size, String padStr); static String leftPad(String str, int size); static String leftPad(String str, int size, char padChar); static String subStringUntilFirst(String str, String s); static String subStringUntilLast(String str, String s); static String subStringAfterFirst(String str, String s); static String subStringAfterLast(String str, String s); static String leftPad(String str, int size, String padStr); static String whiteSpacesToSingleSpace(String str); static String eliminateWhiteSpaces(String str); static String[] separateGrams(String word, int gramSize); static final String EMPTY_STRING; static final String[] EMPTY_STRING_ARRAY; }### Answer:
@Test public void hasTextTest() { assertFalse(hasText(null)); assertTrue(hasText("a")); assertTrue(hasText("abc")); assertFalse(hasText("")); assertFalse(hasText(null)); assertFalse(hasText(" ")); assertFalse(hasText("\t")); assertFalse(hasText("\n")); assertFalse(hasText(" \t")); } |
### Question:
Strings { public static boolean allHasText(String... strings) { checkVarargString(strings); for (String s : strings) { if (!hasText(s)) { return false; } } return true; } private Strings(); static boolean isNullOrEmpty(String str); static boolean hasText(String s); static boolean allHasText(String... strings); static boolean allNullOrEmpty(String... strings); static String leftTrim(String s); static String rightTrim(String str); static boolean containsNone(String str, String invalidCharsStr); static boolean containsOnly(String str, String allowedChars); static String repeat(char c, int count); static String repeat(String str, int count); static String reverse(String str); static String insertFromLeft(String str, int interval, String stringToInsert); static String insertFromRight(String str, int interval, String stringToInsert); static String rightPad(String str, int size); static String rightPad(String str, int size, char padChar); static String rightPad(String str, int size, String padStr); static String leftPad(String str, int size); static String leftPad(String str, int size, char padChar); static String subStringUntilFirst(String str, String s); static String subStringUntilLast(String str, String s); static String subStringAfterFirst(String str, String s); static String subStringAfterLast(String str, String s); static String leftPad(String str, int size, String padStr); static String whiteSpacesToSingleSpace(String str); static String eliminateWhiteSpaces(String str); static String[] separateGrams(String word, int gramSize); static final String EMPTY_STRING; static final String[] EMPTY_STRING_ARRAY; }### Answer:
@Test public void testIfAllHasText() { assertTrue(allHasText("fg", "a", "hyh")); assertFalse(allHasText("fg", null, "hyh")); assertFalse(allHasText("fg", " ", "hyh")); }
@Test(expected = IllegalArgumentException.class) public void testIfAllHasTextExceptionIAE() { allHasText(); } |
### Question:
Strings { public static boolean allNullOrEmpty(String... strings) { checkVarargString(strings); for (String s : strings) { if (!isNullOrEmpty(s)) { return false; } } return true; } private Strings(); static boolean isNullOrEmpty(String str); static boolean hasText(String s); static boolean allHasText(String... strings); static boolean allNullOrEmpty(String... strings); static String leftTrim(String s); static String rightTrim(String str); static boolean containsNone(String str, String invalidCharsStr); static boolean containsOnly(String str, String allowedChars); static String repeat(char c, int count); static String repeat(String str, int count); static String reverse(String str); static String insertFromLeft(String str, int interval, String stringToInsert); static String insertFromRight(String str, int interval, String stringToInsert); static String rightPad(String str, int size); static String rightPad(String str, int size, char padChar); static String rightPad(String str, int size, String padStr); static String leftPad(String str, int size); static String leftPad(String str, int size, char padChar); static String subStringUntilFirst(String str, String s); static String subStringUntilLast(String str, String s); static String subStringAfterFirst(String str, String s); static String subStringAfterLast(String str, String s); static String leftPad(String str, int size, String padStr); static String whiteSpacesToSingleSpace(String str); static String eliminateWhiteSpaces(String str); static String[] separateGrams(String word, int gramSize); static final String EMPTY_STRING; static final String[] EMPTY_STRING_ARRAY; }### Answer:
@Test public void testAllEmpty() { assertTrue(allNullOrEmpty("", "", null)); assertFalse(allNullOrEmpty("", null, "hyh")); assertFalse(allNullOrEmpty(" ", "", "")); }
@Test(expected = IllegalArgumentException.class) public void testAllEmptyExceptionIAE() { allNullOrEmpty(); } |
### Question:
Strings { public static String leftTrim(String s) { if (s == null) { return null; } if (s.length() == 0) { return EMPTY_STRING; } int j = 0; for (int i = 0; i < s.length(); i++) { if (Character.isWhitespace(s.charAt(i))) { j++; } else { break; } } return s.substring(j); } private Strings(); static boolean isNullOrEmpty(String str); static boolean hasText(String s); static boolean allHasText(String... strings); static boolean allNullOrEmpty(String... strings); static String leftTrim(String s); static String rightTrim(String str); static boolean containsNone(String str, String invalidCharsStr); static boolean containsOnly(String str, String allowedChars); static String repeat(char c, int count); static String repeat(String str, int count); static String reverse(String str); static String insertFromLeft(String str, int interval, String stringToInsert); static String insertFromRight(String str, int interval, String stringToInsert); static String rightPad(String str, int size); static String rightPad(String str, int size, char padChar); static String rightPad(String str, int size, String padStr); static String leftPad(String str, int size); static String leftPad(String str, int size, char padChar); static String subStringUntilFirst(String str, String s); static String subStringUntilLast(String str, String s); static String subStringAfterFirst(String str, String s); static String subStringAfterLast(String str, String s); static String leftPad(String str, int size, String padStr); static String whiteSpacesToSingleSpace(String str); static String eliminateWhiteSpaces(String str); static String[] separateGrams(String word, int gramSize); static final String EMPTY_STRING; static final String[] EMPTY_STRING_ARRAY; }### Answer:
@Test public void leftTrimTest() { assertNull(leftTrim(null)); assertEquals(leftTrim(""), ""); assertEquals(leftTrim(" \t "), ""); assertEquals(leftTrim(" 123"), "123"); assertEquals(leftTrim("\t123"), "123"); assertEquals(leftTrim("\n123"), "123"); assertEquals(leftTrim("123"), "123"); assertEquals(leftTrim(" \n 123"), "123"); assertEquals(leftTrim("123 "), "123 "); assertEquals(leftTrim(" 3 123 "), "3 123 "); } |
### Question:
Strings { public static String rightTrim(String str) { if (str == null) { return null; } if (str.length() == 0) { return EMPTY_STRING; } int j = str.length(); for (int i = str.length() - 1; i >= 0; --i) { if (Character.isWhitespace(str.charAt(i))) { j--; } else { break; } } return str.substring(0, j); } private Strings(); static boolean isNullOrEmpty(String str); static boolean hasText(String s); static boolean allHasText(String... strings); static boolean allNullOrEmpty(String... strings); static String leftTrim(String s); static String rightTrim(String str); static boolean containsNone(String str, String invalidCharsStr); static boolean containsOnly(String str, String allowedChars); static String repeat(char c, int count); static String repeat(String str, int count); static String reverse(String str); static String insertFromLeft(String str, int interval, String stringToInsert); static String insertFromRight(String str, int interval, String stringToInsert); static String rightPad(String str, int size); static String rightPad(String str, int size, char padChar); static String rightPad(String str, int size, String padStr); static String leftPad(String str, int size); static String leftPad(String str, int size, char padChar); static String subStringUntilFirst(String str, String s); static String subStringUntilLast(String str, String s); static String subStringAfterFirst(String str, String s); static String subStringAfterLast(String str, String s); static String leftPad(String str, int size, String padStr); static String whiteSpacesToSingleSpace(String str); static String eliminateWhiteSpaces(String str); static String[] separateGrams(String word, int gramSize); static final String EMPTY_STRING; static final String[] EMPTY_STRING_ARRAY; }### Answer:
@Test public void rightTrimTest() { assertNull(rightTrim(null)); assertEquals(rightTrim(""), ""); assertEquals(rightTrim(" \t"), ""); assertEquals(rightTrim("aaa "), "aaa"); assertEquals(rightTrim("aaa \t "), "aaa"); assertEquals(rightTrim("aaa\n "), "aaa"); assertEquals(rightTrim("aaa"), "aaa"); assertEquals(rightTrim(" 123 "), " 123"); assertEquals(rightTrim(" 3 123 \t"), " 3 123"); } |
### Question:
Strings { public static String repeat(char c, int count) { if (count < 1) { return EMPTY_STRING; } char[] chars = new char[count]; Arrays.fill(chars, c); return new String(chars); } private Strings(); static boolean isNullOrEmpty(String str); static boolean hasText(String s); static boolean allHasText(String... strings); static boolean allNullOrEmpty(String... strings); static String leftTrim(String s); static String rightTrim(String str); static boolean containsNone(String str, String invalidCharsStr); static boolean containsOnly(String str, String allowedChars); static String repeat(char c, int count); static String repeat(String str, int count); static String reverse(String str); static String insertFromLeft(String str, int interval, String stringToInsert); static String insertFromRight(String str, int interval, String stringToInsert); static String rightPad(String str, int size); static String rightPad(String str, int size, char padChar); static String rightPad(String str, int size, String padStr); static String leftPad(String str, int size); static String leftPad(String str, int size, char padChar); static String subStringUntilFirst(String str, String s); static String subStringUntilLast(String str, String s); static String subStringAfterFirst(String str, String s); static String subStringAfterLast(String str, String s); static String leftPad(String str, int size, String padStr); static String whiteSpacesToSingleSpace(String str); static String eliminateWhiteSpaces(String str); static String[] separateGrams(String word, int gramSize); static final String EMPTY_STRING; static final String[] EMPTY_STRING_ARRAY; }### Answer:
@Test public void repeatTest() { assertEquals(repeat('c', -1), ""); assertEquals(repeat('c', 3), "ccc"); assertEquals(repeat('c', 1), "c"); assertEquals(repeat('c', 0), ""); assertNull(repeat(null, 1)); assertEquals(repeat("ab", -1), ""); assertEquals(repeat("ab", 3), "ababab"); assertEquals(repeat("ab", 1), "ab"); assertEquals(repeat("ab", 0), ""); } |
### Question:
Strings { public static String reverse(String str) { if (str == null) { return null; } if (str.length() == 0) { return EMPTY_STRING; } return new StringBuilder(str).reverse().toString(); } private Strings(); static boolean isNullOrEmpty(String str); static boolean hasText(String s); static boolean allHasText(String... strings); static boolean allNullOrEmpty(String... strings); static String leftTrim(String s); static String rightTrim(String str); static boolean containsNone(String str, String invalidCharsStr); static boolean containsOnly(String str, String allowedChars); static String repeat(char c, int count); static String repeat(String str, int count); static String reverse(String str); static String insertFromLeft(String str, int interval, String stringToInsert); static String insertFromRight(String str, int interval, String stringToInsert); static String rightPad(String str, int size); static String rightPad(String str, int size, char padChar); static String rightPad(String str, int size, String padStr); static String leftPad(String str, int size); static String leftPad(String str, int size, char padChar); static String subStringUntilFirst(String str, String s); static String subStringUntilLast(String str, String s); static String subStringAfterFirst(String str, String s); static String subStringAfterLast(String str, String s); static String leftPad(String str, int size, String padStr); static String whiteSpacesToSingleSpace(String str); static String eliminateWhiteSpaces(String str); static String[] separateGrams(String word, int gramSize); static final String EMPTY_STRING; static final String[] EMPTY_STRING_ARRAY; }### Answer:
@Test public void reverseTest() { assertNull(reverse(null), null); assertEquals(reverse(""), ""); assertEquals(reverse("a"), "a"); assertEquals(reverse("ab"), "ba"); assertEquals(reverse("ab cd "), " dc ba"); } |
### Question:
CharacterGraphDecoder { public List<String> getSuggestions(String input) { return new Decoder().decode(input).getKeyList(); } CharacterGraphDecoder(float maxPenalty); CharacterGraphDecoder(); CharacterGraphDecoder(CharacterGraph graph); CharacterGraphDecoder(float maxPenalty, Map<Character, String> nearKeyMap); CharacterGraph getGraph(); void addWord(String word); void addWords(String... words); void addWords(List<String> vocabulary); List<ScoredItem<String>> getSuggestionsWithScores(String input); List<ScoredItem<String>> getSuggestionsWithScores(String input, CharMatcher matcher); FloatValueMap<String> decode(String input); List<String> getSuggestions(String input); List<String> getSuggestions(String input, CharMatcher matcher); List<String> getSuggestionsSorted(String input); static final Map<Character, String> TURKISH_FQ_NEAR_KEY_MAP; static final Map<Character, String> TURKISH_Q_NEAR_KEY_MAP; static final DiacriticsIgnoringMatcher DIACRITICS_IGNORING_MATCHER; final float maxPenalty; final boolean checkNearKeySubstitution; public Map<Character, String> nearKeyMap; }### Answer:
@Test public void stemEndingTest1() { TurkishMorphology morphology = TurkishMorphology.builder() .setLexicon("bakmak", "gelmek").build(); List<String> endings = Lists.newArrayList("acak", "ecek"); StemEndingGraph graph = new StemEndingGraph(morphology, endings); CharacterGraphDecoder spellChecker = new CharacterGraphDecoder(graph.stemGraph); List<String> res = spellChecker.getSuggestions("bakcaak"); Assert.assertEquals(1, res.size()); Assert.assertEquals("bakacak", res.get(0)); } |
### Question:
Strings { public static String insertFromLeft(String str, int interval, String stringToInsert) { if (interval < 0) { throw new IllegalArgumentException("interval value cannot be negative."); } if (str == null || interval == 0 || interval >= str.length() || isNullOrEmpty(stringToInsert)) { return str; } StringBuilder b = new StringBuilder(); int i = 0; for (char c : str.toCharArray()) { b.append(c); i++; if (i % interval == 0 && i <= str.length() - 1) { b.append(stringToInsert); } } return b.toString(); } private Strings(); static boolean isNullOrEmpty(String str); static boolean hasText(String s); static boolean allHasText(String... strings); static boolean allNullOrEmpty(String... strings); static String leftTrim(String s); static String rightTrim(String str); static boolean containsNone(String str, String invalidCharsStr); static boolean containsOnly(String str, String allowedChars); static String repeat(char c, int count); static String repeat(String str, int count); static String reverse(String str); static String insertFromLeft(String str, int interval, String stringToInsert); static String insertFromRight(String str, int interval, String stringToInsert); static String rightPad(String str, int size); static String rightPad(String str, int size, char padChar); static String rightPad(String str, int size, String padStr); static String leftPad(String str, int size); static String leftPad(String str, int size, char padChar); static String subStringUntilFirst(String str, String s); static String subStringUntilLast(String str, String s); static String subStringAfterFirst(String str, String s); static String subStringAfterLast(String str, String s); static String leftPad(String str, int size, String padStr); static String whiteSpacesToSingleSpace(String str); static String eliminateWhiteSpaces(String str); static String[] separateGrams(String word, int gramSize); static final String EMPTY_STRING; static final String[] EMPTY_STRING_ARRAY; }### Answer:
@Test public void insertFromLeftTest() { final String s = "0123456789"; assertEquals(insertFromLeft(s, 0, "-"), "0123456789"); assertEquals(insertFromLeft(s, 1, "-"), "0-1-2-3-4-5-6-7-8-9"); assertEquals(insertFromLeft("ahmet", 1, " "), "a h m e t"); assertEquals(insertFromLeft(s, 2, "-"), "01-23-45-67-89"); assertEquals(insertFromLeft(s, 3, "-"), "012-345-678-9"); assertEquals(insertFromLeft(s, 5, "-"), "01234-56789"); assertEquals(insertFromLeft(s, 6, "-"), "012345-6789"); assertEquals(insertFromLeft(s, 9, "-"), "012345678-9"); assertEquals(insertFromLeft(s, 10, "-"), "0123456789"); assertEquals(insertFromLeft(s, 12, "-"), "0123456789"); assertEquals(insertFromLeft(s, 2, "--"), "01--23--45--67--89"); }
@Test(expected = IllegalArgumentException.class) public void insertFromLeftExceptionTest2() { insertFromLeft("123", -1, "-"); } |
### Question:
Strings { public static String insertFromRight(String str, int interval, String stringToInsert) { if (interval < 0) { throw new IllegalArgumentException("interval value cannot be negative."); } if (str == null || interval == 0 || interval >= str.length() || isNullOrEmpty(stringToInsert)) { return str; } StringBuilder b = new StringBuilder(); int j = 0; for (int i = str.length() - 1; i >= 0; i--) { b.append(str.charAt(i)); j++; if (j % interval == 0 && j <= str.length() - 1) { b.append(stringToInsert); } } return reverse(b.toString()); } private Strings(); static boolean isNullOrEmpty(String str); static boolean hasText(String s); static boolean allHasText(String... strings); static boolean allNullOrEmpty(String... strings); static String leftTrim(String s); static String rightTrim(String str); static boolean containsNone(String str, String invalidCharsStr); static boolean containsOnly(String str, String allowedChars); static String repeat(char c, int count); static String repeat(String str, int count); static String reverse(String str); static String insertFromLeft(String str, int interval, String stringToInsert); static String insertFromRight(String str, int interval, String stringToInsert); static String rightPad(String str, int size); static String rightPad(String str, int size, char padChar); static String rightPad(String str, int size, String padStr); static String leftPad(String str, int size); static String leftPad(String str, int size, char padChar); static String subStringUntilFirst(String str, String s); static String subStringUntilLast(String str, String s); static String subStringAfterFirst(String str, String s); static String subStringAfterLast(String str, String s); static String leftPad(String str, int size, String padStr); static String whiteSpacesToSingleSpace(String str); static String eliminateWhiteSpaces(String str); static String[] separateGrams(String word, int gramSize); static final String EMPTY_STRING; static final String[] EMPTY_STRING_ARRAY; }### Answer:
@Test public void insertFromRightTest() { final String s = "0123456789"; assertEquals(insertFromRight(s, 0, "-"), "0123456789"); assertEquals(insertFromRight(s, 1, "-"), "0-1-2-3-4-5-6-7-8-9"); assertEquals(insertFromRight(s, 2, "-"), "01-23-45-67-89"); assertEquals(insertFromRight(s, 3, "-"), "0-123-456-789"); assertEquals(insertFromRight(s, 5, "-"), "01234-56789"); assertEquals(insertFromRight(s, 6, "-"), "0123-456789"); assertEquals(insertFromRight(s, 9, "-"), "0-123456789"); assertEquals(insertFromRight(s, 10, "-"), "0123456789"); assertEquals(insertFromRight(s, 12, "-"), "0123456789"); assertEquals(insertFromRight(s, 2, "--"), "01--23--45--67--89"); assertEquals(insertFromRight(s, 3, "--"), "0--123--456--789"); }
@Test(expected = IllegalArgumentException.class) public void insertFromRightExceptionTest2() { insertFromRight("123", -1, "-"); } |
### Question:
Strings { public static String rightPad(String str, int size) { return rightPad(str, size, ' '); } private Strings(); static boolean isNullOrEmpty(String str); static boolean hasText(String s); static boolean allHasText(String... strings); static boolean allNullOrEmpty(String... strings); static String leftTrim(String s); static String rightTrim(String str); static boolean containsNone(String str, String invalidCharsStr); static boolean containsOnly(String str, String allowedChars); static String repeat(char c, int count); static String repeat(String str, int count); static String reverse(String str); static String insertFromLeft(String str, int interval, String stringToInsert); static String insertFromRight(String str, int interval, String stringToInsert); static String rightPad(String str, int size); static String rightPad(String str, int size, char padChar); static String rightPad(String str, int size, String padStr); static String leftPad(String str, int size); static String leftPad(String str, int size, char padChar); static String subStringUntilFirst(String str, String s); static String subStringUntilLast(String str, String s); static String subStringAfterFirst(String str, String s); static String subStringAfterLast(String str, String s); static String leftPad(String str, int size, String padStr); static String whiteSpacesToSingleSpace(String str); static String eliminateWhiteSpaces(String str); static String[] separateGrams(String word, int gramSize); static final String EMPTY_STRING; static final String[] EMPTY_STRING_ARRAY; }### Answer:
@Test public void testRightPad_StringInt() { assertEquals(null, rightPad(null, 5)); assertEquals(" ", rightPad("", 5)); assertEquals("abc ", rightPad("abc", 5)); assertEquals("abc", rightPad("abc", 2)); assertEquals("abc", rightPad("abc", -1)); }
@Test public void testRightPad_StringIntChar() { assertEquals(null, rightPad(null, 5, ' ')); assertEquals(" ", rightPad("", 5, ' ')); assertEquals("abc ", rightPad("abc", 5, ' ')); assertEquals("abc", rightPad("abc", 2, ' ')); assertEquals("abc", rightPad("abc", -1, ' ')); assertEquals("abcxx", rightPad("abc", 5, 'x')); String str = rightPad("aaa", 10000, 'a'); assertEquals(10000, str.length()); }
@Test public void testRightPad_StringIntString() { assertEquals(null, rightPad(null, 5, "-+")); assertEquals(" ", rightPad("", 5, " ")); assertEquals(null, rightPad(null, 8, null)); assertEquals("abc-+-+", rightPad("abc", 7, "-+")); assertEquals("abc-+~", rightPad("abc", 6, "-+~")); assertEquals("abc-+", rightPad("abc", 5, "-+~")); assertEquals("abc", rightPad("abc", 2, " ")); assertEquals("abc", rightPad("abc", -1, " ")); assertEquals("abc ", rightPad("abc", 5, null)); assertEquals("abc ", rightPad("abc", 5, "")); } |
### Question:
Strings { public static String leftPad(String str, int size) { return leftPad(str, size, " "); } private Strings(); static boolean isNullOrEmpty(String str); static boolean hasText(String s); static boolean allHasText(String... strings); static boolean allNullOrEmpty(String... strings); static String leftTrim(String s); static String rightTrim(String str); static boolean containsNone(String str, String invalidCharsStr); static boolean containsOnly(String str, String allowedChars); static String repeat(char c, int count); static String repeat(String str, int count); static String reverse(String str); static String insertFromLeft(String str, int interval, String stringToInsert); static String insertFromRight(String str, int interval, String stringToInsert); static String rightPad(String str, int size); static String rightPad(String str, int size, char padChar); static String rightPad(String str, int size, String padStr); static String leftPad(String str, int size); static String leftPad(String str, int size, char padChar); static String subStringUntilFirst(String str, String s); static String subStringUntilLast(String str, String s); static String subStringAfterFirst(String str, String s); static String subStringAfterLast(String str, String s); static String leftPad(String str, int size, String padStr); static String whiteSpacesToSingleSpace(String str); static String eliminateWhiteSpaces(String str); static String[] separateGrams(String word, int gramSize); static final String EMPTY_STRING; static final String[] EMPTY_STRING_ARRAY; }### Answer:
@Test public void testLeftPad_StringInt() { assertEquals(null, leftPad(null, 5)); assertEquals(" ", leftPad("", 5)); assertEquals(" abc", leftPad("abc", 5)); assertEquals("abc", leftPad("abc", 2)); }
@Test public void testLeftPad_StringIntChar() { assertEquals(null, leftPad(null, 5, ' ')); assertEquals(" ", leftPad("", 5, ' ')); assertEquals(" abc", leftPad("abc", 5, ' ')); assertEquals("xxabc", leftPad("abc", 5, 'x')); assertEquals("\uffff\uffffabc", leftPad("abc", 5, '\uffff')); assertEquals("abc", leftPad("abc", 2, ' ')); String str = leftPad("aaa", 10000, 'a'); assertEquals(10000, str.length()); }
@Test public void testLeftPad_StringIntString() { assertEquals(null, leftPad(null, 5, "-+")); assertEquals(null, leftPad(null, 5, null)); assertEquals(" ", leftPad("", 5, " ")); assertEquals("-+-+abc", leftPad("abc", 7, "-+")); assertEquals("-+~abc", leftPad("abc", 6, "-+~")); assertEquals("-+abc", leftPad("abc", 5, "-+~")); assertEquals("abc", leftPad("abc", 2, " ")); assertEquals("abc", leftPad("abc", -1, " ")); assertEquals(" abc", leftPad("abc", 5, null)); assertEquals(" abc", leftPad("abc", 5, "")); } |
### Question:
CharacterGraphDecoder { public List<ScoredItem<String>> getSuggestionsWithScores(String input) { Decoder decoder = new Decoder(); return getMatches(input, decoder); } CharacterGraphDecoder(float maxPenalty); CharacterGraphDecoder(); CharacterGraphDecoder(CharacterGraph graph); CharacterGraphDecoder(float maxPenalty, Map<Character, String> nearKeyMap); CharacterGraph getGraph(); void addWord(String word); void addWords(String... words); void addWords(List<String> vocabulary); List<ScoredItem<String>> getSuggestionsWithScores(String input); List<ScoredItem<String>> getSuggestionsWithScores(String input, CharMatcher matcher); FloatValueMap<String> decode(String input); List<String> getSuggestions(String input); List<String> getSuggestions(String input, CharMatcher matcher); List<String> getSuggestionsSorted(String input); static final Map<Character, String> TURKISH_FQ_NEAR_KEY_MAP; static final Map<Character, String> TURKISH_Q_NEAR_KEY_MAP; static final DiacriticsIgnoringMatcher DIACRITICS_IGNORING_MATCHER; final float maxPenalty; final boolean checkNearKeySubstitution; public Map<Character, String> nearKeyMap; }### Answer:
@Test public void stemEndingTest2() { TurkishMorphology morphology = TurkishMorphology.builder() .setLexicon("üzmek", "yüz", "güz").build(); List<String> endings = Lists.newArrayList("düm"); StemEndingGraph graph = new StemEndingGraph(morphology, endings); CharacterGraphDecoder spellChecker = new CharacterGraphDecoder(graph.stemGraph); List<ScoredItem<String>> res = spellChecker.getSuggestionsWithScores("yüzdüm"); Assert.assertEquals(3, res.size()); assertContainsAll(res, "yüzdüm", "üzdüm", "güzdüm"); }
@Test public void stemEndingTest3() { TurkishMorphology morphology = TurkishMorphology.builder().setLexicon("o", "ol", "ola") .build(); List<String> endings = Lists.newArrayList("arak", "acak"); StemEndingGraph graph = new StemEndingGraph(morphology, endings); CharacterGraphDecoder spellChecker = new CharacterGraphDecoder(graph.stemGraph); List<ScoredItem<String>> res = spellChecker.getSuggestionsWithScores("olarak"); assertContainsAll(res, "olarak", "olacak", "olaarak"); }
@Test public void stemEndingTest() { TurkishMorphology morphology = TurkishMorphology.builder() .setLexicon("Türkiye", "Bayram").build(); List<String> endings = Lists.newArrayList("ında", "de"); StemEndingGraph graph = new StemEndingGraph(morphology, endings); CharacterGraphDecoder spellChecker = new CharacterGraphDecoder(graph.stemGraph); List<ScoredItem<String>> res = spellChecker.getSuggestionsWithScores("türkiyede"); assertContainsAll(res, "türkiyede"); } |
### Question:
Strings { public static String whiteSpacesToSingleSpace(String str) { if (str == null) { return null; } if (str.isEmpty()) { return str; } return MULTI_SPACE.matcher(WHITE_SPACE_EXCEPT_SPACE.matcher(str).replaceAll(" ")) .replaceAll(" "); } private Strings(); static boolean isNullOrEmpty(String str); static boolean hasText(String s); static boolean allHasText(String... strings); static boolean allNullOrEmpty(String... strings); static String leftTrim(String s); static String rightTrim(String str); static boolean containsNone(String str, String invalidCharsStr); static boolean containsOnly(String str, String allowedChars); static String repeat(char c, int count); static String repeat(String str, int count); static String reverse(String str); static String insertFromLeft(String str, int interval, String stringToInsert); static String insertFromRight(String str, int interval, String stringToInsert); static String rightPad(String str, int size); static String rightPad(String str, int size, char padChar); static String rightPad(String str, int size, String padStr); static String leftPad(String str, int size); static String leftPad(String str, int size, char padChar); static String subStringUntilFirst(String str, String s); static String subStringUntilLast(String str, String s); static String subStringAfterFirst(String str, String s); static String subStringAfterLast(String str, String s); static String leftPad(String str, int size, String padStr); static String whiteSpacesToSingleSpace(String str); static String eliminateWhiteSpaces(String str); static String[] separateGrams(String word, int gramSize); static final String EMPTY_STRING; static final String[] EMPTY_STRING_ARRAY; }### Answer:
@Test public void testWhiteSpacesToSingleSpace() { assertEquals(whiteSpacesToSingleSpace(null), null); assertEquals(whiteSpacesToSingleSpace(""), ""); assertEquals(whiteSpacesToSingleSpace("asd"), "asd"); assertEquals(whiteSpacesToSingleSpace("a a"), "a a"); assertEquals(whiteSpacesToSingleSpace(" "), " "); assertEquals(whiteSpacesToSingleSpace("\t"), " "); assertEquals(whiteSpacesToSingleSpace("\n"), " "); assertEquals(whiteSpacesToSingleSpace("\t \n"), " "); assertEquals(whiteSpacesToSingleSpace(" \t \n\r \f"), " "); assertEquals(whiteSpacesToSingleSpace(" a\t a\r\fa"), " a a a"); } |
### Question:
Strings { public static String eliminateWhiteSpaces(String str) { if (str == null) { return null; } if (str.isEmpty()) { return str; } return WHITE_SPACE.matcher(str).replaceAll(""); } private Strings(); static boolean isNullOrEmpty(String str); static boolean hasText(String s); static boolean allHasText(String... strings); static boolean allNullOrEmpty(String... strings); static String leftTrim(String s); static String rightTrim(String str); static boolean containsNone(String str, String invalidCharsStr); static boolean containsOnly(String str, String allowedChars); static String repeat(char c, int count); static String repeat(String str, int count); static String reverse(String str); static String insertFromLeft(String str, int interval, String stringToInsert); static String insertFromRight(String str, int interval, String stringToInsert); static String rightPad(String str, int size); static String rightPad(String str, int size, char padChar); static String rightPad(String str, int size, String padStr); static String leftPad(String str, int size); static String leftPad(String str, int size, char padChar); static String subStringUntilFirst(String str, String s); static String subStringUntilLast(String str, String s); static String subStringAfterFirst(String str, String s); static String subStringAfterLast(String str, String s); static String leftPad(String str, int size, String padStr); static String whiteSpacesToSingleSpace(String str); static String eliminateWhiteSpaces(String str); static String[] separateGrams(String word, int gramSize); static final String EMPTY_STRING; static final String[] EMPTY_STRING_ARRAY; }### Answer:
@Test public void testEliminateWhiteSpaces() { assertEquals(eliminateWhiteSpaces(null), null); assertEquals(eliminateWhiteSpaces(""), ""); assertEquals(eliminateWhiteSpaces("asd"), "asd"); assertEquals(eliminateWhiteSpaces("a "), "a"); assertEquals(eliminateWhiteSpaces("a a "), "aa"); assertEquals(eliminateWhiteSpaces("a \t a \t\r\f"), "aa"); } |
### Question:
Strings { public static String subStringAfterFirst(String str, String s) { if (isNullOrEmpty(str) || isNullOrEmpty(s)) { return str; } final int pos = str.indexOf(s); if (pos < 0) { return str; } else { return str.substring(pos + s.length()); } } private Strings(); static boolean isNullOrEmpty(String str); static boolean hasText(String s); static boolean allHasText(String... strings); static boolean allNullOrEmpty(String... strings); static String leftTrim(String s); static String rightTrim(String str); static boolean containsNone(String str, String invalidCharsStr); static boolean containsOnly(String str, String allowedChars); static String repeat(char c, int count); static String repeat(String str, int count); static String reverse(String str); static String insertFromLeft(String str, int interval, String stringToInsert); static String insertFromRight(String str, int interval, String stringToInsert); static String rightPad(String str, int size); static String rightPad(String str, int size, char padChar); static String rightPad(String str, int size, String padStr); static String leftPad(String str, int size); static String leftPad(String str, int size, char padChar); static String subStringUntilFirst(String str, String s); static String subStringUntilLast(String str, String s); static String subStringAfterFirst(String str, String s); static String subStringAfterLast(String str, String s); static String leftPad(String str, int size, String padStr); static String whiteSpacesToSingleSpace(String str); static String eliminateWhiteSpaces(String str); static String[] separateGrams(String word, int gramSize); static final String EMPTY_STRING; static final String[] EMPTY_STRING_ARRAY; }### Answer:
@Test public void testSubstringAfterFirst() { assertEquals(subStringAfterFirst("hello", "el"), "lo"); assertEquals(subStringAfterFirst("hellohello", "el"), "lohello"); assertEquals(subStringAfterFirst("hello", "hello"), ""); assertEquals(subStringAfterFirst("hello", ""), "hello"); assertEquals(subStringAfterFirst("hello", null), "hello"); assertEquals(subStringAfterFirst("", "el"), ""); assertEquals(subStringAfterFirst(null, "el"), null); } |
### Question:
Strings { public static String subStringAfterLast(String str, String s) { if (isNullOrEmpty(str) || isNullOrEmpty(s)) { return str; } final int pos = str.lastIndexOf(s); if (pos < 0) { return str; } else { return str.substring(pos + s.length()); } } private Strings(); static boolean isNullOrEmpty(String str); static boolean hasText(String s); static boolean allHasText(String... strings); static boolean allNullOrEmpty(String... strings); static String leftTrim(String s); static String rightTrim(String str); static boolean containsNone(String str, String invalidCharsStr); static boolean containsOnly(String str, String allowedChars); static String repeat(char c, int count); static String repeat(String str, int count); static String reverse(String str); static String insertFromLeft(String str, int interval, String stringToInsert); static String insertFromRight(String str, int interval, String stringToInsert); static String rightPad(String str, int size); static String rightPad(String str, int size, char padChar); static String rightPad(String str, int size, String padStr); static String leftPad(String str, int size); static String leftPad(String str, int size, char padChar); static String subStringUntilFirst(String str, String s); static String subStringUntilLast(String str, String s); static String subStringAfterFirst(String str, String s); static String subStringAfterLast(String str, String s); static String leftPad(String str, int size, String padStr); static String whiteSpacesToSingleSpace(String str); static String eliminateWhiteSpaces(String str); static String[] separateGrams(String word, int gramSize); static final String EMPTY_STRING; static final String[] EMPTY_STRING_ARRAY; }### Answer:
@Test public void testSubstringAfterLast() { assertEquals(subStringAfterLast("hello\\world", "\\"), "world"); assertEquals(subStringAfterLast("hello", "el"), "lo"); assertEquals(subStringAfterLast("hellohello", "el"), "lo"); assertEquals(subStringAfterLast("hello", "hello"), ""); assertEquals(subStringAfterLast("hello", ""), "hello"); assertEquals(subStringAfterLast("hello", null), "hello"); assertEquals(subStringAfterLast("", "el"), ""); assertEquals(subStringAfterLast(null, "el"), null); } |
### Question:
Strings { public static String subStringUntilFirst(String str, String s) { if (isNullOrEmpty(str) || isNullOrEmpty(s)) { return str; } final int pos = str.indexOf(s); if (pos < 0) { return str; } else { return str.substring(0, pos); } } private Strings(); static boolean isNullOrEmpty(String str); static boolean hasText(String s); static boolean allHasText(String... strings); static boolean allNullOrEmpty(String... strings); static String leftTrim(String s); static String rightTrim(String str); static boolean containsNone(String str, String invalidCharsStr); static boolean containsOnly(String str, String allowedChars); static String repeat(char c, int count); static String repeat(String str, int count); static String reverse(String str); static String insertFromLeft(String str, int interval, String stringToInsert); static String insertFromRight(String str, int interval, String stringToInsert); static String rightPad(String str, int size); static String rightPad(String str, int size, char padChar); static String rightPad(String str, int size, String padStr); static String leftPad(String str, int size); static String leftPad(String str, int size, char padChar); static String subStringUntilFirst(String str, String s); static String subStringUntilLast(String str, String s); static String subStringAfterFirst(String str, String s); static String subStringAfterLast(String str, String s); static String leftPad(String str, int size, String padStr); static String whiteSpacesToSingleSpace(String str); static String eliminateWhiteSpaces(String str); static String[] separateGrams(String word, int gramSize); static final String EMPTY_STRING; static final String[] EMPTY_STRING_ARRAY; }### Answer:
@Test public void testSubstringUntilFirst() { assertEquals(subStringUntilFirst("hello", "el"), "h"); assertEquals(subStringUntilFirst("hellohello", "el"), "h"); assertEquals(subStringUntilFirst("hello", "hello"), ""); assertEquals(subStringUntilFirst("hello", ""), "hello"); assertEquals(subStringUntilFirst("hello", null), "hello"); assertEquals(subStringUntilFirst("", "el"), ""); assertEquals(subStringUntilFirst(null, "el"), null); } |
### Question:
Strings { public static String subStringUntilLast(String str, String s) { if (isNullOrEmpty(str) || isNullOrEmpty(s)) { return str; } final int pos = str.lastIndexOf(s); if (pos < 0) { return str; } return str.substring(0, pos); } private Strings(); static boolean isNullOrEmpty(String str); static boolean hasText(String s); static boolean allHasText(String... strings); static boolean allNullOrEmpty(String... strings); static String leftTrim(String s); static String rightTrim(String str); static boolean containsNone(String str, String invalidCharsStr); static boolean containsOnly(String str, String allowedChars); static String repeat(char c, int count); static String repeat(String str, int count); static String reverse(String str); static String insertFromLeft(String str, int interval, String stringToInsert); static String insertFromRight(String str, int interval, String stringToInsert); static String rightPad(String str, int size); static String rightPad(String str, int size, char padChar); static String rightPad(String str, int size, String padStr); static String leftPad(String str, int size); static String leftPad(String str, int size, char padChar); static String subStringUntilFirst(String str, String s); static String subStringUntilLast(String str, String s); static String subStringAfterFirst(String str, String s); static String subStringAfterLast(String str, String s); static String leftPad(String str, int size, String padStr); static String whiteSpacesToSingleSpace(String str); static String eliminateWhiteSpaces(String str); static String[] separateGrams(String word, int gramSize); static final String EMPTY_STRING; static final String[] EMPTY_STRING_ARRAY; }### Answer:
@Test public void testSubstringUntilLast() { assertEquals(subStringUntilLast("hello", "el"), "h"); assertEquals(subStringUntilLast("hellohello", "el"), "helloh"); assertEquals(subStringUntilLast("hello", "hello"), ""); assertEquals(subStringUntilLast("hello", ""), "hello"); assertEquals(subStringUntilLast("hello", null), "hello"); assertEquals(subStringUntilLast("", "el"), ""); assertEquals(subStringUntilLast(null, "el"), null); } |
### Question:
Strings { public static String[] separateGrams(String word, int gramSize) { if (gramSize < 1) { throw new IllegalArgumentException("Gram size cannot be smaller than 1"); } if (gramSize > word.length()) { return EMPTY_STRING_ARRAY; } String[] grams = new String[word.length() - gramSize + 1]; for (int i = 0; i <= word.length() - gramSize; i++) { grams[i] = word.substring(i, i + gramSize); } return grams; } private Strings(); static boolean isNullOrEmpty(String str); static boolean hasText(String s); static boolean allHasText(String... strings); static boolean allNullOrEmpty(String... strings); static String leftTrim(String s); static String rightTrim(String str); static boolean containsNone(String str, String invalidCharsStr); static boolean containsOnly(String str, String allowedChars); static String repeat(char c, int count); static String repeat(String str, int count); static String reverse(String str); static String insertFromLeft(String str, int interval, String stringToInsert); static String insertFromRight(String str, int interval, String stringToInsert); static String rightPad(String str, int size); static String rightPad(String str, int size, char padChar); static String rightPad(String str, int size, String padStr); static String leftPad(String str, int size); static String leftPad(String str, int size, char padChar); static String subStringUntilFirst(String str, String s); static String subStringUntilLast(String str, String s); static String subStringAfterFirst(String str, String s); static String subStringAfterLast(String str, String s); static String leftPad(String str, int size, String padStr); static String whiteSpacesToSingleSpace(String str); static String eliminateWhiteSpaces(String str); static String[] separateGrams(String word, int gramSize); static final String EMPTY_STRING; static final String[] EMPTY_STRING_ARRAY; }### Answer:
@Test public void testGrams() { assertArrayEquals(separateGrams("hello", 1), new String[]{"h", "e", "l", "l", "o"}); assertArrayEquals(separateGrams("hello", 2), new String[]{"he", "el", "ll", "lo"}); assertArrayEquals(separateGrams("hello", 3), new String[]{"hel", "ell", "llo"}); assertArrayEquals(separateGrams("hello", 4), new String[]{"hell", "ello"}); assertArrayEquals(separateGrams("hello", 5), new String[]{"hello"}); assertArrayEquals(separateGrams("hello", 6), EMPTY_STRING_ARRAY); }
@Test(expected = IllegalArgumentException.class) public void gram0sizeExceptionTest() { separateGrams("123", 0); } |
### Question:
Bytes { public static int normalize(int i, int bitCount) { int max = 0xffffffff >>> (32 - bitCount); if (i > max) { throw new IllegalArgumentException("The integer cannot fit to bit boundaries."); } if (i > (max >>> 1)) { return i - (max + 1); } else { return i; } } static byte[] toByteArray(int... uints); static int toInt(byte[] pb, boolean bigEndian); static int normalize(int i, int bitCount); static void normalize(int iarr[], int bitCount); static byte[] toByteArray(int i, int size, boolean isBigEndian); static int toInt(byte b0, byte b1, byte b2, byte b3, boolean bigEndian); static byte[] toByteArray(int i, boolean bigEndian); static byte[] toByteArray(short i, boolean bigEndian); static int[] toIntArray(byte[] ba, int amount, boolean bigEndian); static int[] toIntArray(byte[] ba, final int amount, final int bytePerInteger,
boolean bigEndian); static int[] toReducedBitIntArray(
byte[] ba,
final int amount,
int bytePerInteger,
int bitAmount,
boolean bigEndian); static short[] toShortArray(byte[] ba, int amount, boolean bigEndian); static byte[] toByteArray(short[] sa, int amount, boolean bigEndian); static byte[] toByteArray(int[] ia, int amount, int bytePerInteger, boolean bigEndian); static String toHexWithZeros(byte b); static String toHex(byte b); static String toHex(byte[] bytes); static String toHexWithZeros(byte[] bytes); static void hexDump(OutputStream os, byte[] bytes, int columns); static void hexDump(byte[] bytes, int columns); static final byte[] EMPTY_BYTE_ARRAY; }### Answer:
@Test public void testNormalize() { assertEquals(Bytes.normalize(0xff, 8), -1); assertEquals(Bytes.normalize(0x8000, 16), Short.MIN_VALUE); } |
### Question:
Bytes { public static short[] toShortArray(byte[] ba, int amount, boolean bigEndian) { final int size = determineSize(amount, ba.length, 2); short[] result = new short[size / 2]; int i = 0; for (int j = 0; j < size; j += 2) { if (bigEndian) { result[i++] = (short) (ba[j] << 8 & 0xff00 | ba[j + 1] & 0xff); } else { result[i++] = (short) (ba[j + 1] << 8 & 0xff00 | ba[j] & 0xff); } } return result; } static byte[] toByteArray(int... uints); static int toInt(byte[] pb, boolean bigEndian); static int normalize(int i, int bitCount); static void normalize(int iarr[], int bitCount); static byte[] toByteArray(int i, int size, boolean isBigEndian); static int toInt(byte b0, byte b1, byte b2, byte b3, boolean bigEndian); static byte[] toByteArray(int i, boolean bigEndian); static byte[] toByteArray(short i, boolean bigEndian); static int[] toIntArray(byte[] ba, int amount, boolean bigEndian); static int[] toIntArray(byte[] ba, final int amount, final int bytePerInteger,
boolean bigEndian); static int[] toReducedBitIntArray(
byte[] ba,
final int amount,
int bytePerInteger,
int bitAmount,
boolean bigEndian); static short[] toShortArray(byte[] ba, int amount, boolean bigEndian); static byte[] toByteArray(short[] sa, int amount, boolean bigEndian); static byte[] toByteArray(int[] ia, int amount, int bytePerInteger, boolean bigEndian); static String toHexWithZeros(byte b); static String toHex(byte b); static String toHex(byte[] bytes); static String toHexWithZeros(byte[] bytes); static void hexDump(OutputStream os, byte[] bytes, int columns); static void hexDump(byte[] bytes, int columns); static final byte[] EMPTY_BYTE_ARRAY; }### Answer:
@Test public void testToShort() { byte[] barr = {0x7e, (byte) 0xac, (byte) 0x8a, (byte) 0x93}; short[] sarrBe = {0x7eac, (short) 0x8a93}; short[] sarrLe = {(short) 0xac7e, (short) 0x938a}; Assert.assertArrayEquals(Bytes.toShortArray(barr, barr.length, true), sarrBe); Assert.assertArrayEquals(Bytes.toShortArray(barr, barr.length, false), sarrLe); } |
### Question:
Bytes { public static String toHex(byte b) { return String.format("%x", b); } static byte[] toByteArray(int... uints); static int toInt(byte[] pb, boolean bigEndian); static int normalize(int i, int bitCount); static void normalize(int iarr[], int bitCount); static byte[] toByteArray(int i, int size, boolean isBigEndian); static int toInt(byte b0, byte b1, byte b2, byte b3, boolean bigEndian); static byte[] toByteArray(int i, boolean bigEndian); static byte[] toByteArray(short i, boolean bigEndian); static int[] toIntArray(byte[] ba, int amount, boolean bigEndian); static int[] toIntArray(byte[] ba, final int amount, final int bytePerInteger,
boolean bigEndian); static int[] toReducedBitIntArray(
byte[] ba,
final int amount,
int bytePerInteger,
int bitAmount,
boolean bigEndian); static short[] toShortArray(byte[] ba, int amount, boolean bigEndian); static byte[] toByteArray(short[] sa, int amount, boolean bigEndian); static byte[] toByteArray(int[] ia, int amount, int bytePerInteger, boolean bigEndian); static String toHexWithZeros(byte b); static String toHex(byte b); static String toHex(byte[] bytes); static String toHexWithZeros(byte[] bytes); static void hexDump(OutputStream os, byte[] bytes, int columns); static void hexDump(byte[] bytes, int columns); static final byte[] EMPTY_BYTE_ARRAY; }### Answer:
@Test public void toHextTest() { assertEquals(toHex((byte) 0), "0"); assertEquals(toHex((byte) 1), "1"); assertEquals(toHex((byte) 15), "f"); assertEquals(toHex((byte) 127), "7f"); assertEquals(toHex((byte) 0xcc), "cc"); assertEquals(toHex(new byte[]{(byte) 0x01}), "1"); assertEquals(toHex(new byte[]{(byte) 0xcc}), "cc"); assertEquals(toHex(new byte[]{0x00, 0x00}), "0"); assertEquals(toHex(new byte[]{0x01, 0x1f, (byte) 0xcc}), "11fcc"); assertEquals(toHex(new byte[]{0x01, 0x1f, 0x00}), "11f00"); assertEquals(toHex(new byte[]{0x00, 0x01, 0x1f, 0x01, 0x00, 0x00}), "11f010000"); }
@Test(expected = NullPointerException.class) public void toHexExceptionTest() { toHex(null); } |
### Question:
Bytes { public static String toHexWithZeros(byte b) { if (b == 0) { return "00"; } String s = toHex(b); if (s.length() == 1) { return "0" + s; } else { return s; } } static byte[] toByteArray(int... uints); static int toInt(byte[] pb, boolean bigEndian); static int normalize(int i, int bitCount); static void normalize(int iarr[], int bitCount); static byte[] toByteArray(int i, int size, boolean isBigEndian); static int toInt(byte b0, byte b1, byte b2, byte b3, boolean bigEndian); static byte[] toByteArray(int i, boolean bigEndian); static byte[] toByteArray(short i, boolean bigEndian); static int[] toIntArray(byte[] ba, int amount, boolean bigEndian); static int[] toIntArray(byte[] ba, final int amount, final int bytePerInteger,
boolean bigEndian); static int[] toReducedBitIntArray(
byte[] ba,
final int amount,
int bytePerInteger,
int bitAmount,
boolean bigEndian); static short[] toShortArray(byte[] ba, int amount, boolean bigEndian); static byte[] toByteArray(short[] sa, int amount, boolean bigEndian); static byte[] toByteArray(int[] ia, int amount, int bytePerInteger, boolean bigEndian); static String toHexWithZeros(byte b); static String toHex(byte b); static String toHex(byte[] bytes); static String toHexWithZeros(byte[] bytes); static void hexDump(OutputStream os, byte[] bytes, int columns); static void hexDump(byte[] bytes, int columns); static final byte[] EMPTY_BYTE_ARRAY; }### Answer:
@Test public void toHexWithZerostWithZerosTest() { assertEquals(toHexWithZeros((byte) 0), "00"); assertEquals(toHexWithZeros((byte) 1), "01"); assertEquals(toHexWithZeros((byte) 15), "0f"); assertEquals(toHexWithZeros((byte) 127), "7f"); assertEquals(toHexWithZeros((byte) 0xcc), "cc"); assertEquals(toHexWithZeros(new byte[]{(byte) 0x01}), "01"); assertEquals(toHexWithZeros(new byte[]{(byte) 0xcc}), "cc"); assertEquals(toHexWithZeros(new byte[]{0x00, 0x00}), "0000"); assertEquals(toHexWithZeros(new byte[]{0x01, 0x1f, (byte) 0xcc}), "011fcc"); assertEquals(toHexWithZeros(new byte[]{0x01, 0x1f, 0x00}), "011f00"); assertEquals(toHexWithZeros(new byte[]{0x00, 0x01, 0x1f, 0x01, 0x00, 0x00}), "00011f010000"); }
@Test(expected = NullPointerException.class) public void toHexWithZerosExceptionTest() { toHexWithZeros(null); } |
### Question:
Bytes { public static void hexDump(OutputStream os, byte[] bytes, int columns) throws IOException { Dumper.hexDump(new ByteArrayInputStream(bytes, 0, bytes.length), os, columns, bytes.length); } static byte[] toByteArray(int... uints); static int toInt(byte[] pb, boolean bigEndian); static int normalize(int i, int bitCount); static void normalize(int iarr[], int bitCount); static byte[] toByteArray(int i, int size, boolean isBigEndian); static int toInt(byte b0, byte b1, byte b2, byte b3, boolean bigEndian); static byte[] toByteArray(int i, boolean bigEndian); static byte[] toByteArray(short i, boolean bigEndian); static int[] toIntArray(byte[] ba, int amount, boolean bigEndian); static int[] toIntArray(byte[] ba, final int amount, final int bytePerInteger,
boolean bigEndian); static int[] toReducedBitIntArray(
byte[] ba,
final int amount,
int bytePerInteger,
int bitAmount,
boolean bigEndian); static short[] toShortArray(byte[] ba, int amount, boolean bigEndian); static byte[] toByteArray(short[] sa, int amount, boolean bigEndian); static byte[] toByteArray(int[] ia, int amount, int bytePerInteger, boolean bigEndian); static String toHexWithZeros(byte b); static String toHex(byte b); static String toHex(byte[] bytes); static String toHexWithZeros(byte[] bytes); static void hexDump(OutputStream os, byte[] bytes, int columns); static void hexDump(byte[] bytes, int columns); static final byte[] EMPTY_BYTE_ARRAY; }### Answer:
@Test @Ignore(value = "Not a test") public void dump() throws IOException { Bytes.hexDump(new byte[]{0x01}, 20); } |
### Question:
SimpleTextReader implements AutoCloseable { public String asString() throws IOException { String res = IOs.readAsString(getReader()); if (trim) { return res.trim(); } else { return res; } } SimpleTextReader(InputStream is, Template template); SimpleTextReader(File file); SimpleTextReader(File file, String encoding); SimpleTextReader(String fileName); SimpleTextReader(String fileName, String encoding); SimpleTextReader(InputStream is); SimpleTextReader(InputStream is, String encoding); static SimpleTextReader trimmingUTF8Reader(File file); static LineIterator trimmingUTF8LineIterator(File file); static IterableLineReader trimmingUTF8IterableLineReader(File file); static SimpleTextReader trimmingReader(InputStream is, String encoding); static LineIterator trimmingLineIterator(InputStream is, String encoding); static IterableLineReader trimmingIterableLineReader(InputStream is, String encoding); String getEncoding(); SimpleTextReader cloneForStream(InputStream is); SimpleTextReader cloneForFile(File file); byte[] asByteArray(); String asString(); List<String> asStringList(); IterableLineReader getIterableReader(); LineIterator getLineIterator(); long countLines(); void close(); }### Answer:
@Test public void testUtf8() throws IOException { String content = new SimpleTextReader(utf8_tr_with_bom.getFile(), "utf-8").asString(); assertEquals(content, "\u015fey"); }
@Test public void asStringTest() throws IOException { String a = new SimpleTextReader(multi_line_text_file.getFile()).asString(); System.out.println(a); } |
### Question:
SimpleTextReader implements AutoCloseable { public List<String> asStringList() throws IOException { return IOs.readAsStringList(getReader(), trim, filters.toArray(new Filter[0])); } SimpleTextReader(InputStream is, Template template); SimpleTextReader(File file); SimpleTextReader(File file, String encoding); SimpleTextReader(String fileName); SimpleTextReader(String fileName, String encoding); SimpleTextReader(InputStream is); SimpleTextReader(InputStream is, String encoding); static SimpleTextReader trimmingUTF8Reader(File file); static LineIterator trimmingUTF8LineIterator(File file); static IterableLineReader trimmingUTF8IterableLineReader(File file); static SimpleTextReader trimmingReader(InputStream is, String encoding); static LineIterator trimmingLineIterator(InputStream is, String encoding); static IterableLineReader trimmingIterableLineReader(InputStream is, String encoding); String getEncoding(); SimpleTextReader cloneForStream(InputStream is); SimpleTextReader cloneForFile(File file); byte[] asByteArray(); String asString(); List<String> asStringList(); IterableLineReader getIterableReader(); LineIterator getLineIterator(); long countLines(); void close(); }### Answer:
@Test public void multilineTest() throws IOException { List<String> list = new SimpleTextReader(multi_line_text_file.getFile()).asStringList(); assertEquals(list.size(), 17); assertEquals(list.get(1), "uno"); assertEquals(list.get(2), " dos"); }
@Test public void multilineConstarintTest() throws IOException { List<String> list = new SimpleTextReader.Builder(multi_line_text_file.getFile()) .allowMatchingRegexp("^[^#]") .ignoreWhiteSpaceLines() .trim() .build() .asStringList(); assertEquals(list.size(), 12); assertEquals(list.get(0), "uno"); assertEquals(list.get(1), "dos"); } |
### Question:
SimpleTextReader implements AutoCloseable { public IterableLineReader getIterableReader() throws IOException { return new IterableLineReader(getReader(), trim, filters); } SimpleTextReader(InputStream is, Template template); SimpleTextReader(File file); SimpleTextReader(File file, String encoding); SimpleTextReader(String fileName); SimpleTextReader(String fileName, String encoding); SimpleTextReader(InputStream is); SimpleTextReader(InputStream is, String encoding); static SimpleTextReader trimmingUTF8Reader(File file); static LineIterator trimmingUTF8LineIterator(File file); static IterableLineReader trimmingUTF8IterableLineReader(File file); static SimpleTextReader trimmingReader(InputStream is, String encoding); static LineIterator trimmingLineIterator(InputStream is, String encoding); static IterableLineReader trimmingIterableLineReader(InputStream is, String encoding); String getEncoding(); SimpleTextReader cloneForStream(InputStream is); SimpleTextReader cloneForFile(File file); byte[] asByteArray(); String asString(); List<String> asStringList(); IterableLineReader getIterableReader(); LineIterator getLineIterator(); long countLines(); void close(); }### Answer:
@Test public void iterableTest() throws IOException { int i = 0; for (String s : new SimpleTextReader(multi_line_text_file.getFile()).getIterableReader()) { if (i == 1) { assertEquals(s.trim(), "uno"); } if (i == 2) { assertEquals(s.trim(), "dos"); } if (i == 3) { assertEquals(s.trim(), "tres"); } i++; } assertEquals(i, 17); } |
### Question:
Hash implements Comparable<Hash> { @Override public int compareTo(Hash o) { if (bytes.length != o.bytes.length) { return bytes.length - o.bytes.length; } BigInteger a = new BigInteger(1, bytes); BigInteger b = new BigInteger(1, o.bytes); return a.compareTo(b); } Hash(byte[] bytes); byte[] getBytes(); String getBytesAsString(); static Hash fromString(String str); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); @Override int compareTo(Hash o); static Hash hash(Object input, HashAlgorithm alg); static Hash hash160(byte[] bytes); static Hash hash256(byte[] bytes); static Hash sha256(byte[] bytes); static Hash ripemd160(byte[] bytes); static Hash sha1(byte[] bytes); static Hash hash160(Hash obj); static Hash hash256(Hash obj); static Hash ripemd160(Hash obj); static Hash sha256(Hash obj); static Hash sha1(Hash obj); static Hash hash160(String obj); static Hash hash256(String obj); static Hash ripemd160(String obj); static Hash sha256(String obj); static Hash sha1(String obj); static Hash hash160(Boolean obj); static Hash hash256(Boolean obj); static Hash ripemd160(Boolean obj); static Hash sha256(Boolean obj); static Hash sha1(Boolean obj); static Hash hash160(Number obj); static Hash hash256(Number obj); static Hash ripemd160(Number obj); static Hash sha256(Number obj); static Hash sha1(Number obj); }### Answer:
@Test public void testCompareTo() { Hash a = Hash.fromString("000000"); Hash b = Hash.fromString("000123"); assertTrue(a.compareTo(b) < 0); assertTrue(b.compareTo(a) > 0); } |
### Question:
ECKeyStore { public void changePassword(char[] password) throws KeyStoreException { try { for (String alias : Collections.list(ks.aliases())) { Entry entry = ks.getEntry(alias, new PasswordProtection(this.password)); ks.setEntry(alias, entry, new PasswordProtection(password)); } Arrays.fill(this.password, '0'); this.password = Arrays.copyOf(password, password.length); } catch (NoSuchAlgorithmException | UnrecoverableEntryException e) { throw new KeyStoreException(e); } } ECKeyStore(); ECKeyStore(char[] password); ECKeyStore(InputStream input, char[] password); static String getUniqueID(PrivateKey key); String addKey(PrivateKey key); PrivateKey getKey(String keyID); boolean containsKey(String keyID); void store(File ksFile); void changePassword(char[] password); }### Answer:
@Test public void changePassword() throws KeyStoreException { ECKeyStore ks = new ECKeyStore(); PrivateKey k1 = PrivateKey.fresh(NetworkType.TESTNET); String alias1 = ks.addKey(k1); ks.changePassword("test".toCharArray()); PrivateKey k2 = ks.getKey(ECKeyStore.getUniqueID(k1)); assertTrue(ks.containsKey(alias1)); assertArrayEquals(k1.getBytes(), k2.getBytes()); assertEquals(k1.getNetworkType(), k2.getNetworkType()); } |
### Question:
MemoryMetricsCollector extends SystemMetricsCollector<MemoryMetrics> { @Override @ThreadSafe(enableChecks = false) public synchronized boolean getSnapshot(MemoryMetrics snapshot) { checkNotNull(snapshot, "Null value passed to getSnapshot!"); if (!mIsEnabled) { return false; } snapshot.sequenceNumber = mCounter.incrementAndGet(); snapshot.javaHeapMaxSizeKb = getRuntimeMaxMemory() / KB; snapshot.javaHeapAllocatedKb = (getRuntimeTotalMemory() - getRuntimeFreeMemory()) / KB; snapshot.nativeHeapSizeKb = Debug.getNativeHeapSize() / KB; snapshot.nativeHeapAllocatedKb = Debug.getNativeHeapAllocatedSize() / KB; snapshot.vmSizeKb = -1; snapshot.vmRssKb = -1; try { ProcFileReader reader = mProcFileReader.get(); if (reader == null) { reader = new ProcFileReader(getPath()); mProcFileReader.set(reader); } reader.reset(); if (reader.isValid()) { snapshot.vmSizeKb = readField(reader); snapshot.vmRssKb = readField(reader); } } catch (ProcFileReader.ParseException pe) { SystemMetricsLogger.wtf(TAG, "Unable to parse memory (statm) field", pe); } return true; } @Override @ThreadSafe(enableChecks = false) synchronized boolean getSnapshot(MemoryMetrics snapshot); synchronized void enable(); @Override MemoryMetrics createMetrics(); }### Answer:
@Test public void testBrokenFile() throws Exception { MemoryMetricsCollectorWithProcFile collector = new MemoryMetricsCollectorWithProcFile() .setPath(createFile("I am a weird android manufacturer")); MemoryMetrics snapshot = new MemoryMetrics(); collector.getSnapshot(snapshot); assertThat(collector.getSnapshot(snapshot)).isTrue(); assertThat(snapshot.vmSizeKb).isEqualTo(-1); assertThat(snapshot.vmRssKb).isEqualTo(-1); }
@Test public void testVirtualMemory() throws Exception { String statm = "4 2 0 4 0 0 0"; MemoryMetricsCollectorWithProcFile collector = new MemoryMetricsCollectorWithProcFile().setPath(createFile(statm)); MemoryMetrics snapshot = new MemoryMetrics(); assertThat(collector.getSnapshot(snapshot)).isTrue(); assertThat(snapshot.vmSizeKb).isEqualTo(16); assertThat(snapshot.vmRssKb).isEqualTo(8); }
@Test public void testDefaultDisabled() { ShadowDebug.setNativeHeapSize(4 * 1024); ShadowDebug.setNativeHeapAllocatedSize(3 * 1024); MemoryMetrics snapshot = new MemoryMetrics(); MemoryMetricsCollector collector = new MemoryMetricsCollector(); collector.getSnapshot(snapshot); assertThat(collector.getSnapshot(snapshot)).isFalse(); assertThat(snapshot.nativeHeapSizeKb).isEqualTo(0); assertThat(snapshot.nativeHeapAllocatedKb).isEqualTo(0); } |
### Question:
WakeLockMetrics extends SystemMetrics<WakeLockMetrics> { @Override public WakeLockMetrics set(WakeLockMetrics b) { heldTimeMs = b.heldTimeMs; acquiredCount = b.acquiredCount; if (b.isAttributionEnabled && isAttributionEnabled) { tagTimeMs.clear(); tagTimeMs.putAll(b.tagTimeMs); } return this; } WakeLockMetrics(); WakeLockMetrics(boolean isAttributionEnabled); @Override WakeLockMetrics sum(@Nullable WakeLockMetrics b, @Nullable WakeLockMetrics output); @Override WakeLockMetrics diff(@Nullable WakeLockMetrics b, @Nullable WakeLockMetrics output); @Override WakeLockMetrics set(WakeLockMetrics b); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); @Nullable JSONObject attributionToJSONObject(); public boolean isAttributionEnabled; final SimpleArrayMap<String, Long> tagTimeMs; public long heldTimeMs; public long acquiredCount; }### Answer:
@Test public void testSetWithoutAttribution() { WakeLockMetrics metrics = new WakeLockMetrics(); metrics.heldTimeMs = 10l; metrics.acquiredCount = 31; WakeLockMetrics alternate = new WakeLockMetrics(); alternate.set(metrics); assertThat(alternate).isEqualTo(metrics); }
@Test public void testSetWithAttribution() { WakeLockMetrics metrics = new WakeLockMetrics(true); metrics.heldTimeMs = 10l; metrics.acquiredCount = 23; metrics.tagTimeMs.put("TestWakeLock", 10l); WakeLockMetrics alternate = new WakeLockMetrics(true); alternate.set(metrics); assertThat(alternate).isEqualTo(metrics); } |
### Question:
WakeLockMetrics extends SystemMetrics<WakeLockMetrics> { @Override public WakeLockMetrics sum(@Nullable WakeLockMetrics b, @Nullable WakeLockMetrics output) { if (output == null) { output = new WakeLockMetrics(isAttributionEnabled); } if (b == null) { output.set(this); } else { output.heldTimeMs = heldTimeMs + b.heldTimeMs; output.acquiredCount = acquiredCount + b.acquiredCount; if (output.isAttributionEnabled) { output.tagTimeMs.clear(); for (int i = 0, size = tagTimeMs.size(); i < size; i++) { String tag = tagTimeMs.keyAt(i); Long currentTimeMs = b.tagTimeMs.get(tag); output.tagTimeMs.put( tag, tagTimeMs.valueAt(i) + (currentTimeMs == null ? 0 : currentTimeMs)); } for (int i = 0, size = b.tagTimeMs.size(); i < size; i++) { String tag = b.tagTimeMs.keyAt(i); if (tagTimeMs.get(tag) == null) { output.tagTimeMs.put(tag, b.tagTimeMs.valueAt(i)); } } } } return output; } WakeLockMetrics(); WakeLockMetrics(boolean isAttributionEnabled); @Override WakeLockMetrics sum(@Nullable WakeLockMetrics b, @Nullable WakeLockMetrics output); @Override WakeLockMetrics diff(@Nullable WakeLockMetrics b, @Nullable WakeLockMetrics output); @Override WakeLockMetrics set(WakeLockMetrics b); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); @Nullable JSONObject attributionToJSONObject(); public boolean isAttributionEnabled; final SimpleArrayMap<String, Long> tagTimeMs; public long heldTimeMs; public long acquiredCount; }### Answer:
@Test public void testSumWithAttribution() { WakeLockMetrics metricsA = new WakeLockMetrics(true); metricsA.heldTimeMs = 20l; metricsA.acquiredCount = 4; metricsA.tagTimeMs.put("TestWakeLock1", 10l); metricsA.tagTimeMs.put("TestWakeLock3", 10l); WakeLockMetrics metricsB = new WakeLockMetrics(true); metricsB.heldTimeMs = 20l; metricsB.acquiredCount = 5; metricsB.tagTimeMs.put("TestWakeLock2", 10l); metricsB.tagTimeMs.put("TestWakeLock3", 10l); WakeLockMetrics output = new WakeLockMetrics(true); output.tagTimeMs.put("Test", 1L); output.heldTimeMs = 100L; output.acquiredCount = 442; metricsA.sum(metricsB, output); WakeLockMetrics expectedOutput = new WakeLockMetrics(true); expectedOutput.heldTimeMs = 40l; expectedOutput.acquiredCount = 9; expectedOutput.tagTimeMs.put("TestWakeLock1", 10l); expectedOutput.tagTimeMs.put("TestWakeLock2", 10l); expectedOutput.tagTimeMs.put("TestWakeLock3", 20l); assertThat(output).isEqualTo(expectedOutput); } |
### Question:
WakeLockMetrics extends SystemMetrics<WakeLockMetrics> { @Override public WakeLockMetrics diff(@Nullable WakeLockMetrics b, @Nullable WakeLockMetrics output) { if (output == null) { output = new WakeLockMetrics(isAttributionEnabled); } if (b == null) { output.set(this); } else { output.heldTimeMs = heldTimeMs - b.heldTimeMs; output.acquiredCount = acquiredCount - b.acquiredCount; if (output.isAttributionEnabled) { output.tagTimeMs.clear(); for (int i = 0, size = tagTimeMs.size(); i < size; i++) { String tag = tagTimeMs.keyAt(i); Long currentTimeMs = b.tagTimeMs.get(tag); long difference = tagTimeMs.valueAt(i) - (currentTimeMs == null ? 0 : currentTimeMs); if (difference != 0) { output.tagTimeMs.put(tag, difference); } } } } return output; } WakeLockMetrics(); WakeLockMetrics(boolean isAttributionEnabled); @Override WakeLockMetrics sum(@Nullable WakeLockMetrics b, @Nullable WakeLockMetrics output); @Override WakeLockMetrics diff(@Nullable WakeLockMetrics b, @Nullable WakeLockMetrics output); @Override WakeLockMetrics set(WakeLockMetrics b); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); @Nullable JSONObject attributionToJSONObject(); public boolean isAttributionEnabled; final SimpleArrayMap<String, Long> tagTimeMs; public long heldTimeMs; public long acquiredCount; }### Answer:
@Test public void testDiffWithAttribution() { WakeLockMetrics metricsA = new WakeLockMetrics(true); metricsA.heldTimeMs = 25l; metricsA.acquiredCount = 100; metricsA.tagTimeMs.put("TestWakeLock1", 15l); metricsA.tagTimeMs.put("TestWakeLock2", 10l); WakeLockMetrics metricsB = new WakeLockMetrics(true); metricsB.heldTimeMs = 20l; metricsB.acquiredCount = 90; metricsB.tagTimeMs.put("TestWakeLock1", 10l); metricsB.tagTimeMs.put("TestWakeLock2", 10l); WakeLockMetrics output = new WakeLockMetrics(true); output.tagTimeMs.put("Test", 1L); output.acquiredCount = 341; output.heldTimeMs = 100L; metricsA.diff(metricsB, output); WakeLockMetrics expectedOutput = new WakeLockMetrics(true); expectedOutput.acquiredCount = 10; expectedOutput.heldTimeMs = 5l; expectedOutput.tagTimeMs.put("TestWakeLock1", 5l); assertThat(output).isEqualTo(expectedOutput); } |
### Question:
WakeLockMetrics extends SystemMetrics<WakeLockMetrics> { public @Nullable JSONObject attributionToJSONObject() throws JSONException { if (!isAttributionEnabled) { return null; } JSONObject attribution = new JSONObject(); for (int i = 0, size = tagTimeMs.size(); i < size; i++) { long currentTagTimeMs = tagTimeMs.valueAt(i); if (currentTagTimeMs > 0) { attribution.put(tagTimeMs.keyAt(i), currentTagTimeMs); } } return attribution; } WakeLockMetrics(); WakeLockMetrics(boolean isAttributionEnabled); @Override WakeLockMetrics sum(@Nullable WakeLockMetrics b, @Nullable WakeLockMetrics output); @Override WakeLockMetrics diff(@Nullable WakeLockMetrics b, @Nullable WakeLockMetrics output); @Override WakeLockMetrics set(WakeLockMetrics b); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); @Nullable JSONObject attributionToJSONObject(); public boolean isAttributionEnabled; final SimpleArrayMap<String, Long> tagTimeMs; public long heldTimeMs; public long acquiredCount; }### Answer:
@Test public void testAttributionToJSONObject() throws JSONException { WakeLockMetrics metrics = new WakeLockMetrics(); metrics.isAttributionEnabled = true; metrics.acquiredCount = 2; metrics.heldTimeMs = 400; metrics.tagTimeMs.put("Test", 100l); JSONObject attribution = metrics.attributionToJSONObject(); assertThat(attribution.length()).isEqualTo(1); assertThat(attribution.has("Test")).isTrue(); assertThat(attribution.getLong("Test")).isEqualTo(100); } |
### Question:
CompositeMetricsSerializer extends SystemMetricsSerializer<CompositeMetrics> { public <T extends SystemMetrics<T>> CompositeMetricsSerializer addMetricsSerializer( Class<T> metricsClass, SystemMetricsSerializer<T> serializer) { Class<? extends SystemMetrics<?>> existingClass = mDeserializerClasses.get(serializer.getTag()); if (existingClass != null && existingClass != metricsClass) { throw new RuntimeException( "Serializers " + existingClass.getCanonicalName() + " and " + metricsClass.getCanonicalName() + " have a conflicting tag: `" + serializer.getTag() + "`."); } mSerializers.put(metricsClass, serializer); mDeserializers.put(serializer.getTag(), serializer); mDeserializerClasses.put(serializer.getTag(), metricsClass); return this; } CompositeMetricsSerializer addMetricsSerializer(
Class<T> metricsClass, SystemMetricsSerializer<T> serializer); @Override long getTag(); @Override void serializeContents(CompositeMetrics metrics, DataOutput output); @Override boolean deserializeContents(CompositeMetrics metrics, DataInput input); }### Answer:
@Test(expected = RuntimeException.class) public void testMetricsWithTheSameTag() { CompositeMetricsSerializer serializer = new CompositeMetricsSerializer(); serializer.addMetricsSerializer(A.class, new ASerializer()); serializer.addMetricsSerializer(B.class, new BSerializer()); } |
### Question:
SystemMetricsSerializer { public abstract void serializeContents(T metrics, DataOutput output) throws IOException; final void serialize(T metrics, DataOutput output); final boolean deserialize(T metrics, DataInput input); abstract long getTag(); abstract void serializeContents(T metrics, DataOutput output); abstract boolean deserializeContents(T metrics, DataInput input); }### Answer:
@Test public void testSerializeContents() throws Exception { T instance = createInitializedInstance(); ByteArrayOutputStream baos = new ByteArrayOutputStream(); getSerializer().serializeContents(instance, new DataOutputStream(baos)); ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray()); T output = createInstance(); assertThat(getSerializer().deserializeContents(output, new DataInputStream(bais))).isTrue(); assertThat(output).isEqualTo(instance); } |
### Question:
SystemMetricsSerializer { public final boolean deserialize(T metrics, DataInput input) throws IOException { if (input.readShort() != MAGIC || input.readShort() != VERSION || input.readLong() != getTag()) { return false; } return deserializeContents(metrics, input); } final void serialize(T metrics, DataOutput output); final boolean deserialize(T metrics, DataInput input); abstract long getTag(); abstract void serializeContents(T metrics, DataOutput output); abstract boolean deserializeContents(T metrics, DataInput input); }### Answer:
@Test public void testRandomContents() throws Exception { ByteArrayOutputStream baos = new ByteArrayOutputStream(); DataOutputStream daos = new DataOutputStream(baos); daos.writeChars("Random test string that doesn't make any sense"); DataInputStream dis = new DataInputStream(new ByteArrayInputStream(baos.toByteArray())); T output = createInstance(); assertThat(getSerializer().deserialize(output, dis)).isFalse(); } |
### Question:
CompositeMetricsReporter implements SystemMetricsReporter<CompositeMetrics> { public void reportTo(CompositeMetrics metrics, SystemMetricsReporter.Event event) { for (int i = 0; i < mMetricsReporterMap.size(); i++) { Class<? extends SystemMetrics> metricsClass = mMetricsReporterMap.keyAt(i); if (metrics.isValid(metricsClass)) { SystemMetrics systemMetrics = metrics.getMetric(metricsClass); SystemMetricsReporter reporter = mMetricsReporterMap.get(metricsClass); reporter.reportTo(systemMetrics, event); } } } void reportTo(CompositeMetrics metrics, SystemMetricsReporter.Event event); CompositeMetricsReporter addMetricsReporter(
Class<T> metricsClass, SystemMetricsReporter<T> reporter); @Nullable T getReporter(
Class<S> metricsClass); }### Answer:
@Test public void testInvalidMetricsSkipped() { TimeMetrics timeMetrics = new TimeMetrics(); timeMetrics.realtimeMs = 100; timeMetrics.uptimeMs = 10; CompositeMetrics metrics = new CompositeMetrics().putMetric(TimeMetrics.class, timeMetrics); metrics.setIsValid(TimeMetrics.class, false); mReporter.reportTo(metrics, mEvent); assertThat(mEvent.eventMap.size()).isEqualTo(0); }
@Test public void testValidMetricsLogged() { TimeMetrics timeMetrics = new TimeMetrics(); timeMetrics.realtimeMs = 100; timeMetrics.uptimeMs = 10; CompositeMetrics metrics = new CompositeMetrics().putMetric(TimeMetrics.class, timeMetrics); metrics.setIsValid(TimeMetrics.class, true); mReporter.reportTo(metrics, mEvent); assertThat(mEvent.eventMap.size()).isEqualTo(2); } |
### Question:
SensorMetricsCollector extends SystemMetricsCollector<SensorMetrics> { @Override public synchronized boolean getSnapshot(SensorMetrics snapshot) { Utilities.checkNotNull(snapshot, "Null value passed to getSnapshot!"); if (!mEnabled) { return false; } long currentTimeMs = SystemClock.elapsedRealtime(); snapshot.set(mCumulativeMetrics); for (int i = 0, l = mActiveSensors.size(); i < l; i++) { Sensor sensor = mActiveSensors.keyAt(i); SensorData data = mActiveSensors.valueAt(i); if (data.activeCount <= 0) { continue; } long sensorActiveTimeMs = currentTimeMs - data.startTimeMs; double sensorPowerMah = energyConsumedMah(sensor, sensorActiveTimeMs); snapshot.total.activeTimeMs += sensorActiveTimeMs; snapshot.total.powerMah += sensorPowerMah; boolean isWakeupSensor = Util.isWakeupSensor(sensor); if (isWakeupSensor) { snapshot.total.wakeUpTimeMs += sensorActiveTimeMs; } if (snapshot.isAttributionEnabled) { int type = sensor.getType(); SensorMetrics.Consumption consumption = snapshot.sensorConsumption.get(type); if (consumption == null) { consumption = new SensorMetrics.Consumption(); snapshot.sensorConsumption.put(type, consumption); } consumption.activeTimeMs += sensorActiveTimeMs; consumption.powerMah += sensorPowerMah; if (isWakeupSensor) { consumption.wakeUpTimeMs += sensorActiveTimeMs; } } } return true; } @Override int hashCode(); synchronized void disable(); synchronized void register(SensorEventListener listener, Sensor sensor); synchronized void unregister(SensorEventListener listener, @Nullable Sensor sensor); @Override synchronized boolean getSnapshot(SensorMetrics snapshot); @Override SensorMetrics createMetrics(); }### Answer:
@Test public void test_blank() { collector.getSnapshot(metrics); assertThat(metrics.total.activeTimeMs).isEqualTo(0); assertThat(metrics.total.powerMah).isEqualTo(0); assertThat(metrics.total.wakeUpTimeMs).isEqualTo(0); } |
### Question:
CameraMetricsReporter implements SystemMetricsReporter<CameraMetrics> { @Override public void reportTo(CameraMetrics metrics, SystemMetricsReporter.Event event) { if (metrics.cameraOpenTimeMs != 0) { event.add(CAMERA_OPEN_TIME_MS, metrics.cameraOpenTimeMs); } if (metrics.cameraPreviewTimeMs != 0) { event.add(CAMERA_PREVIEW_TIME_MS, metrics.cameraPreviewTimeMs); } } @Override void reportTo(CameraMetrics metrics, SystemMetricsReporter.Event event); static final String CAMERA_OPEN_TIME_MS; static final String CAMERA_PREVIEW_TIME_MS; }### Answer:
@Test public void testZeroLogging() { CameraMetrics zeroMetrics = new CameraMetrics(); ReporterEvent event = new ReporterEvent(); mCameraMetricsReporter.reportTo(zeroMetrics, event); assertThat(event.eventMap.isEmpty()).isTrue(); }
@Test public void testNonZeroLogging() { CameraMetrics metrics1 = new CameraMetrics(); metrics1.cameraOpenTimeMs = 0; metrics1.cameraPreviewTimeMs = 200; ReporterEvent event = new ReporterEvent(); mCameraMetricsReporter.reportTo(metrics1, event); assertThat(event.eventMap.get(mCameraMetricsReporter.CAMERA_OPEN_TIME_MS)).isNull(); assertThat(event.eventMap.get(mCameraMetricsReporter.CAMERA_PREVIEW_TIME_MS)).isEqualTo(200L); CameraMetrics metrics2 = new CameraMetrics(); metrics2.cameraOpenTimeMs = 200; metrics2.cameraPreviewTimeMs = 400; mCameraMetricsReporter.reportTo(metrics2, event); assertThat(event.eventMap.get(mCameraMetricsReporter.CAMERA_OPEN_TIME_MS)).isEqualTo(200L); assertThat(event.eventMap.get(mCameraMetricsReporter.CAMERA_PREVIEW_TIME_MS)).isEqualTo(400L); } |
### Question:
CpuFrequencyMetricsReporter implements SystemMetricsReporter<CpuFrequencyMetrics> { @Override public void reportTo(CpuFrequencyMetrics metrics, SystemMetricsReporter.Event event) { JSONObject output = metrics.toJSONObject(); if (output != null && output.length() != 0) { event.add(CPU_TIME_IN_STATE_S, output.toString()); } } @Override void reportTo(CpuFrequencyMetrics metrics, SystemMetricsReporter.Event event); }### Answer:
@Test public void testZeroLogging() { mReporter.reportTo(mMetrics, mEvent); assertThat(mEvent.eventMap.isEmpty()).isTrue(); } |
### Question:
TrafficStatsNetworkBytesCollector extends NetworkBytesCollector { @Override public synchronized boolean getTotalBytes(long[] bytes) { if (!mIsValid) { return false; } updateTotalBytes(); System.arraycopy(mTotalBytes, 0, bytes, 0, bytes.length); return true; } TrafficStatsNetworkBytesCollector(Context context); @Override boolean supportsBgDistinction(); @Override synchronized boolean getTotalBytes(long[] bytes); }### Answer:
@Test public void testEmpty() throws Exception { TrafficStatsNetworkBytesCollector collector = new TrafficStatsNetworkBytesCollector(RuntimeEnvironment.application); collector.getTotalBytes(mBytes); assertThat(mBytes).isEqualTo(new long[8]); }
@Test public void testInitialValues() throws Exception { ShadowTrafficStats.setUidRxBytes(10000); ShadowTrafficStats.setUidTxBytes(20000); TrafficStatsNetworkBytesCollector collector = new TrafficStatsNetworkBytesCollector(RuntimeEnvironment.application); assertThat(collector.getTotalBytes(mBytes)).isTrue(); assertThat(mBytes).isEqualTo(new long[] {0, 0, 10000, 20000, 0, 0, 0, 0}); }
@Test public void testUnsupportedValues() throws Exception { ShadowTrafficStats.setUidRxBytes(UNSUPPORTED); ShadowTrafficStats.setUidTxBytes(UNSUPPORTED); TrafficStatsNetworkBytesCollector collector = new TrafficStatsNetworkBytesCollector(RuntimeEnvironment.application); assertThat(collector.getTotalBytes(mBytes)).isFalse(); }
@Test public void testBroadcastNetworkChanges() throws Exception { ShadowTrafficStats.setUidRxBytes(10000); ShadowTrafficStats.setUidTxBytes(20000); TrafficStatsNetworkBytesCollector collector = new TrafficStatsNetworkBytesCollector(RuntimeEnvironment.application); assertThat(collector.getTotalBytes(mBytes)).isTrue(); ShadowTrafficStats.setUidRxBytes(11000); ShadowTrafficStats.setUidTxBytes(22000); ConnectivityManager connectivityManager = (ConnectivityManager) RuntimeEnvironment.application.getSystemService(Context.CONNECTIVITY_SERVICE); ShadowConnectivityManager shadowConnectivityManager = Shadows.shadowOf(connectivityManager); NetworkInfo networkInfo = ShadowNetworkInfo.newInstance(null, ConnectivityManager.TYPE_WIFI, 0, true, true); shadowConnectivityManager.setActiveNetworkInfo(networkInfo); collector.mReceiver.onReceive(null, null); ShadowTrafficStats.setUidRxBytes(11100); ShadowTrafficStats.setUidTxBytes(22200); assertThat(collector.getTotalBytes(mBytes)).isTrue(); assertThat(mBytes[RX | MOBILE]).isEqualTo(11000); assertThat(mBytes[TX | MOBILE]).isEqualTo(22000); assertThat(mBytes[RX | WIFI]).isEqualTo(100); assertThat(mBytes[TX | WIFI]).isEqualTo(200); } |
### Question:
CompositeMetricsCollector extends SystemMetricsCollector<CompositeMetrics> { @Override @ThreadSafe(enableChecks = false) public boolean getSnapshot(CompositeMetrics snapshot) { checkNotNull(snapshot, "Null value passed to getSnapshot!"); boolean result = false; SimpleArrayMap<Class<? extends SystemMetrics>, SystemMetrics> snapshotMetrics = snapshot.getMetrics(); for (int i = 0, size = snapshotMetrics.size(); i < size; i++) { Class<? extends SystemMetrics> metricsClass = snapshotMetrics.keyAt(i); SystemMetricsCollector collector = mMetricsCollectorMap.get(metricsClass); boolean snapshotResult = false; if (collector != null) { SystemMetrics metric = snapshot.getMetric(metricsClass); snapshotResult = collector.getSnapshot(metric); } snapshot.setIsValid(metricsClass, snapshotResult); result |= snapshotResult; } return result; } protected CompositeMetricsCollector(Builder builder); T getMetricsCollector(
Class<S> metricsClass); @Override @ThreadSafe(enableChecks = false) boolean getSnapshot(CompositeMetrics snapshot); @Override CompositeMetrics createMetrics(); }### Answer:
@Test public void testNullSnapshot() { mExpectedException.expect(IllegalArgumentException.class); mCollector.getSnapshot(null); }
@Test public void allSnapshotsSucceed() throws Exception { mACollector.succeeds = true; mACollector.currentValue = 100; mBCollector.succeeds = true; mBCollector.currentValue = 120; assertThat(mCollector.getSnapshot(mMetrics)).isTrue(); assertThat(mMetrics.getMetrics().size()).isEqualTo(2); assertThat(mMetrics.getMetric(A.class).value).isEqualTo(100); assertThat(mMetrics.isValid(A.class)).isEqualTo(true); assertThat(mMetrics.getMetric(B.class).value).isEqualTo(120); assertThat(mMetrics.isValid(B.class)).isEqualTo(true); }
@Test public void partialFailures() throws Exception { mACollector.succeeds = true; mACollector.currentValue = 100; mBCollector.succeeds = false; assertThat(mCollector.getSnapshot(mMetrics)).isTrue(); assertThat(mMetrics.getMetrics().size()).isEqualTo(2); assertThat(mMetrics.getMetric(A.class).value).isEqualTo(100); assertThat(mMetrics.isValid(A.class)).isEqualTo(true); assertThat(mMetrics.isValid(B.class)).isEqualTo(false); }
@Test public void allSnapshotsFail() throws Exception { mACollector.succeeds = false; mBCollector.succeeds = false; assertThat(mCollector.getSnapshot(mMetrics)).isFalse(); assertThat(mMetrics.getMetrics().size()).isEqualTo(2); assertThat(mMetrics.isValid(A.class)).isEqualTo(false); assertThat(mMetrics.isValid(B.class)).isEqualTo(false); }
@Test public void subsetSnapshots() throws Exception { mACollector.currentValue = 100; mACollector.succeeds = true; CompositeMetrics m = new CompositeMetrics().putMetric(A.class, new A()); mCollector.getSnapshot(m); assertThat(mCollector.getSnapshot(m)).isTrue(); assertThat(m.getMetrics().size()).isEqualTo(1); assertThat(m.getMetric(A.class).value).isEqualTo(100); assertThat(m.isValid(A.class)).isEqualTo(true); assertThat(m.getMetric(B.class)).isNull(); }
@Test public void supersetSnapshots() throws Exception { mACollector.currentValue = 100; mACollector.succeeds = true; CompositeMetrics m = new CompositeMetrics().putMetric(A.class, new A()).putMetric(C.class, new C()); mCollector.getSnapshot(m); assertThat(mCollector.getSnapshot(m)).isTrue(); assertThat(m.getMetrics().size()).isEqualTo(2); assertThat(m.getMetric(A.class).value).isEqualTo(100); assertThat(m.isValid(A.class)).isEqualTo(true); assertThat(m.getMetric(B.class)).isNull(); assertThat(m.isValid(C.class)).isFalse(); } |
### Question:
MemoryMetrics extends SystemMetrics<MemoryMetrics> { public MemoryMetrics sum(@Nullable MemoryMetrics b, @Nullable MemoryMetrics output) { if (output == null) { output = new MemoryMetrics(); } if (b == null) { output.set(this); } else { MemoryMetrics latest = sequenceNumber > b.sequenceNumber ? this : b; output.sequenceNumber = latest.sequenceNumber; output.javaHeapMaxSizeKb = latest.javaHeapMaxSizeKb; output.javaHeapAllocatedKb = latest.javaHeapAllocatedKb; output.nativeHeapSizeKb = latest.nativeHeapSizeKb; output.nativeHeapAllocatedKb = latest.nativeHeapAllocatedKb; output.vmSizeKb = latest.vmSizeKb; output.vmRssKb = latest.vmRssKb; } return output; } MemoryMetrics(); @Override MemoryMetrics set(MemoryMetrics metrics); MemoryMetrics sum(@Nullable MemoryMetrics b, @Nullable MemoryMetrics output); @Override MemoryMetrics diff(@Nullable MemoryMetrics b, @Nullable MemoryMetrics output); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); public long sequenceNumber; public long javaHeapMaxSizeKb; public long javaHeapAllocatedKb; public long nativeHeapSizeKb; public long nativeHeapAllocatedKb; public long vmSizeKb; public long vmRssKb; }### Answer:
@Override @Test public void testSum() throws Exception { MemoryMetrics a = createMemoryMetrics(1); MemoryMetrics b = createMemoryMetrics(2); MemoryMetrics sum = new MemoryMetrics(); MemoryMetricsCollector collector = new MemoryMetricsCollector(); collector.enable(); collector.getSnapshot(a); collector.getSnapshot(b); sum = b.sum(a, sum); assertThat(sum.sequenceNumber).isEqualTo(b.sequenceNumber); assertThat(sum.javaHeapMaxSizeKb).isEqualTo(b.javaHeapMaxSizeKb); assertThat(sum.javaHeapAllocatedKb).isEqualTo(b.javaHeapAllocatedKb); assertThat(sum.nativeHeapSizeKb).isEqualTo(b.nativeHeapSizeKb); assertThat(sum.nativeHeapAllocatedKb).isEqualTo(b.nativeHeapAllocatedKb); assertThat(sum.vmSizeKb).isEqualTo(b.vmSizeKb); assertThat(sum.vmRssKb).isEqualTo(b.vmRssKb); sum = a.sum(b, null); assertThat(sum.sequenceNumber).isEqualTo(b.sequenceNumber); assertThat(sum.javaHeapMaxSizeKb).isEqualTo(b.javaHeapMaxSizeKb); assertThat(sum.javaHeapAllocatedKb).isEqualTo(b.javaHeapAllocatedKb); assertThat(sum.nativeHeapSizeKb).isEqualTo(b.nativeHeapSizeKb); assertThat(sum.nativeHeapAllocatedKb).isEqualTo(b.nativeHeapAllocatedKb); assertThat(sum.vmSizeKb).isEqualTo(b.vmSizeKb); assertThat(sum.vmRssKb).isEqualTo(b.vmRssKb); } |
### Question:
AppWakeupMetrics extends SystemMetrics<AppWakeupMetrics> { @Override public AppWakeupMetrics sum(@Nullable AppWakeupMetrics b, @Nullable AppWakeupMetrics output) { if (output == null) { output = new AppWakeupMetrics(); } if (b == null) { output.set(this); } else { output.appWakeups.clear(); for (int i = 0; i < appWakeups.size(); i++) { String tag = appWakeups.keyAt(i); output.appWakeups.put(tag, new WakeupDetails(appWakeups.valueAt(i).reason)); appWakeups.valueAt(i).sum(b.appWakeups.get(tag), output.appWakeups.get(tag)); } for (int i = 0; i < b.appWakeups.size(); i++) { String tag = b.appWakeups.keyAt(i); if (!output.appWakeups.containsKey(tag)) { output.appWakeups.put(tag, b.appWakeups.valueAt(i)); } } } return output; } @Override AppWakeupMetrics set(AppWakeupMetrics metrics); @Override AppWakeupMetrics sum(@Nullable AppWakeupMetrics b, @Nullable AppWakeupMetrics output); @Override AppWakeupMetrics diff(@Nullable AppWakeupMetrics b, @Nullable AppWakeupMetrics output); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); JSONArray toJSON(); public SimpleArrayMap<String, WakeupDetails> appWakeups; }### Answer:
@Test @Override public void testSum() throws Exception { AppWakeupMetrics a = getAppWakeupMetrics(4, 0); AppWakeupMetrics b = getAppWakeupMetrics(7, 10); AppWakeupMetrics output = new AppWakeupMetrics(); a.sum(b, output); assertThat(output.appWakeups.size()).isEqualTo(7); verifyKeyAndReason(output.appWakeups); verifyWakeupDetails(output.appWakeups.valueAt(0), 10, 12); verifyWakeupDetails(output.appWakeups.valueAt(1), 12, 14); verifyWakeupDetails(output.appWakeups.valueAt(2), 14, 16); verifyWakeupDetails(output.appWakeups.valueAt(3), 16, 18); verifyWakeupDetails(output.appWakeups.valueAt(4), 14, 15); verifyWakeupDetails(output.appWakeups.valueAt(5), 15, 16); verifyWakeupDetails(output.appWakeups.valueAt(6), 16, 17); } |
### Question:
AppWakeupMetrics extends SystemMetrics<AppWakeupMetrics> { @Override public AppWakeupMetrics diff(@Nullable AppWakeupMetrics b, @Nullable AppWakeupMetrics output) { if (output == null) { output = new AppWakeupMetrics(); } if (b == null) { output.set(this); } else { output.appWakeups.clear(); for (int i = 0; i < appWakeups.size(); i++) { String tag = appWakeups.keyAt(i); output.appWakeups.put(tag, new WakeupDetails(appWakeups.valueAt(i).reason)); appWakeups.valueAt(i).diff(b.appWakeups.get(tag), output.appWakeups.get(tag)); } } return output; } @Override AppWakeupMetrics set(AppWakeupMetrics metrics); @Override AppWakeupMetrics sum(@Nullable AppWakeupMetrics b, @Nullable AppWakeupMetrics output); @Override AppWakeupMetrics diff(@Nullable AppWakeupMetrics b, @Nullable AppWakeupMetrics output); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); JSONArray toJSON(); public SimpleArrayMap<String, WakeupDetails> appWakeups; }### Answer:
@Test @Override public void testDiff() throws Exception { AppWakeupMetrics a = getAppWakeupMetrics(7, 5); AppWakeupMetrics b = getAppWakeupMetrics(4, 10); AppWakeupMetrics output = new AppWakeupMetrics(); b.diff(a, output); assertThat(output.appWakeups.size()).isEqualTo(4); verifyKeyAndReason(output.appWakeups); verifyWakeupDetails(output.appWakeups.valueAt(0), 5, 5); verifyWakeupDetails(output.appWakeups.valueAt(1), 5, 5); verifyWakeupDetails(output.appWakeups.valueAt(2), 5, 5); verifyWakeupDetails(output.appWakeups.valueAt(3), 5, 5); } |
### Question:
AppWakeupMetrics extends SystemMetrics<AppWakeupMetrics> { public JSONArray toJSON() throws JSONException { JSONArray jsonArray = new JSONArray(); for (int i = 0; i < appWakeups.size(); i++) { JSONObject obj = new JSONObject(); AppWakeupMetrics.WakeupDetails details = appWakeups.valueAt(i); obj.put("key", appWakeups.keyAt(i)); obj.put("type", details.reason.toString()); obj.put("count", details.count); obj.put("time_ms", details.wakeupTimeMs); jsonArray.put(obj); } return jsonArray; } @Override AppWakeupMetrics set(AppWakeupMetrics metrics); @Override AppWakeupMetrics sum(@Nullable AppWakeupMetrics b, @Nullable AppWakeupMetrics output); @Override AppWakeupMetrics diff(@Nullable AppWakeupMetrics b, @Nullable AppWakeupMetrics output); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); JSONArray toJSON(); public SimpleArrayMap<String, WakeupDetails> appWakeups; }### Answer:
@Test public void testWakeupAttribution() throws JSONException { AppWakeupMetrics metrics = new AppWakeupMetrics(); metrics.appWakeups.put( "wakeup", new AppWakeupMetrics.WakeupDetails(AppWakeupMetrics.WakeupReason.ALARM, 1L, 100L)); JSONArray json = metrics.toJSON(); assertThat(json.length()).isEqualTo(1); JSONObject wakeup = json.getJSONObject(0); assertThat(wakeup.getInt("time_ms")).isEqualTo(100); assertThat(wakeup.getInt("count")).isEqualTo(1); assertThat(wakeup.getString("type")).isEqualTo("ALARM"); assertThat(wakeup.getString("key")).isEqualTo("wakeup"); } |
### Question:
SystemMetricsCollector { public abstract boolean getSnapshot(T snapshot); abstract boolean getSnapshot(T snapshot); abstract T createMetrics(); }### Answer:
@Test public void testNullSnapshot() throws Exception { mExpectedException.expect(IllegalArgumentException.class); T instance = getClazz().newInstance(); instance.getSnapshot(null); } |
### Question:
MemoryMetrics extends SystemMetrics<MemoryMetrics> { @Override public MemoryMetrics diff(@Nullable MemoryMetrics b, @Nullable MemoryMetrics output) { if (output == null) { output = new MemoryMetrics(); } if (b == null) { output.set(this); } else { MemoryMetrics latest = sequenceNumber >= b.sequenceNumber ? this : b; output.sequenceNumber = latest.sequenceNumber; output.javaHeapMaxSizeKb = latest.javaHeapMaxSizeKb; output.javaHeapAllocatedKb = latest.javaHeapAllocatedKb; output.nativeHeapSizeKb = latest.nativeHeapSizeKb; output.nativeHeapAllocatedKb = latest.nativeHeapAllocatedKb; output.vmSizeKb = latest.vmSizeKb; output.vmRssKb = latest.vmRssKb; } return output; } MemoryMetrics(); @Override MemoryMetrics set(MemoryMetrics metrics); MemoryMetrics sum(@Nullable MemoryMetrics b, @Nullable MemoryMetrics output); @Override MemoryMetrics diff(@Nullable MemoryMetrics b, @Nullable MemoryMetrics output); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); public long sequenceNumber; public long javaHeapMaxSizeKb; public long javaHeapAllocatedKb; public long nativeHeapSizeKb; public long nativeHeapAllocatedKb; public long vmSizeKb; public long vmRssKb; }### Answer:
@Override @Test public void testDiff() throws Exception { MemoryMetrics a = createMemoryMetrics(1); MemoryMetrics b = createMemoryMetrics(2); MemoryMetrics sum = new MemoryMetrics(); MemoryMetricsCollector collector = new MemoryMetricsCollector(); collector.enable(); collector.getSnapshot(a); collector.getSnapshot(b); sum = b.diff(a, sum); assertThat(sum.sequenceNumber).isEqualTo(b.sequenceNumber); assertThat(sum.javaHeapMaxSizeKb).isEqualTo(b.javaHeapMaxSizeKb); assertThat(sum.javaHeapAllocatedKb).isEqualTo(b.javaHeapAllocatedKb); assertThat(sum.nativeHeapSizeKb).isEqualTo(b.nativeHeapSizeKb); assertThat(sum.nativeHeapAllocatedKb).isEqualTo(b.nativeHeapAllocatedKb); assertThat(sum.vmSizeKb).isEqualTo(b.vmSizeKb); assertThat(sum.vmRssKb).isEqualTo(b.vmRssKb); sum = a.diff(b, null); assertThat(sum.sequenceNumber).isEqualTo(b.sequenceNumber); assertThat(sum.javaHeapMaxSizeKb).isEqualTo(b.javaHeapMaxSizeKb); assertThat(sum.javaHeapAllocatedKb).isEqualTo(b.javaHeapAllocatedKb); assertThat(sum.nativeHeapSizeKb).isEqualTo(b.nativeHeapSizeKb); assertThat(sum.nativeHeapAllocatedKb).isEqualTo(b.nativeHeapAllocatedKb); assertThat(sum.vmSizeKb).isEqualTo(b.vmSizeKb); assertThat(sum.vmRssKb).isEqualTo(b.vmRssKb); } |
### Question:
SystemMetrics implements Serializable { public abstract T set(T b); abstract T sum(@Nullable T b, @Nullable T output); abstract T diff(@Nullable T b, @Nullable T output); abstract T set(T b); T sum(@Nullable T b); T diff(@Nullable T b); }### Answer:
@Test public void testSet() throws Exception { T a = createInitializedInstance(); T empty = createInstance(); empty.set(a); assertThat(empty).isEqualTo(a); } |
### Question:
SystemMetrics implements Serializable { public abstract T sum(@Nullable T b, @Nullable T output); abstract T sum(@Nullable T b, @Nullable T output); abstract T diff(@Nullable T b, @Nullable T output); abstract T set(T b); T sum(@Nullable T b); T diff(@Nullable T b); }### Answer:
@Test public void testSum() throws Exception { T a = createInitializedInstance(); int increment = 1; for (Field field : getClazz().getFields()) { if (MetricsUtil.isNumericField(field)) { field.set(a, 2 * increment); increment += 1; } } T b = createInitializedInstance(); T sum = createInstance(); a.sum(b, sum); increment = 1; for (Field field : getClazz().getFields()) { if (MetricsUtil.isNumericField(field)) { MetricsUtil.testValue(sum, field, 3 * increment); increment += 1; } } } |
### Question:
SystemMetrics implements Serializable { public abstract T diff(@Nullable T b, @Nullable T output); abstract T sum(@Nullable T b, @Nullable T output); abstract T diff(@Nullable T b, @Nullable T output); abstract T set(T b); T sum(@Nullable T b); T diff(@Nullable T b); }### Answer:
@Test public void testDiff() throws Exception { T a = createInitializedInstance(); T b = createInitializedInstance(); T diff = createInitializedInstance(); int index = 1; for (Field field : getClazz().getFields()) { if (MetricsUtil.isNumericField(field)) { field.set(a, 2 * index); index += 1; } } a.diff(b, diff); int increment = 1; for (Field field : getClazz().getFields()) { if (MetricsUtil.isNumericField(field)) { MetricsUtil.testValue(diff, field, increment); increment += 1; } } }
@Test public void testNullOutput() throws Exception { T instanceA = createInitializedInstance(); T instanceB = createInitializedInstance(); T diff = instanceA.diff(instanceB, null); assertThat(diff).isNotNull(); }
@Test public void testNullSubtrahend() throws Exception { T instanceA = createInitializedInstance(); T diff = createInitializedInstance(); instanceA.diff(null, diff); assertThat(instanceA).isEqualTo(diff); } |
### Question:
ProcFileReader { public ProcFileReader reset() { mIsValid = true; if (mFile != null) { try { mFile.seek(0); } catch (IOException ioe) { close(); } } if (mFile == null) { try { mFile = new RandomAccessFile(mPath, "r"); } catch (IOException ioe) { mIsValid = false; close(); } } if (mIsValid) { mPosition = -1; mBufferSize = 0; mChar = 0; mPrev = 0; mRewound = false; } return this; } ProcFileReader(String path); ProcFileReader(String path, int bufferSize); ProcFileReader start(); ProcFileReader reset(); boolean isValid(); boolean hasNext(); boolean hasReachedEOF(); CharBuffer readWord(CharBuffer buffer); long readNumber(); void skipSpaces(); void skipLine(); void skipPast(char skipPast); void close(); }### Answer:
@Test public void testReset() throws Exception { String contents = "notanumber"; String testPath = createFile(contents); ProcFileReader reader = new ProcFileReader(testPath).start(); assertThat(reader.readWord(CharBuffer.allocate(20)).toString()).isEqualTo(contents); assertThat(reader.hasReachedEOF()).isTrue(); reader.reset(); assertThat(reader.readWord(CharBuffer.allocate(20)).toString()).isEqualTo(contents); assertThat(reader.hasReachedEOF()).isTrue(); } |
### Question:
StatefulSystemMetricsCollector { @Nullable public R getLatestDiffAndReset() { if (getLatestDiff() == null) { return null; } R temp = mPrev; mPrev = mCurr; mCurr = temp; return mDiff; } StatefulSystemMetricsCollector(S collector); StatefulSystemMetricsCollector(S collector, R curr, R prev, R diff); S getCollector(); @Nullable R getLatestDiffAndReset(); @Nullable R getLatestDiff(); }### Answer:
@Test public void testGetLatestDiffAndReset() throws Exception { DummyMetricCollector collector = new DummyMetricCollector(); collector.currentValue = 10; StatefulSystemMetricsCollector<DummyMetric, DummyMetricCollector> statefulCollector = new StatefulSystemMetricsCollector<>(collector); assertThat(statefulCollector.getLatestDiffAndReset().value).isEqualTo(0); collector.currentValue = 20; assertThat(statefulCollector.getLatestDiffAndReset().value).isEqualTo(10); assertThat(statefulCollector.getLatestDiffAndReset().value).isEqualTo(0); } |
### Question:
StatefulSystemMetricsCollector { @Nullable public R getLatestDiff() { mIsValid &= mCollector.getSnapshot(this.mCurr); if (!mIsValid) { return null; } mCurr.diff(mPrev, mDiff); return mDiff; } StatefulSystemMetricsCollector(S collector); StatefulSystemMetricsCollector(S collector, R curr, R prev, R diff); S getCollector(); @Nullable R getLatestDiffAndReset(); @Nullable R getLatestDiff(); }### Answer:
@Test public void testCustomBaseSnapshot() throws Exception { DummyMetric metric = new DummyMetric(); metric.value = 0; DummyMetricCollector collector = new DummyMetricCollector(); collector.currentValue = 10; StatefulSystemMetricsCollector<DummyMetric, DummyMetricCollector> withCustomInitialSnapshot = new StatefulSystemMetricsCollector<>( collector, collector.createMetrics(), metric, collector.createMetrics()); StatefulSystemMetricsCollector<DummyMetric, DummyMetricCollector> defaultInitialSnapshot = new StatefulSystemMetricsCollector<>(collector); assertThat(withCustomInitialSnapshot.getLatestDiff().value).isEqualTo(10); assertThat(defaultInitialSnapshot.getLatestDiff().value).isEqualTo(0); }
@Test public void testGetLatestDiff() { DummyMetricCollector collector = new DummyMetricCollector(); collector.currentValue = 10; StatefulSystemMetricsCollector<DummyMetric, DummyMetricCollector> statefulCollector = new StatefulSystemMetricsCollector<>(collector); assertThat(statefulCollector.getLatestDiff().value).isEqualTo(0); collector.currentValue = 20; assertThat(statefulCollector.getLatestDiff().value).isEqualTo(10); collector.currentValue = 30; assertThat(statefulCollector.getLatestDiff().value).isEqualTo(20); } |
### Question:
HealthStatsMetrics extends SystemMetrics<HealthStatsMetrics> { @Override public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; HealthStatsMetrics that = (HealthStatsMetrics) o; if (dataType != null ? !dataType.equals(that.dataType) : that.dataType != null) return false; return Utilities.sparseArrayEquals(measurement, that.measurement) && Utilities.sparseArrayEquals(measurements, that.measurements) && Utilities.sparseArrayEquals(timer, that.timer) && Utilities.sparseArrayEquals(timers, that.timers) && Utilities.sparseArrayEquals(stats, that.stats); } HealthStatsMetrics(); HealthStatsMetrics(HealthStats healthStats); HealthStatsMetrics(HealthStatsMetrics metrics); @Override HealthStatsMetrics sum(
@Nullable HealthStatsMetrics b, @Nullable HealthStatsMetrics output); @Override HealthStatsMetrics diff(
@Nullable HealthStatsMetrics b, @Nullable HealthStatsMetrics output); @Override HealthStatsMetrics set(HealthStatsMetrics b); HealthStatsMetrics set(HealthStats healthStats); @Override String toString(); static String getKeyName(int key); JSONObject toJSONObject(); @Override boolean equals(Object o); @Override int hashCode(); public String dataType; final SparseArray<Long> measurement; final SparseArray<TimerMetrics> timer; final SparseArray<ArrayMap<String, Long>> measurements; final SparseArray<ArrayMap<String, TimerMetrics>> timers; final SparseArray<ArrayMap<String, HealthStatsMetrics>> stats; }### Answer:
@Test public void testEquals() { HealthStatsMetrics metricsA = new HealthStatsMetrics(); HealthStatsMetrics metricsB = new HealthStatsMetrics(); assertThat(metricsA).isEqualTo(metricsB); } |
### Question:
SensorMetrics extends SystemMetrics<SensorMetrics> { @Override public boolean equals(Object o) { if (this == o) { return true; } if (o == null || getClass() != o.getClass()) { return false; } SensorMetrics that = (SensorMetrics) o; return isAttributionEnabled == that.isAttributionEnabled && total.equals(that.total) && Utilities.sparseArrayEquals(sensorConsumption, that.sensorConsumption); } SensorMetrics(); SensorMetrics(boolean isAttributionEnabled); @Override SensorMetrics sum(@Nullable SensorMetrics b, @Nullable SensorMetrics output); @Override SensorMetrics diff(@Nullable SensorMetrics b, @Nullable SensorMetrics output); @Override SensorMetrics set(SensorMetrics b); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); @Nullable JSONObject attributionToJSONObject(); public boolean isAttributionEnabled; final Consumption total; final SparseArray<Consumption> sensorConsumption; }### Answer:
@Test public void testEquals() { assertThat(new SensorMetrics()).isEqualTo(new SensorMetrics()); assertThat(createAttributedMetrics()).isEqualTo(createAttributedMetrics()); } |
### Question:
HealthStatsMetrics extends SystemMetrics<HealthStatsMetrics> { @Override public HealthStatsMetrics set(HealthStatsMetrics b) { dataType = b.dataType; measurement.clear(); for (int i = 0; i < b.measurement.size(); i++) { measurement.append(b.measurement.keyAt(i), b.measurement.valueAt(i)); } timer.clear(); for (int i = 0; i < b.timer.size(); i++) { timer.append(b.timer.keyAt(i), new TimerMetrics(b.timer.valueAt(i))); } measurements.clear(); for (int i = 0; i < b.measurements.size(); i++) { ArrayMap<String, Long> value = new ArrayMap<>(); value.putAll((Map<String, Long>) b.measurements.valueAt(i)); measurements.append(b.measurements.keyAt(i), value); } timers.clear(); for (int i = 0; i < b.timers.size(); i++) { ArrayMap<String, TimerMetrics> bValue = b.timers.valueAt(i); ArrayMap<String, TimerMetrics> value = new ArrayMap<>(); for (int j = 0; j < bValue.size(); j++) { value.put(bValue.keyAt(j), new TimerMetrics(bValue.valueAt(j))); } timers.append(b.timers.keyAt(i), value); } stats.clear(); for (int i = 0; i < b.stats.size(); i++) { ArrayMap<String, HealthStatsMetrics> bValue = b.stats.valueAt(i); ArrayMap<String, HealthStatsMetrics> value = new ArrayMap<>(); for (int j = 0; j < bValue.size(); j++) { value.put(bValue.keyAt(j), new HealthStatsMetrics(bValue.valueAt(j))); } stats.append(b.stats.keyAt(i), value); } return this; } HealthStatsMetrics(); HealthStatsMetrics(HealthStats healthStats); HealthStatsMetrics(HealthStatsMetrics metrics); @Override HealthStatsMetrics sum(
@Nullable HealthStatsMetrics b, @Nullable HealthStatsMetrics output); @Override HealthStatsMetrics diff(
@Nullable HealthStatsMetrics b, @Nullable HealthStatsMetrics output); @Override HealthStatsMetrics set(HealthStatsMetrics b); HealthStatsMetrics set(HealthStats healthStats); @Override String toString(); static String getKeyName(int key); JSONObject toJSONObject(); @Override boolean equals(Object o); @Override int hashCode(); public String dataType; final SparseArray<Long> measurement; final SparseArray<TimerMetrics> timer; final SparseArray<ArrayMap<String, Long>> measurements; final SparseArray<ArrayMap<String, TimerMetrics>> timers; final SparseArray<ArrayMap<String, HealthStatsMetrics>> stats; }### Answer:
@Test public void testSetUninitialized() { HealthStatsMetrics initialized = createTestMetrics(); HealthStatsMetrics uninitialized = new HealthStatsMetrics(); uninitialized.set(initialized); assertThat(uninitialized).isEqualTo(initialized); }
@Test public void testSetInitialized() throws Exception { HealthStatsMetrics initialized = createTestMetrics(); HealthStatsMetrics uninitialized = new HealthStatsMetrics(); initialized.set(uninitialized); assertThat(uninitialized).isEqualTo(initialized); } |
### Question:
HealthStatsMetrics extends SystemMetrics<HealthStatsMetrics> { @VisibleForTesting static <K, V> ArrayMap<K, V> opArrayMaps(int op, ArrayMap<K, V> a, @Nullable ArrayMap<K, V> b) { int aSize = a.size(); ArrayMap<K, V> output = new ArrayMap<>(); for (int i = 0; i < aSize; i++) { K key = a.keyAt(i); V bValue = b == null ? null : b.get(key); output.put(key, bValue == null ? a.valueAt(i) : (V) opValues(op, a.valueAt(i), bValue)); } if (op == OP_SUM) { int bSize = b == null ? 0 : b.size(); for (int i = 0; i < bSize; i++) { K key = b.keyAt(i); if (a.get(key) == null) { output.put(key, b.valueAt(i)); } } } return output; } HealthStatsMetrics(); HealthStatsMetrics(HealthStats healthStats); HealthStatsMetrics(HealthStatsMetrics metrics); @Override HealthStatsMetrics sum(
@Nullable HealthStatsMetrics b, @Nullable HealthStatsMetrics output); @Override HealthStatsMetrics diff(
@Nullable HealthStatsMetrics b, @Nullable HealthStatsMetrics output); @Override HealthStatsMetrics set(HealthStatsMetrics b); HealthStatsMetrics set(HealthStats healthStats); @Override String toString(); static String getKeyName(int key); JSONObject toJSONObject(); @Override boolean equals(Object o); @Override int hashCode(); public String dataType; final SparseArray<Long> measurement; final SparseArray<TimerMetrics> timer; final SparseArray<ArrayMap<String, Long>> measurements; final SparseArray<ArrayMap<String, TimerMetrics>> timers; final SparseArray<ArrayMap<String, HealthStatsMetrics>> stats; }### Answer:
@Test public void testSumArrayMaps() { ArrayMap<String, Long> a = new ArrayMap<>(); a.put("a", 1L); a.put("c", 2L); ArrayMap<String, Long> b = new ArrayMap<>(); b.put("b", 1L); b.put("c", 3L); ArrayMap<String, Long> sum = HealthStatsMetrics.opArrayMaps(OP_SUM, a, b); assertThat(sum.get("a")).isEqualTo(1); assertThat(sum.get("b")).isEqualTo(1); assertThat(sum.get("c")).isEqualTo(5); assertThat(sum.size()).isEqualTo(3); }
@Test public void testDiffArrayMaps() { ArrayMap<String, Long> a = new ArrayMap<>(); a.put("a", 1L); a.put("c", 2L); ArrayMap<String, Long> b = new ArrayMap<>(); b.put("b", 1L); b.put("c", 3L); ArrayMap<String, Long> sum = HealthStatsMetrics.opArrayMaps(OP_DIFF, a, b); assertThat(sum.get("a")).isEqualTo(1); assertThat(sum.get("c")).isEqualTo(-1); assertThat(sum.size()).isEqualTo(2); } |
### Question:
HealthStatsMetrics extends SystemMetrics<HealthStatsMetrics> { @VisibleForTesting static <K> SparseArray<K> op(int op, SparseArray<K> a, SparseArray<K> b, SparseArray<K> output) { output.clear(); for (int i = 0; i < a.size(); i++) { int aKey = a.keyAt(i); output.put(aKey, (K) opValues(op, a.valueAt(i), b.get(aKey))); } if (op == OP_SUM) { for (int i = 0; i < b.size(); i++) { int bKey = b.keyAt(i); if (a.get(bKey) == null) { output.put(bKey, b.valueAt(i)); } } } return output; } HealthStatsMetrics(); HealthStatsMetrics(HealthStats healthStats); HealthStatsMetrics(HealthStatsMetrics metrics); @Override HealthStatsMetrics sum(
@Nullable HealthStatsMetrics b, @Nullable HealthStatsMetrics output); @Override HealthStatsMetrics diff(
@Nullable HealthStatsMetrics b, @Nullable HealthStatsMetrics output); @Override HealthStatsMetrics set(HealthStatsMetrics b); HealthStatsMetrics set(HealthStats healthStats); @Override String toString(); static String getKeyName(int key); JSONObject toJSONObject(); @Override boolean equals(Object o); @Override int hashCode(); public String dataType; final SparseArray<Long> measurement; final SparseArray<TimerMetrics> timer; final SparseArray<ArrayMap<String, Long>> measurements; final SparseArray<ArrayMap<String, TimerMetrics>> timers; final SparseArray<ArrayMap<String, HealthStatsMetrics>> stats; }### Answer:
@Test public void testSumSparseArrays() { SparseArray<Long> a = new SparseArray<>(); a.put(10, 10L); a.put(30, 30L); SparseArray<Long> b = new SparseArray<>(); b.put(10, 10L); b.put(20, 20L); SparseArray<Long> sum = new SparseArray<>(); HealthStatsMetrics.op(OP_SUM, a, b, sum); assertThat(sum.get(10)).isEqualTo(20); assertThat(sum.get(20)).isEqualTo(20); assertThat(sum.get(30)).isEqualTo(30); assertThat(sum.size()).isEqualTo(3); }
@Test public void testDiffSparseArrays() { SparseArray<Long> a = new SparseArray<>(); a.put(10, 10L); a.put(30, 30L); SparseArray<Long> b = new SparseArray<>(); b.put(10, 10L); b.put(20, 20L); SparseArray<Long> sum = new SparseArray<>(); HealthStatsMetrics.op(OP_DIFF, a, b, sum); assertThat(sum.get(10)).isEqualTo(0); assertThat(sum.get(30)).isEqualTo(30); assertThat(sum.size()).isEqualTo(2); } |
### Question:
HealthStatsMetrics extends SystemMetrics<HealthStatsMetrics> { @Override public HealthStatsMetrics sum( @Nullable HealthStatsMetrics b, @Nullable HealthStatsMetrics output) { if (output == null) { output = new HealthStatsMetrics(); } output.dataType = dataType; if (b == null) { output.set(this); } else if (!strEquals(b.dataType, dataType)) { throw new IllegalArgumentException( "Attempting to add different types of HealthStatMetrics: " + dataType + " and " + b.dataType); } else { op(OP_SUM, measurement, b.measurement, output.measurement); op(OP_SUM, measurements, b.measurements, output.measurements); op(OP_SUM, timer, b.timer, output.timer); op(OP_SUM, timers, b.timers, output.timers); op(OP_SUM, stats, b.stats, output.stats); } return output; } HealthStatsMetrics(); HealthStatsMetrics(HealthStats healthStats); HealthStatsMetrics(HealthStatsMetrics metrics); @Override HealthStatsMetrics sum(
@Nullable HealthStatsMetrics b, @Nullable HealthStatsMetrics output); @Override HealthStatsMetrics diff(
@Nullable HealthStatsMetrics b, @Nullable HealthStatsMetrics output); @Override HealthStatsMetrics set(HealthStatsMetrics b); HealthStatsMetrics set(HealthStats healthStats); @Override String toString(); static String getKeyName(int key); JSONObject toJSONObject(); @Override boolean equals(Object o); @Override int hashCode(); public String dataType; final SparseArray<Long> measurement; final SparseArray<TimerMetrics> timer; final SparseArray<ArrayMap<String, Long>> measurements; final SparseArray<ArrayMap<String, TimerMetrics>> timers; final SparseArray<ArrayMap<String, HealthStatsMetrics>> stats; }### Answer:
@Test public void testSum() { HealthStatsMetrics a = createTestMetrics(); HealthStatsMetrics b = createTestMetrics(); HealthStatsMetrics sum = a.sum(b, null); HealthStatsMetrics expectedSum = new HealthStatsMetrics(); expectedSum.dataType = TEST_DATATYPE; expectedSum.measurement.put(123, 2000L); expectedSum.measurements.put(234, new ArrayMap<String, Long>()); expectedSum.measurements.get(234).put("measurements", 4000L); expectedSum.timer.put(345, new HealthStatsMetrics.TimerMetrics(10, 4000)); ArrayMap<String, HealthStatsMetrics.TimerMetrics> timersValues = new ArrayMap<>(); timersValues.put("timers", new HealthStatsMetrics.TimerMetrics(12, 6000)); expectedSum.timers.put(456, timersValues); ArrayMap<String, HealthStatsMetrics> value = new ArrayMap<>(); value.put("stats", new HealthStatsMetrics(expectedSum)); expectedSum.stats.put(1234, value); assertThat(sum).isEqualTo(expectedSum); } |
### Question:
HealthStatsMetrics extends SystemMetrics<HealthStatsMetrics> { @Override public HealthStatsMetrics diff( @Nullable HealthStatsMetrics b, @Nullable HealthStatsMetrics output) { if (output == null) { output = new HealthStatsMetrics(); } output.dataType = dataType; if (b == null || compareSnapshotAge(this, b) < 0 ) { output.set(this); } else if (!strEquals(b.dataType, dataType)) { throw new IllegalArgumentException( "Attempting to subtract different types of HealthStatMetrics: " + dataType + " and " + b.dataType); } else { op(OP_DIFF, measurement, b.measurement, output.measurement); op(OP_DIFF, measurements, b.measurements, output.measurements); op(OP_DIFF, timer, b.timer, output.timer); op(OP_DIFF, timers, b.timers, output.timers); op(OP_DIFF, stats, b.stats, output.stats); } return output; } HealthStatsMetrics(); HealthStatsMetrics(HealthStats healthStats); HealthStatsMetrics(HealthStatsMetrics metrics); @Override HealthStatsMetrics sum(
@Nullable HealthStatsMetrics b, @Nullable HealthStatsMetrics output); @Override HealthStatsMetrics diff(
@Nullable HealthStatsMetrics b, @Nullable HealthStatsMetrics output); @Override HealthStatsMetrics set(HealthStatsMetrics b); HealthStatsMetrics set(HealthStats healthStats); @Override String toString(); static String getKeyName(int key); JSONObject toJSONObject(); @Override boolean equals(Object o); @Override int hashCode(); public String dataType; final SparseArray<Long> measurement; final SparseArray<TimerMetrics> timer; final SparseArray<ArrayMap<String, Long>> measurements; final SparseArray<ArrayMap<String, TimerMetrics>> timers; final SparseArray<ArrayMap<String, HealthStatsMetrics>> stats; }### Answer:
@Test public void testDiff() { HealthStatsMetrics a = createTestMetrics(); HealthStatsMetrics b = createTestMetrics(); HealthStatsMetrics diff = a.diff(b, null); HealthStatsMetrics expectedDiff = new HealthStatsMetrics(); expectedDiff.dataType = TEST_DATATYPE; expectedDiff.measurement.put(123, 0L); expectedDiff.measurements.put(234, new ArrayMap<String, Long>()); expectedDiff.measurements.get(234).put("measurements", 0L); expectedDiff.timer.put(345, new HealthStatsMetrics.TimerMetrics(0, 0)); ArrayMap<String, HealthStatsMetrics.TimerMetrics> timersValues = new ArrayMap<>(); timersValues.put("timers", new HealthStatsMetrics.TimerMetrics(0, 0)); expectedDiff.timers.put(456, timersValues); ArrayMap<String, HealthStatsMetrics> value = new ArrayMap<>(); value.put("stats", new HealthStatsMetrics(expectedDiff)); expectedDiff.stats.put(1234, value); assertThat(diff).isEqualTo(expectedDiff); }
@Test public void testDiffWithReset() { HealthStatsMetrics a = createTestMetrics(); a.measurement.put(UidHealthStats.MEASUREMENT_REALTIME_BATTERY_MS, 100L); HealthStatsMetrics b = createTestMetrics(); b.measurement.put(UidHealthStats.MEASUREMENT_REALTIME_BATTERY_MS, 200L); HealthStatsMetrics output = a.diff(b, null); HealthStatsMetrics expectedOutput = createTestMetrics(); expectedOutput.measurement.put(UidHealthStats.MEASUREMENT_REALTIME_BATTERY_MS, 100L); assertThat(output).isEqualTo(expectedOutput); } |
### Question:
SensorMetrics extends SystemMetrics<SensorMetrics> { @Override public SensorMetrics set(SensorMetrics b) { total.set(b.total); if (isAttributionEnabled && b.isAttributionEnabled) { sensorConsumption.clear(); for (int i = 0, l = b.sensorConsumption.size(); i < l; i++) { sensorConsumption.put(b.sensorConsumption.keyAt(i), b.sensorConsumption.valueAt(i)); } } return this; } SensorMetrics(); SensorMetrics(boolean isAttributionEnabled); @Override SensorMetrics sum(@Nullable SensorMetrics b, @Nullable SensorMetrics output); @Override SensorMetrics diff(@Nullable SensorMetrics b, @Nullable SensorMetrics output); @Override SensorMetrics set(SensorMetrics b); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); @Nullable JSONObject attributionToJSONObject(); public boolean isAttributionEnabled; final Consumption total; final SparseArray<Consumption> sensorConsumption; }### Answer:
@Test public void testSet() { SensorMetrics metrics = new SensorMetrics(true); metrics.set(createAttributedMetrics()); assertThat(metrics).isEqualTo(createAttributedMetrics()); }
@Test public void testUnattributedSet() { SensorMetrics metrics = new SensorMetrics(); metrics.set(createAttributedMetrics()); SensorMetrics comparisonMetrics = createAttributedMetrics(); comparisonMetrics.isAttributionEnabled = false; comparisonMetrics.sensorConsumption.clear(); assertThat(metrics).isEqualTo(comparisonMetrics); } |
### Question:
TimeMetricsCollector extends SystemMetricsCollector<TimeMetrics> { @Override @ThreadSafe(enableChecks = false) public boolean getSnapshot(TimeMetrics snapshot) { checkNotNull(snapshot, "Null value passed to getSnapshot!"); snapshot.realtimeMs = SystemClock.elapsedRealtime(); snapshot.uptimeMs = SystemClock.uptimeMillis(); return true; } @Override @ThreadSafe(enableChecks = false) boolean getSnapshot(TimeMetrics snapshot); @Override TimeMetrics createMetrics(); }### Answer:
@Test public void testTimes() { ShadowSystemClock.setUptimeMillis(1234); ShadowSystemClock.setElapsedRealtime(9876); TimeMetrics snapshot = new TimeMetrics(); TimeMetricsCollector collector = new TimeMetricsCollector(); collector.getSnapshot(snapshot); assertThat(snapshot.uptimeMs).isEqualTo(1234); assertThat(snapshot.realtimeMs).isEqualTo(9876); } |
### Question:
BluetoothMetrics extends SystemMetrics<BluetoothMetrics> { @Override public boolean equals(Object o) { if (this == o) { return true; } if (o == null || getClass() != o.getClass()) { return false; } BluetoothMetrics that = (BluetoothMetrics) o; if (bleScanCount != that.bleScanCount || bleScanDurationMs != that.bleScanDurationMs || bleOpportunisticScanCount != that.bleOpportunisticScanCount || bleOpportunisticScanDurationMs != that.bleOpportunisticScanDurationMs) { return false; } return true; } @Override BluetoothMetrics sum(@Nullable BluetoothMetrics b, @Nullable BluetoothMetrics output); @Override BluetoothMetrics diff(@Nullable BluetoothMetrics b, @Nullable BluetoothMetrics output); @Override BluetoothMetrics set(BluetoothMetrics b); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); public int bleScanCount; public long bleScanDurationMs; public int bleOpportunisticScanCount; public long bleOpportunisticScanDurationMs; }### Answer:
@Test public void testEquals() { BluetoothMetrics metricsA = new BluetoothMetrics(); metricsA.bleScanDurationMs = 1000; metricsA.bleScanCount = 2; metricsA.bleOpportunisticScanDurationMs = 4000; metricsA.bleOpportunisticScanCount = 8; BluetoothMetrics metricsB = new BluetoothMetrics(); metricsB.bleScanDurationMs = 1000; metricsB.bleScanCount = 2; metricsB.bleOpportunisticScanDurationMs = 4000; metricsB.bleOpportunisticScanCount = 8; assertThat(new BluetoothMetrics()).isEqualTo(new BluetoothMetrics()); assertThat(metricsA).isEqualTo(metricsB); } |
### Question:
BluetoothMetrics extends SystemMetrics<BluetoothMetrics> { @Override public BluetoothMetrics set(BluetoothMetrics b) { bleScanCount = b.bleScanCount; bleScanDurationMs = b.bleScanDurationMs; bleOpportunisticScanCount = b.bleOpportunisticScanCount; bleOpportunisticScanDurationMs = b.bleOpportunisticScanDurationMs; return this; } @Override BluetoothMetrics sum(@Nullable BluetoothMetrics b, @Nullable BluetoothMetrics output); @Override BluetoothMetrics diff(@Nullable BluetoothMetrics b, @Nullable BluetoothMetrics output); @Override BluetoothMetrics set(BluetoothMetrics b); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); public int bleScanCount; public long bleScanDurationMs; public int bleOpportunisticScanCount; public long bleOpportunisticScanDurationMs; }### Answer:
@Test public void testSet() { BluetoothMetrics metrics = new BluetoothMetrics(); metrics.bleScanDurationMs = 1000; metrics.bleScanCount = 10; metrics.bleOpportunisticScanDurationMs = 5000; metrics.bleOpportunisticScanCount = 3; BluetoothMetrics alternate = new BluetoothMetrics(); alternate.set(metrics); assertThat(alternate).isEqualTo(metrics); } |
### Question:
BluetoothMetrics extends SystemMetrics<BluetoothMetrics> { @Override public BluetoothMetrics diff(@Nullable BluetoothMetrics b, @Nullable BluetoothMetrics output) { if (output == null) { output = new BluetoothMetrics(); } if (b == null) { output.set(this); } else { output.bleScanCount = bleScanCount - b.bleScanCount; output.bleScanDurationMs = bleScanDurationMs - b.bleScanDurationMs; output.bleOpportunisticScanCount = bleOpportunisticScanCount - b.bleOpportunisticScanCount; output.bleOpportunisticScanDurationMs = bleOpportunisticScanDurationMs - b.bleOpportunisticScanDurationMs; } return output; } @Override BluetoothMetrics sum(@Nullable BluetoothMetrics b, @Nullable BluetoothMetrics output); @Override BluetoothMetrics diff(@Nullable BluetoothMetrics b, @Nullable BluetoothMetrics output); @Override BluetoothMetrics set(BluetoothMetrics b); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); public int bleScanCount; public long bleScanDurationMs; public int bleOpportunisticScanCount; public long bleOpportunisticScanDurationMs; }### Answer:
@Test public void testDiff() { BluetoothMetrics metrics = new BluetoothMetrics(); metrics.bleScanDurationMs = 1000; metrics.bleScanCount = 10; metrics.bleOpportunisticScanDurationMs = 5000; metrics.bleOpportunisticScanCount = 3; BluetoothMetrics olderMetrics = new BluetoothMetrics(); olderMetrics.bleScanDurationMs = 800; olderMetrics.bleScanCount = 7; olderMetrics.bleOpportunisticScanDurationMs = 2000; olderMetrics.bleOpportunisticScanCount = 1; BluetoothMetrics deltaMetrics = new BluetoothMetrics(); deltaMetrics = metrics.diff(olderMetrics, deltaMetrics); assertThat(deltaMetrics.bleScanCount).isEqualTo(3); assertThat(deltaMetrics.bleScanDurationMs).isEqualTo(200); assertThat(deltaMetrics.bleOpportunisticScanCount).isEqualTo(2); assertThat(deltaMetrics.bleOpportunisticScanDurationMs).isEqualTo(3000); } |
### Question:
BluetoothMetrics extends SystemMetrics<BluetoothMetrics> { @Override public BluetoothMetrics sum(@Nullable BluetoothMetrics b, @Nullable BluetoothMetrics output) { if (output == null) { output = new BluetoothMetrics(); } if (b == null) { output.set(this); } else { output.bleScanCount = bleScanCount + b.bleScanCount; output.bleScanDurationMs = bleScanDurationMs + b.bleScanDurationMs; output.bleOpportunisticScanCount = bleOpportunisticScanCount + b.bleOpportunisticScanCount; output.bleOpportunisticScanDurationMs = bleOpportunisticScanDurationMs + b.bleOpportunisticScanDurationMs; } return output; } @Override BluetoothMetrics sum(@Nullable BluetoothMetrics b, @Nullable BluetoothMetrics output); @Override BluetoothMetrics diff(@Nullable BluetoothMetrics b, @Nullable BluetoothMetrics output); @Override BluetoothMetrics set(BluetoothMetrics b); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); public int bleScanCount; public long bleScanDurationMs; public int bleOpportunisticScanCount; public long bleOpportunisticScanDurationMs; }### Answer:
@Test public void testSum() { BluetoothMetrics metricsA = new BluetoothMetrics(); metricsA.bleScanDurationMs = 1000; metricsA.bleScanCount = 10; metricsA.bleOpportunisticScanDurationMs = 4000; metricsA.bleOpportunisticScanCount = 1; BluetoothMetrics metricsB = new BluetoothMetrics(); metricsB.bleScanDurationMs = 2000; metricsB.bleScanCount = 20; metricsB.bleOpportunisticScanDurationMs = 8000; metricsB.bleOpportunisticScanCount = 2; BluetoothMetrics output = new BluetoothMetrics(); metricsA.sum(metricsB, output); assertThat(output.bleScanCount).isEqualTo(30); assertThat(output.bleScanDurationMs).isEqualTo(3000); assertThat(output.bleOpportunisticScanCount).isEqualTo(3); assertThat(output.bleOpportunisticScanDurationMs).isEqualTo(12000); } |
### Question:
CpuFrequencyMetrics extends SystemMetrics<CpuFrequencyMetrics> { @Override public boolean equals(Object o) { if (this == o) { return true; } if (o == null || getClass() != o.getClass()) { return false; } CpuFrequencyMetrics that = (CpuFrequencyMetrics) o; if (timeInStateS.length != that.timeInStateS.length) { return false; } for (int i = 0, size = timeInStateS.length; i < size; i++) { if (!sparseIntArrayEquals(timeInStateS[i], that.timeInStateS[i])) { return false; } } return true; } CpuFrequencyMetrics(); @Override CpuFrequencyMetrics sum(
@Nullable CpuFrequencyMetrics b, @Nullable CpuFrequencyMetrics output); @Override CpuFrequencyMetrics diff(
@Nullable CpuFrequencyMetrics b, @Nullable CpuFrequencyMetrics output); @Override CpuFrequencyMetrics set(CpuFrequencyMetrics b); @Override boolean equals(Object o); static boolean sparseIntArrayEquals(SparseIntArray a, SparseIntArray b); @Override int hashCode(); @Override String toString(); @Nullable JSONObject toJSONObject(); final SparseIntArray[] timeInStateS; }### Answer:
@Test public void testEquals() { CpuFrequencyMetrics metricsA = new CpuFrequencyMetrics(); metricsA.timeInStateS[0].put(200, 2000); metricsA.timeInStateS[0].put(100, 1000); metricsA.timeInStateS[1].put(300, 3000); CpuFrequencyMetrics metricsB = new CpuFrequencyMetrics(); metricsB.timeInStateS[0].put(100, 1000); metricsB.timeInStateS[0].put(200, 2000); metricsB.timeInStateS[1].put(300, 3000); assertThat(metricsA).isEqualTo(metricsB); } |
### Question:
CpuFrequencyMetrics extends SystemMetrics<CpuFrequencyMetrics> { @Override public CpuFrequencyMetrics sum( @Nullable CpuFrequencyMetrics b, @Nullable CpuFrequencyMetrics output) { if (output == null) { output = new CpuFrequencyMetrics(); } if (b == null) { output.set(this); } else { for (int i = 0; i < timeInStateS.length; i++) { SparseIntArray aCore = timeInStateS[i]; SparseIntArray bCore = b.timeInStateS[i]; SparseIntArray outputCore = output.timeInStateS[i]; for (int j = 0; j < aCore.size(); j++) { int frequency = aCore.keyAt(j); outputCore.put(frequency, aCore.valueAt(j) + bCore.get(frequency, 0)); } for (int j = 0; j < bCore.size(); j++) { int frequency = bCore.keyAt(j); if (aCore.indexOfKey(frequency) < 0) { outputCore.put(frequency, bCore.valueAt(j)); } } } } return output; } CpuFrequencyMetrics(); @Override CpuFrequencyMetrics sum(
@Nullable CpuFrequencyMetrics b, @Nullable CpuFrequencyMetrics output); @Override CpuFrequencyMetrics diff(
@Nullable CpuFrequencyMetrics b, @Nullable CpuFrequencyMetrics output); @Override CpuFrequencyMetrics set(CpuFrequencyMetrics b); @Override boolean equals(Object o); static boolean sparseIntArrayEquals(SparseIntArray a, SparseIntArray b); @Override int hashCode(); @Override String toString(); @Nullable JSONObject toJSONObject(); final SparseIntArray[] timeInStateS; }### Answer:
@Test public void testSum() { CpuFrequencyMetrics metricsA = new CpuFrequencyMetrics(); metricsA.timeInStateS[0].put(100, 1); metricsA.timeInStateS[0].put(200, 2); metricsA.timeInStateS[1].put(1000, 1); CpuFrequencyMetrics metricsB = new CpuFrequencyMetrics(); metricsB.timeInStateS[0].put(200, 5); metricsB.timeInStateS[0].put(300, 3); metricsB.timeInStateS[2].put(2000, 2); CpuFrequencyMetrics output = new CpuFrequencyMetrics(); metricsA.sum(metricsB, output); assertThat(output.timeInStateS[0].size()).isEqualTo(3); assertThat(output.timeInStateS[0].get(100)).isEqualTo(1); assertThat(output.timeInStateS[0].get(200)).isEqualTo(7); assertThat(output.timeInStateS[0].get(300)).isEqualTo(3); assertThat(output.timeInStateS[1].size()).isEqualTo(1); assertThat(output.timeInStateS[1].get(1000)).isEqualTo(1); assertThat(output.timeInStateS[2].size()).isEqualTo(1); assertThat(output.timeInStateS[2].get(2000)).isEqualTo(2); assertThat(output.timeInStateS[3].size()).isEqualTo(0); } |
### Question:
SensorMetrics extends SystemMetrics<SensorMetrics> { @Override public SensorMetrics sum(@Nullable SensorMetrics b, @Nullable SensorMetrics output) { if (output == null) { output = new SensorMetrics(isAttributionEnabled); } if (b == null) { output.set(this); } else { total.sum(b.total, output.total); if (output.isAttributionEnabled) { op(+1, sensorConsumption, b.sensorConsumption, output.sensorConsumption); } } return output; } SensorMetrics(); SensorMetrics(boolean isAttributionEnabled); @Override SensorMetrics sum(@Nullable SensorMetrics b, @Nullable SensorMetrics output); @Override SensorMetrics diff(@Nullable SensorMetrics b, @Nullable SensorMetrics output); @Override SensorMetrics set(SensorMetrics b); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); @Nullable JSONObject attributionToJSONObject(); public boolean isAttributionEnabled; final Consumption total; final SparseArray<Consumption> sensorConsumption; }### Answer:
@Test public void testAttributedSum() { SensorMetrics a = createAttributedMetrics(); SensorMetrics b = createAttributedMetrics(); SensorMetrics result = a.sum(b); assertThat(result.total.powerMah).isEqualTo(a.total.powerMah * 2); assertThat(result.total.wakeUpTimeMs).isEqualTo(a.total.wakeUpTimeMs * 2); assertThat(result.total.activeTimeMs).isEqualTo(a.total.activeTimeMs * 2); for (int i = 0, l = result.sensorConsumption.size(); i < l; i++) { int key = result.sensorConsumption.keyAt(i); SensorMetrics.Consumption value = result.sensorConsumption.valueAt(i); assertThat(value).isEqualTo(a.sensorConsumption.get(key).sum(b.sensorConsumption.get(key))); } } |
### Question:
WakeLockMetrics extends SystemMetrics<WakeLockMetrics> { @Override public boolean equals(Object o) { if (this == o) { return true; } if (o == null || getClass() != o.getClass()) { return false; } WakeLockMetrics that = (WakeLockMetrics) o; if (isAttributionEnabled != that.isAttributionEnabled || heldTimeMs != that.heldTimeMs || acquiredCount != that.acquiredCount) { return false; } return Utilities.simpleArrayMapEquals(tagTimeMs, that.tagTimeMs); } WakeLockMetrics(); WakeLockMetrics(boolean isAttributionEnabled); @Override WakeLockMetrics sum(@Nullable WakeLockMetrics b, @Nullable WakeLockMetrics output); @Override WakeLockMetrics diff(@Nullable WakeLockMetrics b, @Nullable WakeLockMetrics output); @Override WakeLockMetrics set(WakeLockMetrics b); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); @Nullable JSONObject attributionToJSONObject(); public boolean isAttributionEnabled; final SimpleArrayMap<String, Long> tagTimeMs; public long heldTimeMs; public long acquiredCount; }### Answer:
@Test public void testEquals() { assertThat(new WakeLockMetrics()).isEqualTo(new WakeLockMetrics()); assertThat(createInitializedMetrics()).isEqualTo(createInitializedMetrics()); } |
### Question:
SensorMetrics extends SystemMetrics<SensorMetrics> { @Override public SensorMetrics diff(@Nullable SensorMetrics b, @Nullable SensorMetrics output) { if (output == null) { output = new SensorMetrics(isAttributionEnabled); } if (b == null) { output.set(this); } else { total.diff(b.total, output.total); if (output.isAttributionEnabled) { op(-1, sensorConsumption, b.sensorConsumption, output.sensorConsumption); } } return output; } SensorMetrics(); SensorMetrics(boolean isAttributionEnabled); @Override SensorMetrics sum(@Nullable SensorMetrics b, @Nullable SensorMetrics output); @Override SensorMetrics diff(@Nullable SensorMetrics b, @Nullable SensorMetrics output); @Override SensorMetrics set(SensorMetrics b); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); @Nullable JSONObject attributionToJSONObject(); public boolean isAttributionEnabled; final Consumption total; final SparseArray<Consumption> sensorConsumption; }### Answer:
@Test public void testAttributedDiff() { SensorMetrics a = createAttributedMetrics(); SensorMetrics b = createAttributedMetrics(); SensorMetrics result = a.diff(b); assertThat(result).isEqualTo(new SensorMetrics(true)); } |
### Question:
UndertowEndpointManager implements WebSocketConnectionCallback, XEndpointManager<UndertowEndpoint> { UndertowEndpoint createEndpoint(WebSocketChannel channel) { final UndertowEndpoint endpoint = new UndertowEndpoint(this, channel); try { channel.setOption(Options.TCP_NODELAY, NODELAY); } catch (IOException e) { throw new OptionAssignmentException("Error setting option", e); } channel.getReceiveSetter().set(endpoint); channel.resumeReceives(); scanner.addEndpoint(endpoint); listener.onConnect(endpoint); if (idleTimeoutMillis != 0) { channel.setIdleTimeout(idleTimeoutMillis); } return endpoint; } UndertowEndpointManager(XEndpointScanner<UndertowEndpoint> scanner, int idleTimeoutMillis, XEndpointConfig<?> config,
XEndpointListener<? super UndertowEndpoint> listener); @Override void onConnect(WebSocketHttpExchange exchange, WebSocketChannel channel); @Override Collection<UndertowEndpoint> getEndpoints(); }### Answer:
@Test(expected=OptionAssignmentException.class) public void testCreateEndpointWithError() throws IOException { @SuppressWarnings("unchecked") final XEndpointListener<UndertowEndpoint> listener = mock(XEndpointListener.class); final UndertowEndpointManager mgr = new UndertowEndpointManager(null, 0, new DerivedEndpointConfig(), listener); final WebSocketChannel channel = Mockito.mock(WebSocketChannel.class); when(channel.setOption(any(), any())).thenThrow(new IOException("Boom")); mgr.createEndpoint(channel); } |
### Question:
UndertowEndpoint extends AbstractReceiveListener implements XEndpoint { WebSocketCallback<Void> wrapCallback(XSendCallback callback) { return new WebSocketCallback<Void>() { private final AtomicBoolean onceOnly = new AtomicBoolean(); @Override public void complete(WebSocketChannel channel, Void context) { if (onceOnly.compareAndSet(false, true)) { backlog.decrementAndGet(); if (callback != null) callback.onComplete(UndertowEndpoint.this); } } @Override public void onError(WebSocketChannel channel, Void context, Throwable cause) { if (onceOnly.compareAndSet(false, true)) { backlog.decrementAndGet(); if (callback != null) callback.onError(UndertowEndpoint.this, cause); } } }; } UndertowEndpoint(UndertowEndpointManager manager, WebSocketChannel channel); @Override @SuppressWarnings("unchecked") T getContext(); @Override void setContext(Object context); @Override void send(String payload, XSendCallback callback); @Override void send(ByteBuffer payload, XSendCallback callback); WebSocketChannel getChannel(); @Override void flush(); @Override void sendPing(); @Override void close(); @Override void terminate(); @Override InetSocketAddress getRemoteAddress(); @Override long getBacklog(); @Override boolean isOpen(); @Override long getLastActivityTime(); @Override String toString(); }### Answer:
@Test public void testCallbackOnceOnlyComplete() { createEndpointManager(); final XSendCallback callback = mock(XSendCallback.class); final WebSocketCallback<Void> wsCallback = endpoint.wrapCallback(callback); wsCallback.complete(channel, null); verify(callback, times(1)).onComplete(eq(endpoint)); wsCallback.complete(channel, null); verify(callback, times(1)).onComplete(eq(endpoint)); } |
### Question:
PomHelper { public static boolean updatePomVersions(List<PomUpdateStatus> pomsToChange, List<DependencyVersionChange> changes) throws IOException { Map<String, String> propertyChanges = new TreeMap<>(); for (PomUpdateStatus status : pomsToChange) { status.updateVersions(changes, propertyChanges); } if (!propertyChanges.isEmpty()) { for (PomUpdateStatus status : pomsToChange) { status.updateProperties(propertyChanges); } } boolean answer = false; for (PomUpdateStatus status : pomsToChange) { if (status.saveIfChanged()) { answer = true; } } return answer; } static boolean updatePomVersionsInPoms(File dir, List<DependencyVersionChange> changes); static boolean updatePomVersions(List<PomUpdateStatus> pomsToChange, List<DependencyVersionChange> changes); static boolean updatePluginVersion(Document doc, DependencyVersionChange change, Map<String, String> propertyChanges, boolean lazyAdd); static boolean updateDependencyVersion(Document doc, DependencyVersionChange change, Map<String, String> propertyChanges); static boolean updateProperties(Document doc, Map<String, String> propertyChanges); }### Answer:
@Test public void testVersionReplacement() throws Exception { File outDir = Tests.copyPackageSources(getClass()); LOG.info("Updating poms in " + outDir); File[] files = outDir.listFiles(); assertNotNull("No output files!", files); assertTrue("No output files!", files.length > 0); List<PomUpdateStatus> pomsToChange = new ArrayList<>(); for (File file : files) { try { PomUpdateStatus pomUpdateStatus = PomUpdateStatus.createPomUpdateStatus(file); pomUpdateStatus.setRootPom(true); pomsToChange.add(pomUpdateStatus); } catch (Exception e) { fail("Failed to parse " + file, e); } } Map<String, String> propertyVersions = new HashMap<>(); propertyVersions.put("assertj.version", assertJVersion); propertyVersions.put("fabric8.maven.plugin.version", fmpVersion); propertyVersions.put("fabric8.version", fabric8Version); propertyVersions.put("spring-boot.version", springBootVersion); List<DependencyVersionChange> changes = new ArrayList<>(); changes.add(new MavenDependencyVersionChange("io.fabric8:fabric8-maven-plugin", fmpVersion, MavenScopes.PLUGIN, true, ElementProcessors.createFabric8MavenPluginElementProcessor())); changes.add(new DependencyVersionChange(Kind.MAVEN, "org.assertj:assertj-core", assertJVersion, MavenScopes.ARTIFACT)); changes.add(new DependencyVersionChange(Kind.MAVEN, "io.fabric8:fabric8-project-bom-with-platform-deps", fabric8Version, MavenScopes.ARTIFACT)); changes.add(new DependencyVersionChange(Kind.MAVEN, "org.springframework.boot:spring-boot-dependencies", springBootVersion, MavenScopes.ARTIFACT)); PomHelper.updatePomVersions(pomsToChange, changes); for (File file : files) { Document doc; try { doc = parseXmlFile(file); } catch (Exception e) { fail("Failed to parse " + file + " due to " + e, e); continue; } assertPropertiesValid(file, doc, propertyVersions); assertChangesValid(file, doc, changes); } } |
### Question:
BorderingDistanceMetric implements SpatialDistanceMetric { @Override public double distance(Geometry g1, Geometry g2) { if (adjacencyList.isEmpty()) { throw new UnsupportedOperationException(); } int srcId = getContainingGeometry(g1); int destId = getContainingGeometry(g2); if (srcId < 0) { throw new IllegalArgumentException("No containing geometry for source geometry"); } if (destId < 0) { throw new IllegalArgumentException("No containing geometry for destination geometry"); } if (srcId == destId) { return 0; } TIntSet seen = new TIntHashSet(); TIntLinkedList queue = new TIntLinkedList(); for (int id: adjacencyList.get(srcId).toArray()) { if (id == destId) { return 1; } queue.add(id); seen.add(id); } for (int level = 2; level <= maxSteps; level++) { int nodes = queue.size(); for (int i = 0; i < nodes; i++) { int id = queue.removeAt(0); if (!adjacencyList.containsKey(id)) { continue; } for (int id2 : adjacencyList.get(id).toArray()) { if (id2 == destId) { return level; } if (!seen.contains(id2)) { queue.add(id2); seen.add(id2); } } } } return Double.POSITIVE_INFINITY; } BorderingDistanceMetric(SpatialDataDao dao, String layer); @Override void setValidConcepts(TIntSet concepts); @Override void enableCache(boolean enable); @Override String getName(); @Override double distance(Geometry g1, Geometry g2); @Override float[][] distance(List<Geometry> rowGeometries, List<Geometry> colGeometries); @Override float[][] distance(List<Geometry> geometries); @Override List<Neighbor> getNeighbors(Geometry g, int maxNeighbors); @Override List<Neighbor> getNeighbors(Geometry g, int maxNeighbors, double maxDistance); void setBufferWidth(double bufferWidth); void setMaxSteps(int maxSteps); void setForceContains(boolean forceContains); }### Answer:
@Test public void testSimple() throws DaoException { assertEquals(0, metric.distance(g("Minnesota"), g("Minnesota")), 0.01); assertEquals(1, metric.distance(g("Wisconsin"), g("Minnesota")), 0.01); assertEquals(1, metric.distance(g("North Dakota"), g("Minnesota")), 0.01); assertEquals(1, metric.distance(g("South Dakota"), g("Minnesota")), 0.01); assertEquals(1, metric.distance(g("Iowa"), g("Minnesota")), 0.01); assertEquals(2, metric.distance(g("Illinois"), g("Minnesota")), 0.01); assertEquals(4, metric.distance(g("Texas"), g("Minnesota")), 0.01); assertEquals(0, metric.distance(g("Minnesota").getCentroid(), g("Minnesota")), 0.01); assertEquals(0, metric.distance(g("Minnesota"), g("Minnesota").getCentroid()), 0.01); assertEquals(4, metric.distance(g("Minnesota").getCentroid(), g("Texas").getCentroid()), 0.01); } |
### Question:
Configurator implements Cloneable { public <T> T get(Class<T> klass, String name) throws ConfigurationException { return get(klass, name, null); } Configurator(Configuration conf); Configuration getConf(); T get(Class<T> klass, String name); T get(Class<T> klass, String name, String runtimeKey, String runtimeValue); T get(Class<T> klass, String name, Map<String, String> runtimeParams); String resolveComponentName(Class klass, String name); Config getConfig(Class klass, String name); T construct(Class<T> klass, String name, Config conf, Map<String, String> runtimeParams); T get(Class<T> klass); void close(); static final int MAX_FILE_SIZE; }### Answer:
@Test public void testRuntimeParams() throws ConfigurationException, IOException { Configurator conf = new Configurator(new Configuration()); Integer i1 = conf.get(Integer.class, "foo"); assertEquals(i1, 42); Integer i2 = conf.get(Integer.class, "foo"); assertEquals(i1, i2); Map<String, String> args3 = new HashMap<String, String>(); args3.put("overrideConstant", "423523524"); Integer i3 = conf.get(Integer.class, "foo", args3); assertEquals(i3, 423523524); Map<String, String> args4 = new HashMap<String, String>(); args4.put("overrideConstant", "423523236"); Integer i4 = conf.get(Integer.class, "foo", args4); assertEquals(i4, 423523236); assertEquals(new Integer(423523524), i3); assertNotSame(new Integer(423523524), i3); Integer i5 = conf.get(Integer.class, "foo", args3); assertEquals(i3, i5); assertSame(i3, i5); }
@Test public void testSimple() throws ConfigurationException { Configurator conf = new Configurator(new Configuration()); Integer i = conf.get(Integer.class, "foo"); assertEquals(i, 42); Integer j = conf.get(Integer.class, "bar"); assertEquals(j, 23); Integer k = conf.get(Integer.class, "baz"); assertEquals(k, 0); Integer l = conf.get(Integer.class, "biff"); assertEquals(l, 1); }
@Test public void testNonExistentJar() throws ConfigurationException { String separator = System.getProperty("path.separator"); System.setProperty("java.class.path", System.getProperty("java.class.path") + separator + "foobarbaz.jar"); Configurator conf = new Configurator(new Configuration()); Integer i = conf.get(Integer.class, "foo"); assertEquals(i, 42); Integer j = conf.get(Integer.class, "bar"); assertEquals(j, 23); Integer k = conf.get(Integer.class, "baz"); assertEquals(k, 0); Integer l = conf.get(Integer.class, "biff"); assertEquals(l, 1); } |
### Question:
SparseMatrix implements Matrix<SparseMatrixRow> { @Override public Iterator<SparseMatrixRow> iterator() { return new SparseMatrixIterator(); } SparseMatrix(File path); long lastModified(); @Override SparseMatrixRow getRow(int rowId); @Override int[] getRowIds(); @Override int getNumRows(); ValueConf getValueConf(); @Override Iterator<SparseMatrixRow> iterator(); void close(); @Override File getPath(); static final Logger LOG; static final int DEFAULT_HEADER_SIZE; static final int FILE_HEADER; }### Answer:
@Test public void testWrite() throws IOException { File tmp = File.createTempFile("matrix", null); SparseMatrixWriter.write(tmp, srcRows.iterator()); }
@Test public void testReadWrite() throws IOException { File tmp = File.createTempFile("matrix", null); SparseMatrixWriter.write(tmp, srcRows.iterator()); Matrix m1 = new SparseMatrix(tmp); Matrix m2 = new SparseMatrix(tmp); }
@Test public void testTranspose() throws IOException { for (int numOpenPages: new int[] { 1, Integer.MAX_VALUE}) { File tmp1 = File.createTempFile("matrix", null); File tmp2 = File.createTempFile("matrix", null); File tmp3 = File.createTempFile("matrix", null); SparseMatrixWriter.write(tmp1, srcRows.iterator()); SparseMatrix m = new SparseMatrix(tmp1); verifyIsSourceMatrix(m); new SparseMatrixTransposer(m, tmp2, 1).transpose(); SparseMatrix m2 = new SparseMatrix(tmp2); new SparseMatrixTransposer(m2, tmp3, 1).transpose(); Matrix m3 = new SparseMatrix(tmp3); verifyIsSourceMatrixUnordered(m3, .001); } }
@Test public void testRows() throws IOException { for (int numOpenPages: new int[] { 1, Integer.MAX_VALUE}) { File tmp = File.createTempFile("matrix", null); SparseMatrixWriter.write(tmp, srcRows.iterator()); Matrix m = new SparseMatrix(tmp); verifyIsSourceMatrix(m); } } |
### Question:
DenseMatrix implements Matrix<DenseMatrixRow> { @Override public Iterator<DenseMatrixRow> iterator() { return new DenseMatrixIterator(); } DenseMatrix(File path); @Override DenseMatrixRow getRow(int rowId); @Override int[] getRowIds(); int[] getColIds(); @Override int getNumRows(); ValueConf getValueConf(); @Override Iterator<DenseMatrixRow> iterator(); @Override File getPath(); @Override void close(); static final Logger LOG; static final int FILE_HEADER; static final int DEFAULT_HEADER_SIZE; }### Answer:
@Test public void testWrite() throws IOException { File tmp = File.createTempFile("matrix", null); DenseMatrixWriter.write(tmp, srcRows.iterator()); }
@Test public void testReadWrite() throws IOException { File tmp = File.createTempFile("matrix", null); DenseMatrixWriter.write(tmp, srcRows.iterator()); DenseMatrix m1 = new DenseMatrix(tmp); DenseMatrix m2 = new DenseMatrix(tmp); }
@Test public void testTranspose() throws IOException { for (int numOpenPages: new int[] { 1, Integer.MAX_VALUE}) { File tmp1 = File.createTempFile("matrix", null); File tmp2 = File.createTempFile("matrix", null); File tmp3 = File.createTempFile("matrix", null); DenseMatrixWriter.write(tmp1, srcRows.iterator()); DenseMatrix m = new DenseMatrix(tmp1); verifyIsSourceMatrix(m); } }
@Test public void testRows() throws IOException { for (int numOpenPages: new int[] { 1, Integer.MAX_VALUE}) { File tmp = File.createTempFile("matrix", null); DenseMatrixWriter.write(tmp, srcRows.iterator()); DenseMatrix m = new DenseMatrix(tmp); verifyIsSourceMatrix(m); } } |
### Question:
PageViewUtils { public static SortedSet<DateTime> timestampsInInterval(DateTime start, DateTime end) { if (start.isAfter(end)) { throw new IllegalArgumentException(); } DateTime current = new DateTime( start.year().get(), start.monthOfYear().get(), start.dayOfMonth().get(), start.hourOfDay().get(), 0); if (current.isBefore(start)) { current = current.plusHours(1); } SortedSet<DateTime> result = new TreeSet<DateTime>(); while (!current.isAfter(end)) { result.add(current); current = current.plusHours(1); } return result; } static SortedSet<DateTime> timestampsInInterval(DateTime start, DateTime end); }### Answer:
@Test public void testTstampsInRange() { long now = System.currentTimeMillis(); Random random = new Random(); for (int i = 0; i < 1000; i++) { long tstamp = (long) (random.nextDouble() * now); DateTime beg = new DateTime(tstamp); DateTime end = beg.plusHours(1); SortedSet<DateTime> tstamps = PageViewUtils.timestampsInInterval(beg, end); assertEquals(tstamps.size(), 1); DateTime dt = tstamps.first(); assertTrue(beg.isBefore(dt)); assertTrue(end.isAfter(dt)); } } |
### Question:
BorderingDistanceMetric implements SpatialDistanceMetric { @Override public List<Neighbor> getNeighbors(Geometry g, int maxNeighbors) { return getNeighbors(g, maxNeighbors, Double.MAX_VALUE); } BorderingDistanceMetric(SpatialDataDao dao, String layer); @Override void setValidConcepts(TIntSet concepts); @Override void enableCache(boolean enable); @Override String getName(); @Override double distance(Geometry g1, Geometry g2); @Override float[][] distance(List<Geometry> rowGeometries, List<Geometry> colGeometries); @Override float[][] distance(List<Geometry> geometries); @Override List<Neighbor> getNeighbors(Geometry g, int maxNeighbors); @Override List<Neighbor> getNeighbors(Geometry g, int maxNeighbors, double maxDistance); void setBufferWidth(double bufferWidth); void setMaxSteps(int maxSteps); void setForceContains(boolean forceContains); }### Answer:
@Test public void testKnn() throws DaoException { List<SpatialDistanceMetric.Neighbor> neighbors = metric.getNeighbors(g("Minnesota"), 100); for (int i = 0; i < neighbors.size(); i++) { SpatialDistanceMetric.Neighbor n = neighbors.get(i); String name = n(n.conceptId); if (i == 0) { assertEquals(name, "Minnesota"); } else if (i <= 4) { assertTrue(Arrays.asList("North Dakota", "Iowa", "Wisconsin", "South Dakota").contains(name)); } } SpatialDistanceMetric.Neighbor last = neighbors.get(neighbors.size() - 1); assertEquals(8.0, last.distance, 0.01); assertEquals("Maine", n(last.conceptId)); } |
### Question:
Title implements Externalizable { public Title(String text, LanguageInfo language) { this(text, false, language); } Title(String text, LanguageInfo language); Title(String text, boolean isCanonical, LanguageInfo lang); Title(String title, Language language); String getCanonicalTitle(); LanguageInfo getLanguageInfo(); Language getLanguage(); NameSpace getNamespace(); String getNamespaceString(); String getTitleStringWithoutNamespace(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object o); Title toUpperCase(); String toUrl(); long longHashCode(); static long longHashCode(Language l, String title, NameSpace ns); static long longHashCode(int langId, String title, int nsArbitraryId); String[] getNameAndDisambiguator(); static String canonicalize(String title, LanguageInfo lang); @Override void readExternal(ObjectInput in); @Override void writeExternal(ObjectOutput out); }### Answer:
@Test public void testTitle(){ LanguageInfo lang = LanguageInfo.getByLangCode("en"); Title pokemon = new Title("Pokemon: The Movie",lang); assert (pokemon.getNamespaceString() == null); assert (pokemon.getNamespace()==NameSpace.ARTICLE); assert (pokemon.getTitleStringWithoutNamespace().equals("Pokemon: The Movie")); Title axelson = new Title("Ax:son Johnson family",lang); assert (axelson.getNamespaceString() == null); assert (axelson.getNamespace()==NameSpace.ARTICLE); assert(axelson.getTitleStringWithoutNamespace().equals("Ax:son Johnson family")); Title pokemonTalk = new Title("Talk:Pokemon: The Movie",lang); assert (pokemonTalk.getNamespaceString().equals("Talk")); assert (pokemonTalk.getNamespace()==NameSpace.TALK); assert (pokemonTalk.getTitleStringWithoutNamespace().equals("Pokemon: The Movie")); Title badCategory = new Title("Category: ",lang); assert (badCategory.getNamespaceString().equals("Category")); assert (badCategory.getNamespace()==NameSpace.CATEGORY); assert (badCategory.getTitleStringWithoutNamespace().equals("")); } |
### Question:
WikidataParser { public WikidataEntity parse(String json) throws WpParseException { JacksonTermedStatementDocument mwDoc; try { mwDoc = mapper.readValue(json, JacksonTermedStatementDocument.class); } catch (IOException e) { LOG.info("Error parsing: " + json); throw new WpParseException(e); } WikidataEntity record = new WikidataEntity(mwDoc.getEntityId().getId()); for (List<MonolingualTextValue> vlist : mwDoc.getAliases().values()) { if (vlist.isEmpty()) continue; if (!validLanguage(vlist.get(0).getLanguageCode())) continue; Language lang = Language.getByLangCodeLenient(vlist.get(0).getLanguageCode()); record.getAliases().put(lang, new ArrayList<String>()); for (MonolingualTextValue v : vlist) { record.getAliases().get(lang).add(v.getText()); } } for (MonolingualTextValue v : mwDoc.getDescriptions().values()) { if (validLanguage(v.getLanguageCode())) { Language lang = Language.getByLangCodeLenient(v.getLanguageCode()); record.getDescriptions().put(lang, v.getText()); } } for (MonolingualTextValue v : mwDoc.getLabels().values()) { if (validLanguage(v.getLanguageCode())) { Language lang = Language.getByLangCodeLenient(v.getLanguageCode()); record.getLabels().put(lang, v.getText()); } } if (mwDoc instanceof JacksonItemDocument) { for (List<JacksonStatement> statements : ((JacksonItemDocument)mwDoc).getJsonClaims().values()) { for (JacksonStatement s : statements) { record.getStatements().add(parseOneClaim(record, s)); } } } return record; } WikidataParser(); WikidataParser(LanguageSet langs); WikidataEntity parse(String json); WikidataValue snakToValue(final String type, Value snak); WikidataValue jsonToValue(String type, JsonElement element); static Object gsonToPrimitive(JsonElement element); }### Answer:
@Test public void testWikidataRawRecord() throws IOException, WpParseException { String json = WpIOUtils.resourceToString("/testPage.json"); WikidataParser parser = new WikidataParser(); WikidataEntity entity = parser.parse(json); assertEquals(entity.getType(), WikidataEntity.Type.ITEM); assertEquals(entity.getId(), 157); assertEquals(entity.getLabels().get(Language.ES), "Fran\u00e7ois Hollande"); assertEquals(entity.getDescriptions().get(Language.EN), "24th President of the French Republic"); WikidataStatement stm = entity.getStatements().get(0); assertEquals(stm.getProperty().getId(), 40); assertEquals(stm.getValue().getType(), WikidataValue.Type.ITEM); assertEquals(stm.getValue().getItemValue(), 16783695); } |
### Question:
GoogleSimilarity implements VectorSimilarity { public GoogleSimilarity(int numPages) { this.numPages = numPages; } GoogleSimilarity(int numPages); @Override synchronized void setMatrices(SparseMatrix features, SparseMatrix transpose, File dataDir); @Override double similarity(TIntFloatMap vector1, TIntFloatMap vector2); @Override double similarity(MatrixRow a, MatrixRow b); @Override SRResultList mostSimilar(TIntFloatMap query, int maxResults, TIntSet validIds); @Override double getMinValue(); @Override double getMaxValue(); }### Answer:
@Test public void testUtils() { TIntFloatMap row1 = getMap(ROW1_IDS, ROW1_VALS); TIntFloatMap row2 = getMap(ROW2_IDS, ROW2_VALS); double expected = googleSimilarity(row1, row2); double actual = SimUtils.googleSimilarity(6, 5, 3, NUM_PAGES); assertEquals(expected, actual, 0.0001); } |
### Question:
CosineSimilarity implements VectorSimilarity { @Override public double similarity(MatrixRow a, MatrixRow b) { return SimUtils.cosineSimilarity(a, b); } @Override synchronized void setMatrices(SparseMatrix features, SparseMatrix transpose, File dataDir); @Override double similarity(MatrixRow a, MatrixRow b); @Override double similarity(TIntFloatMap vector1, TIntFloatMap vector2); @Override SRResultList mostSimilar(TIntFloatMap query, int maxResults, TIntSet validIds); @Override double getMinValue(); @Override double getMaxValue(); }### Answer:
@Test public void testMap() { TIntFloatMap row1 = getMap(ROW1_IDS, ROW1_VALS); TIntFloatMap row2 = getMap(ROW2_IDS, ROW2_VALS); double expected = cosineSimilarity(row1, row2); double actual = new CosineSimilarity().similarity(row1, row2); assertEquals(expected, actual, 0.0001); actual = new CosineSimilarity().similarity(row2, row1); assertEquals(expected, actual, 0.0001); }
@Test public void testRows() { TIntFloatMap map1 = getMap(ROW1_IDS, ROW1_VALS); TIntFloatMap map2 = getMap(ROW2_IDS, ROW2_VALS); SparseMatrixRow row1 = getRow(ROW1_IDS, ROW1_VALS); SparseMatrixRow row2 = getRow(ROW2_IDS, ROW2_VALS); double expected = cosineSimilarity(map1, map2); double actual = new CosineSimilarity().similarity(row1, row2); assertEquals(expected, actual, 0.0001); actual = new CosineSimilarity().similarity(row2, row1); assertEquals(expected, actual, 0.0001); }
@Ignore @Test public void benchmark() { int numOuter = 100; int numInner = 10000; long before = System.currentTimeMillis(); double sum = 0; Random random = new Random(); for (int i = 0; i < numOuter; i++) { int overlap[] = new int[10]; for (int j = 0; j < overlap.length; j++) { overlap[j] = random.nextInt(Integer.MAX_VALUE / 10); } SparseMatrixRow row1 = makeRow(100, overlap); SparseMatrixRow row2 = makeRow(100, overlap); CosineSimilarity sim = new CosineSimilarity(); for (int j = 0; j < numInner; j++) { sum += sim.similarity(row1, row2); } } long after = System.currentTimeMillis(); System.out.println("elapsed is " + (after - before) + " sim is " + (sum / (numOuter * numInner))); } |
### Question:
SimUtils { public static double cosineSimilarity(TIntDoubleMap X, TIntDoubleMap Y) { double xDotX = 0.0; double yDotY = 0.0; double xDotY = 0.0; for (int id : X.keys()) { double x = X.get(id); xDotX += x * x; if (Y.containsKey(id)) { xDotY += x * Y.get(id); } } for (double y : Y.values()) { yDotY += y * y; } return xDotX * yDotY != 0 ? xDotY / Math.sqrt(xDotX * yDotY): 0.0; } static double cosineSimilarity(TIntDoubleMap X, TIntDoubleMap Y); static double cosineSimilarity(TIntFloatMap X, TIntFloatMap Y); static double cosineSimilarity(MatrixRow a, MatrixRow b); static double googleSimilarity(int sizeA, int sizeB, int intersection, int numTotal); static TIntDoubleMap normalizeVector(TIntDoubleMap X); static TIntFloatMap normalizeVector(TIntFloatMap X); static Map sortByValue(TIntDoubleHashMap unsortMap); static WikiBrainScoreDoc[] pruneSimilar(WikiBrainScoreDoc[] wikibrainScoreDocs); static double cosineSimilarity(float[] X, float[] Y); }### Answer:
@Test public void testCosineSimilarity() { TIntDoubleHashMap zeroVector = zeroVector(keyList1); TIntDoubleHashMap testVector1 = testVector(keyList2, 0); TIntDoubleHashMap testVector2 = testVector(keyList2, 1); assertEquals("Cosine similarity between a vector and itself must be 1", 1.0, SimUtils.cosineSimilarity(testVector1, testVector1), 0.0); assertEquals("Cosine similarity between a vector and zero vector must be 0", 0.0, SimUtils.cosineSimilarity(testVector1, zeroVector), 0.0); } |
### Question:
SimUtils { public static TIntDoubleMap normalizeVector(TIntDoubleMap X) { TIntDoubleHashMap Y = new TIntDoubleHashMap(); double sumSquares = 0.0; for (double x : X.values()) { sumSquares += x * x; } if (sumSquares != 0.0) { double norm = Math.sqrt(sumSquares); for (int id : X.keys()) { Y.put(id, X.get(id) / norm); } return Y; } return X; } static double cosineSimilarity(TIntDoubleMap X, TIntDoubleMap Y); static double cosineSimilarity(TIntFloatMap X, TIntFloatMap Y); static double cosineSimilarity(MatrixRow a, MatrixRow b); static double googleSimilarity(int sizeA, int sizeB, int intersection, int numTotal); static TIntDoubleMap normalizeVector(TIntDoubleMap X); static TIntFloatMap normalizeVector(TIntFloatMap X); static Map sortByValue(TIntDoubleHashMap unsortMap); static WikiBrainScoreDoc[] pruneSimilar(WikiBrainScoreDoc[] wikibrainScoreDocs); static double cosineSimilarity(float[] X, float[] Y); }### Answer:
@Test public void testNormalizeVector() { TIntDoubleHashMap zeroVector1 = zeroVector(keyList1); TIntDoubleHashMap testVector1 = testVector(keyList2, 0); TIntDoubleHashMap testVector2 = testVector(keyList2, 1); TIntDoubleMap zeroVector1Normalized = SimUtils.normalizeVector(zeroVector1); TIntDoubleMap testVector1Normalized = SimUtils.normalizeVector(testVector1); TIntDoubleMap testVector2Normalized = SimUtils.normalizeVector(testVector2); for (int keyNum : zeroVector1.keys()) { assertEquals("Every score in the zero vector remains the same after normalization", zeroVector1.get(keyNum), zeroVector1Normalized.get(keyNum), 0.0); } double testValue = 0.0; for (double value : testVector1Normalized.values()) { testValue += value * value; } assertEquals("Normalized vector has length of 1", 1.0, testValue, 0.00001); } |
### Question:
GraphDistanceMetric implements SpatialDistanceMetric { @Override public double distance(Geometry g1, Geometry g2) { if (adjacencyList.isEmpty()) { throw new UnsupportedOperationException(); } List<ClosestPointIndex.Result> closest = index.query(g2, 1); int maxSteps = maxDistance; if (maxSteps == 0 || closest.isEmpty()) { return Double.POSITIVE_INFINITY; } if (g1 == g2 || g1.equals(g2)) { return 0; } int targetId = closest.get(0).id; TIntSet seen = new TIntHashSet(); TIntLinkedList queue = new TIntLinkedList(); for (ClosestPointIndex.Result n : index.query(g1, numNeighbors)) { if (n.id== targetId) { return 1; } queue.add(n.id); seen.add(n.id); } for (int level = 2; level <= maxSteps; level++) { int nodes = queue.size(); for (int i = 0; i < nodes; i++) { int id = queue.removeAt(0); if (!adjacencyList.containsKey(id)) { continue; } for (int id2 : adjacencyList.get(id).toArray()) { if (id2 == targetId) { return level; } if (!seen.contains(id2)) { queue.add(id2); seen.add(id2); } } } } return Double.POSITIVE_INFINITY; } GraphDistanceMetric(SpatialDataDao dao, ClosestPointIndex index); GraphDistanceMetric(SpatialDataDao dao, SphericalDistanceMetric spherical); GraphDistanceMetric(SpatialDataDao dao); void setNumNeighbors(int numNeighbors); void setMaxDistance(int maxDistance); void setValidNodes(TIntSet nodes); @Override void setValidConcepts(TIntSet concepts); @Override void enableCache(boolean enable); @Override String getName(); @Override double distance(Geometry g1, Geometry g2); @Override float[][] distance(List<Geometry> rowGeometries, List<Geometry> colGeometries); @Override float[][] distance(List<Geometry> geometries); @Override List<Neighbor> getNeighbors(Geometry g, int maxNeighbors); @Override List<Neighbor> getNeighbors(Geometry g, int maxNeighbors, double maxDistance); void setDirected(boolean directed); }### Answer:
@Test public void testLattice() throws DaoException { GraphDistanceMetric metric = getLatticeMetric(); assertEquals(1.0, metric.distance(lattice[2][0], lattice[0][0]), 0.01); assertEquals(1.0, metric.distance(lattice[2][0], lattice[1][0]), 0.01); assertEquals(0.0, metric.distance(lattice[2][0], lattice[2][0]), 0.01); assertEquals(1.0, metric.distance(lattice[2][0], lattice[3][0]), 0.01); assertEquals(1.0, metric.distance(lattice[2][0], lattice[4][0]), 0.01); for (int i = 0; i < LATTICE_ROWS; i++) { for (int j = 0; j < 20; j++) { int d = (int) Math.round(metric.distance(lattice[2][0], lattice[i][j])); System.err.print(" " + d); } System.err.println(""); } } |
### Question:
SimUtils { public static Map sortByValue(TIntDoubleHashMap unsortMap) { if (unsortMap.isEmpty()) { return new HashMap(); } HashMap<Integer, Double> tempMap = new HashMap<Integer, Double>(); TIntDoubleIterator iterator = unsortMap.iterator(); for ( int i = unsortMap.size(); i-- > 0; ) { iterator.advance(); tempMap.put( iterator.key(), iterator.value() ); } List<Map.Entry> list = new LinkedList<Map.Entry>(tempMap.entrySet()); Collections.sort(list, Collections.reverseOrder(new Comparator() { public int compare(Object o1, Object o2) { return ((Comparable) ((Map.Entry) (o1)).getValue()) .compareTo(((Map.Entry) (o2)).getValue()); } })); Map sortedMap = new LinkedHashMap(); for (Iterator it = list.iterator(); it.hasNext();) { Map.Entry entry = (Map.Entry) it.next(); sortedMap.put(entry.getKey(), entry.getValue()); } return sortedMap; } static double cosineSimilarity(TIntDoubleMap X, TIntDoubleMap Y); static double cosineSimilarity(TIntFloatMap X, TIntFloatMap Y); static double cosineSimilarity(MatrixRow a, MatrixRow b); static double googleSimilarity(int sizeA, int sizeB, int intersection, int numTotal); static TIntDoubleMap normalizeVector(TIntDoubleMap X); static TIntFloatMap normalizeVector(TIntFloatMap X); static Map sortByValue(TIntDoubleHashMap unsortMap); static WikiBrainScoreDoc[] pruneSimilar(WikiBrainScoreDoc[] wikibrainScoreDocs); static double cosineSimilarity(float[] X, float[] Y); }### Answer:
@Test public void testSortByValue() { int testMapSize = 1000; Random random = new Random(System.currentTimeMillis()); TIntDoubleHashMap testMap = new TIntDoubleHashMap(); for(int i = 0 ; i < testMapSize ; ++i) { testMap.put(random.nextInt(), random.nextDouble()); } Map<Integer, Double> sortedMap = SimUtils.sortByValue(testMap); Assert.assertEquals(testMapSize, sortedMap.size() ); Double previous = null; } |
### Question:
DatasetDao { public static Collection<Info> readInfos() throws DaoException { try { return readInfos(WpIOUtils.openResource(RESOURCE_DATASET_INFO)); } catch (IOException e) { throw new DaoException(e); } } DatasetDao(); DatasetDao(Collection<Info> info); void setNormalize(boolean normalize); List<Dataset> getAllInLanguage(Language lang); Dataset read(Language language, File path); Dataset get(Language language, String name); boolean isGroup(String name); List<Dataset> getGroup(Language language, String name); List<Dataset> getDatasetOrGroup(Language language, String name); Info getInfo(String name); void setDisambiguator(Disambiguator dab); void setResolvePhrases(boolean resolvePhrases); void setGroups(Map<String, List<String>> groups); void write(Dataset dataset, File path); static Collection<Info> readInfos(); static Collection<Info> readInfos(BufferedReader reader); static final String RESOURCE_DATSET; static final String RESOURCE_DATASET_INFO; }### Answer:
@Test public void testInfos() throws DaoException { Collection<DatasetDao.Info> infos = DatasetDao.readInfos(); assertEquals(18, infos.size()); } |
### Question:
DatasetDao { public Dataset get(Language language, String name) throws DaoException { if (groups.containsKey(name)) { List<Dataset> members = new ArrayList<Dataset>(); for (String n : groups.get(name)) { members.add(get(language, n)); } return new Dataset(name, members); } if (name.contains("/") || name.contains("\\")) { throw new DaoException("get() reads a dataset by name for a jar. Try read() instead?"); } Info info = getInfo(name); if (info == null) { throw new DaoException("no dataset with name '" + name + "'"); } if (!info.languages.containsLanguage(language)) { throw new DaoException("dataset '" + name + "' does not support language " + language); } try { return read(name, language, WpIOUtils.openResource(RESOURCE_DATSET + "/" + name)); } catch (IOException e) { throw new DaoException(e); } } DatasetDao(); DatasetDao(Collection<Info> info); void setNormalize(boolean normalize); List<Dataset> getAllInLanguage(Language lang); Dataset read(Language language, File path); Dataset get(Language language, String name); boolean isGroup(String name); List<Dataset> getGroup(Language language, String name); List<Dataset> getDatasetOrGroup(Language language, String name); Info getInfo(String name); void setDisambiguator(Disambiguator dab); void setResolvePhrases(boolean resolvePhrases); void setGroups(Map<String, List<String>> groups); void write(Dataset dataset, File path); static Collection<Info> readInfos(); static Collection<Info> readInfos(BufferedReader reader); static final String RESOURCE_DATSET; static final String RESOURCE_DATASET_INFO; }### Answer:
@Test public void testDaoRead() throws DaoException { DatasetDao dao = new DatasetDao(); Dataset ds = dao.get(Language.getByLangCode("en"), "wordsim353.txt"); assertEquals(353, ds.getData().size()); assertEquals("en", ds.getLanguage().getLangCode()); double sim = Double.NaN; for (KnownSim ks : ds.getData()) { if (ks.phrase1.equals("morality") && ks.phrase2.equals("marriage")) { sim = ks.similarity; } } assertTrue(!Double.isNaN(sim)); assertEquals(sim, 0.354145342886, 0.000001); } |
### Question:
MostSimilarGuess { public double getNDGC() { if (observations.isEmpty()) { return 0.0; } TIntDoubleMap actual = new TIntDoubleHashMap(); for (KnownSim ks : known.getMostSimilar()) { actual.put(ks.wpId2, ks.similarity); } int ranks[] = new int[observations.size()]; double scores[] = new double[observations.size()]; double s = 0.0; for (int i = 0; i < observations.size(); i++) { Observation o = observations.get(i); double k = (o.rank == 1) ? 1 : Math.log(o.rank + 1); s += actual.get(o.id) / k; scores[i] = actual.get(o.id); ranks[i] = o.rank; } Arrays.sort(ranks); Arrays.sort(scores); ArrayUtils.reverse(scores); double t = 0; for (int i = 0; i < scores.length; i++) { double k = (ranks[i] == 1) ? 1 : Math.log(ranks[i] + 1); t += scores[i] / k; } return s / t; } MostSimilarGuess(KnownMostSim known, String str); MostSimilarGuess(KnownMostSim known, SRResultList guess); String toString(); List<Observation> getObservations(); int getLength(); KnownMostSim getKnown(); double getNDGC(); double getPenalizedNDGC(); PrecisionRecallAccumulator getPrecisionRecall(int n, double threshold); }### Answer:
@Test public void testNdgc() { double ndgc = ( (0.80 + 0.00 / Math.log(2+1) + 0.95 / Math.log(4+1) + 0.91 / Math.log(7+1)) / (0.95 + 0.91 / Math.log(2+1) + 0.80 / Math.log(4+1) + 0.00 / Math.log(7+1))); assertEquals(ndgc, guess.getNDGC(), 0.001); } |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.