HHH-18979 use static imports in test

Author: gavinking

hibernate-core/src/test/java/org/hibernate/orm/test/query/restriction/RestrictionTest.java

@@ -7,16 +7,28 @@
 import jakarta.persistence.Entity;
 import jakarta.persistence.Id;
 import jakarta.persistence.metamodel.SingularAttribute;
-import org.hibernate.query.Order;
-import org.hibernate.query.Restriction;
-import org.hibernate.query.range.Range;
 import org.hibernate.testing.orm.junit.DomainModel;
 import org.hibernate.testing.orm.junit.SessionFactory;
 import org.hibernate.testing.orm.junit.SessionFactoryScope;
 import org.junit.jupiter.api.Test;
 
 import java.util.List;
 
+import static org.hibernate.query.Order.asc;
+import static org.hibernate.query.Order.desc;
+import static org.hibernate.query.Restriction.all;
+import static org.hibernate.query.Restriction.any;
+import static org.hibernate.query.Restriction.between;
+import static org.hibernate.query.Restriction.contains;
+import static org.hibernate.query.Restriction.endWith;
+import static org.hibernate.query.Restriction.equal;
+import static org.hibernate.query.Restriction.equalIgnoringCase;
+import static org.hibernate.query.Restriction.greaterThan;
+import static org.hibernate.query.Restriction.in;
+import static org.hibernate.query.Restriction.like;
+import static org.hibernate.query.Restriction.restrict;
+import static org.hibernate.query.Restriction.unrestricted;
+import static org.hibernate.query.range.Range.singleCaseInsensitiveValue;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 
 @SessionFactory
@@ -41,81 +53,81 @@ void test(SessionFactoryScope scope) {
 
 		Book book = scope.fromSession( session ->
 				session.createSelectionQuery( "from Book", Book.class )
-						.addRestriction( Restriction.equal( isbn, "9781932394153" ) )
+						.addRestriction( equal( isbn, "9781932394153" ) )
 						.getSingleResult() );
 		assertEquals( "Hibernate in Action", book.title );
 		List<Book> books = scope.fromSession( session ->
 				session.createSelectionQuery( "from Book", Book.class)
-						.addRestriction( Restriction.like( title, "%Hibernate%" ) )
-						.setOrder( Order.desc( title ) )
+						.addRestriction( like( title, "%Hibernate%" ) )
+						.setOrder( desc( title ) )
 						.getResultList() );
 		assertEquals( 2, books.size() );
 		assertEquals( "Java Persistence with Hibernate", books.get(0).title );
 		assertEquals( "Hibernate in Action", books.get(1).title );
 		List<Book> booksByIsbn = scope.fromSession( session ->
 				session.createSelectionQuery( "from Book", Book.class)
-						.addRestriction( Restriction.in( isbn, List.of("9781932394153", "9781617290459") ) )
-						.setOrder( Order.asc( title ) )
+						.addRestriction( in( isbn, List.of("9781932394153", "9781617290459") ) )
+						.setOrder( asc( title ) )
 						.getResultList() );
 		assertEquals( 2, booksByIsbn.size() );
 		assertEquals( "Hibernate in Action", booksByIsbn.get(0).title );
 		assertEquals( "Java Persistence with Hibernate", booksByIsbn.get(1).title );
 		List<Book> booksByPages = scope.fromSession( session ->
 				session.createSelectionQuery( "from Book", Book.class)
-						.addRestriction( Restriction.greaterThan( pages, 500 ) )
+						.addRestriction( greaterThan( pages, 500 ) )
 						.getResultList() );
 		assertEquals( 1, booksByPages.size() );
 		List<Book> booksByPageRange = scope.fromSession( session ->
 				session.createSelectionQuery( "from Book", Book.class)
-						.addRestriction( Restriction.between( pages, 150, 400 ) )
+						.addRestriction( between( pages, 150, 400 ) )
 						.getResultList() );
 		assertEquals( 1, booksByPageRange.size() );
 		Book bookByTitle = scope.fromSession( session ->
 				session.createSelectionQuery( "from Book", Book.class)
-						.addRestriction( Restriction.equalIgnoringCase( title, "hibernate in action" ) )
+						.addRestriction( equalIgnoringCase( title, "hibernate in action" ) )
 						.getSingleResultOrNull() );
 		assertEquals( "9781932394153", bookByTitle.isbn );
 		Book bookByTitleUnsafe = scope.fromSession( session ->
 				session.createSelectionQuery( "from Book", Book.class)
-						.addRestriction( Restriction.restrict( Book.class, "title",
-								Range.singleCaseInsensitiveValue("hibernate in action") ) )
+						.addRestriction( restrict( Book.class, "title",
+								singleCaseInsensitiveValue("hibernate in action") ) )
 						.getSingleResultOrNull() );
 		assertEquals( "9781932394153", bookByTitleUnsafe.isbn );
 		List<Book> allBooks = scope.fromSession( session ->
 				session.createSelectionQuery( "from Book", Book.class)
-						.addRestriction( Restriction.unrestricted() )
+						.addRestriction( unrestricted() )
 						.getResultList() );
 		assertEquals( 2, allBooks.size() );
 		List<Book> noBooks = scope.fromSession( session ->
 				session.createSelectionQuery( "from Book", Book.class)
-						.addRestriction( Restriction.unrestricted().negated() )
+						.addRestriction( unrestricted().negated() )
 						.getResultList() );
 		assertEquals( 0, noBooks.size() );
 		List<Book> books1 = scope.fromSession( session ->
 				session.createSelectionQuery( "from Book", Book.class)
-						.addRestriction( Restriction.endWith(title, "Hibernate") )
+						.addRestriction( endWith(title, "Hibernate") )
 						.getResultList() );
 		assertEquals( 1, books1.size() );
 		List<Book> books2 = scope.fromSession( session ->
 				session.createSelectionQuery( "from Book", Book.class)
-						.addRestriction( Restriction.like(title, "*Hibernat?", false, '?', '*') )
+						.addRestriction( like(title, "*Hibernat?", false, '?', '*') )
 						.getResultList() );
 		assertEquals( 1, books2.size() );
 		List<Book> books3 = scope.fromSession( session ->
 				session.createSelectionQuery( "from Book", Book.class)
-						.addRestriction( Restriction.contains(title, "Hibernate") )
+						.addRestriction( contains(title, "Hibernate") )
 						.getResultList() );
 		assertEquals( 2, books3.size() );
 		List<Book> booksByTitleAndIsbn = scope.fromSession( session ->
 				session.createSelectionQuery( "from Book", Book.class)
-						.addRestriction( Restriction.all( Restriction.contains(title, "Hibernate"),
-								Restriction.equal( isbn, "9781932394153" ) ) )
+						.addRestriction( all( contains(title, "Hibernate"),
+								equal( isbn, "9781932394153" ) ) )
 						.getResultList() );
 		assertEquals( 1, booksByTitleAndIsbn.size() );
 		List<Book> booksByTitleOrIsbn = scope.fromSession( session ->
 				session.createSelectionQuery( "from Book", Book.class)
-						.addRestriction( Restriction.any( Restriction.contains(title, "Hibernate"),
-								Restriction.equal( isbn, "9781932394153" ) ) )
+						.addRestriction( any( contains(title, "Hibernate"),
+								equal( isbn, "9781932394153" ) ) )
 						.getResultList() );
 		assertEquals( 2, booksByTitleOrIsbn.size() );
 	}