14552398690

Committed 19 Apr 2025 07:59PM UTC coverage: 52.924% (+2.3%) from 50.591%

Build # 14552398690

Build Type

push

github

Committed by

ljacqu

Commit Message

Write sanitizer tests that don't require the dictionary file

Run Details

268 of 576 branches covered (46.53%)

1 of 2 new or added lines in 1 file covered. (50.0%)

36 existing lines in 9 files now uncovered.

724 of 1368 relevant lines covered (52.92%)

3.06 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

56.52

/src/main/java/ch/jalu/wordeval/evaluators/impl/AllVowelsAlphabetically.java

package ch.jalu.wordeval.evaluators.impl;

import ch.jalu.wordeval.dictionary.Word;
import ch.jalu.wordeval.evaluators.PostEvaluator;
import ch.jalu.wordeval.evaluators.export.EvaluatorExportUtil;
import ch.jalu.wordeval.evaluators.processing.AllWordsEvaluatorProvider;
import ch.jalu.wordeval.evaluators.result.WordGroupWithKey;
import ch.jalu.wordeval.evaluators.result.WordWithKey;
import ch.jalu.wordeval.language.Language;
import ch.jalu.wordeval.language.LetterType;
import com.google.common.collect.ListMultimap;
import lombok.Getter;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;

/**
 * Finds words with all vowels that appear alphabetically, such as "arbeidsonrust".
 */
public class AllVowelsAlphabetically implements PostEvaluator {

  private final List<String> vowels;
  @Getter
  private final List<WordGroupWithKey> results = new ArrayList<>();

  public AllVowelsAlphabetically(Language language) {
    vowels = language.getVowels();
  }

  @Override
  public void evaluate(AllWordsEvaluatorProvider allWordsEvaluatorProvider) {
    VowelCount vowelCount =
        allWordsEvaluatorProvider.getEvaluator(VowelCount.class, vc -> vc.getLetterType() == LetterType.VOWELS);

    List<WordGroupWithKey> wordGroupsByKey = vowelCount.getResults().stream()
        .filter(entry -> entry.getKey().length() > 1)
        .filter(entry -> hasVowelsAlphabetically(entry.getWord().getWithoutAccents()))
        .collect(Collectors.groupingBy(WordWithKey::getKey,
            Collectors.mapping(WordWithKey::getWord, Collectors.toSet())))
        .entrySet().stream()
        .map(e -> new WordGroupWithKey(e.getValue(), e.getKey()))
        .toList();

    results.addAll(wordGroupsByKey);
  }

  private boolean hasVowelsAlphabetically(String word) {
    int idx = 0;
    String curVowel = vowels.get(idx);
    for (int i = 0; i < word.length(); ++i) {
      String str = word.substring(i, i + 1);
      if (vowels.contains(str)) {
        if (str.equals(curVowel)) {
          idx++;
          curVowel = idx >= vowels.size() ? null : vowels.get(idx);
        } else {
          return false;
        }
      }
    }
    return true;
  }

  @Override
  public ListMultimap<Object, Object> getTopResults(int topScores, int maxLimit) {
    Comparator<WordGroupWithKey> comparator = Comparator.comparingInt((WordGroupWithKey group) -> group.getKey().length())
        .reversed(); // todo: unit test

    List<WordGroupWithKey> sortedResult = results.stream()
        .sorted(comparator)
        .toList();

    Set<Integer> uniqueValues = new HashSet<>();
    ListMultimap<Object, Object> filteredResults = EvaluatorExportUtil.newListMultimap();
    for (WordGroupWithKey wordGroup : sortedResult) {
      int score = wordGroup.getKey().length();
      if (uniqueValues.add(score) && uniqueValues.size() > topScores) {
        break;
      }
      List<String> wordList = wordGroup.getWords().stream()
          .map(Word::getRaw)
          .toList();
      filteredResults.put(wordGroup.getKey(), wordList);
      if (filteredResults.size() >= maxLimit) {
        break;
      }
    }

    return filteredResults;
  }

  @Override
  public String getId() {
    return "vowels.alphabetical";
  }
}

