@Test
public void testFuture() {
Tester tester = new Tester("aramak", "gitmek [A:Voicing, Aorist_A]");
tester.assertHasParses(
"arayacak", "arayacağız", "aramayacak", "aratacak", "arayacaklar", "arayacaktık");
tester.assertHasParses("gidecek", "gideceğiz", "gitmeyecek", "gidecekler", "gidecektik");
}
public void testMethodIndirection() throws Exception {
PythonScriptEngineInitializer initializer = new PythonScriptEngineInitializer();
ScriptEngine engine = initializer.instantiate(Collections.<String>emptySet(), null);
Bindings bindings = engine.createBindings();
Tester tester = new Tester();
bindings.put("tester", tester);
engine.setBindings(bindings, ScriptContext.ENGINE_SCOPE);
engine.eval("tester.increment()");
Assert.assertEquals(tester.getInvocationCoung(), 1, "Unexpected number of tester invocations.");
Map<String, Set<Method>> methods = getMethodsByName(Tester.class);
for (Set<Method> ms : methods.values()) {
Set<String> fns = initializer.generateIndirectionMethods("tester", ms);
for (String fn : fns) {
engine.eval(fn);
}
}
engine.eval("increment()");
Assert.assertEquals(
tester.getInvocationCoung(),
2,
"Unexpected number of tester invocations after calling an indirected method.");
}
@Test
public void testPast() {
Tester tester = new Tester("aramak", "gitmek [A:Voicing, Aorist_A]");
tester.assertHasParses(
"aradı", "gitti", "gittik", "gittiyse", "gittim", "gittiniz", "gittiydim");
tester.assertUnParseable("gittiz", "gittimiş");
}
@Test
public void testCausative() {
Tester tester = new Tester("yapmak", "aramak");
tester.assertHasParses("yaptırttır", "yaptır", "yaptırt", "arat", "arattır", "arattırt");
tester.assertHasParses("yaptırarak", "yaptırtarak", "yaptırtmayacak");
tester.assertUnParseable("yapt", "aratt");
}
@Test
public void stemChange() {
Tester tester = new Tester("demek [A:StemChange]", "yemek [A:StemChange]");
tester.assertHasParses(
"ye", "de", "yeme", "deme", "yiyor", "diyor", "yemiyor", "demiyor", "yedi", "dedi");
tester.assertUnParseable("yi", "di", "yime", "dime", "yeyor", "deyor", "yemeyor");
}
@Test
public void testA3pl() {
Tester tester = new Tester("elma", "mavi [P:Adj]");
tester.assertHasParses("elmalar", "elmalara", "elmalarda", "elmalardaki", "elmalardakilerdeki");
tester.assertHasParses("elmalardı", "elmalaraydı", "elmalardır", "elmalardandır", "elmalarsa");
tester.assertHasParses("maviler", "mavilere", "mavilerim", "mavilerdendir", "mavilerdeymiş");
}
@Test
public void PresPart_yAn() {
Tester tester = new Tester("aramak", "gitmek [A:Voicing, Aorist_A]");
//
tester.assertHasParses(
"gidene", "arayandan", "gitmeyenden", "aramayanı", "aratmayanı", "aranmayanı");
}
public static int perform(String... args) throws Exception {
Options options = new Options();
options.addOption("a", "artifacts", true, "Artifacts");
options.addOption("x", "exitcode", false, "Status in exit code");
CommandLineParser parser = new DefaultParser();
final CommandLine cmd = parser.parse(options, args);
List<Path> testFolders =
new ArrayList<Path>() {
{
for (String arg : cmd.getArgs()) add(Paths.get(arg));
}
};
String artifacts = cmd.getOptionValue("a", "https://vefa.difi.no/validator/repo/");
List<Validation> validations;
if (artifacts.startsWith("http"))
validations = Tester.perform(URI.create(artifacts), testFolders);
else validations = Tester.perform(Paths.get(artifacts), testFolders);
int result = 0;
if (cmd.hasOption("x"))
for (Validation validation : validations)
if (validation.getReport().getFlag().compareTo(FlagType.EXPECTED) > 0)
result = Math.max(result, validation.getReport().getFlag().compareTo(FlagType.EXPECTED));
return result;
}
// test the updateStats method
void testUpdateStats(Tester t) {
player.updateStats(avocado);
t.checkExpect(player, new Player(751f, 7.7f, 600, new Posn(0, CollectTheFruit.height - 30)));
resetPlayer();
player.updateStats(twinkie);
t.checkExpect(player, new Player(630f, 3.9f, 0, new Posn(0, CollectTheFruit.height - 30)));
}
// Test the hasWon() method
void testHasWon(Tester t) {
resetPlayer();
t.checkExpect(player.hasWon(), false);
resetPlayer();
player.score = 100000;
t.checkExpect(player.hasWon(), true);
}
@Test
public void methodCallIsLimitedByTokenCostFunction() {
RateLimit rateLimit = new RateLimit(100, perSecond(0));
TokenCostFunction tokenCostFuction =
new TokenCostFunction() {
@Override
public int calculateCost(Method method, Object[] args) {
return (Integer) args[0] * 2;
}
};
Tester rateLimitedTester =
rateLimiterFactory.limitRate(
mockTester, methodMatching("rateLimit.*"), tokenCostFuction, rateLimit);
rateLimitedTester.rateLimitMe(48); // Use 96 of the 100 tokens available.
try {
rateLimitedTester.rateLimitMe(10); // Fail: wants 20, but only 4 remaining.
} catch (CapacityExceededException e) {
}
rateLimitedTester.rateLimitMe(2); // Use remaining 4 tokens.
try {
rateLimitedTester.rateLimitMe(1); // FailsL wants 2, but none available.
} catch (CapacityExceededException e) {
}
verify(mockTester, times(1)).rateLimitMe(48);
verify(mockTester, times(1)).rateLimitMe(2);
}
@Test
public void testDim() {
// Noun-Noun
Tester tester = new Tester("armut");
tester.assertHasParses("armutçuk", "armutçuğu", "armutcağız", "armutcağızı");
tester.assertUnParseable("armutçuğ", "armutçukcuk", "armutçukcağız", "armutcağızcık");
// TODO: check oflazer parse "babacım = baba+Noun+A3sg+Pnon+Nom^DB+Noun+Dim+A3sg+P1sg+Nom
}
@Test
public void testBecome() {
// noun
Tester tester = new Tester("elma", "mavi [P:Adj]");
tester.assertHasParses("elmalaş");
// adj
tester.assertHasParses("mavileş");
}
@Test
public void testAcquire() {
// noun
Tester tester = new Tester("elma", "mavi [P:Adj]");
tester.assertHasParses("elmalan", "elmalanıyor", "elmalandırmak");
// adj
tester.assertHasParses("mavilendirilebileceğinden");
}
@Test
public void testAorist() {
Tester tester =
new Tester("aramak", "gitmek [A:Voicing, Aorist_A]", "gelmek [A:NonTransitive, Aorist_I]");
tester.assertHasParses("arar", "ararsa", "gider", "gelir", "aramaz");
tester.assertHasParses("ararlar", "ararlarsa", "ararsalar");
tester.assertUnParseable("geler", "gidir");
}
// test the changeSpeed method
void testChangeSpeed(Tester t) {
resetPlayer();
player.changeSpeed(0.1f);
t.checkExpect(player.speed, 6.4f);
resetPlayer();
player.changeSpeed(-0.1f);
t.checkExpect(player.speed, 5.4f);
}
public static void main(String[] args) {
Tester.checkEqual(
ClassWithStaticInnerInterfaces.class.getName(), "ClassWithStaticInnerInterfaces");
Tester.checkEqual(
ClassWithStaticInnerInterfaces.Inner1.class.getName(),
"ClassWithStaticInnerInterfaces$Inner1");
Tester.checkEqual(I1.class.getName(), "I1");
}
@Test
public void testRelated() {
// Noun-Adj
Tester tester = new Tester("elma");
tester.assertHasParses("elmadaki", "elmadakini");
tester.assertHasParses("elmanınki", "elmanınkinde", "elmanınkinden");
tester.assertUnParseable("elmaki", "elmayaki", "elmadakiki");
// TODO: add akşamki etc. uses Rel_kI instead of Rel_ki
}
boolean testAllSuch(Tester t) {
return t.checkExpect(imglistshortnames.allSuchImageFile(this.FourFiles), true)
&&
/*t.checkExpect(imglistjpgs.allSuchImageFile(this.givenFiles),
true) &&
t.checkExpect(imglistgif.allSuchImageFile(this.givenFiles),
true); */
t.checkExpect(img1.kind.equals(img7.kind), true);
}
@Test
public void testProgressive() {
// Noun-Noun
Tester tester = new Tester("aramak", "gelmek");
tester.assertHasParses(
"arıyor", "aramıyor", "geliyor", "gelmiyor", "arıyordu", "arıyorlardı", "gelmiyorlarsa");
tester.assertHasParses("arıyormuş", "aramıyorsak", "geliyormuşuz");
tester.assertHasParses("aramakta", "aramamakta", "gelmekte", "gelmemekte");
}
public void testUnkownClassOption() throws Exception {
class A {}
CommandDescriptor<Instance<A>> cmd = CommandFactory.DEFAULT.create(A.class);
//
Tester<A> tester = new Tester<A>(cmd, "-o");
tester.assertEnd(Event.Stop.Unresolved.NoSuchOption.class, 0);
}
// test the method sort for the lists of Strings
boolean testSort(Tester t) {
return t.checkExpect(this.mtLoString.sort(), this.mtLoString)
&& t.checkExpect(
this.unsorted.sort(),
new ConsLoString(
"and ",
new ConsLoString(
"Book ",
new ConsLoString("Pen ", new ConsLoString("Water ", this.mtLoString)))));
}
@Test
public void proxyPassesCallOnToDecoratedObject() {
Tester rateLimitedTester =
rateLimiterFactory.limitRate(
mockTester, methodMatching(".*"), fixedCost(1), new RateLimit(10, 10, perSecond(0)));
rateLimitedTester.rateLimitMe(11);
verify(mockTester).rateLimitMe(11);
assertNotSame(rateLimitedTester, mockTester);
}
// test the method reverse for the lists of Strings
boolean testReverse(Tester t) {
return t.checkExpect(this.mtLoString.reverse(), this.mtLoString)
&& t.checkExpect(this.palindrome.reverse(), this.palindrome)
&& t.checkExpect(
this.sorted.reverse(),
new ConsLoString(
"g",
new ConsLoString(
"d", new ConsLoString("c", new ConsLoString("a", this.mtLoString)))));
}
// Test the IsDead() method
void testIsDead(Tester t) {
resetPlayer();
t.checkExpect(player.isDead(), false);
resetPlayer();
player.speed = 0;
t.checkExpect(player.isDead(), true);
resetPlayer();
player.hunger = 0;
t.checkExpect(player.isDead(), true);
}
@Test
public void testPassive() {
// Noun-Noun
Tester tester = new Tester("yapmak", "aramak", "gelmek");
tester.assertHasParses("aranıl", "yapıl", "aran", "gelin", "gelinil");
tester.assertUnParseable("aral", "gelil", "kavurul", "kavurunul");
// causative and passive
tester.assertHasParses(
"yaptırıl", "yaptırtıl", "yaptırttırıl", "aratıl", "arattırıl", "arattırtıl");
}
@Test
public void asif() {
Tester tester = new Tester("aramak", "gitmek [A:Voicing, Aorist_A]");
tester.assertHasParses(
"ararcasına",
"aramazcasına",
"arıyormuşçasına",
"aranılmışçasına",
"gidebilirmişsinizcesine");
}
public static void main(String[] args) {
try {
new ConstructorExecInitFails();
} catch (NoAspectBoundException e) {
Tester.check(e.getCause() instanceof NoAspectBoundException,
"Expected NoAspectBoundException, found " + e.getCause());
return;
}
Tester.checkFailed("shouldn't be able to run");
}
// test the method insert for the lists of Strings
boolean testInsert(Tester t) {
return t.checkExpect(this.mtLoString.insert("a"), new ConsLoString("a", this.mtLoString))
&& t.checkExpect(
this.sorted.insert("b"),
new ConsLoString(
"a",
new ConsLoString(
"b",
new ConsLoString(
"c", new ConsLoString("d", new ConsLoString("g", this.mtLoString))))));
}
@Test
public void FutPart_yAcAK() {
Tester tester = new Tester("aramak", "gitmek [A:Voicing, Aorist_A]");
// WithoutDoing_mAdAn
tester.assertHasParses(
"gidecekleri",
"gitmeyeceklere",
"arayacaklardan",
"aramayacaklardan",
"arayamayacaklardan");
}
