CodeCow/querydsl
1
0
Fork 0
mirror of https://github.com/querydsl/querydsl.git synced 2026-07-03 21:07:49 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

Renamed DomainType -> Person.

Browse Source 
Created a test that fails in AliasTest.
This commit is contained in:
Vesa Martilla 2010-09-23 14:45:42 +00:00
parent 01540f42ec
commit 2fbb0fbd59
3 changed files with 75 additions and 69 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

140
querydsl-scala/src/test/scala/com/mysema/query/scala/AliasTest.scala
View File

@ -9,7 +9,7 @@ import org.junit.Test
class AliasTest {
val domainType = alias(classOf[DomainType])
val person = alias(classOf[Person])
def assertEquals(expected: String, actual: Any) {
org.junit.Assert.assertEquals(expected, actual.toString);
@ -17,168 +17,174 @@ class AliasTest {
@Test
def Path_Equality {
assertEquals("domainType.firstName = domainType.lastName", domainType.firstName $eq domainType.lastName);
assertEquals("person.firstName = person.lastName", person.firstName $eq person.lastName);
}
@Test
def String_Equality {
assertEquals("domainType.firstName = Hello", domainType.firstName $eq "Hello");
assertEquals("domainType.firstName != Hello", domainType.firstName $ne "Hello");
assertEquals("domainType.firstName != Hello", domainType.firstName $ne "Hello");
assertEquals("person.firstName = Ben", person.firstName $eq "Ben");
assertEquals("person.firstName != Ben", person.firstName $ne "Ben");
assertEquals("person.firstName != Ben", person.firstName $ne "Ben");
}
@Test
def String_Like {
assertEquals("domainType.firstName like Hello", domainType.firstName $like "Hello");
assertEquals("person.firstName like Ben", person.firstName $like "Ben");
}
@Test
def String_Order {
assertEquals("domainType.firstName ASC", domainType.firstName asc);
assertEquals("person.firstName ASC", person.firstName asc);
}
@Test
def String_Append {
assertEquals("domainType.firstName + x", domainType.firstName $append "x");
assertEquals("domainType.firstName + + domainType.lastName", domainType.firstName $append " " $append domainType.lastName);
assertEquals("person.firstName + x", person.firstName $append "x");
assertEquals("person.firstName + + person.lastName", person.firstName $append " " $append person.lastName);
}
@Test
def String_And {
val andClause = (domainType.firstName $like "An%") $and (domainType.firstName $like "Be%");
assertEquals("domainType.firstName like An% && domainType.firstName like Be%", andClause);
val andClause = (person.firstName $like "An%") $and (person.firstName $like "Be%");
assertEquals("person.firstName like An% && person.firstName like Be%", andClause);
}
@Test
def String_Or {
val orClause = (domainType.firstName $like "An%") $or (domainType.firstName $like "Be%");
assertEquals("domainType.firstName like An% || domainType.firstName like Be%", orClause);
val orClause = (person.firstName $like "An%") $or (person.firstName $like "Be%");
assertEquals("person.firstName like An% || person.firstName like Be%", orClause);
}
@Test
def String_Not {
assertEquals("!domainType.firstName like An%", (domainType.firstName $like "An%") not);
assertEquals("!person.firstName like An%", (person.firstName $like "An%") not);
assertEquals("!domainType.firstName like An%", not(domainType.firstName $like "An%"));
assertEquals("!person.firstName like An%", not(person.firstName $like "An%"));
}
@Test
def String_Trim {
assertEquals("trim(domainType.firstName)", domainType.firstName $trim);
assertEquals("trim(person.firstName)", person.firstName $trim);
}
@Test
def String_Is_Empty {
assertEquals("empty(domainType.firstName)", domainType.firstName $isEmpty);
assertEquals("empty(person.firstName)", person.firstName $isEmpty);
}
@Test
def Number_Comparison {
assertEquals("domainType.scalaInt < 5", domainType.scalaInt $lt 5);
assertEquals("domainType.javaInt < 5", domainType.javaInt $lt 5);
assertEquals("domainType.javaInt > 5", domainType.javaInt $gt 5);
assertEquals("domainType.javaInt <= 5", domainType.javaInt $loe 5);
assertEquals("domainType.javaInt >= 5", domainType.javaInt $goe 5);
assertEquals("domainType.javaInt = 5", domainType.javaInt $eq 5);
assertEquals("domainType.javaInt != 5", domainType.javaInt $ne 5);
assertEquals("person.scalaInt < 5", person.scalaInt $lt 5);
assertEquals("person.javaInt < 5", person.javaInt $lt 5);
assertEquals("person.javaInt > 5", person.javaInt $gt 5);
assertEquals("person.javaInt <= 5", person.javaInt $loe 5);
assertEquals("person.javaInt >= 5", person.javaInt $goe 5);
assertEquals("person.javaInt = 5", person.javaInt $eq 5);
assertEquals("person.javaInt != 5", person.javaInt $ne 5);
}
@Test
def Number_Between {
assertEquals("domainType.scalaInt between 2 and 3", domainType.scalaInt $between (2, 3));
assertEquals("domainType.javaInt between 2 and 3", domainType.javaInt $between (2, 3));
assertEquals("person.scalaInt between 2 and 3", person.scalaInt $between (2, 3));
assertEquals("person.javaInt between 2 and 3", person.javaInt $between (2, 3));
}
@Test
def Number_Arithmetic {
assertEquals("domainType.scalaInt + 3", domainType.scalaInt $add 3);
assertEquals("domainType.scalaInt - 3", domainType.scalaInt $subtract 3);
assertEquals("domainType.scalaInt / 3", domainType.scalaInt $divide 3);
assertEquals("domainType.scalaInt * 3", domainType.scalaInt $multiply 3);
assertEquals("domainType.scalaInt * -1", domainType.scalaInt $negate);
assertEquals("domainType.scalaInt % 4", domainType.scalaInt $mod 4);
assertEquals("round(domainType.scalaInt)", domainType.scalaInt $round);
assertEquals("floor(domainType.scalaInt)", domainType.scalaInt $floor);
assertEquals("ceil(domainType.scalaInt)", domainType.scalaInt $ceil);
assertEquals("sqrt(domainType.scalaInt)", domainType.scalaInt $sqrt);
assertEquals("person.scalaInt + 3", person.scalaInt $add 3);
assertEquals("person.scalaInt - 3", person.scalaInt $subtract 3);
assertEquals("person.scalaInt / 3", person.scalaInt $divide 3);
assertEquals("person.scalaInt * 3", person.scalaInt $multiply 3);
assertEquals("person.scalaInt * -1", person.scalaInt $negate);
assertEquals("person.scalaInt % 4", person.scalaInt $mod 4);
assertEquals("round(person.scalaInt)", person.scalaInt $round);
assertEquals("floor(person.scalaInt)", person.scalaInt $floor);
assertEquals("ceil(person.scalaInt)", person.scalaInt $ceil);
assertEquals("sqrt(person.scalaInt)", person.scalaInt $sqrt);
}
@Test
def Number_Casts {
assertEquals("cast(domainType.javaInt,class java.lang.Long)", domainType.javaInt $longValue);
assertEquals("cast(domainType.scalaInt,class java.lang.Long)", domainType.scalaInt $longValue);
assertEquals("cast(person.javaInt,class java.lang.Long)", person.javaInt $longValue);
assertEquals("cast(person.scalaInt,class java.lang.Long)", person.scalaInt $longValue);
}
@Test
def Java_Collections_Size {
assertEquals("size(domainType.javaCollection)", domainType.javaCollection $size);
assertEquals("size(domainType.javaSet)", domainType.javaSet $size);
assertEquals("size(domainType.javaList)", domainType.javaList $size);
assertEquals("size(domainType.javaMap)", domainType.javaMap $size);
assertEquals("size(person.javaCollection)", person.javaCollection $size);
assertEquals("size(person.javaSet)", person.javaSet $size);
assertEquals("size(person.javaList)", person.javaList $size);
assertEquals("size(person.javaMap)", person.javaMap $size);
}
@Test
def Java_Collections_Is_Empty {
assertEquals("empty(domainType.javaCollection)", domainType.javaCollection $isEmpty);
assertEquals("empty(domainType.javaSet)", domainType.javaSet $isEmpty);
assertEquals("empty(domainType.javaList)", domainType.javaList $isEmpty);
assertEquals("empty(domainType.javaMap)", domainType.javaMap $isEmpty);
assertEquals("empty(person.javaCollection)", person.javaCollection $isEmpty);
assertEquals("empty(person.javaSet)", person.javaSet $isEmpty);
assertEquals("empty(person.javaList)", person.javaList $isEmpty);
assertEquals("empty(person.javaMap)", person.javaMap $isEmpty);
}
@Test
def Java_Collections_Get {
assertEquals("domainType.javaList.get(0) is not null", domainType.javaList.get(0) $isNotNull);
assertEquals("domainType.javaMap.get(xxx) is null", domainType.javaMap.get("xxx") $isNull);
assertEquals("person.javaList.get(0) is not null", person.javaList.get(0) $isNotNull);
assertEquals("person.javaMap.get(xxx) is null", person.javaMap.get("xxx") $isNull);
}
@Test
def Java_Collections_Get_And_Starts_With {
assertEquals("startsWith(domainType.javaMap.get(xxx),X)", domainType.javaMap.get("xxx") $startsWith "X");
assertEquals("startsWith(person.javaMap.get(xxx),X)", person.javaMap.get("xxx") $startsWith "X");
}
@Test
def Scala_Collections_Size {
assertEquals("size(domainType.scalaList)", domainType.scalaList $size);
assertEquals("size(domainType.scalaMap)", domainType.scalaMap $size);
assertEquals("size(person.scalaList)", person.scalaList $size);
assertEquals("size(person.scalaMap)", person.scalaMap $size);
}
@Test
def Scala_Collections_Is_Empty {
assertEquals("empty(domainType.scalaList)", domainType.scalaList $isEmpty);
assertEquals("empty(domainType.scalaMap)", domainType.scalaMap $isEmpty);
assertEquals("empty(person.scalaList)", person.scalaList $isEmpty);
assertEquals("empty(person.scalaMap)", person.scalaMap $isEmpty);
}
@Test
def Scala_Collections_Get {
assertEquals("domainType.scalaList.get(0) is not null", domainType.scalaList(0) $isNotNull);
assertEquals("domainType.scalaList.get(0) is not null", domainType.scalaList(0) $isNotNull);
assertEquals("domainType.scalaMap.get(xxx) is null", domainType.scalaMap("xxx") $isNull);
assertEquals("person.scalaList.get(0) is not null", person.scalaList(0) $isNotNull);
assertEquals("person.scalaList.get(0) is not null", person.scalaList(0) $isNotNull);
assertEquals("person.scalaMap.get(xxx) is null", person.scalaMap("xxx") $isNull);
}
@Test
def Scala_Collections_Contains {
assertEquals("X in domainType.scalaList", domainType.scalaList $contains "X");
assertEquals("X in domainType.javaList", domainType.javaList $contains "X");
assertEquals("X in person.scalaList", person.scalaList $contains "X");
assertEquals("X in person.javaList", person.javaList $contains "X");
}
@Test
def Scala_Collections_Get_And_Starts_With {
assertEquals("startsWith(domainType.scalaMap.get(xxx),X)", domainType.scalaMap("xxx") $startsWith "X");
assertEquals("startsWith(person.scalaMap.get(xxx),X)", person.scalaMap("xxx") $startsWith "X");
}
@Test
def Array_Size {
assertEquals("size(domainType.array)", domainType.array $size ());
assertEquals("size(person.array)", person.array $size ());
}
@Test
def Complex_Expressions() {
val expr = ((domainType.firstName $startsWith domainType.lastName)
$and (domainType.javaInt $lt domainType.scalaInt)
$or (domainType.javaDouble $isNull));
assertEquals("startsWith(domainType.firstName,domainType.lastName) " +
"&& domainType.javaInt < domainType.scalaInt " +
"|| domainType.javaDouble is null", expr);
def Complex_Starts_With_And_Less_Than_And_Is_Null() {
val expr = ((person.firstName $startsWith person.lastName)
$and (person.javaInt $lt person.scalaInt)
$or (person.javaDouble $isNull));
assertEquals("startsWith(person.firstName,person.lastName) " +
"&& person.javaInt < person.scalaInt " +
"|| person.javaDouble is null", expr);
}
@Test
def I_Used_To_Be_Complex_Now_I_Am_Simple() {
val expr = person.firstName $startsWith "amin";
assertEquals("endsWith(person.firstName,amin)", expr);
}
}

2
querydsl-scala/src/test/scala/com/mysema/query/scala/ExampleDomain.scala
View File

@ -1,6 +1,6 @@
package com.mysema.query.scala;
class DomainType {
class Person {
var scalaInt: Int = _;
var javaInt: Integer = null;

2
querydsl-scala/src/test/scala/com/mysema/query/scala/JPAQueryTest.scala
View File

@ -9,7 +9,7 @@ import org.junit.Assert._
class JPAQueryTest {
var domainType = alias(classOf[DomainType])
var domainType = alias(classOf[Person])
@Test
def OneLiner() {