1	package ch.jalu.wordeval.evaluators.impl;
2
3	import ch.jalu.wordeval.dictionary.Word;
4	import ch.jalu.wordeval.evaluators.PostEvaluator;
5	import ch.jalu.wordeval.evaluators.export.EvaluatorExportUtil;
6	import ch.jalu.wordeval.evaluators.processing.AllWordsEvaluatorProvider;
7	import ch.jalu.wordeval.evaluators.result.WordGroupWithKey;
8	import ch.jalu.wordeval.evaluators.result.WordWithKey;
9	import ch.jalu.wordeval.language.Language;
10	import ch.jalu.wordeval.language.LetterType;
11	import com.google.common.collect.ListMultimap;
12	import lombok.Getter;
13
14	import java.util.ArrayList;
15	import java.util.Comparator;
16	import java.util.HashSet;
17	import java.util.List;
18	import java.util.Set;
19	import java.util.stream.Collectors;
20
21	/**
22	* Finds words with all vowels that appear alphabetically, such as "arbeidsonrust".
23	*/
24	public class AllVowelsAlphabetically implements PostEvaluator {
25
26	private final List<String> vowels;
27	@Getter	5✔
28	private final List<WordGroupWithKey> results = new ArrayList<>();
29
30	public AllVowelsAlphabetically(Language language) {	2✔
31	vowels = language.getVowels();	4✔
32	}	1✔
33
34	@Override
35	public void evaluate(AllWordsEvaluatorProvider allWordsEvaluatorProvider) {
36	VowelCount vowelCount =	3✔
37	allWordsEvaluatorProvider.getEvaluator(VowelCount.class, vc -> vc.getLetterType() == LetterType.VOWELS);	10!
38
39	List<WordGroupWithKey> wordGroupsByKey = vowelCount.getResults().stream()	4✔
40	.filter(entry -> entry.getKey().length() > 1)	12✔
41	.filter(entry -> hasVowelsAlphabetically(entry.getWord().getWithoutAccents()))	9✔
42	.collect(Collectors.groupingBy(WordWithKey::getKey,	3✔
43	Collectors.mapping(WordWithKey::getWord, Collectors.toSet())))	2✔
44	.entrySet().stream()	3✔
45	.map(e -> new WordGroupWithKey(e.getValue(), e.getKey()))	11✔
46	.toList();	2✔
47
48	results.addAll(wordGroupsByKey);	5✔
49	}	1✔
50
51	private boolean hasVowelsAlphabetically(String word) {
52	int idx = 0;	2✔
53	String curVowel = vowels.get(idx);	6✔
54	for (int i = 0; i < word.length(); ++i) {	8✔
55	String str = word.substring(i, i + 1);	7✔
56	if (vowels.contains(str)) {	5✔
57	if (str.equals(curVowel)) {	4✔
58	idx++;	1✔
59	curVowel = idx >= vowels.size() ? null : vowels.get(idx);	12!
60	} else {
61	return false;	2✔
62	}
63	}
64	}
65	return true;	2✔
66	}
67
68	@Override
69	public ListMultimap<Object, Object> getTopResults(int topScores, int maxLimit) {
70	Comparator<WordGroupWithKey> comparator = Comparator.comparingInt((WordGroupWithKey group) -> group.getKey().length())	×
71	.reversed(); // todo: unit test	×
72
73	List<WordGroupWithKey> sortedResult = results.stream()	×
74	.sorted(comparator)	×
75	.toList();	×
76
77	Set<Integer> uniqueValues = new HashSet<>();	×
78	ListMultimap<Object, Object> filteredResults = EvaluatorExportUtil.newListMultimap();	×
79	for (WordGroupWithKey wordGroup : sortedResult) {	×
80	int score = wordGroup.getKey().length();	×
81	if (uniqueValues.add(score) && uniqueValues.size() > topScores) {	×
82	break;	×
83	}
84	List<String> wordList = wordGroup.getWords().stream()	×
85	.map(Word::getRaw)	×
86	.toList();	×
87	filteredResults.put(wordGroup.getKey(), wordList);	×
88	if (filteredResults.size() >= maxLimit) {	×
89	break;	×
90	}
91	}	×
92
93	return filteredResults;	×
94	}
95
96	@Override
97	public String getId() {
UNCOV 98	return "vowels.alphabetical";	×
99	}
100	}

ljacqu / wordeval / 14552398690

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous