diff --git a/.github/dependabot.yml b/.github/dependabot.yml new file mode 100644 index 0000000000..2bd7143061 --- /dev/null +++ b/.github/dependabot.yml @@ -0,0 +1,17 @@ +# To get started with Dependabot version updates, you'll need to specify which +# package ecosystems to update and where the package manifests are located. +# Please see the documentation for all configuration options: +# https://docs.github.com/github/administering-a-repository/configuration-options-for-dependency-updates + +version: 2 +updates: + - package-ecosystem: "github-actions" + directory: "/" + schedule: + interval: "monthly" + groups: + workflow-actions: + patterns: + - "*" + allow: + - dependency-name: "actions/*" diff --git a/.github/workflows/build_test.yml b/.github/workflows/build_test.yml index 109aede3b3..38b3308676 100644 --- a/.github/workflows/build_test.yml +++ b/.github/workflows/build_test.yml @@ -9,20 +9,18 @@ jobs: steps: - name: Checkout PR Branch - uses: actions/checkout@v2 + uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2 with: ref: ${{ github.event.pull_request.head.sha }} fetch-depth: 0 - name: Setup Java 11 - uses: actions/setup-java@v1 + uses: actions/setup-java@3a4f6e1af504cf6a31855fa899c6aa5355ba6c12 # v4.7.0 with: java-version: 11 - java-package: jdk - architecture: x64 + distribution: temurin - name: Build and Test - uses: GabrielBB/xvfb-action@v1 - with: - run: mvn clean install - + uses: GabrielBB/xvfb-action@b706e4e27b14669b486812790492dc50ca16b465 # v1.7 + with: + run: ./mvnw clean install diff --git a/.mvn/wrapper/maven-wrapper.jar b/.mvn/wrapper/maven-wrapper.jar new file mode 100644 index 0000000000..7967f30dd1 Binary files /dev/null and b/.mvn/wrapper/maven-wrapper.jar differ diff --git a/.mvn/wrapper/maven-wrapper.properties b/.mvn/wrapper/maven-wrapper.properties new file mode 100644 index 0000000000..f5b763a229 --- /dev/null +++ b/.mvn/wrapper/maven-wrapper.properties @@ -0,0 +1,20 @@ +# Licensed to the Apache Software Foundation (ASF) under one +# or more contributor license agreements. See the NOTICE file +# distributed with this work for additional information +# regarding copyright ownership. The ASF licenses this file +# to you under the Apache License, Version 2.0 (the +# "License"); you may not use this file except in compliance +# with the License. You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, +# software distributed under the License is distributed on an +# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +# KIND, either express or implied. See the License for the +# specific language governing permissions and limitations +# under the License. +wrapperVersion=3.3.2 +distributionType=bin +distributionUrl=https://repo.maven.apache.org/maven2/org/apache/maven/apache-maven/3.9.7/apache-maven-3.9.7-bin.zip +wrapperUrl=https://repo.maven.apache.org/maven2/org/apache/maven/wrapper/maven-wrapper/3.3.2/maven-wrapper-3.3.2.jar diff --git a/.release/.gitignore b/.release/.gitignore new file mode 100644 index 0000000000..cdd9a17d6b --- /dev/null +++ b/.release/.gitignore @@ -0,0 +1,3 @@ +# The folder into which we checkout our release scripts into +* +!.gitignore \ No newline at end of file diff --git a/ant/pom.xml b/ant/pom.xml index 5b08096009..d69d021f64 100644 --- a/ant/pom.xml +++ b/ant/pom.xml @@ -21,7 +21,7 @@ org.hibernate.tool hibernate-tools-parent - 6.5.0.Final + 6.6.27-SNAPSHOT hibernate-tools-ant @@ -30,6 +30,11 @@ Hibernate Tools Ant Tasks jar + + + false + + org.apache.ant @@ -48,6 +53,47 @@ hibernate-tools-tests-utils test + + com.h2database + h2 + test + + + + + org.codehaus.mojo + build-helper-maven-plugin + + + add-test-source + generate-test-sources + + add-test-source + + + + src/it/java + + + + + + + + org.apache.maven.plugins + maven-failsafe-plugin + + + + integration-test + verify + + + + + + + diff --git a/ant/src/it/java/org/hibernate/tool/ant/Hbm2JavaTestIT.java b/ant/src/it/java/org/hibernate/tool/ant/Hbm2JavaTestIT.java new file mode 100644 index 0000000000..b372bba6b8 --- /dev/null +++ b/ant/src/it/java/org/hibernate/tool/ant/Hbm2JavaTestIT.java @@ -0,0 +1,99 @@ +package org.hibernate.tool.ant; + +import org.hibernate.tool.it.ant.TestTemplate; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; + +public class Hbm2JavaTestIT extends TestTemplate { + + @Test + public void testJpaDefault() throws Exception { + setHibernateToolTaskXml( + " \n" + + " \n" + + " \n" + + " \n" + ); + setDatabaseCreationScript(new String[] { + "create table PERSON (ID int not null, NAME varchar(20), primary key (ID))" + }); + createProjectAndBuild(); + assertFolderExists("generated", 1); + assertFileExists("generated/Person.java"); + String generatedPersonJavaFileContents = getFileContents("generated/Person.java"); + assertTrue(generatedPersonJavaFileContents.contains("import jakarta.persistence.Entity;")); + assertTrue(generatedPersonJavaFileContents.contains("public class Person ")); + } + + @Test + public void testNoAnnotations() throws Exception { + setHibernateToolTaskXml( + " \n" + + " \n" + + " \n" + + " \n" + ); + setDatabaseCreationScript(new String[] { + "create table PERSON (ID int not null, NAME varchar(20), primary key (ID))" + }); + createProjectAndBuild(); + assertFolderExists("generated", 1); + assertFileExists("generated/Person.java"); + String generatedPersonJavaFileContents = getFileContents("generated/Person.java"); + assertFalse(generatedPersonJavaFileContents.contains("import jakarta.persistence.Entity;")); + assertTrue(generatedPersonJavaFileContents.contains("public class Person ")); + } + + @Test + public void testNoGenerics() throws Exception { + setHibernateToolTaskXml( + " \n" + + " \n" + + " \n" + + " \n" + ); + setDatabaseCreationScript(new String[] { + "create table PERSON (ID int not null, NAME varchar(20), " + + "primary key (ID))", + "create table ITEM (ID int not null, NAME varchar(20), OWNER_ID int not null, " + + "primary key (ID), foreign key (OWNER_ID) references PERSON(ID))" + }); + createProjectAndBuild(); + assertFolderExists("generated", 2); + assertFileExists("generated/Person.java"); + String generatedPersonJavaFileContents = getFileContents("generated/Person.java"); + assertTrue(generatedPersonJavaFileContents.contains("public class Person ")); + assertFalse(generatedPersonJavaFileContents.contains("Set")); + assertFileExists("generated/Item.java"); + String generatedItemJavaFileContents = getFileContents("generated/Item.java"); + assertTrue(generatedItemJavaFileContents.contains("public class Item ")); + } + + @Test + public void testUseGenerics() throws Exception { + setHibernateToolTaskXml( + " \n" + + " \n" + + " \n" + + " \n" + ); + setDatabaseCreationScript(new String[] { + "create table PERSON (ID int not null, NAME varchar(20), " + + "primary key (ID))", + "create table ITEM (ID int not null, NAME varchar(20), OWNER_ID int not null, " + + "primary key (ID), foreign key (OWNER_ID) references PERSON(ID))" + }); + createProjectAndBuild(); + assertFolderExists("generated", 2); + assertFileExists("generated/Person.java"); + String generatedPersonJavaFileContents = getFileContents("generated/Person.java"); + assertTrue(generatedPersonJavaFileContents.contains("public class Person ")); + assertTrue(generatedPersonJavaFileContents.contains("Set")); + assertFileExists("generated/Item.java"); + String generatedItemJavaFileContents = getFileContents("generated/Item.java"); + assertTrue(generatedItemJavaFileContents.contains("public class Item ")); + } + +} diff --git a/ant/src/it/java/org/hibernate/tool/ant/TutorialTestIT.java b/ant/src/it/java/org/hibernate/tool/ant/TutorialTestIT.java new file mode 100644 index 0000000000..232c5a004b --- /dev/null +++ b/ant/src/it/java/org/hibernate/tool/ant/TutorialTestIT.java @@ -0,0 +1,26 @@ +package org.hibernate.tool.ant; + +import org.hibernate.tool.it.ant.TestTemplate; +import org.junit.jupiter.api.Test; + +public class TutorialTestIT extends TestTemplate { + + @Test + public void testTutorial() throws Exception { + setHibernateToolTaskXml( + " \n" + + " \n" + + " \n" + + " \n" + ); + setDatabaseCreationScript(new String[] { + "create table PERSON (ID int not null, NAME varchar(20), primary key (ID))" + }); + createProjectAndBuild(); + assertFolderExists("generated-sources", 1); + assertFileExists("generated-sources/Person.java"); + + + } + +} diff --git a/ant/src/it/java/org/hibernate/tool/it/ant/TestTemplate.java b/ant/src/it/java/org/hibernate/tool/it/ant/TestTemplate.java new file mode 100644 index 0000000000..d0d111a020 --- /dev/null +++ b/ant/src/it/java/org/hibernate/tool/it/ant/TestTemplate.java @@ -0,0 +1,134 @@ +package org.hibernate.tool.it.ant; + +import org.apache.tools.ant.DefaultLogger; +import org.apache.tools.ant.Project; +import org.apache.tools.ant.ProjectHelper; +import org.junit.jupiter.api.io.TempDir; + +import java.io.File; +import java.nio.file.Files; +import java.sql.Connection; +import java.sql.DriverManager; +import java.sql.Statement; +import java.util.Objects; + +import static org.junit.jupiter.api.Assertions.*; + +public abstract class TestTemplate { + + @TempDir + private File projectDir; + + private String hibernateToolTaskXml; + private String[] databaseCreationScript; + + protected File getProjectDir() { + return projectDir; + } + + protected void setHibernateToolTaskXml(String xml) { + this.hibernateToolTaskXml = xml; + } + + protected void setDatabaseCreationScript(String[] sqls) { + this.databaseCreationScript = sqls; + } + + protected String constructBuildXmlFileContents() { + assertNotNull(hibernateToolTaskXml); + return buildXmlFileContents.replace("@hibernateToolTaskXml@", hibernateToolTaskXml); + } + + protected String getFileContents(String path) throws Exception { + return new String( + Files.readAllBytes( + new File(getProjectDir(), path).toPath())); + } + + protected void createProjectAndBuild() throws Exception { + createBuildXmlFile(); + createDatabase(); + createHibernatePropertiesFile(); + runAntBuild(); + } + + protected void assertFolderExists(String path, int amountOfChildren) { + File generatedOutputFolder = new File(getProjectDir(), path); + assertTrue(generatedOutputFolder.exists()); + assertTrue(generatedOutputFolder.isDirectory()); + assertEquals(amountOfChildren, Objects.requireNonNull(generatedOutputFolder.list()).length); + } + + protected void assertFileExists(String path) { + File generatedPersonJavaFile = new File(getProjectDir(), path); + assertTrue(generatedPersonJavaFile.exists()); + assertTrue(generatedPersonJavaFile.isFile()); + } + + private void runAntBuild() { + File buildXmlFile = new File(getProjectDir(), "build.xml"); + Project project = new Project(); + project.setBaseDir(getProjectDir()); + project.addBuildListener(getConsoleLogger()); + ProjectHelper.getProjectHelper().parse(project, buildXmlFile); + project.executeTarget(project.getDefaultTarget()); + } + + private void createBuildXmlFile() throws Exception { + File buildXmlFile = new File(getProjectDir(), "build.xml"); + assertFalse(buildXmlFile.exists()); + Files.writeString(buildXmlFile.toPath(), constructBuildXmlFileContents()); + assertTrue(buildXmlFile.exists()); + } + + private String constructJdbcConnectionString() { + return "jdbc:h2:" + getProjectDir().getAbsolutePath() + "/database/test;AUTO_SERVER=TRUE"; + } + + private void createDatabase() throws Exception { + File databaseFile = new File(getProjectDir(), "database/test.mv.db"); + assertFalse(databaseFile.exists()); + assertFalse(databaseFile.isFile()); + Connection connection = DriverManager.getConnection(constructJdbcConnectionString()); + Statement statement = connection.createStatement(); + for (String sql : databaseCreationScript) { + statement.execute(sql); + } + statement.close(); + connection.close(); + assertTrue(databaseFile.exists()); + assertTrue(databaseFile.isFile()); + } + + private void createHibernatePropertiesFile() throws Exception { + File hibernatePropertiesFile = new File(getProjectDir(), "hibernate.properties"); + String hibernatePropertiesFileContents = + "hibernate.connection.driver_class=org.h2.Driver\n" + + "hibernate.connection.url=" + constructJdbcConnectionString() + "\n" + + "hibernate.connection.username=\n" + + "hibernate.connection.password=\n" + + "hibernate.default_catalog=TEST\n" + + "hibernate.default_schema=PUBLIC\n"; + Files.writeString(hibernatePropertiesFile.toPath(), hibernatePropertiesFileContents); + assertTrue(hibernatePropertiesFile.exists()); + } + + private DefaultLogger getConsoleLogger() { + DefaultLogger consoleLogger = new DefaultLogger(); + consoleLogger.setErrorPrintStream(System.err); + consoleLogger.setOutputPrintStream(System.out); + consoleLogger.setMessageOutputLevel(Project.MSG_INFO); + return consoleLogger; + } + + private static final String buildXmlFileContents = + " \n" + + " \n" + + " \n" + + "@hibernateToolTaskXml@" + + " \n" + + " \n" ; + +} diff --git a/ant/src/main/java/org/hibernate/tool/ant/Hbm2JavaExporterTask.java b/ant/src/main/java/org/hibernate/tool/ant/Hbm2JavaExporterTask.java index 67faeb5ef2..06b7926bcc 100644 --- a/ant/src/main/java/org/hibernate/tool/ant/Hbm2JavaExporterTask.java +++ b/ant/src/main/java/org/hibernate/tool/ant/Hbm2JavaExporterTask.java @@ -29,9 +29,9 @@ */ public class Hbm2JavaExporterTask extends ExporterTask { - boolean ejb3 = false; + boolean ejb3 = true; - boolean jdk5 = false; + boolean jdk5 = true; public Hbm2JavaExporterTask(HibernateToolTask parent) { super( parent ); diff --git a/ci/release/Jenkinsfile b/ci/release/Jenkinsfile new file mode 100644 index 0000000000..fca39280c1 --- /dev/null +++ b/ci/release/Jenkinsfile @@ -0,0 +1,120 @@ +/* + * Hibernate Tools, Tooling for your Hibernate Projects + * + * Copyright 2016-2024 Red Hat, Inc. + * + * Licensed under the GNU Lesser General Public License (LGPL), + * version 2.1 or later (the "License"). + * You may not use this file except in compliance with the License. + * You may read the licence in the 'lgpl.txt' file in the root folder of + * project or obtain a copy at + * + * http://www.gnu.org/licenses/lgpl-2.1.html + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +@Library('hibernate-jenkins-pipeline-helpers') _ + +import org.hibernate.jenkins.pipeline.helpers.version.Version + +pipeline { + agent { + label 'Release' + } + tools { + maven 'Apache Maven 3.9' + jdk 'OpenJDK 11 Latest' + } + options { + buildDiscarder logRotator(daysToKeepStr: '30', numToKeepStr: '10') + disableConcurrentBuilds(abortPrevious: false) + } + parameters { + string( + name: 'RELEASE_VERSION', + defaultValue: '6.6.27.Final', + description: 'The version to be released, e.g. 6.6.27.Final.', + trim: true + ) + string( + name: 'DEVELOPMENT_VERSION', + defaultValue: '6.6.28-SNAPSHOT', + description: 'The next version to be used after the release, e.g. 6.6.28-SNAPSHOT.', + trim: true + ) + booleanParam( + name: 'RELEASE_DRY_RUN', + defaultValue: true, + description: 'If true, just simulate the release, without pushing any commits or tags, and without uploading any artifacts or documentation.' + ) + booleanParam( + name: 'RELEASE_PUBLISH_AUTOMATICALLY', + defaultValue: false, + description: 'If true, staging repository will get closed and published automatically, otherwise the artifacts will only be uploaded and the publishing (releasing the staging repository) has to be performed manually at Maven Central portal.' + ) + } + stages { + stage('Release') { + when { + beforeAgent true + // Releases must be triggered explicitly + // This is just for safety; normally the Jenkins job for this pipeline + // should be configured to "Suppress automatic SCM triggering" + // See https://stackoverflow.com/questions/58259326/prevent-jenkins-multibranch-pipeline-from-triggering-builds-for-new-branches + triggeredBy cause: "UserIdCause" + } + steps { + script { + // Check that all the necessary parameters are set + if (!params.RELEASE_VERSION) { + throw new IllegalArgumentException("Missing value for parameter RELEASE_VERSION.") + } + if (!params.DEVELOPMENT_VERSION) { + throw new IllegalArgumentException("Missing value for parameter DEVELOPMENT_VERSION.") + } + + def releaseVersion = Version.parseReleaseVersion(params.RELEASE_VERSION) + def developmentVersion = Version.parseDevelopmentVersion(params.DEVELOPMENT_VERSION) + env.JRELEASER_DRY_RUN = params.RELEASE_DRY_RUN + if (!params.RELEASE_PUBLISH_AUTOMATICALLY) { + env.JRELEASER_DEPLOY_MAVEN_MAVENCENTRAL_STAGE='UPLOAD' + } + echo "Performing full release for version ${releaseVersion.toString()}" + + withMaven(mavenSettingsConfig: params.RELEASE_DRY_RUN ? null : 'ci-hibernate.deploy.settings.maven', + mavenLocalRepo: env.WORKSPACE_TMP + '/.m2repository') { + configFileProvider([configFile(fileId: 'release.config.ssh', targetLocation: env.HOME + '/.ssh/config'), + configFile(fileId: 'release.config.ssh.knownhosts', targetLocation: env.HOME + '/.ssh/known_hosts')]) { + // using MAVEN_GPG_PASSPHRASE (the default env variable name for passphrase in maven gpg plugin) + withCredentials([file(credentialsId: 'release.gpg.private-key', variable: 'RELEASE_GPG_PRIVATE_KEY_PATH'), + string(credentialsId: 'release.gpg.passphrase', variable: 'JRELEASER_GPG_PASSPHRASE'), + usernamePassword(credentialsId: 'central.sonatype.com', passwordVariable: 'JRELEASER_MAVENCENTRAL_TOKEN', usernameVariable: 'JRELEASER_MAVENCENTRAL_USERNAME'), + usernamePassword(credentialsId: 'gradle-plugin-portal-api-key', passwordVariable: 'GRADLE_PUBLISH_SECRET', usernameVariable: 'GRADLE_PUBLISH_KEY'), + string(credentialsId: 'Hibernate-CI.github.com', variable: 'JRELEASER_GITHUB_TOKEN')]) { + sshagent(['ed25519.Hibernate-CI.github.com', 'hibernate.filemgmt.jboss.org', 'hibernate-ci.frs.sourceforge.net']) { + sh 'cat $HOME/.ssh/config' + dir('.release/scripts') { + sh 'git clone https://github.com/hibernate/hibernate-release-scripts.git .' + } + sh """ + bash -xe .release/scripts/release.sh -j ${params.RELEASE_DRY_RUN ? '-d' : ''} \ + tools ${releaseVersion.toString()} ${developmentVersion.toString()} + """ + } + } + } + } + } + } + } + } + post { + always { + notifyBuildResult notifySuccessAfterSuccess: true, maintainers: 'koen@hibernate.org' + } + } +} diff --git a/gradle/.gitattributes b/gradle/.gitattributes new file mode 100644 index 0000000000..097f9f98d9 --- /dev/null +++ b/gradle/.gitattributes @@ -0,0 +1,9 @@ +# +# https://help.github.com/articles/dealing-with-line-endings/ +# +# Linux start script should use lf +/gradlew text eol=lf + +# These are Windows script files and should use crlf +*.bat text eol=crlf + diff --git a/gradle/.gitignore b/gradle/.gitignore new file mode 100644 index 0000000000..1b6985c009 --- /dev/null +++ b/gradle/.gitignore @@ -0,0 +1,5 @@ +# Ignore Gradle project-specific cache directory +.gradle + +# Ignore Gradle build output directory +build diff --git a/gradle/README.md b/gradle/README.md new file mode 100644 index 0000000000..ae406d1031 --- /dev/null +++ b/gradle/README.md @@ -0,0 +1,23 @@ + + +[![Hibernate](https://static.jboss.org/hibernate/images/hibernate_200x150.png)](https://tools.hibernate.org) + +# Hibernate Tools Gradle Plugin + +## Overview + +This [Gradle](https://gradle.org/) plugin brings the power of the [Hibernate Tools API](../orm) to your Gradle build. If you are looking for a quick tutorial on the use of the Hibernate Tools Gradle plugin, we can refer you to the [5 minute tutorial](docs/5-minute-tutorial.md). diff --git a/gradle/docs/5-minute-tutorial.md b/gradle/docs/5-minute-tutorial.md new file mode 100644 index 0000000000..e389b300fd --- /dev/null +++ b/gradle/docs/5-minute-tutorial.md @@ -0,0 +1,181 @@ + + +[![Hibernate](https://static.jboss.org/hibernate/images/hibernate_200x150.png)](https://tools.hibernate.org) + +# Hibernate Tools Gradle : 5 Minute Tutorial + +The best way to get to know the Hibernate Tools Gradle plugin is to start to use it. +Hence we will provide a quick tutorial that gives you the first taste of it. +Before tackling this tutorial, make sure you have the [Gradle](https://gradle.org) build tool +[installed](https://gradle.org/install/) and available on your machine. + +## Create a Gradle Java Project + +Let’s assume in this case that we start off with a very simple default Gradle Java application +that we create from a command-line window with the instruction below. + +```shell +gradle init --type java-application --dsl groovy +``` + +Gradle will ask you some details about your application. The conversation is shown below +for completenes but of course you can make your own choices. + +```shell +Enter target Java version (min: 7, default: 21): + +Project name (default: 5-minute-tutorial): + +Select application structure: + 1: Single application project + 2: Application and library project +Enter selection (default: Single application project) [1..2] 1 + +Select test framework: + 1: JUnit 4 + 2: TestNG + 3: Spock + 4: JUnit Jupiter +Enter selection (default: JUnit Jupiter) [1..4] 4 + +Generate build using new APIs and behavior (some features may change in the next minor release)? (default: no) [yes, no] + + +> Task :init +Learn more about Gradle by exploring our Samples at https://docs.gradle.org/8.13/samples/sample_building_java_applications.html + +BUILD SUCCESSFUL in 19s +1 actionable task: 1 executed +``` + +Now you should see two folders along with a number of Gradle specific files that have +been created. It is beyond the scope of this short tutorial to explain all these artefacts. +We will focus mainly on the `build.gradle` file in the `app` folder. But to make the plugin work +you will need to modify the file `gradle.properties` that was generated in the root folder. + +## Disable the Configuration Cache + +Currently the Hibernate Tools Gradle plugin does not support the configuration cache. +As the Gradle init task generates a `gradle.properties` file in the root folder that +explicitly enables the use of the configuration cache, you will need to comment out +or delete the line where this happens. + +```properties +#org.gradle.configuration-cache=true +``` + +You could also get rid of the entire `gradle.properties` file as we don't need it for the purpose of this +tutorial. Now we can tackle the `build.gradle` file. + +## Modify the generated `app\build.gradle` file + +We have to specify the use of the Gradle plugin in the `plugin` section of the `build.gradle` file. +So we add `id 'org.hibernate.tool.hibernate-tools-gradle' version '6.6.27.Final'` to that section. + +```groovy +... +plugins { + ... + id 'org.hibernate.tool.hibernate-tools-gradle' version '6.6.27.Final' +} +... +``` + +Also we need to depend on the java library containing the [H2 database]() drivers. +This is done in the `dependencies` section of the `gradle.build` file, +to which we add `implementation 'com.h2database:h2:2.3.232'`. + +```groovy +... +dependencies { + ... + implementation 'com.h2database:h2:2.3.232' +} +... +``` + +You could as an alternative also replace the entire `gradle.build` file +with the contents as shown below. + +```groovy +plugins { + id 'application' + id 'org.hibernate.tool.hibernate-tools-gradle' version '6.6.27.Final' +} + +repositories { + mavenCentral() +} + +dependencies { + implementation('com.h2database:h2:2.3.232') +} +``` + +With this in place, we need to make sure that the Hibernate Tools Gradle plugin knows where +to find the database from which to generate the artefacts. This is done by spefifying the +Hibernate properties in the file `hibernate.properties`. + +## Specify the Hibernate Properties + +For the purpose of this tutorial introduction, let's assume that you have a database running, e.g. +[H2 Sakila database](https://github.com/hibernate/sakila-h2) reacheable at the following JDBC URL: +`jdbc:h2:tcp://localhost/./sakila`. + +With this set up, the `hibernate.properties` file should contain the properties as specified below. + +```properties +hibernate.connection.driver_class=org.h2.Driver +hibernate.connection.url=jdbc:h2:tcp://localhost/./sakila +hibernate.connection.username=sa +hibernate.default_catalog=SAKILA +hibernate.default_schema=PUBLIC +``` + +For the file to be found by the plugin, add it as a resource to the project in the +`app/src/main/resources` subfolder. + +## Run the Reverse Engineering + +With all the previous elements in place, generating the Java classes from the Sakila database +becomes as simple as issuing `./gradlew generateJava` in your command line window. + +```shell +me@machine 5-minute-tutorial % ./gradlew generateJava + +> Task :app:generateJava +Starting Task 'generateJava' +Creating Java exporter +Loading the properties file : path/to/5-minute-tutorial/app/src/main/resources/hibernate.properties +Properties file is loaded +Starting Java export to directory: path/to/5-minute-tutorial/app/generated-sources... +... +Java export finished +Ending Task 'generateJava' +``` + +By default, you will find the files in the folder `app/generated-sources`. + +``` +koen@Lateralus generated-sources % ls +Actor.java City.java Film.java FilmCategory.java Inventory.java Rental.java +Address.java Country.java FilmActor.java FilmCategoryId.java Language.java Staff.java +Category.java Customer.java FilmActorId.java FilmText.java Payment.java Store.java +``` + +Congratulations! You have succesfully created Java classes for the Sakila database... Now it's +probably time to dive somewhat deeper in the available functionality. \ No newline at end of file diff --git a/gradle/docs/examples/5-minute-tutorial/.gitattributes b/gradle/docs/examples/5-minute-tutorial/.gitattributes new file mode 100644 index 0000000000..f91f64602e --- /dev/null +++ b/gradle/docs/examples/5-minute-tutorial/.gitattributes @@ -0,0 +1,12 @@ +# +# https://help.github.com/articles/dealing-with-line-endings/ +# +# Linux start script should use lf +/gradlew text eol=lf + +# These are Windows script files and should use crlf +*.bat text eol=crlf + +# Binary files should be left untouched +*.jar binary + diff --git a/gradle/docs/examples/5-minute-tutorial/.gitignore b/gradle/docs/examples/5-minute-tutorial/.gitignore new file mode 100644 index 0000000000..2cff1e80a7 --- /dev/null +++ b/gradle/docs/examples/5-minute-tutorial/.gitignore @@ -0,0 +1,8 @@ +# Ignore Gradle project-specific cache directory +.gradle + +# Ignore Gradle build output directory +build + +# Ignore the output generated by the Hibernate Tools plugin +generated-sources \ No newline at end of file diff --git a/gradle/docs/examples/5-minute-tutorial/app/build.gradle b/gradle/docs/examples/5-minute-tutorial/app/build.gradle new file mode 100644 index 0000000000..11c50b2db8 --- /dev/null +++ b/gradle/docs/examples/5-minute-tutorial/app/build.gradle @@ -0,0 +1,45 @@ +/* + * This file was generated by the Gradle 'init' task. + * + * This generated file contains a sample Java application project to get you started. + * For more details on building Java & JVM projects, please refer to https://docs.gradle.org/8.13/userguide/building_java_projects.html in the Gradle documentation. + */ + +plugins { + // Apply the application plugin to add support for building a CLI application in Java. + id 'application' + id 'org.hibernate.tool.hibernate-tools-gradle' version '6.6.27.Final' +} + +repositories { + // Use Maven Central for resolving dependencies. + mavenCentral() +} + +dependencies { + // Use JUnit Jupiter for testing. + testImplementation libs.junit.jupiter + + testRuntimeOnly 'org.junit.platform:junit-platform-launcher' + + // This dependency is used by the application. + implementation libs.guava + implementation 'com.h2database:h2:2.3.232' +} + +// Apply a specific Java toolchain to ease working on different environments. +java { + toolchain { + languageVersion = JavaLanguageVersion.of(21) + } +} + +application { + // Define the main class for the application. + mainClass = 'org.example.App' +} + +tasks.named('test') { + // Use JUnit Platform for unit tests. + useJUnitPlatform() +} diff --git a/gradle/docs/examples/5-minute-tutorial/app/src/main/java/org/example/App.java b/gradle/docs/examples/5-minute-tutorial/app/src/main/java/org/example/App.java new file mode 100644 index 0000000000..e7e1af9398 --- /dev/null +++ b/gradle/docs/examples/5-minute-tutorial/app/src/main/java/org/example/App.java @@ -0,0 +1,14 @@ +/* + * This source file was generated by the Gradle 'init' task + */ +package org.example; + +public class App { + public String getGreeting() { + return "Hello World!"; + } + + public static void main(String[] args) { + System.out.println(new App().getGreeting()); + } +} diff --git a/gradle/docs/examples/5-minute-tutorial/app/src/main/resources/hibernate.properties b/gradle/docs/examples/5-minute-tutorial/app/src/main/resources/hibernate.properties new file mode 100644 index 0000000000..60b2483a2f --- /dev/null +++ b/gradle/docs/examples/5-minute-tutorial/app/src/main/resources/hibernate.properties @@ -0,0 +1,23 @@ +############################################################################ +# Hibernate Tools, Tooling for your Hibernate Projects # +# # +# Copyright 2004-2025 Red Hat, Inc. # +# # +# Licensed under the Apache License, Version 2.0 (the "License"); # +# you may not use this file except in compliance with the License. # +# You may obtain a copy of the License at # +# # +# http://www.apache.org/licenses/LICENSE-2.0 # +# # +# Unless required by applicable law or agreed to in writing, software # +# distributed under the License is distributed on an "AS IS" basis, # +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # +# See the License for the specific language governing permissions and # +# limitations under the License. # +############################################################################ +hibernate.connection.driver_class=org.h2.Driver +hibernate.connection.url=jdbc:h2:tcp://localhost/./sakila +hibernate.connection.username=sa +hibernate.default_catalog=SAKILA +hibernate.default_schema=PUBLIC + diff --git a/gradle/docs/examples/5-minute-tutorial/app/src/test/java/org/example/AppTest.java b/gradle/docs/examples/5-minute-tutorial/app/src/test/java/org/example/AppTest.java new file mode 100644 index 0000000000..f5ce33d353 --- /dev/null +++ b/gradle/docs/examples/5-minute-tutorial/app/src/test/java/org/example/AppTest.java @@ -0,0 +1,14 @@ +/* + * This source file was generated by the Gradle 'init' task + */ +package org.example; + +import org.junit.jupiter.api.Test; +import static org.junit.jupiter.api.Assertions.*; + +class AppTest { + @Test void appHasAGreeting() { + App classUnderTest = new App(); + assertNotNull(classUnderTest.getGreeting(), "app should have a greeting"); + } +} diff --git a/gradle/docs/examples/5-minute-tutorial/gradle.properties b/gradle/docs/examples/5-minute-tutorial/gradle.properties new file mode 100644 index 0000000000..c7e3d0408a --- /dev/null +++ b/gradle/docs/examples/5-minute-tutorial/gradle.properties @@ -0,0 +1,5 @@ +# This file was generated by the Gradle 'init' task. +# https://docs.gradle.org/current/userguide/build_environment.html#sec:gradle_configuration_properties + +#org.gradle.configuration-cache=true + diff --git a/gradle/docs/examples/5-minute-tutorial/gradle/libs.versions.toml b/gradle/docs/examples/5-minute-tutorial/gradle/libs.versions.toml new file mode 100644 index 0000000000..afde0223fa --- /dev/null +++ b/gradle/docs/examples/5-minute-tutorial/gradle/libs.versions.toml @@ -0,0 +1,10 @@ +# This file was generated by the Gradle 'init' task. +# https://docs.gradle.org/current/userguide/platforms.html#sub::toml-dependencies-format + +[versions] +guava = "33.3.1-jre" +junit-jupiter = "5.11.3" + +[libraries] +guava = { module = "com.google.guava:guava", version.ref = "guava" } +junit-jupiter = { module = "org.junit.jupiter:junit-jupiter", version.ref = "junit-jupiter" } diff --git a/gradle/docs/examples/5-minute-tutorial/gradle/wrapper/gradle-wrapper.jar b/gradle/docs/examples/5-minute-tutorial/gradle/wrapper/gradle-wrapper.jar new file mode 100644 index 0000000000..9bbc975c74 Binary files /dev/null and b/gradle/docs/examples/5-minute-tutorial/gradle/wrapper/gradle-wrapper.jar differ diff --git a/gradle/docs/examples/5-minute-tutorial/gradle/wrapper/gradle-wrapper.properties b/gradle/docs/examples/5-minute-tutorial/gradle/wrapper/gradle-wrapper.properties new file mode 100644 index 0000000000..37f853b1c8 --- /dev/null +++ b/gradle/docs/examples/5-minute-tutorial/gradle/wrapper/gradle-wrapper.properties @@ -0,0 +1,7 @@ +distributionBase=GRADLE_USER_HOME +distributionPath=wrapper/dists +distributionUrl=https\://services.gradle.org/distributions/gradle-8.13-bin.zip +networkTimeout=10000 +validateDistributionUrl=true +zipStoreBase=GRADLE_USER_HOME +zipStorePath=wrapper/dists diff --git a/gradle/docs/examples/5-minute-tutorial/gradlew b/gradle/docs/examples/5-minute-tutorial/gradlew new file mode 100755 index 0000000000..faf93008b7 --- /dev/null +++ b/gradle/docs/examples/5-minute-tutorial/gradlew @@ -0,0 +1,251 @@ +#!/bin/sh + +# +# Copyright © 2015-2021 the original authors. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# https://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# SPDX-License-Identifier: Apache-2.0 +# + +############################################################################## +# +# Gradle start up script for POSIX generated by Gradle. +# +# Important for running: +# +# (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is +# noncompliant, but you have some other compliant shell such as ksh or +# bash, then to run this script, type that shell name before the whole +# command line, like: +# +# ksh Gradle +# +# Busybox and similar reduced shells will NOT work, because this script +# requires all of these POSIX shell features: +# * functions; +# * expansions «$var», «${var}», «${var:-default}», «${var+SET}», +# «${var#prefix}», «${var%suffix}», and «$( cmd )»; +# * compound commands having a testable exit status, especially «case»; +# * various built-in commands including «command», «set», and «ulimit». +# +# Important for patching: +# +# (2) This script targets any POSIX shell, so it avoids extensions provided +# by Bash, Ksh, etc; in particular arrays are avoided. +# +# The "traditional" practice of packing multiple parameters into a +# space-separated string is a well documented source of bugs and security +# problems, so this is (mostly) avoided, by progressively accumulating +# options in "$@", and eventually passing that to Java. +# +# Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS, +# and GRADLE_OPTS) rely on word-splitting, this is performed explicitly; +# see the in-line comments for details. +# +# There are tweaks for specific operating systems such as AIX, CygWin, +# Darwin, MinGW, and NonStop. +# +# (3) This script is generated from the Groovy template +# https://github.com/gradle/gradle/blob/HEAD/platforms/jvm/plugins-application/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt +# within the Gradle project. +# +# You can find Gradle at https://github.com/gradle/gradle/. +# +############################################################################## + +# Attempt to set APP_HOME + +# Resolve links: $0 may be a link +app_path=$0 + +# Need this for daisy-chained symlinks. +while + APP_HOME=${app_path%"${app_path##*/}"} # leaves a trailing /; empty if no leading path + [ -h "$app_path" ] +do + ls=$( ls -ld "$app_path" ) + link=${ls#*' -> '} + case $link in #( + /*) app_path=$link ;; #( + *) app_path=$APP_HOME$link ;; + esac +done + +# This is normally unused +# shellcheck disable=SC2034 +APP_BASE_NAME=${0##*/} +# Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036) +APP_HOME=$( cd -P "${APP_HOME:-./}" > /dev/null && printf '%s\n' "$PWD" ) || exit + +# Use the maximum available, or set MAX_FD != -1 to use that value. +MAX_FD=maximum + +warn () { + echo "$*" +} >&2 + +die () { + echo + echo "$*" + echo + exit 1 +} >&2 + +# OS specific support (must be 'true' or 'false'). +cygwin=false +msys=false +darwin=false +nonstop=false +case "$( uname )" in #( + CYGWIN* ) cygwin=true ;; #( + Darwin* ) darwin=true ;; #( + MSYS* | MINGW* ) msys=true ;; #( + NONSTOP* ) nonstop=true ;; +esac + +CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar + + +# Determine the Java command to use to start the JVM. +if [ -n "$JAVA_HOME" ] ; then + if [ -x "$JAVA_HOME/jre/sh/java" ] ; then + # IBM's JDK on AIX uses strange locations for the executables + JAVACMD=$JAVA_HOME/jre/sh/java + else + JAVACMD=$JAVA_HOME/bin/java + fi + if [ ! -x "$JAVACMD" ] ; then + die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME + +Please set the JAVA_HOME variable in your environment to match the +location of your Java installation." + fi +else + JAVACMD=java + if ! command -v java >/dev/null 2>&1 + then + die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. + +Please set the JAVA_HOME variable in your environment to match the +location of your Java installation." + fi +fi + +# Increase the maximum file descriptors if we can. +if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then + case $MAX_FD in #( + max*) + # In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked. + # shellcheck disable=SC2039,SC3045 + MAX_FD=$( ulimit -H -n ) || + warn "Could not query maximum file descriptor limit" + esac + case $MAX_FD in #( + '' | soft) :;; #( + *) + # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked. + # shellcheck disable=SC2039,SC3045 + ulimit -n "$MAX_FD" || + warn "Could not set maximum file descriptor limit to $MAX_FD" + esac +fi + +# Collect all arguments for the java command, stacking in reverse order: +# * args from the command line +# * the main class name +# * -classpath +# * -D...appname settings +# * --module-path (only if needed) +# * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables. + +# For Cygwin or MSYS, switch paths to Windows format before running java +if "$cygwin" || "$msys" ; then + APP_HOME=$( cygpath --path --mixed "$APP_HOME" ) + CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" ) + + JAVACMD=$( cygpath --unix "$JAVACMD" ) + + # Now convert the arguments - kludge to limit ourselves to /bin/sh + for arg do + if + case $arg in #( + -*) false ;; # don't mess with options #( + /?*) t=${arg#/} t=/${t%%/*} # looks like a POSIX filepath + [ -e "$t" ] ;; #( + *) false ;; + esac + then + arg=$( cygpath --path --ignore --mixed "$arg" ) + fi + # Roll the args list around exactly as many times as the number of + # args, so each arg winds up back in the position where it started, but + # possibly modified. + # + # NB: a `for` loop captures its iteration list before it begins, so + # changing the positional parameters here affects neither the number of + # iterations, nor the values presented in `arg`. + shift # remove old arg + set -- "$@" "$arg" # push replacement arg + done +fi + + +# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. +DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"' + +# Collect all arguments for the java command: +# * DEFAULT_JVM_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments, +# and any embedded shellness will be escaped. +# * For example: A user cannot expect ${Hostname} to be expanded, as it is an environment variable and will be +# treated as '${Hostname}' itself on the command line. + +set -- \ + "-Dorg.gradle.appname=$APP_BASE_NAME" \ + -classpath "$CLASSPATH" \ + org.gradle.wrapper.GradleWrapperMain \ + "$@" + +# Stop when "xargs" is not available. +if ! command -v xargs >/dev/null 2>&1 +then + die "xargs is not available" +fi + +# Use "xargs" to parse quoted args. +# +# With -n1 it outputs one arg per line, with the quotes and backslashes removed. +# +# In Bash we could simply go: +# +# readarray ARGS < <( xargs -n1 <<<"$var" ) && +# set -- "${ARGS[@]}" "$@" +# +# but POSIX shell has neither arrays nor command substitution, so instead we +# post-process each arg (as a line of input to sed) to backslash-escape any +# character that might be a shell metacharacter, then use eval to reverse +# that process (while maintaining the separation between arguments), and wrap +# the whole thing up as a single "set" statement. +# +# This will of course break if any of these variables contains a newline or +# an unmatched quote. +# + +eval "set -- $( + printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" | + xargs -n1 | + sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' | + tr '\n' ' ' + )" '"$@"' + +exec "$JAVACMD" "$@" diff --git a/gradle/docs/examples/5-minute-tutorial/gradlew.bat b/gradle/docs/examples/5-minute-tutorial/gradlew.bat new file mode 100644 index 0000000000..9d21a21834 --- /dev/null +++ b/gradle/docs/examples/5-minute-tutorial/gradlew.bat @@ -0,0 +1,94 @@ +@rem +@rem Copyright 2015 the original author or authors. +@rem +@rem Licensed under the Apache License, Version 2.0 (the "License"); +@rem you may not use this file except in compliance with the License. +@rem You may obtain a copy of the License at +@rem +@rem https://www.apache.org/licenses/LICENSE-2.0 +@rem +@rem Unless required by applicable law or agreed to in writing, software +@rem distributed under the License is distributed on an "AS IS" BASIS, +@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +@rem See the License for the specific language governing permissions and +@rem limitations under the License. +@rem +@rem SPDX-License-Identifier: Apache-2.0 +@rem + +@if "%DEBUG%"=="" @echo off +@rem ########################################################################## +@rem +@rem Gradle startup script for Windows +@rem +@rem ########################################################################## + +@rem Set local scope for the variables with windows NT shell +if "%OS%"=="Windows_NT" setlocal + +set DIRNAME=%~dp0 +if "%DIRNAME%"=="" set DIRNAME=. +@rem This is normally unused +set APP_BASE_NAME=%~n0 +set APP_HOME=%DIRNAME% + +@rem Resolve any "." and ".." in APP_HOME to make it shorter. +for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi + +@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. +set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m" + +@rem Find java.exe +if defined JAVA_HOME goto findJavaFromJavaHome + +set JAVA_EXE=java.exe +%JAVA_EXE% -version >NUL 2>&1 +if %ERRORLEVEL% equ 0 goto execute + +echo. 1>&2 +echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. 1>&2 +echo. 1>&2 +echo Please set the JAVA_HOME variable in your environment to match the 1>&2 +echo location of your Java installation. 1>&2 + +goto fail + +:findJavaFromJavaHome +set JAVA_HOME=%JAVA_HOME:"=% +set JAVA_EXE=%JAVA_HOME%/bin/java.exe + +if exist "%JAVA_EXE%" goto execute + +echo. 1>&2 +echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% 1>&2 +echo. 1>&2 +echo Please set the JAVA_HOME variable in your environment to match the 1>&2 +echo location of your Java installation. 1>&2 + +goto fail + +:execute +@rem Setup the command line + +set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar + + +@rem Execute Gradle +"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %* + +:end +@rem End local scope for the variables with windows NT shell +if %ERRORLEVEL% equ 0 goto mainEnd + +:fail +rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of +rem the _cmd.exe /c_ return code! +set EXIT_CODE=%ERRORLEVEL% +if %EXIT_CODE% equ 0 set EXIT_CODE=1 +if not ""=="%GRADLE_EXIT_CONSOLE%" exit %EXIT_CODE% +exit /b %EXIT_CODE% + +:mainEnd +if "%OS%"=="Windows_NT" endlocal + +:omega diff --git a/gradle/docs/examples/5-minute-tutorial/settings.gradle b/gradle/docs/examples/5-minute-tutorial/settings.gradle new file mode 100644 index 0000000000..458084916d --- /dev/null +++ b/gradle/docs/examples/5-minute-tutorial/settings.gradle @@ -0,0 +1,14 @@ +/* + * This file was generated by the Gradle 'init' task. + * + * The settings file is used to specify which projects to include in your build. + * For more detailed information on multi-project builds, please refer to https://docs.gradle.org/8.13/userguide/multi_project_builds.html in the Gradle documentation. + */ + +plugins { + // Apply the foojay-resolver plugin to allow automatic download of JDKs + id 'org.gradle.toolchains.foojay-resolver-convention' version '0.9.0' +} + +rootProject.name = '5-minute-tutorial' +include('app') diff --git a/gradle/gradle/libs.versions.toml b/gradle/gradle/libs.versions.toml new file mode 100644 index 0000000000..a008468ff8 --- /dev/null +++ b/gradle/gradle/libs.versions.toml @@ -0,0 +1,8 @@ +# This file was generated by the Gradle 'init' task. +# https://docs.gradle.org/current/userguide/platforms.html#sub::toml-dependencies-format + +[versions] +junit-jupiter = "5.13.3" + +[libraries] +junit-jupiter = { module = "org.junit.jupiter:junit-jupiter", version.ref = "junit-jupiter" } diff --git a/gradle/gradle/wrapper/gradle-wrapper.jar b/gradle/gradle/wrapper/gradle-wrapper.jar new file mode 100644 index 0000000000..e6441136f3 Binary files /dev/null and b/gradle/gradle/wrapper/gradle-wrapper.jar differ diff --git a/gradle/gradle/wrapper/gradle-wrapper.properties b/gradle/gradle/wrapper/gradle-wrapper.properties new file mode 100644 index 0000000000..d4081da476 --- /dev/null +++ b/gradle/gradle/wrapper/gradle-wrapper.properties @@ -0,0 +1,7 @@ +distributionBase=GRADLE_USER_HOME +distributionPath=wrapper/dists +distributionUrl=https\://services.gradle.org/distributions/gradle-8.14.3-bin.zip +networkTimeout=10000 +validateDistributionUrl=true +zipStoreBase=GRADLE_USER_HOME +zipStorePath=wrapper/dists diff --git a/gradle/gradlew b/gradle/gradlew new file mode 100755 index 0000000000..b740cf1339 --- /dev/null +++ b/gradle/gradlew @@ -0,0 +1,249 @@ +#!/bin/sh + +# +# Copyright © 2015-2021 the original authors. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# https://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# + +############################################################################## +# +# Gradle start up script for POSIX generated by Gradle. +# +# Important for running: +# +# (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is +# noncompliant, but you have some other compliant shell such as ksh or +# bash, then to run this script, type that shell name before the whole +# command line, like: +# +# ksh Gradle +# +# Busybox and similar reduced shells will NOT work, because this script +# requires all of these POSIX shell features: +# * functions; +# * expansions «$var», «${var}», «${var:-default}», «${var+SET}», +# «${var#prefix}», «${var%suffix}», and «$( cmd )»; +# * compound commands having a testable exit status, especially «case»; +# * various built-in commands including «command», «set», and «ulimit». +# +# Important for patching: +# +# (2) This script targets any POSIX shell, so it avoids extensions provided +# by Bash, Ksh, etc; in particular arrays are avoided. +# +# The "traditional" practice of packing multiple parameters into a +# space-separated string is a well documented source of bugs and security +# problems, so this is (mostly) avoided, by progressively accumulating +# options in "$@", and eventually passing that to Java. +# +# Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS, +# and GRADLE_OPTS) rely on word-splitting, this is performed explicitly; +# see the in-line comments for details. +# +# There are tweaks for specific operating systems such as AIX, CygWin, +# Darwin, MinGW, and NonStop. +# +# (3) This script is generated from the Groovy template +# https://github.com/gradle/gradle/blob/HEAD/platforms/jvm/plugins-application/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt +# within the Gradle project. +# +# You can find Gradle at https://github.com/gradle/gradle/. +# +############################################################################## + +# Attempt to set APP_HOME + +# Resolve links: $0 may be a link +app_path=$0 + +# Need this for daisy-chained symlinks. +while + APP_HOME=${app_path%"${app_path##*/}"} # leaves a trailing /; empty if no leading path + [ -h "$app_path" ] +do + ls=$( ls -ld "$app_path" ) + link=${ls#*' -> '} + case $link in #( + /*) app_path=$link ;; #( + *) app_path=$APP_HOME$link ;; + esac +done + +# This is normally unused +# shellcheck disable=SC2034 +APP_BASE_NAME=${0##*/} +# Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036) +APP_HOME=$( cd "${APP_HOME:-./}" > /dev/null && pwd -P ) || exit + +# Use the maximum available, or set MAX_FD != -1 to use that value. +MAX_FD=maximum + +warn () { + echo "$*" +} >&2 + +die () { + echo + echo "$*" + echo + exit 1 +} >&2 + +# OS specific support (must be 'true' or 'false'). +cygwin=false +msys=false +darwin=false +nonstop=false +case "$( uname )" in #( + CYGWIN* ) cygwin=true ;; #( + Darwin* ) darwin=true ;; #( + MSYS* | MINGW* ) msys=true ;; #( + NONSTOP* ) nonstop=true ;; +esac + +CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar + + +# Determine the Java command to use to start the JVM. +if [ -n "$JAVA_HOME" ] ; then + if [ -x "$JAVA_HOME/jre/sh/java" ] ; then + # IBM's JDK on AIX uses strange locations for the executables + JAVACMD=$JAVA_HOME/jre/sh/java + else + JAVACMD=$JAVA_HOME/bin/java + fi + if [ ! -x "$JAVACMD" ] ; then + die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME + +Please set the JAVA_HOME variable in your environment to match the +location of your Java installation." + fi +else + JAVACMD=java + if ! command -v java >/dev/null 2>&1 + then + die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. + +Please set the JAVA_HOME variable in your environment to match the +location of your Java installation." + fi +fi + +# Increase the maximum file descriptors if we can. +if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then + case $MAX_FD in #( + max*) + # In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked. + # shellcheck disable=SC2039,SC3045 + MAX_FD=$( ulimit -H -n ) || + warn "Could not query maximum file descriptor limit" + esac + case $MAX_FD in #( + '' | soft) :;; #( + *) + # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked. + # shellcheck disable=SC2039,SC3045 + ulimit -n "$MAX_FD" || + warn "Could not set maximum file descriptor limit to $MAX_FD" + esac +fi + +# Collect all arguments for the java command, stacking in reverse order: +# * args from the command line +# * the main class name +# * -classpath +# * -D...appname settings +# * --module-path (only if needed) +# * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables. + +# For Cygwin or MSYS, switch paths to Windows format before running java +if "$cygwin" || "$msys" ; then + APP_HOME=$( cygpath --path --mixed "$APP_HOME" ) + CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" ) + + JAVACMD=$( cygpath --unix "$JAVACMD" ) + + # Now convert the arguments - kludge to limit ourselves to /bin/sh + for arg do + if + case $arg in #( + -*) false ;; # don't mess with options #( + /?*) t=${arg#/} t=/${t%%/*} # looks like a POSIX filepath + [ -e "$t" ] ;; #( + *) false ;; + esac + then + arg=$( cygpath --path --ignore --mixed "$arg" ) + fi + # Roll the args list around exactly as many times as the number of + # args, so each arg winds up back in the position where it started, but + # possibly modified. + # + # NB: a `for` loop captures its iteration list before it begins, so + # changing the positional parameters here affects neither the number of + # iterations, nor the values presented in `arg`. + shift # remove old arg + set -- "$@" "$arg" # push replacement arg + done +fi + + +# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. +DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"' + +# Collect all arguments for the java command: +# * DEFAULT_JVM_OPTS, JAVA_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments, +# and any embedded shellness will be escaped. +# * For example: A user cannot expect ${Hostname} to be expanded, as it is an environment variable and will be +# treated as '${Hostname}' itself on the command line. + +set -- \ + "-Dorg.gradle.appname=$APP_BASE_NAME" \ + -classpath "$CLASSPATH" \ + org.gradle.wrapper.GradleWrapperMain \ + "$@" + +# Stop when "xargs" is not available. +if ! command -v xargs >/dev/null 2>&1 +then + die "xargs is not available" +fi + +# Use "xargs" to parse quoted args. +# +# With -n1 it outputs one arg per line, with the quotes and backslashes removed. +# +# In Bash we could simply go: +# +# readarray ARGS < <( xargs -n1 <<<"$var" ) && +# set -- "${ARGS[@]}" "$@" +# +# but POSIX shell has neither arrays nor command substitution, so instead we +# post-process each arg (as a line of input to sed) to backslash-escape any +# character that might be a shell metacharacter, then use eval to reverse +# that process (while maintaining the separation between arguments), and wrap +# the whole thing up as a single "set" statement. +# +# This will of course break if any of these variables contains a newline or +# an unmatched quote. +# + +eval "set -- $( + printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" | + xargs -n1 | + sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' | + tr '\n' ' ' + )" '"$@"' + +exec "$JAVACMD" "$@" diff --git a/gradle/gradlew.bat b/gradle/gradlew.bat new file mode 100644 index 0000000000..25da30dbde --- /dev/null +++ b/gradle/gradlew.bat @@ -0,0 +1,92 @@ +@rem +@rem Copyright 2015 the original author or authors. +@rem +@rem Licensed under the Apache License, Version 2.0 (the "License"); +@rem you may not use this file except in compliance with the License. +@rem You may obtain a copy of the License at +@rem +@rem https://www.apache.org/licenses/LICENSE-2.0 +@rem +@rem Unless required by applicable law or agreed to in writing, software +@rem distributed under the License is distributed on an "AS IS" BASIS, +@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +@rem See the License for the specific language governing permissions and +@rem limitations under the License. +@rem + +@if "%DEBUG%"=="" @echo off +@rem ########################################################################## +@rem +@rem Gradle startup script for Windows +@rem +@rem ########################################################################## + +@rem Set local scope for the variables with windows NT shell +if "%OS%"=="Windows_NT" setlocal + +set DIRNAME=%~dp0 +if "%DIRNAME%"=="" set DIRNAME=. +@rem This is normally unused +set APP_BASE_NAME=%~n0 +set APP_HOME=%DIRNAME% + +@rem Resolve any "." and ".." in APP_HOME to make it shorter. +for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi + +@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. +set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m" + +@rem Find java.exe +if defined JAVA_HOME goto findJavaFromJavaHome + +set JAVA_EXE=java.exe +%JAVA_EXE% -version >NUL 2>&1 +if %ERRORLEVEL% equ 0 goto execute + +echo. 1>&2 +echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. 1>&2 +echo. 1>&2 +echo Please set the JAVA_HOME variable in your environment to match the 1>&2 +echo location of your Java installation. 1>&2 + +goto fail + +:findJavaFromJavaHome +set JAVA_HOME=%JAVA_HOME:"=% +set JAVA_EXE=%JAVA_HOME%/bin/java.exe + +if exist "%JAVA_EXE%" goto execute + +echo. 1>&2 +echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% 1>&2 +echo. 1>&2 +echo Please set the JAVA_HOME variable in your environment to match the 1>&2 +echo location of your Java installation. 1>&2 + +goto fail + +:execute +@rem Setup the command line + +set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar + + +@rem Execute Gradle +"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %* + +:end +@rem End local scope for the variables with windows NT shell +if %ERRORLEVEL% equ 0 goto mainEnd + +:fail +rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of +rem the _cmd.exe /c_ return code! +set EXIT_CODE=%ERRORLEVEL% +if %EXIT_CODE% equ 0 set EXIT_CODE=1 +if not ""=="%GRADLE_EXIT_CONSOLE%" exit %EXIT_CODE% +exit /b %EXIT_CODE% + +:mainEnd +if "%OS%"=="Windows_NT" endlocal + +:omega diff --git a/gradle/plugin/bin/.gitignore b/gradle/plugin/bin/.gitignore new file mode 100644 index 0000000000..dc141cdac9 --- /dev/null +++ b/gradle/plugin/bin/.gitignore @@ -0,0 +1,3 @@ +/functionalTest/ +/main/ +/test/ diff --git a/gradle/plugin/build.gradle b/gradle/plugin/build.gradle new file mode 100644 index 0000000000..837bba02a3 --- /dev/null +++ b/gradle/plugin/build.gradle @@ -0,0 +1,145 @@ +plugins { + id 'java-gradle-plugin' + id 'maven-publish' + id 'com.gradle.plugin-publish' version '1.2.1' +} + +group = 'org.hibernate.tool' +project.description = 'Gradle plugin to provide hibernate-tools reverse engineering and code/schema generation abilities.' +project.version = "$projectVersion" + +java { + toolchain { + languageVersion = JavaLanguageVersion.of(11) + } +} + +repositories { + mavenCentral() + mavenLocal() +} + +dependencies { + + implementation "org.hibernate.tool:hibernate-tools-orm:$projectVersion" + + testImplementation libs.junit.jupiter + + testRuntimeOnly 'org.junit.platform:junit-platform-launcher' + testRuntimeOnly "com.h2database:h2:$h2Version" +} + +rootProject.ext.set("gradle.publish.key", System.env.PLUGIN_PORTAL_USERNAME) +rootProject.ext.set("gradle.publish.secret", System.env.PLUGIN_PORTAL_PASSWORD) + +gradlePlugin { + website = 'https://github.com/hibernate/hibernate-tools/tree/main/gradle/plugin' + vcsUrl = 'https://github.com/hibernate/hibernate-tools/tree/main/gradle/plugin' + plugins { + hibernate { + id = 'org.hibernate.tool.hibernate-tools-gradle' + implementationClass = 'org.hibernate.tool.gradle.Plugin' + displayName = 'Hibernate Tools Gradle Plugin' + description = project.description + tags = ['hibernate','tools','reverse engineering','reveng','generation'] + } + } +} + +sourceSets { + functionalTest { + } +} + +configurations.functionalTestImplementation.extendsFrom(configurations.testImplementation) +configurations.functionalTestRuntimeOnly.extendsFrom(configurations.testRuntimeOnly) + +tasks.register('functionalTest', Test) { + testClassesDirs = sourceSets.functionalTest.output.classesDirs + classpath = sourceSets.functionalTest.runtimeClasspath + useJUnitPlatform() + environment("HIBERNATE_TOOLS_VERSION", projectVersion); + environment("H2_VERSION", h2Version); +} + +gradlePlugin.testSourceSets.add(sourceSets.functionalTest) + +tasks.named('check') { + dependsOn(tasks.functionalTest) +} + +tasks.named('test') { + useJUnitPlatform() +} + +tasks.named('publishPlugins') { + onlyIf { + def isDryRun = System.getenv('JRELEASER_DRY_RUN') + !Boolean.parseBoolean(isDryRun) + } +} + +publishing { + publications { + pluginMaven(MavenPublication) { + pom { + name = project.name + groupId = 'org.hibernate.tool' + artifactId = project.name + version = project.version + + description = project.description + url = 'https://hibernate.org/tools' + + organization { + name = 'Hibernate.org' + url = 'https://hibernate.org' + } + + licenses { + license { + name = 'Apache License, version 2.0' + url = 'https://www.apache.org/licenses/LICENSE-2.0' + } + } + + scm { + url = 'https://github.com/hibernate/hibernate-tools' + connection = 'scm:git:https://github.com/hibernate/hibernate-tools.git' + developerConnection = 'scm:git:git@github.com:hibernate/hibernate-tools.git' + } + + developers { + developer { + id = 'maxandersen' + name = 'Max Andersen' + email = 'max@hibernate.org' + url = 'https://in.relation.to/Bloggers/Max' + } + developer { + id = 'koentsje' + name = 'Koen Aers' + email = 'koen@hibernate.org' + url = 'https://koentsje.blogspot.be' + } + } + + issueManagement { + system = 'jira' + url = 'https://hibernate.atlassian.net/browse/HBX' + } + } + } + } + repositories { + maven { + name = "staging" + var mavenPath = findProperty("mavenStagingDirectory") + if (mavenPath == null) { + url = rootProject.layout.buildDirectory.dir("staging-deploy${File.separator}maven") + } else { + url = URI.create(mavenPath).toURL() + } + } + } +} diff --git a/gradle/plugin/src/functionalTest/java/org/hibernate/tool/gradle/GenerateCfgTest.java b/gradle/plugin/src/functionalTest/java/org/hibernate/tool/gradle/GenerateCfgTest.java new file mode 100644 index 0000000000..aee4e698e2 --- /dev/null +++ b/gradle/plugin/src/functionalTest/java/org/hibernate/tool/gradle/GenerateCfgTest.java @@ -0,0 +1,38 @@ +package org.hibernate.tool.gradle; + +import static org.junit.jupiter.api.Assertions.assertTrue; + +import java.io.File; +import java.io.IOException; +import java.nio.file.Files; + +import org.gradle.testkit.runner.BuildResult; +import org.hibernate.tool.gradle.test.func.utils.FuncTestConstants; +import org.hibernate.tool.gradle.test.func.utils.FuncTestTemplate; +import org.junit.jupiter.api.Test; + +class GenerateCfgTest extends FuncTestTemplate implements FuncTestConstants { + + @Test + void testGenerateCfg() throws IOException { + performTask("generateCfg", true); + } + + @Override + public void verifyBuild(BuildResult buildResult) { + try { + File generatedSourcesFolder = new File(projectDir, "generated-sources"); + assertTrue(buildResult.getOutput().contains("Starting CFG export to directory: " + generatedSourcesFolder.getCanonicalPath())); + assertTrue(generatedSourcesFolder.exists()); + assertTrue(generatedSourcesFolder.isDirectory()); + File cfgFile = new File(generatedSourcesFolder, "hibernate.cfg.xml"); + assertTrue(cfgFile.exists()); + assertTrue(cfgFile.isFile()); + String cfgContents = Files.readString(cfgFile.toPath()); + assertTrue(cfgContents.contains("")); + } catch (Exception e) { + throw new RuntimeException(e); + } + } + + } diff --git a/gradle/plugin/src/functionalTest/java/org/hibernate/tool/gradle/GenerateDaoTest.java b/gradle/plugin/src/functionalTest/java/org/hibernate/tool/gradle/GenerateDaoTest.java new file mode 100644 index 0000000000..4b87877980 --- /dev/null +++ b/gradle/plugin/src/functionalTest/java/org/hibernate/tool/gradle/GenerateDaoTest.java @@ -0,0 +1,46 @@ +package org.hibernate.tool.gradle; + +import static org.junit.jupiter.api.Assertions.assertTrue; + +import java.io.File; +import java.io.IOException; + +import org.gradle.testkit.runner.BuildResult; +import org.hibernate.tool.gradle.test.func.utils.FuncTestConstants; +import org.hibernate.tool.gradle.test.func.utils.FuncTestTemplate; +import org.junit.jupiter.api.Test; + +class GenerateDaoTest extends FuncTestTemplate implements FuncTestConstants { + + private static final String BUILD_FILE_HIBERNATE_TOOLS_SECTION = + "hibernateTools {\n" + + " packageName = 'foo.model'\n" + + "}\n"; + + @Override + public String getBuildFileHibernateToolsSection() { + return BUILD_FILE_HIBERNATE_TOOLS_SECTION; + } + + @Test + void testGenerateJava() throws IOException { + performTask("generateDao", true); + } + + @Override + protected void verifyBuild(BuildResult buildResult) { + try { + File generatedSourcesFolder = new File(projectDir, "generated-sources"); + assertTrue(buildResult.getOutput().contains( + "Starting DAO export to directory: " + generatedSourcesFolder.getCanonicalPath())); + assertTrue(generatedSourcesFolder.exists()); + assertTrue(generatedSourcesFolder.isDirectory()); + File fooFile = new File(generatedSourcesFolder, "foo/model/FooHome.java"); + assertTrue(fooFile.exists()); + assertTrue(fooFile.isFile()); + } catch (Exception e) { + throw new RuntimeException(e); + } + } + + } diff --git a/gradle/plugin/src/functionalTest/java/org/hibernate/tool/gradle/GenerateHbmTest.java b/gradle/plugin/src/functionalTest/java/org/hibernate/tool/gradle/GenerateHbmTest.java new file mode 100644 index 0000000000..0697a1c382 --- /dev/null +++ b/gradle/plugin/src/functionalTest/java/org/hibernate/tool/gradle/GenerateHbmTest.java @@ -0,0 +1,46 @@ +package org.hibernate.tool.gradle; + +import static org.junit.jupiter.api.Assertions.assertTrue; + +import java.io.File; +import java.io.IOException; + +import org.gradle.testkit.runner.BuildResult; +import org.hibernate.tool.gradle.test.func.utils.FuncTestConstants; +import org.hibernate.tool.gradle.test.func.utils.FuncTestTemplate; +import org.junit.jupiter.api.Test; + +class GenerateHbmTest extends FuncTestTemplate implements FuncTestConstants { + + private static final String BUILD_FILE_HIBERNATE_TOOLS_SECTION = + "hibernateTools {\n" + + " packageName = 'foo.model'\n" + + "}\n"; + + @Override + public String getBuildFileHibernateToolsSection() { + return BUILD_FILE_HIBERNATE_TOOLS_SECTION; + } + + @Test + void testGenerateHbm() throws IOException { + performTask("generateHbm", true); + } + + @Override + protected void verifyBuild(BuildResult buildResult) { + try { + File generatedSourcesFolder = new File(projectDir, "generated-sources"); + assertTrue(buildResult.getOutput().contains( + "Starting HBM export to directory: " + generatedSourcesFolder.getCanonicalPath())); + assertTrue(generatedSourcesFolder.exists()); + assertTrue(generatedSourcesFolder.isDirectory()); + File fooFile = new File(generatedSourcesFolder, "foo/model/Foo.hbm.xml"); + assertTrue(fooFile.exists()); + assertTrue(fooFile.isFile()); + } catch (Exception e) { + throw new RuntimeException(e); + } + } + + } diff --git a/gradle/plugin/src/functionalTest/java/org/hibernate/tool/gradle/GenerateJavaTest.java b/gradle/plugin/src/functionalTest/java/org/hibernate/tool/gradle/GenerateJavaTest.java new file mode 100644 index 0000000000..d6bc58734c --- /dev/null +++ b/gradle/plugin/src/functionalTest/java/org/hibernate/tool/gradle/GenerateJavaTest.java @@ -0,0 +1,46 @@ +package org.hibernate.tool.gradle; + +import static org.junit.jupiter.api.Assertions.assertTrue; + +import java.io.File; +import java.io.IOException; + +import org.gradle.testkit.runner.BuildResult; +import org.hibernate.tool.gradle.test.func.utils.FuncTestConstants; +import org.hibernate.tool.gradle.test.func.utils.FuncTestTemplate; +import org.junit.jupiter.api.Test; + +class GenerateJavaTest extends FuncTestTemplate implements FuncTestConstants { + + private static final String BUILD_FILE_HIBERNATE_TOOLS_SECTION = + "hibernateTools {\n" + + " packageName = 'foo.model'\n" + + "}\n"; + + @Override + public String getBuildFileHibernateToolsSection() { + return BUILD_FILE_HIBERNATE_TOOLS_SECTION; + } + + @Test + void testGenerateJava() throws IOException { + performTask("generateJava", true); + } + + @Override + protected void verifyBuild(BuildResult buildResult) { + try { + File generatedSourcesFolder = new File(projectDir, "generated-sources"); + assertTrue(buildResult.getOutput().contains( + "Starting Java export to directory: " + generatedSourcesFolder.getCanonicalPath())); + assertTrue(generatedSourcesFolder.exists()); + assertTrue(generatedSourcesFolder.isDirectory()); + File fooFile = new File(generatedSourcesFolder, "foo/model/Foo.java"); + assertTrue(fooFile.exists()); + assertTrue(fooFile.isFile()); + } catch (Exception e) { + throw new RuntimeException(e); + } + } + + } diff --git a/gradle/plugin/src/functionalTest/java/org/hibernate/tool/gradle/RunSqlTest.java b/gradle/plugin/src/functionalTest/java/org/hibernate/tool/gradle/RunSqlTest.java new file mode 100644 index 0000000000..796597a6ac --- /dev/null +++ b/gradle/plugin/src/functionalTest/java/org/hibernate/tool/gradle/RunSqlTest.java @@ -0,0 +1,45 @@ +/* + * This source file was generated by the Gradle 'init' task + */ +package org.hibernate.tool.gradle; + +import static org.junit.jupiter.api.Assertions.assertTrue; + +import java.io.File; +import java.io.IOException; + +import org.gradle.testkit.runner.BuildResult; +import org.hibernate.tool.gradle.test.func.utils.FuncTestConstants; +import org.hibernate.tool.gradle.test.func.utils.FuncTestTemplate; +import org.junit.jupiter.api.Test; + +class RunSqlTest extends FuncTestTemplate implements FuncTestConstants { + + private static final String BUILD_FILE_HIBERNATE_TOOLS_SECTION = + "hibernateTools {\n" + + " sqlToRun = 'create table foo (id int not null primary key, baz varchar(256))'\n" + + " hibernateProperties = 'foo.bar'" + + "}\n"; + + @Override + public String getBuildFileHibernateToolsSection() { + return BUILD_FILE_HIBERNATE_TOOLS_SECTION; + } + + @Override + public String getHibernatePropertiesFileName() { + return "foo.bar"; + } + + @Test + void testRunSql() throws IOException { + performTask("runSql", false); + } + + @Override + protected void verifyBuild(BuildResult buildResult) { + assertTrue(buildResult.getOutput().contains("Running SQL: create table foo (id int not null primary key, baz varchar(256))")); + assertTrue(new File(projectDir, DATABASE_FOLDER_NAME + "/" + DATABASE_FILE_NAME).exists()); + } + + } \ No newline at end of file diff --git a/gradle/plugin/src/functionalTest/java/org/hibernate/tool/gradle/java/JpaDefaultTest.java b/gradle/plugin/src/functionalTest/java/org/hibernate/tool/gradle/java/JpaDefaultTest.java new file mode 100644 index 0000000000..d6754e11fc --- /dev/null +++ b/gradle/plugin/src/functionalTest/java/org/hibernate/tool/gradle/java/JpaDefaultTest.java @@ -0,0 +1,167 @@ +package org.hibernate.tool.gradle.java; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import java.io.File; +import java.nio.file.Files; +import java.sql.Connection; +import java.sql.DriverManager; +import java.sql.ResultSet; +import java.sql.Statement; +import java.util.List; + +import org.gradle.testkit.runner.BuildResult; +import org.gradle.testkit.runner.GradleRunner; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.io.TempDir; + +public class JpaDefaultTest { + + private static final List GRADLE_INIT_PROJECT_ARGUMENTS = List.of( + "init", "--type", "java-application", "--dsl", "groovy", "--test-framework", "junit-jupiter", "--java-version", "11"); + + @TempDir + private File projectDir; + + private File gradlePropertiesFile; + private File gradleBuildFile; + private File databaseFile; + + @Test + public void testTutorial() throws Exception { + assertTrue(projectDir.exists()); + createGradleProject(); + editGradleBuildFile(); + editGradlePropertiesFile(); + createDatabase(); + createHibernatePropertiesFile(); + verifyDatabase(); + executeGenerateJavaTask(); + verifyProject(); + } + + private void verifyDatabase() throws Exception { + Connection connection = DriverManager.getConnection(constructJdbcConnectionString()); + ResultSet resultSet = connection.createStatement().executeQuery("select * from PERSON"); + assertTrue(resultSet.next()); + assertEquals(1, resultSet.getInt(1)); + assertEquals("foo", resultSet.getString(2)); + } + + private void createGradleProject() throws Exception { + GradleRunner runner = GradleRunner.create(); + runner.withArguments(GRADLE_INIT_PROJECT_ARGUMENTS); + runner.forwardOutput(); + runner.withProjectDir(projectDir); + BuildResult buildResult = runner.build(); + assertTrue(buildResult.getOutput().contains("BUILD SUCCESSFUL")); + gradlePropertiesFile = new File(projectDir, "gradle.properties"); + assertTrue(gradlePropertiesFile.exists()); + assertTrue(gradlePropertiesFile.isFile()); + File appDir = new File(projectDir, "app"); + assertTrue(appDir.exists()); + assertTrue(appDir.isDirectory()); + gradleBuildFile = new File(appDir, "build.gradle"); + assertTrue(gradleBuildFile.exists()); + assertTrue(gradleBuildFile.isFile()); + databaseFile = new File(projectDir, "database/test.mv.db"); + assertFalse(databaseFile.exists()); + } + + private void editGradleBuildFile() throws Exception { + StringBuffer gradleBuildFileContents = new StringBuffer( + new String(Files.readAllBytes(gradleBuildFile.toPath()))); + addHibernateToolsPluginLine(gradleBuildFileContents); + addH2DatabaseDependencyLine(gradleBuildFileContents); + Files.writeString(gradleBuildFile.toPath(), gradleBuildFileContents.toString()); + } + + private void editGradlePropertiesFile() throws Exception { + // The Hibernate Tools Gradle plugin does not support the configuration cache. + // As this is enabled by default when initializing a new Gradle project, the setting needs to be commented out + // in the gradle.properties file. + StringBuffer gradlePropertiesFileContents = new StringBuffer( + new String(Files.readAllBytes(gradlePropertiesFile.toPath()))); + int pos = gradlePropertiesFileContents.indexOf("org.gradle.configuration-cache=true"); + gradlePropertiesFileContents.insert(pos, "#"); + Files.writeString(gradlePropertiesFile.toPath(), gradlePropertiesFileContents.toString()); + } + + private void createDatabase() throws Exception { + String CREATE_PERSON_TABLE = "create table PERSON (ID int not null, NAME varchar(20), primary key (ID))"; + Connection connection = DriverManager.getConnection(constructJdbcConnectionString()); + Statement statement = connection.createStatement(); + statement.execute(CREATE_PERSON_TABLE); + statement.execute("insert into PERSON values (1, 'foo')"); + statement.close(); + connection.close(); + assertTrue(databaseFile.exists()); + assertTrue(databaseFile.isFile()); + } + + private void createHibernatePropertiesFile() throws Exception { + File hibernatePropertiesFile = new File(projectDir, "app/src/main/resources/hibernate.properties"); + StringBuffer hibernatePropertiesFileContents = new StringBuffer(); + hibernatePropertiesFileContents + .append("hibernate.connection.driver_class=org.h2.Driver\n") + .append("hibernate.connection.url=" + constructJdbcConnectionString() + "\n") + .append("hibernate.connection.username=\n") + .append("hibernate.connection.password=\n") + .append("hibernate.default_catalog=TEST\n") + .append("hibernate.default_schema=PUBLIC\n"); + Files.writeString(hibernatePropertiesFile.toPath(), hibernatePropertiesFileContents.toString()); + assertTrue(hibernatePropertiesFile.exists()); + } + + private void executeGenerateJavaTask() throws Exception { + GradleRunner gradleRunner = GradleRunner.create(); + gradleRunner.forwardOutput(); + gradleRunner.withProjectDir(projectDir); + gradleRunner.withPluginClasspath(); + gradleRunner.withArguments("generateJava"); + BuildResult buildResult = gradleRunner.build(); + assertTrue(buildResult.getOutput().contains("BUILD SUCCESSFUL")); + } + + private void verifyProject() throws Exception { + File generatedOutputFolder = new File(projectDir, "app/generated-sources"); + assertTrue(generatedOutputFolder.exists()); + assertTrue(generatedOutputFolder.isDirectory()); + assertEquals(1, generatedOutputFolder.list().length); + File generatedPersonJavaFile = new File(generatedOutputFolder, "Person.java"); + assertTrue(generatedPersonJavaFile.exists()); + assertTrue(generatedPersonJavaFile.isFile()); + String generatedPersonJavaFileContents = new String( + Files.readAllBytes(generatedPersonJavaFile.toPath())); + assertTrue(generatedPersonJavaFileContents.contains("import jakarta.persistence.Entity;")); + assertTrue(generatedPersonJavaFileContents.contains("public class Person ")); + } + + private void addHibernateToolsPluginLine(StringBuffer gradleBuildFileContents) { + int pos = gradleBuildFileContents.indexOf("plugins {"); + pos = gradleBuildFileContents.indexOf("}", pos); + gradleBuildFileContents.insert(pos, constructHibernateToolsPluginLine() + "\n"); + } + + private void addH2DatabaseDependencyLine(StringBuffer gradleBuildFileContents) { + int pos = gradleBuildFileContents.indexOf("dependencies {"); + pos = gradleBuildFileContents.indexOf("}", pos); + gradleBuildFileContents.insert(pos, constructH2DatabaseDependencyLine() + "\n"); + } + + private String constructJdbcConnectionString() { + return "jdbc:h2:" + projectDir.getAbsolutePath() + "/database/test;AUTO_SERVER=TRUE"; + } + + private String constructHibernateToolsPluginLine() { + return " id 'org.hibernate.tool.hibernate-tools-gradle' version '" + + System.getenv("HIBERNATE_TOOLS_VERSION") + "'"; + } + + private String constructH2DatabaseDependencyLine() { + return " implementation 'com.h2database:h2:" + System.getenv("H2_VERSION") + "'"; + } + +} diff --git a/gradle/plugin/src/functionalTest/java/org/hibernate/tool/gradle/java/NoAnnotationsTest.java b/gradle/plugin/src/functionalTest/java/org/hibernate/tool/gradle/java/NoAnnotationsTest.java new file mode 100644 index 0000000000..c848ba2a02 --- /dev/null +++ b/gradle/plugin/src/functionalTest/java/org/hibernate/tool/gradle/java/NoAnnotationsTest.java @@ -0,0 +1,181 @@ +package org.hibernate.tool.gradle.java; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import java.io.File; +import java.nio.file.Files; +import java.sql.Connection; +import java.sql.DriverManager; +import java.sql.ResultSet; +import java.sql.Statement; +import java.util.List; + +import org.gradle.testkit.runner.BuildResult; +import org.gradle.testkit.runner.GradleRunner; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.io.TempDir; + +public class NoAnnotationsTest { + + private static final List GRADLE_INIT_PROJECT_ARGUMENTS = List.of( + "init", "--type", "java-application", "--dsl", "groovy", "--test-framework", "junit-jupiter", "--java-version", "11"); + + @TempDir + private File projectDir; + + private File gradlePropertiesFile; + private File gradleBuildFile; + private File databaseFile; + + @Test + public void testTutorial() throws Exception { + assertTrue(projectDir.exists()); + createGradleProject(); + editGradleBuildFile(); + editGradlePropertiesFile(); + createDatabase(); + createHibernatePropertiesFile(); + verifyDatabase(); + executeGenerateJavaTask(); + verifyProject(); + } + + private void verifyDatabase() throws Exception { + Connection connection = DriverManager.getConnection(constructJdbcConnectionString()); + ResultSet resultSet = connection.createStatement().executeQuery("select * from PERSON"); + assertTrue(resultSet.next()); + assertEquals(1, resultSet.getInt(1)); + assertEquals("foo", resultSet.getString(2)); + } + + private void createGradleProject() throws Exception { + GradleRunner runner = GradleRunner.create(); + runner.withArguments(GRADLE_INIT_PROJECT_ARGUMENTS); + runner.forwardOutput(); + runner.withProjectDir(projectDir); + BuildResult buildResult = runner.build(); + assertTrue(buildResult.getOutput().contains("BUILD SUCCESSFUL")); + gradlePropertiesFile = new File(projectDir, "gradle.properties"); + assertTrue(gradlePropertiesFile.exists()); + assertTrue(gradlePropertiesFile.isFile()); + File appDir = new File(projectDir, "app"); + assertTrue(appDir.exists()); + assertTrue(appDir.isDirectory()); + gradleBuildFile = new File(appDir, "build.gradle"); + assertTrue(gradleBuildFile.exists()); + assertTrue(gradleBuildFile.isFile()); + databaseFile = new File(projectDir, "database/test.mv.db"); + assertFalse(databaseFile.exists()); + } + + private void editGradleBuildFile() throws Exception { + StringBuffer gradleBuildFileContents = new StringBuffer( + new String(Files.readAllBytes(gradleBuildFile.toPath()))); + addHibernateToolsPluginLine(gradleBuildFileContents); + addH2DatabaseDependencyLine(gradleBuildFileContents); + addHibernateToolsExtension(gradleBuildFileContents); + Files.writeString(gradleBuildFile.toPath(), gradleBuildFileContents.toString()); + } + + private void editGradlePropertiesFile() throws Exception { + // The Hibernate Tools Gradle plugin does not support the configuration cache. + // As this is enabled by default when initializing a new Gradle project, the setting needs to be commented out + // in the gradle.properties file. + StringBuffer gradlePropertiesFileContents = new StringBuffer( + new String(Files.readAllBytes(gradlePropertiesFile.toPath()))); + int pos = gradlePropertiesFileContents.indexOf("org.gradle.configuration-cache=true"); + gradlePropertiesFileContents.insert(pos, "#"); + Files.writeString(gradlePropertiesFile.toPath(), gradlePropertiesFileContents.toString()); + } + + private void createDatabase() throws Exception { + String CREATE_PERSON_TABLE = "create table PERSON (ID int not null, NAME varchar(20), primary key (ID))"; + Connection connection = DriverManager.getConnection(constructJdbcConnectionString()); + Statement statement = connection.createStatement(); + statement.execute(CREATE_PERSON_TABLE); + statement.execute("insert into PERSON values (1, 'foo')"); + statement.close(); + connection.close(); + assertTrue(databaseFile.exists()); + assertTrue(databaseFile.isFile()); + } + + private void createHibernatePropertiesFile() throws Exception { + File hibernatePropertiesFile = new File(projectDir, "app/src/main/resources/hibernate.properties"); + StringBuffer hibernatePropertiesFileContents = new StringBuffer(); + hibernatePropertiesFileContents + .append("hibernate.connection.driver_class=org.h2.Driver\n") + .append("hibernate.connection.url=" + constructJdbcConnectionString() + "\n") + .append("hibernate.connection.username=\n") + .append("hibernate.connection.password=\n") + .append("hibernate.default_catalog=TEST\n") + .append("hibernate.default_schema=PUBLIC\n"); + Files.writeString(hibernatePropertiesFile.toPath(), hibernatePropertiesFileContents.toString()); + assertTrue(hibernatePropertiesFile.exists()); + } + + private void executeGenerateJavaTask() throws Exception { + GradleRunner gradleRunner = GradleRunner.create(); + gradleRunner.forwardOutput(); + gradleRunner.withProjectDir(projectDir); + gradleRunner.withPluginClasspath(); + gradleRunner.withArguments("generateJava"); + BuildResult buildResult = gradleRunner.build(); + assertTrue(buildResult.getOutput().contains("BUILD SUCCESSFUL")); + } + + private void verifyProject() throws Exception { + File generatedOutputFolder = new File(projectDir, "app/generated-sources"); + assertTrue(generatedOutputFolder.exists()); + assertTrue(generatedOutputFolder.isDirectory()); + assertEquals(1, generatedOutputFolder.list().length); + File generatedPersonJavaFile = new File(generatedOutputFolder, "Person.java"); + assertTrue(generatedPersonJavaFile.exists()); + assertTrue(generatedPersonJavaFile.isFile()); + String generatedPersonJavaFileContents = new String( + Files.readAllBytes(generatedPersonJavaFile.toPath())); + assertFalse(generatedPersonJavaFileContents.contains("import jakarta.persistence.Entity;")); + assertTrue(generatedPersonJavaFileContents.contains("public class Person ")); + } + + private void addHibernateToolsPluginLine(StringBuffer gradleBuildFileContents) { + int pos = gradleBuildFileContents.indexOf("plugins {"); + pos = gradleBuildFileContents.indexOf("}", pos); + gradleBuildFileContents.insert(pos, constructHibernateToolsPluginLine() + "\n"); + } + + private void addH2DatabaseDependencyLine(StringBuffer gradleBuildFileContents) { + int pos = gradleBuildFileContents.indexOf("dependencies {"); + pos = gradleBuildFileContents.indexOf("}", pos); + gradleBuildFileContents.insert(pos, constructH2DatabaseDependencyLine() + "\n"); + } + + private void addHibernateToolsExtension(StringBuffer gradleBuildFileContents) { + int pos = gradleBuildFileContents.indexOf("dependencies {"); + pos = gradleBuildFileContents.indexOf("}", pos); + StringBuffer hibernateToolsExtension = new StringBuffer(); + hibernateToolsExtension + .append("\n") + .append("\n") + .append("hibernateTools { \n") + .append(" generateAnnotations=false \n") + .append("}"); + gradleBuildFileContents.insert(pos + 1, hibernateToolsExtension.toString()); + } + + private String constructJdbcConnectionString() { + return "jdbc:h2:" + projectDir.getAbsolutePath() + "/database/test;AUTO_SERVER=TRUE"; + } + + private String constructHibernateToolsPluginLine() { + return " id 'org.hibernate.tool.hibernate-tools-gradle' version '" + + System.getenv("HIBERNATE_TOOLS_VERSION") + "'"; + } + + private String constructH2DatabaseDependencyLine() { + return " implementation 'com.h2database:h2:" + System.getenv("H2_VERSION") + "'"; + } + +} diff --git a/gradle/plugin/src/functionalTest/java/org/hibernate/tool/gradle/java/NoGenerics.java b/gradle/plugin/src/functionalTest/java/org/hibernate/tool/gradle/java/NoGenerics.java new file mode 100644 index 0000000000..fccf951273 --- /dev/null +++ b/gradle/plugin/src/functionalTest/java/org/hibernate/tool/gradle/java/NoGenerics.java @@ -0,0 +1,181 @@ +package org.hibernate.tool.gradle.java; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import java.io.File; +import java.nio.file.Files; +import java.sql.Connection; +import java.sql.DriverManager; +import java.sql.Statement; +import java.util.List; + +import org.gradle.testkit.runner.BuildResult; +import org.gradle.testkit.runner.GradleRunner; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.io.TempDir; + +public class NoGenerics { + + private static final List GRADLE_INIT_PROJECT_ARGUMENTS = List.of( + "init", "--type", "java-application", "--dsl", "groovy", "--test-framework", "junit-jupiter", "--java-version", "11"); + + @TempDir + private File projectDir; + + private File gradlePropertiesFile; + private File gradleBuildFile; + private File databaseFile; + + @Test + public void testTutorial() throws Exception { + assertTrue(projectDir.exists()); + createGradleProject(); + editGradleBuildFile(); + editGradlePropertiesFile(); + createDatabase(); + createHibernatePropertiesFile(); + executeGenerateJavaTask(); + verifyProject(); + } + + private void createGradleProject() throws Exception { + GradleRunner runner = GradleRunner.create(); + runner.withArguments(GRADLE_INIT_PROJECT_ARGUMENTS); + runner.forwardOutput(); + runner.withProjectDir(projectDir); + BuildResult buildResult = runner.build(); + assertTrue(buildResult.getOutput().contains("BUILD SUCCESSFUL")); + gradlePropertiesFile = new File(projectDir, "gradle.properties"); + assertTrue(gradlePropertiesFile.exists()); + assertTrue(gradlePropertiesFile.isFile()); + File appDir = new File(projectDir, "app"); + assertTrue(appDir.exists()); + assertTrue(appDir.isDirectory()); + gradleBuildFile = new File(appDir, "build.gradle"); + assertTrue(gradleBuildFile.exists()); + assertTrue(gradleBuildFile.isFile()); + databaseFile = new File(projectDir, "database/test.mv.db"); + assertFalse(databaseFile.exists()); + } + + private void editGradleBuildFile() throws Exception { + StringBuffer gradleBuildFileContents = new StringBuffer( + new String(Files.readAllBytes(gradleBuildFile.toPath()))); + addHibernateToolsPluginLine(gradleBuildFileContents); + addH2DatabaseDependencyLine(gradleBuildFileContents); + addHibernateToolsExtension(gradleBuildFileContents); + Files.writeString(gradleBuildFile.toPath(), gradleBuildFileContents.toString()); + } + + private void editGradlePropertiesFile() throws Exception { + // The Hibernate Tools Gradle plugin does not support the configuration cache. + // As this is enabled by default when initializing a new Gradle project, the setting needs to be commented out + // in the gradle.properties file. + StringBuffer gradlePropertiesFileContents = new StringBuffer( + new String(Files.readAllBytes(gradlePropertiesFile.toPath()))); + int pos = gradlePropertiesFileContents.indexOf("org.gradle.configuration-cache=true"); + gradlePropertiesFileContents.insert(pos, "#"); + Files.writeString(gradlePropertiesFile.toPath(), gradlePropertiesFileContents.toString()); + } + + private void createDatabase() throws Exception { + String CREATE_PERSON_TABLE = + "create table PERSON (ID int not null, NAME varchar(20), primary key (ID))"; + String CREATE_ITEM_TABLE = + "create table ITEM (ID int not null, NAME varchar(20), OWNER_ID int not null, " + + " primary key (ID), foreign key (OWNER_ID) references PERSON(ID))"; + Connection connection = DriverManager.getConnection(constructJdbcConnectionString()); + Statement statement = connection.createStatement(); + statement.execute(CREATE_PERSON_TABLE); + statement.execute(CREATE_ITEM_TABLE); + statement.close(); + connection.close(); + assertTrue(databaseFile.exists()); + assertTrue(databaseFile.isFile()); + } + + private void createHibernatePropertiesFile() throws Exception { + File hibernatePropertiesFile = new File(projectDir, "app/src/main/resources/hibernate.properties"); + StringBuffer hibernatePropertiesFileContents = new StringBuffer(); + hibernatePropertiesFileContents + .append("hibernate.connection.driver_class=org.h2.Driver\n") + .append("hibernate.connection.url=" + constructJdbcConnectionString() + "\n") + .append("hibernate.connection.username=\n") + .append("hibernate.connection.password=\n") + .append("hibernate.default_catalog=TEST\n") + .append("hibernate.default_schema=PUBLIC\n"); + Files.writeString(hibernatePropertiesFile.toPath(), hibernatePropertiesFileContents.toString()); + assertTrue(hibernatePropertiesFile.exists()); + } + + private void executeGenerateJavaTask() throws Exception { + GradleRunner gradleRunner = GradleRunner.create(); + gradleRunner.forwardOutput(); + gradleRunner.withProjectDir(projectDir); + gradleRunner.withPluginClasspath(); + gradleRunner.withArguments("generateJava"); + BuildResult buildResult = gradleRunner.build(); + assertTrue(buildResult.getOutput().contains("BUILD SUCCESSFUL")); + } + + private void verifyProject() throws Exception { + File generatedOutputFolder = new File(projectDir, "app/generated-sources"); + assertTrue(generatedOutputFolder.exists()); + assertTrue(generatedOutputFolder.isDirectory()); + assertEquals(2, generatedOutputFolder.list().length); + File generatedPersonJavaFile = new File(generatedOutputFolder, "Person.java"); + assertTrue(generatedPersonJavaFile.exists()); + assertTrue(generatedPersonJavaFile.isFile()); + String generatedPersonJavaFileContents = new String( + Files.readAllBytes(generatedPersonJavaFile.toPath())); + assertTrue(generatedPersonJavaFileContents.contains("public class Person ")); + assertFalse(generatedPersonJavaFileContents.contains("Set")); + File generatedItemJavaFile = new File(generatedOutputFolder, "Item.java"); + assertTrue(generatedItemJavaFile.exists()); + assertTrue(generatedItemJavaFile.isFile()); + String generatedItemJavaFileContents = new String( + Files.readAllBytes(generatedItemJavaFile.toPath())); + assertTrue(generatedItemJavaFileContents.contains("public class Item ")); + } + + private void addHibernateToolsPluginLine(StringBuffer gradleBuildFileContents) { + int pos = gradleBuildFileContents.indexOf("plugins {"); + pos = gradleBuildFileContents.indexOf("}", pos); + gradleBuildFileContents.insert(pos, constructHibernateToolsPluginLine() + "\n"); + } + + private void addH2DatabaseDependencyLine(StringBuffer gradleBuildFileContents) { + int pos = gradleBuildFileContents.indexOf("dependencies {"); + pos = gradleBuildFileContents.indexOf("}", pos); + gradleBuildFileContents.insert(pos, constructH2DatabaseDependencyLine() + "\n"); + } + + private void addHibernateToolsExtension(StringBuffer gradleBuildFileContents) { + int pos = gradleBuildFileContents.indexOf("dependencies {"); + pos = gradleBuildFileContents.indexOf("}", pos); + StringBuffer hibernateToolsExtension = new StringBuffer(); + hibernateToolsExtension + .append("\n") + .append("\n") + .append("hibernateTools { \n") + .append(" useGenerics=false \n") + .append("}"); + gradleBuildFileContents.insert(pos + 1, hibernateToolsExtension.toString()); + } + + private String constructJdbcConnectionString() { + return "jdbc:h2:" + projectDir.getAbsolutePath() + "/database/test;AUTO_SERVER=TRUE"; + } + + private String constructHibernateToolsPluginLine() { + return " id 'org.hibernate.tool.hibernate-tools-gradle' version '" + + System.getenv("HIBERNATE_TOOLS_VERSION") + "'"; + } + + private String constructH2DatabaseDependencyLine() { + return " implementation 'com.h2database:h2:" + System.getenv("H2_VERSION") + "'"; + } + +} diff --git a/gradle/plugin/src/functionalTest/java/org/hibernate/tool/gradle/java/UseGenerics.java b/gradle/plugin/src/functionalTest/java/org/hibernate/tool/gradle/java/UseGenerics.java new file mode 100644 index 0000000000..ecb9a10c97 --- /dev/null +++ b/gradle/plugin/src/functionalTest/java/org/hibernate/tool/gradle/java/UseGenerics.java @@ -0,0 +1,167 @@ +package org.hibernate.tool.gradle.java; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import java.io.File; +import java.nio.file.Files; +import java.sql.Connection; +import java.sql.DriverManager; +import java.sql.Statement; +import java.util.List; + +import org.gradle.testkit.runner.BuildResult; +import org.gradle.testkit.runner.GradleRunner; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.io.TempDir; + +public class UseGenerics { + + private static final List GRADLE_INIT_PROJECT_ARGUMENTS = List.of( + "init", "--type", "java-application", "--dsl", "groovy", "--test-framework", "junit-jupiter", "--java-version", "11"); + + @TempDir + private File projectDir; + + private File gradlePropertiesFile; + private File gradleBuildFile; + private File databaseFile; + + @Test + public void testTutorial() throws Exception { + assertTrue(projectDir.exists()); + createGradleProject(); + editGradleBuildFile(); + editGradlePropertiesFile(); + createDatabase(); + createHibernatePropertiesFile(); + executeGenerateJavaTask(); + verifyProject(); + } + + private void createGradleProject() throws Exception { + GradleRunner runner = GradleRunner.create(); + runner.withArguments(GRADLE_INIT_PROJECT_ARGUMENTS); + runner.forwardOutput(); + runner.withProjectDir(projectDir); + BuildResult buildResult = runner.build(); + assertTrue(buildResult.getOutput().contains("BUILD SUCCESSFUL")); + gradlePropertiesFile = new File(projectDir, "gradle.properties"); + assertTrue(gradlePropertiesFile.exists()); + assertTrue(gradlePropertiesFile.isFile()); + File appDir = new File(projectDir, "app"); + assertTrue(appDir.exists()); + assertTrue(appDir.isDirectory()); + gradleBuildFile = new File(appDir, "build.gradle"); + assertTrue(gradleBuildFile.exists()); + assertTrue(gradleBuildFile.isFile()); + databaseFile = new File(projectDir, "database/test.mv.db"); + assertFalse(databaseFile.exists()); + } + + private void editGradleBuildFile() throws Exception { + StringBuffer gradleBuildFileContents = new StringBuffer( + new String(Files.readAllBytes(gradleBuildFile.toPath()))); + addHibernateToolsPluginLine(gradleBuildFileContents); + addH2DatabaseDependencyLine(gradleBuildFileContents); + Files.writeString(gradleBuildFile.toPath(), gradleBuildFileContents.toString()); + } + + private void editGradlePropertiesFile() throws Exception { + // The Hibernate Tools Gradle plugin does not support the configuration cache. + // As this is enabled by default when initializing a new Gradle project, the setting needs to be commented out + // in the gradle.properties file. + StringBuffer gradlePropertiesFileContents = new StringBuffer( + new String(Files.readAllBytes(gradlePropertiesFile.toPath()))); + int pos = gradlePropertiesFileContents.indexOf("org.gradle.configuration-cache=true"); + gradlePropertiesFileContents.insert(pos, "#"); + Files.writeString(gradlePropertiesFile.toPath(), gradlePropertiesFileContents.toString()); + } + + private void createDatabase() throws Exception { + String CREATE_PERSON_TABLE = + "create table PERSON (ID int not null, NAME varchar(20), primary key (ID))"; + String CREATE_ITEM_TABLE = + "create table ITEM (ID int not null, NAME varchar(20), OWNER_ID int not null, " + + " primary key (ID), foreign key (OWNER_ID) references PERSON(ID))"; + Connection connection = DriverManager.getConnection(constructJdbcConnectionString()); + Statement statement = connection.createStatement(); + statement.execute(CREATE_PERSON_TABLE); + statement.execute(CREATE_ITEM_TABLE); + statement.close(); + connection.close(); + assertTrue(databaseFile.exists()); + assertTrue(databaseFile.isFile()); + } + + private void createHibernatePropertiesFile() throws Exception { + File hibernatePropertiesFile = new File(projectDir, "app/src/main/resources/hibernate.properties"); + StringBuffer hibernatePropertiesFileContents = new StringBuffer(); + hibernatePropertiesFileContents + .append("hibernate.connection.driver_class=org.h2.Driver\n") + .append("hibernate.connection.url=" + constructJdbcConnectionString() + "\n") + .append("hibernate.connection.username=\n") + .append("hibernate.connection.password=\n") + .append("hibernate.default_catalog=TEST\n") + .append("hibernate.default_schema=PUBLIC\n"); + Files.writeString(hibernatePropertiesFile.toPath(), hibernatePropertiesFileContents.toString()); + assertTrue(hibernatePropertiesFile.exists()); + } + + private void executeGenerateJavaTask() throws Exception { + GradleRunner gradleRunner = GradleRunner.create(); + gradleRunner.forwardOutput(); + gradleRunner.withProjectDir(projectDir); + gradleRunner.withPluginClasspath(); + gradleRunner.withArguments("generateJava"); + BuildResult buildResult = gradleRunner.build(); + assertTrue(buildResult.getOutput().contains("BUILD SUCCESSFUL")); + } + + private void verifyProject() throws Exception { + File generatedOutputFolder = new File(projectDir, "app/generated-sources"); + assertTrue(generatedOutputFolder.exists()); + assertTrue(generatedOutputFolder.isDirectory()); + assertEquals(2, generatedOutputFolder.list().length); + File generatedPersonJavaFile = new File(generatedOutputFolder, "Person.java"); + assertTrue(generatedPersonJavaFile.exists()); + assertTrue(generatedPersonJavaFile.isFile()); + String generatedPersonJavaFileContents = new String( + Files.readAllBytes(generatedPersonJavaFile.toPath())); + assertTrue(generatedPersonJavaFileContents.contains("public class Person ")); + assertTrue(generatedPersonJavaFileContents.contains("Set")); + File generatedItemJavaFile = new File(generatedOutputFolder, "Item.java"); + assertTrue(generatedItemJavaFile.exists()); + assertTrue(generatedItemJavaFile.isFile()); + String generatedItemJavaFileContents = new String( + Files.readAllBytes(generatedItemJavaFile.toPath())); + assertTrue(generatedItemJavaFileContents.contains("public class Item ")); + } + + private void addHibernateToolsPluginLine(StringBuffer gradleBuildFileContents) { + int pos = gradleBuildFileContents.indexOf("plugins {"); + pos = gradleBuildFileContents.indexOf("}", pos); + gradleBuildFileContents.insert(pos, constructHibernateToolsPluginLine() + "\n"); + } + + private void addH2DatabaseDependencyLine(StringBuffer gradleBuildFileContents) { + int pos = gradleBuildFileContents.indexOf("dependencies {"); + pos = gradleBuildFileContents.indexOf("}", pos); + gradleBuildFileContents.insert(pos, constructH2DatabaseDependencyLine() + "\n"); + } + + private String constructJdbcConnectionString() { + return "jdbc:h2:" + projectDir.getAbsolutePath() + "/database/test;AUTO_SERVER=TRUE"; + } + + private String constructHibernateToolsPluginLine() { + return " id 'org.hibernate.tool.hibernate-tools-gradle' version '" + + System.getenv("HIBERNATE_TOOLS_VERSION") + "'"; + } + + private String constructH2DatabaseDependencyLine() { + return " implementation 'com.h2database:h2:" + System.getenv("H2_VERSION") + "'"; + } + +} diff --git a/gradle/plugin/src/functionalTest/java/org/hibernate/tool/gradle/test/func/utils/FuncTestConstants.java b/gradle/plugin/src/functionalTest/java/org/hibernate/tool/gradle/test/func/utils/FuncTestConstants.java new file mode 100644 index 0000000000..d1620d2e45 --- /dev/null +++ b/gradle/plugin/src/functionalTest/java/org/hibernate/tool/gradle/test/func/utils/FuncTestConstants.java @@ -0,0 +1,65 @@ +package org.hibernate.tool.gradle.test.func.utils; + +public interface FuncTestConstants { + + public static final String DATABASE_NAME = "bardb"; + public static final String DATABASE_FILE_NAME = DATABASE_NAME + ".mv.db"; + public static final String DATABASE_FOLDER_NAME = "database"; + public static final String DATABASE_PATH = DATABASE_FOLDER_NAME + "/" + DATABASE_NAME; + public static final String HIBERNATE_PROPERTIES_FILE_NAME = "hibernate.properties"; + public static final String RESOURCES_FOLDER_PATH = "src/main/resources"; + public static final String GRADLE_BUILD_FILE_NAME = "build.gradle"; + public static final String GRADLE_SETTINGS_FILE_NAME = "settions.gradle"; + public static final String PROJECT_DIR_PLACEHOLDER = "${projectDir}"; + + public static final String HIBERNATE_PROPERTIES_CONTENTS = + "hibernate.connection.driver_class=org.h2.Driver\n" + + "hibernate.connection.url=jdbc:h2:" + PROJECT_DIR_PLACEHOLDER + "/" + DATABASE_PATH + "\n" + + "hibernate.connection.username=sa\n" + + "hibernate.connection.password=\n" + ; + + public static final String BUILD_FILE_PLUGINS_SECTION = + "plugins {\n" + + " id('application')\n" + + " id('org.hibernate.tool.hibernate-tools-gradle')\n" + + "}\n"; + + public static final String BUILD_FILE_REPOSITORIES_SECTION = + "repositories {\n" + + " mavenCentral()\n" + + "}\n"; + + public static final String BUILD_FILE_DEPENDENCIES_SECTION = + "dependencies {\n" + + " implementation('com.h2database:h2:2.1.214')\n" + + "}\n"; + + default String getBuildFilePluginsSection() { + return BUILD_FILE_PLUGINS_SECTION; + } + + default String getBuildFileRepositoriesSection() { + return BUILD_FILE_REPOSITORIES_SECTION; + } + + default String getBuildFileDependenciesSection() { + return BUILD_FILE_DEPENDENCIES_SECTION; + } + + default String getBuildFileHibernateToolsSection() { + return ""; + } + + default String getBuildFileContents() { + return getBuildFilePluginsSection() + + getBuildFileRepositoriesSection() + + getBuildFileDependenciesSection() + + getBuildFileHibernateToolsSection(); + } + + default String getHibernatePropertiesFileName() { + return HIBERNATE_PROPERTIES_FILE_NAME; + } + +} diff --git a/gradle/plugin/src/functionalTest/java/org/hibernate/tool/gradle/test/func/utils/FuncTestTemplate.java b/gradle/plugin/src/functionalTest/java/org/hibernate/tool/gradle/test/func/utils/FuncTestTemplate.java new file mode 100644 index 0000000000..e274eb8d18 --- /dev/null +++ b/gradle/plugin/src/functionalTest/java/org/hibernate/tool/gradle/test/func/utils/FuncTestTemplate.java @@ -0,0 +1,86 @@ +package org.hibernate.tool.gradle.test.func.utils; + +import java.io.File; +import java.io.FileWriter; +import java.io.IOException; +import java.io.Writer; +import java.net.URISyntaxException; +import java.nio.file.Files; + +import org.gradle.testkit.runner.BuildResult; +import org.gradle.testkit.runner.GradleRunner; +import org.junit.jupiter.api.io.TempDir; + +public class FuncTestTemplate implements FuncTestConstants { + + @TempDir + protected File projectDir; + + protected File getBuildFile() { + return new File(projectDir, GRADLE_BUILD_FILE_NAME); + } + + protected File getSettingsFile() { + return new File(projectDir, GRADLE_SETTINGS_FILE_NAME); + } + + protected File getDatabaseFile() { + File databaseDir = new File(projectDir, DATABASE_FOLDER_NAME); + databaseDir.mkdirs(); + return new File(databaseDir, DATABASE_FILE_NAME); + } + + protected File getHibernatePropertiesFile() { + File resourcesDir = new File(projectDir, RESOURCES_FOLDER_PATH); + resourcesDir.mkdirs(); + return new File(resourcesDir, getHibernatePropertiesFileName()); + } + + protected String getHibernatePropertiesContents() { + return HIBERNATE_PROPERTIES_CONTENTS.replace("${projectDir}", projectDir.getAbsolutePath()); + } + + protected void copyDatabase() { + try { + Files.copy( + new File(getClass().getClassLoader().getResource(DATABASE_FILE_NAME).toURI()).toPath(), + getDatabaseFile().toPath()); + } catch (URISyntaxException | IOException e) { + throw new RuntimeException(e); + } + } + + protected void writeString(File file, String string) { + try (Writer writer = new FileWriter(file)) { + writer.write(string); + } catch (IOException e) { + throw new RuntimeException(e); + } + } + + protected void performTask(String taskName, boolean needDatabase) { + prepareBuild(needDatabase); + verifyBuild(runBuild(taskName)); + } + + protected void prepareBuild(boolean needDatabase) { + writeString(getSettingsFile(), ""); + writeString(getBuildFile(),getBuildFileContents()); + writeString(getHibernatePropertiesFile(), getHibernatePropertiesContents()); + if (needDatabase) { + copyDatabase(); + } + } + + protected BuildResult runBuild(String taskName) { + GradleRunner runner = GradleRunner.create(); + runner.forwardOutput(); + runner.withPluginClasspath(); + runner.withArguments(taskName); + runner.withProjectDir(projectDir); + return runner.build(); + } + + protected void verifyBuild(BuildResult buildResult) {} + +} diff --git a/gradle/plugin/src/functionalTest/java/org/hibernate/tool/gradle/tutorial/TutorialTest.java b/gradle/plugin/src/functionalTest/java/org/hibernate/tool/gradle/tutorial/TutorialTest.java new file mode 100644 index 0000000000..b2b6cd4870 --- /dev/null +++ b/gradle/plugin/src/functionalTest/java/org/hibernate/tool/gradle/tutorial/TutorialTest.java @@ -0,0 +1,163 @@ +package org.hibernate.tool.gradle.tutorial; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import java.io.File; +import java.nio.file.Files; +import java.sql.Connection; +import java.sql.DriverManager; +import java.sql.ResultSet; +import java.sql.Statement; +import java.util.List; + +import org.gradle.testkit.runner.BuildResult; +import org.gradle.testkit.runner.GradleRunner; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.io.TempDir; + +public class TutorialTest { + + private static final List GRADLE_INIT_PROJECT_ARGUMENTS = List.of( + "init", "--type", "java-application", "--dsl", "groovy", "--test-framework", "junit-jupiter", "--java-version", "11"); + + @TempDir + private File projectDir; + + private File gradlePropertiesFile; + private File gradleBuildFile; + private File databaseFile; + + @Test + public void testTutorial() throws Exception { + assertTrue(projectDir.exists()); + createGradleProject(); + editGradleBuildFile(); + editGradlePropertiesFile(); + createDatabase(); + createHibernatePropertiesFile(); + verifyDatabase(); + executeGenerateJavaTask(); + verifyProject(); + } + + private void verifyDatabase() throws Exception { + Connection connection = DriverManager.getConnection(constructJdbcConnectionString()); + ResultSet resultSet = connection.createStatement().executeQuery("select * from PERSON"); + assertTrue(resultSet.next()); + assertEquals(1, resultSet.getInt(1)); + assertEquals("foo", resultSet.getString(2)); + } + + private void createGradleProject() throws Exception { + GradleRunner runner = GradleRunner.create(); + runner.withArguments(GRADLE_INIT_PROJECT_ARGUMENTS); + runner.forwardOutput(); + runner.withProjectDir(projectDir); + BuildResult buildResult = runner.build(); + assertTrue(buildResult.getOutput().contains("BUILD SUCCESSFUL")); + gradlePropertiesFile = new File(projectDir, "gradle.properties"); + assertTrue(gradlePropertiesFile.exists()); + assertTrue(gradlePropertiesFile.isFile()); + File appDir = new File(projectDir, "app"); + assertTrue(appDir.exists()); + assertTrue(appDir.isDirectory()); + gradleBuildFile = new File(appDir, "build.gradle"); + assertTrue(gradleBuildFile.exists()); + assertTrue(gradleBuildFile.isFile()); + databaseFile = new File(projectDir, "database/test.mv.db"); + assertFalse(databaseFile.exists()); + } + + private void editGradleBuildFile() throws Exception { + StringBuffer gradleBuildFileContents = new StringBuffer( + new String(Files.readAllBytes(gradleBuildFile.toPath()))); + addHibernateToolsPluginLine(gradleBuildFileContents); + addH2DatabaseDependencyLine(gradleBuildFileContents); + Files.writeString(gradleBuildFile.toPath(), gradleBuildFileContents.toString()); + } + + private void editGradlePropertiesFile() throws Exception { + // The Hibernate Tools Gradle plugin does not support the configuration cache. + // As this is enabled by default when initializing a new Gradle project, the setting needs to be commented out + // in the gradle.properties file. + StringBuffer gradlePropertiesFileContents = new StringBuffer( + new String(Files.readAllBytes(gradlePropertiesFile.toPath()))); + int pos = gradlePropertiesFileContents.indexOf("org.gradle.configuration-cache=true"); + gradlePropertiesFileContents.insert(pos, "#"); + Files.writeString(gradlePropertiesFile.toPath(), gradlePropertiesFileContents.toString()); + } + + private void createDatabase() throws Exception { + String CREATE_PERSON_TABLE = "create table PERSON (ID int not null, NAME varchar(20), primary key (ID))"; + Connection connection = DriverManager.getConnection(constructJdbcConnectionString()); + Statement statement = connection.createStatement(); + statement.execute(CREATE_PERSON_TABLE); + statement.execute("insert into PERSON values (1, 'foo')"); + statement.close(); + connection.close(); + assertTrue(databaseFile.exists()); + assertTrue(databaseFile.isFile()); + } + + private void createHibernatePropertiesFile() throws Exception { + File hibernatePropertiesFile = new File(projectDir, "app/src/main/resources/hibernate.properties"); + StringBuffer hibernatePropertiesFileContents = new StringBuffer(); + hibernatePropertiesFileContents + .append("hibernate.connection.driver_class=org.h2.Driver\n") + .append("hibernate.connection.url=" + constructJdbcConnectionString() + "\n") + .append("hibernate.connection.username=\n") + .append("hibernate.connection.password=\n") + .append("hibernate.default_catalog=TEST\n") + .append("hibernate.default_schema=PUBLIC\n"); + Files.writeString(hibernatePropertiesFile.toPath(), hibernatePropertiesFileContents.toString()); + assertTrue(hibernatePropertiesFile.exists()); + } + + private void executeGenerateJavaTask() throws Exception { + GradleRunner gradleRunner = GradleRunner.create(); + gradleRunner.forwardOutput(); + gradleRunner.withProjectDir(projectDir); + gradleRunner.withPluginClasspath(); + gradleRunner.withArguments("generateJava"); + BuildResult buildResult = gradleRunner.build(); + assertTrue(buildResult.getOutput().contains("BUILD SUCCESSFUL")); + } + + private void verifyProject() { + File generatedOutputFolder = new File(projectDir, "app/generated-sources"); + assertTrue(generatedOutputFolder.exists()); + assertTrue(generatedOutputFolder.isDirectory()); + assertEquals(1, generatedOutputFolder.list().length); + File generatedPersonJavaFile = new File(generatedOutputFolder, "Person.java"); + assertTrue(generatedPersonJavaFile.exists()); + assertTrue(generatedPersonJavaFile.isFile()); + } + + private void addHibernateToolsPluginLine(StringBuffer gradleBuildFileContents) { + int pos = gradleBuildFileContents.indexOf("plugins {"); + pos = gradleBuildFileContents.indexOf("}", pos); + gradleBuildFileContents.insert(pos, constructHibernateToolsPluginLine() + "\n"); + } + + private void addH2DatabaseDependencyLine(StringBuffer gradleBuildFileContents) { + int pos = gradleBuildFileContents.indexOf("dependencies {"); + pos = gradleBuildFileContents.indexOf("}", pos); + gradleBuildFileContents.insert(pos, constructH2DatabaseDependencyLine() + "\n"); + } + + private String constructJdbcConnectionString() { + return "jdbc:h2:" + projectDir.getAbsolutePath() + "/database/test;AUTO_SERVER=TRUE"; + } + + private String constructHibernateToolsPluginLine() { + return " id 'org.hibernate.tool.hibernate-tools-gradle' version '" + + System.getenv("HIBERNATE_TOOLS_VERSION") + "'"; + } + + private String constructH2DatabaseDependencyLine() { + return " implementation 'com.h2database:h2:" + System.getenv("H2_VERSION") + "'"; + } + +} diff --git a/gradle/plugin/src/functionalTest/resources/bardb.mv.db b/gradle/plugin/src/functionalTest/resources/bardb.mv.db new file mode 100644 index 0000000000..fbe5bee5da Binary files /dev/null and b/gradle/plugin/src/functionalTest/resources/bardb.mv.db differ diff --git a/gradle/plugin/src/main/java/org/hibernate/tool/gradle/Extension.java b/gradle/plugin/src/main/java/org/hibernate/tool/gradle/Extension.java new file mode 100644 index 0000000000..75c585525d --- /dev/null +++ b/gradle/plugin/src/main/java/org/hibernate/tool/gradle/Extension.java @@ -0,0 +1,17 @@ +package org.hibernate.tool.gradle; + +import org.gradle.api.Project; + +public class Extension { + + public String sqlToRun = ""; + public String hibernateProperties = "hibernate.properties"; + public String outputFolder = "generated-sources"; + public String packageName = ""; + public String revengStrategy = null; + public Boolean generateAnnotations = true; + public Boolean useGenerics = true; + + public Extension(Project project) {} + +} diff --git a/gradle/plugin/src/main/java/org/hibernate/tool/gradle/Plugin.java b/gradle/plugin/src/main/java/org/hibernate/tool/gradle/Plugin.java new file mode 100644 index 0000000000..f796a9176d --- /dev/null +++ b/gradle/plugin/src/main/java/org/hibernate/tool/gradle/Plugin.java @@ -0,0 +1,34 @@ +package org.hibernate.tool.gradle; + +import java.util.Map; + +import org.gradle.api.Project; +import org.hibernate.tool.gradle.task.AbstractTask; +import org.hibernate.tool.gradle.task.GenerateCfgTask; +import org.hibernate.tool.gradle.task.GenerateDaoTask; +import org.hibernate.tool.gradle.task.GenerateHbmTask; +import org.hibernate.tool.gradle.task.GenerateJavaTask; +import org.hibernate.tool.gradle.task.RunSqlTask; + +public class Plugin implements org.gradle.api.Plugin { + + private static Map> PLUGIN_TASK_MAP = Map.of( + "runSql", RunSqlTask.class, + "generateJava", GenerateJavaTask.class, + "generateCfg", GenerateCfgTask.class, + "generateHbm", GenerateHbmTask.class, + "generateDao", GenerateDaoTask.class + ); + + @SuppressWarnings("unchecked") + public void apply(Project project) { + Extension extension = project.getExtensions().create("hibernateTools", Extension.class, project); + for (String key : PLUGIN_TASK_MAP.keySet()) { + Class taskClass = PLUGIN_TASK_MAP.get(key); + project.getTasks().register(key, (Class)taskClass); + AbstractTask task = (AbstractTask)project.getTasks().getByName(key); + task.doFirst(w -> task.initialize(extension)); + } + } + +} diff --git a/gradle/plugin/src/main/java/org/hibernate/tool/gradle/task/AbstractTask.java b/gradle/plugin/src/main/java/org/hibernate/tool/gradle/task/AbstractTask.java new file mode 100644 index 0000000000..e3c4bad9f7 --- /dev/null +++ b/gradle/plugin/src/main/java/org/hibernate/tool/gradle/task/AbstractTask.java @@ -0,0 +1,142 @@ +package org.hibernate.tool.gradle.task; + +import java.io.File; +import java.io.FileInputStream; +import java.io.FileNotFoundException; +import java.io.IOException; +import java.net.MalformedURLException; +import java.net.URL; +import java.net.URLClassLoader; +import java.util.Properties; +import java.util.Set; + +import org.apache.tools.ant.BuildException; +import org.gradle.api.DefaultTask; +import org.gradle.api.artifacts.Configuration; +import org.gradle.api.artifacts.ConfigurationContainer; +import org.gradle.api.artifacts.ResolvedArtifact; +import org.gradle.api.artifacts.ResolvedConfiguration; +import org.gradle.api.file.SourceDirectorySet; +import org.gradle.api.tasks.Internal; +import org.gradle.api.tasks.SourceSet; +import org.gradle.api.tasks.SourceSetContainer; +import org.hibernate.tool.api.metadata.MetadataConstants; +import org.hibernate.tool.api.metadata.MetadataDescriptor; +import org.hibernate.tool.api.metadata.MetadataDescriptorFactory; +import org.hibernate.tool.api.reveng.RevengSettings; +import org.hibernate.tool.api.reveng.RevengStrategy; +import org.hibernate.tool.api.reveng.RevengStrategyFactory; +import org.hibernate.tool.gradle.Extension; + +public abstract class AbstractTask extends DefaultTask { + + @Internal + private Extension extension = null; + + @Internal + private Properties hibernateProperties = null; + + public void initialize(Extension extension) { + this.extension = extension; + } + + Extension getExtension() { + return this.extension; + } + + void perform() { + getLogger().lifecycle("Starting Task '" + getName() + "'"); + ClassLoader oldLoader = Thread.currentThread().getContextClassLoader(); + try { + Thread.currentThread().setContextClassLoader( + new URLClassLoader( + resolveProjectClassPath(), + oldLoader)); + doWork(); + } finally { + Thread.currentThread().setContextClassLoader(oldLoader); + getLogger().lifecycle("Ending Task '" + getName() + "'"); + } + } + + URL[] resolveProjectClassPath() { + try { + ConfigurationContainer cc = getProject().getConfigurations(); + Configuration defaultConf = cc.getByName("compileClasspath"); + ResolvedConfiguration resolvedConf = defaultConf.getResolvedConfiguration(); + Set ras = resolvedConf.getResolvedArtifacts(); + ResolvedArtifact[] resolvedArtifacts = ras.toArray(new ResolvedArtifact[ras.size()]); + URL[] urls = new URL[ras.size()]; + for (int i = 0; i < ras.size(); i++) { + urls[i] = resolvedArtifacts[i].getFile().toURI().toURL(); + } + return urls; + } catch (MalformedURLException e) { + getLogger().error("MalformedURLException while compiling project classpath"); + throw new BuildException(e); + } + } + + Properties getHibernateProperties() { + if (hibernateProperties == null) { + loadPropertiesFile(getPropertyFile()); + } + return hibernateProperties; + } + + String getHibernateProperty(String name) { + return getHibernateProperties().getProperty(name); + } + + MetadataDescriptor createJdbcDescriptor() { + RevengStrategy strategy = setupReverseEngineeringStrategy(); + Properties hibernateProperties = getHibernateProperties(); + hibernateProperties.put(MetadataConstants.PREFER_BASIC_COMPOSITE_IDS, true); + return MetadataDescriptorFactory.createReverseEngineeringDescriptor(strategy, hibernateProperties); + } + + @Internal + File getOutputFolder() { + return new File(getProject().getProjectDir(), getExtension().outputFolder); + } + + RevengStrategy setupReverseEngineeringStrategy() { + RevengStrategy result = RevengStrategyFactory + .createReverseEngineeringStrategy(getExtension().revengStrategy); + RevengSettings settings = new RevengSettings(result); + settings.setDefaultPackageName(getExtension().packageName); + result.setSettings(settings); + return result; + } + + private File getPropertyFile() { + String hibernatePropertiesFile = getExtension().hibernateProperties; + SourceSetContainer ssc = getProject().getExtensions().getByType(SourceSetContainer.class); + SourceSet ss = ssc.getByName(SourceSet.MAIN_SOURCE_SET_NAME); + SourceDirectorySet sds = ss.getResources(); + for (File f : sds.getFiles()) { + if (hibernatePropertiesFile.equals(f.getName())) { + return f; + } + } + throw new BuildException("File '" + hibernatePropertiesFile + "' could not be found"); + } + + private void loadPropertiesFile(File propertyFile) { + getLogger().lifecycle("Loading the properties file : " + propertyFile.getPath()); + try (FileInputStream is = new FileInputStream(propertyFile)) { + hibernateProperties = new Properties(); + hibernateProperties.load(is); + getLogger().lifecycle("Properties file is loaded"); + } catch (FileNotFoundException e) { + e.printStackTrace(); + throw new BuildException(propertyFile + " not found.", e); + } catch (IOException e) { + e.printStackTrace(); + throw new BuildException("Problem while loading " + propertyFile, e); + } + } + + abstract void doWork(); + +} diff --git a/gradle/plugin/src/main/java/org/hibernate/tool/gradle/task/GenerateCfgTask.java b/gradle/plugin/src/main/java/org/hibernate/tool/gradle/task/GenerateCfgTask.java new file mode 100644 index 0000000000..08e3e79baa --- /dev/null +++ b/gradle/plugin/src/main/java/org/hibernate/tool/gradle/task/GenerateCfgTask.java @@ -0,0 +1,29 @@ +package org.hibernate.tool.gradle.task; + +import java.io.File; + +import org.gradle.api.tasks.TaskAction; +import org.hibernate.tool.api.export.Exporter; +import org.hibernate.tool.api.export.ExporterConstants; +import org.hibernate.tool.api.export.ExporterFactory; +import org.hibernate.tool.api.export.ExporterType; + +public class GenerateCfgTask extends AbstractTask { + + @TaskAction + public void performTask() { + super.perform(); + } + + void doWork() { + getLogger().lifecycle("Creating CFG exporter"); + Exporter cfgExporter = ExporterFactory.createExporter(ExporterType.CFG); + File outputFolder = getOutputFolder(); + cfgExporter.getProperties().put(ExporterConstants.METADATA_DESCRIPTOR, createJdbcDescriptor()); + cfgExporter.getProperties().put(ExporterConstants.DESTINATION_FOLDER, outputFolder); + getLogger().lifecycle("Starting CFG export to directory: " + outputFolder + "..."); + cfgExporter.start(); + getLogger().lifecycle("CFG export finished"); + } + +} diff --git a/gradle/plugin/src/main/java/org/hibernate/tool/gradle/task/GenerateDaoTask.java b/gradle/plugin/src/main/java/org/hibernate/tool/gradle/task/GenerateDaoTask.java new file mode 100644 index 0000000000..74edc40101 --- /dev/null +++ b/gradle/plugin/src/main/java/org/hibernate/tool/gradle/task/GenerateDaoTask.java @@ -0,0 +1,29 @@ +package org.hibernate.tool.gradle.task; + +import java.io.File; + +import org.gradle.api.tasks.TaskAction; +import org.hibernate.tool.api.export.Exporter; +import org.hibernate.tool.api.export.ExporterConstants; +import org.hibernate.tool.api.export.ExporterFactory; +import org.hibernate.tool.api.export.ExporterType; + +public class GenerateDaoTask extends AbstractTask { + + @TaskAction + public void performTask() { + super.perform(); + } + + void doWork() { + getLogger().lifecycle("Creating DAO exporter"); + Exporter hbmExporter = ExporterFactory.createExporter(ExporterType.DAO); + File outputFolder = getOutputFolder(); + hbmExporter.getProperties().put(ExporterConstants.METADATA_DESCRIPTOR, createJdbcDescriptor()); + hbmExporter.getProperties().put(ExporterConstants.DESTINATION_FOLDER, outputFolder); + getLogger().lifecycle("Starting DAO export to directory: " + outputFolder + "..."); + hbmExporter.start(); + getLogger().lifecycle("DAO export finished"); + } + +} diff --git a/gradle/plugin/src/main/java/org/hibernate/tool/gradle/task/GenerateHbmTask.java b/gradle/plugin/src/main/java/org/hibernate/tool/gradle/task/GenerateHbmTask.java new file mode 100644 index 0000000000..495a4cefe1 --- /dev/null +++ b/gradle/plugin/src/main/java/org/hibernate/tool/gradle/task/GenerateHbmTask.java @@ -0,0 +1,29 @@ +package org.hibernate.tool.gradle.task; + +import java.io.File; + +import org.gradle.api.tasks.TaskAction; +import org.hibernate.tool.api.export.Exporter; +import org.hibernate.tool.api.export.ExporterConstants; +import org.hibernate.tool.api.export.ExporterFactory; +import org.hibernate.tool.api.export.ExporterType; + +public class GenerateHbmTask extends AbstractTask { + + @TaskAction + public void performTask() { + super.perform(); + } + + void doWork() { + getLogger().lifecycle("Creating HBM exporter"); + Exporter hbmExporter = ExporterFactory.createExporter(ExporterType.HBM); + File outputFolder = getOutputFolder(); + hbmExporter.getProperties().put(ExporterConstants.METADATA_DESCRIPTOR, createJdbcDescriptor()); + hbmExporter.getProperties().put(ExporterConstants.DESTINATION_FOLDER, outputFolder); + getLogger().lifecycle("Starting HBM export to directory: " + outputFolder + "..."); + hbmExporter.start(); + getLogger().lifecycle("HBM export finished"); + } + +} diff --git a/gradle/plugin/src/main/java/org/hibernate/tool/gradle/task/GenerateJavaTask.java b/gradle/plugin/src/main/java/org/hibernate/tool/gradle/task/GenerateJavaTask.java new file mode 100644 index 0000000000..75b15884aa --- /dev/null +++ b/gradle/plugin/src/main/java/org/hibernate/tool/gradle/task/GenerateJavaTask.java @@ -0,0 +1,31 @@ +package org.hibernate.tool.gradle.task; + +import java.io.File; + +import org.gradle.api.tasks.TaskAction; +import org.hibernate.tool.api.export.Exporter; +import org.hibernate.tool.api.export.ExporterConstants; +import org.hibernate.tool.api.export.ExporterFactory; +import org.hibernate.tool.api.export.ExporterType; + +public class GenerateJavaTask extends AbstractTask { + + @TaskAction + public void performTask() { + super.perform(); + } + + void doWork() { + getLogger().lifecycle("Creating Java exporter"); + Exporter pojoExporter = ExporterFactory.createExporter(ExporterType.JAVA); + pojoExporter.getProperties().setProperty("ejb3", String.valueOf(getExtension().generateAnnotations)); + pojoExporter.getProperties().setProperty("jdk5", String.valueOf(getExtension().useGenerics)); + File outputFolder = getOutputFolder(); + pojoExporter.getProperties().put(ExporterConstants.METADATA_DESCRIPTOR, createJdbcDescriptor()); + pojoExporter.getProperties().put(ExporterConstants.DESTINATION_FOLDER, outputFolder); + getLogger().lifecycle("Starting Java export to directory: " + outputFolder + "..."); + pojoExporter.start(); + getLogger().lifecycle("Java export finished"); + } + +} diff --git a/gradle/plugin/src/main/java/org/hibernate/tool/gradle/task/RunSqlTask.java b/gradle/plugin/src/main/java/org/hibernate/tool/gradle/task/RunSqlTask.java new file mode 100644 index 0000000000..d5b4a35e2f --- /dev/null +++ b/gradle/plugin/src/main/java/org/hibernate/tool/gradle/task/RunSqlTask.java @@ -0,0 +1,70 @@ +package org.hibernate.tool.gradle.task; + +import java.lang.reflect.Constructor; +import java.lang.reflect.InvocationHandler; +import java.lang.reflect.Method; +import java.lang.reflect.Proxy; +import java.sql.Connection; +import java.sql.Driver; +import java.sql.DriverManager; +import java.sql.SQLException; +import java.sql.Statement; + +import org.gradle.api.tasks.TaskAction; + +public class RunSqlTask extends AbstractTask { + + @TaskAction + public void performTask() { + super.perform(); + } + + void doWork() { + registerDriver(); + runSql(); + } + + private void registerDriver() { + String driverClassName = getHibernateProperty("hibernate.connection.driver_class"); + getLogger().lifecycle("Registering the database driver: " + driverClassName); + try { + Class driverClass = Thread.currentThread().getContextClassLoader().loadClass(driverClassName); + Constructor constructor = driverClass.getDeclaredConstructor(); + DriverManager.registerDriver(createDelegatingDriver((Driver)constructor.newInstance())); + getLogger().lifecycle("Database driver is registered"); + } catch (Exception e) { + getLogger().error("Exception while registering the database driver: " + e.getMessage()); + throw new RuntimeException(e); + } + } + + private void runSql() { + try { + String databaseUrl = getHibernateProperty("hibernate.connection.url"); + getLogger().lifecycle("Connecting to database: " + databaseUrl); + Connection connection = DriverManager + .getConnection(databaseUrl, "sa", ""); + Statement statement = connection.createStatement(); + getLogger().lifecycle("Running SQL: " + getExtension().sqlToRun); + statement.execute(getExtension().sqlToRun); + statement.close(); + connection.close(); + } catch (SQLException e) { + getLogger().error("SQLException"); + throw new RuntimeException(e); + } + } + + private Driver createDelegatingDriver(Driver driver) { + return (Driver)Proxy.newProxyInstance( + DriverManager.class.getClassLoader(), + new Class[] { Driver.class}, + new InvocationHandler() { + @Override + public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { + return method.invoke(driver, args); + } + }); + } + +} diff --git a/gradle/plugin/src/test/java/org/hibernate/tool/gradle/ExtensionTest.java b/gradle/plugin/src/test/java/org/hibernate/tool/gradle/ExtensionTest.java new file mode 100644 index 0000000000..981689a872 --- /dev/null +++ b/gradle/plugin/src/test/java/org/hibernate/tool/gradle/ExtensionTest.java @@ -0,0 +1,22 @@ +package org.hibernate.tool.gradle; + +import static org.junit.jupiter.api.Assertions.assertNotNull; + +import java.lang.reflect.Field; +import java.util.HashMap; +import java.util.Map; + +import org.junit.jupiter.api.Test; + +public class ExtensionTest { + + @Test + void testExtension() { + Map extensionFieldMap = new HashMap(); + for(Field field : Extension.class.getDeclaredFields()) { + extensionFieldMap.put(field.getName(), field); + } + assertNotNull(extensionFieldMap.get("sqlToRun")); + } + +} diff --git a/gradle/plugin/src/test/java/org/hibernate/tool/gradle/PluginTest.java b/gradle/plugin/src/test/java/org/hibernate/tool/gradle/PluginTest.java new file mode 100644 index 0000000000..7a1848137f --- /dev/null +++ b/gradle/plugin/src/test/java/org/hibernate/tool/gradle/PluginTest.java @@ -0,0 +1,25 @@ +package org.hibernate.tool.gradle; + +import org.gradle.testfixtures.ProjectBuilder; +import org.gradle.api.Project; +import org.junit.jupiter.api.Test; +import static org.junit.jupiter.api.Assertions.*; + +class PluginTest { + + @Test + void testApply() { + // Create a test project and apply the plugin + Project project = ProjectBuilder.builder().build(); + project.getPlugins().apply("org.hibernate.tool.hibernate-tools-gradle"); + + // Verify the result + assertNotNull(project.getTasks().findByName("generateJava")); + assertNotNull(project.getTasks().findByName("runSql")); + + Object extension = project.getExtensions().getByName("hibernateTools"); + assertNotNull(extension); + assertTrue(extension instanceof Extension); + } + +} diff --git a/gradle/plugin/src/test/java/org/hibernate/tool/gradle/task/AbstractTaskTest.java b/gradle/plugin/src/test/java/org/hibernate/tool/gradle/task/AbstractTaskTest.java new file mode 100644 index 0000000000..4f890dbc7c --- /dev/null +++ b/gradle/plugin/src/test/java/org/hibernate/tool/gradle/task/AbstractTaskTest.java @@ -0,0 +1,87 @@ +package org.hibernate.tool.gradle.task; + +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertNotSame; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertSame; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import java.lang.reflect.Field; +import java.net.URL; + +import org.gradle.api.Project; +import org.gradle.testfixtures.ProjectBuilder; +import org.hibernate.tool.api.reveng.RevengStrategy; +import org.hibernate.tool.gradle.Extension; +import org.hibernate.tool.internal.reveng.strategy.AbstractStrategy; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +public class AbstractTaskTest { + + private static ClassLoader USED_CLASS_LOADER; + private static URL[] URLS = new URL[] {}; + + private AbstractTask abstractTask = null; + + private Field extensionField = null; + private Extension extension = null; + + @BeforeEach + void beforeEach() throws Exception { + USED_CLASS_LOADER = null; + Project project = ProjectBuilder.builder().build(); + abstractTask = project.getTasks().create("foo", FooTask.class); + extensionField = AbstractTask.class.getDeclaredField("extension"); + extensionField.setAccessible(true); + extension = new Extension(project); + } + + @Test + void testInitialize() throws Exception { + assertNull(extensionField.get(abstractTask)); + abstractTask.initialize(extension); + assertSame(extension, extensionField.get(abstractTask)); + } + + @Test + void testGetExtension() throws Exception { + assertNull(abstractTask.getExtension()); + extensionField.set(abstractTask, extension); + assertSame(extension, abstractTask.getExtension()); + } + + @Test + void testPerform() { + ClassLoader contextClassLoader = Thread.currentThread().getContextClassLoader(); + assertNull(USED_CLASS_LOADER); + abstractTask.perform(); + assertNotNull(USED_CLASS_LOADER); + assertNotSame(contextClassLoader, USED_CLASS_LOADER); + } + + @Test + void testResolveProjectClassPath() { + assertSame(URLS, abstractTask.resolveProjectClassPath()); + } + + @Test + public void testSetupReverseEngineeringStrategy() throws Exception { + extension.revengStrategy = FooStrategy.class.getName(); + extensionField.set(abstractTask, extension); + RevengStrategy revengStrategy = abstractTask.setupReverseEngineeringStrategy(); + assertTrue(revengStrategy instanceof FooStrategy); + } + + public static class FooStrategy extends AbstractStrategy {} + + public static class FooTask extends AbstractTask { + void doWork() { + USED_CLASS_LOADER = Thread.currentThread().getContextClassLoader(); + } + URL[] resolveProjectClassPath() { + return URLS; + } + } + +} diff --git a/gradle/pom.xml b/gradle/pom.xml new file mode 100644 index 0000000000..35ff2b2b3f --- /dev/null +++ b/gradle/pom.xml @@ -0,0 +1,140 @@ + + + + + 4.0.0 + + + org.hibernate.tool + hibernate-tools-parent + 6.6.27-SNAPSHOT + + + hibernate-tools-gradle + pom + + Hibernate Tools Gradle Plugin + Gradle plugin to provide hibernate-tools reverse engineering and code/schema generation abilities. + https://hibernate.org/tools/ + + + JIRA + https://hibernate.atlassian.net/projects/HBX + + + + + false + + ./gradlew + + + + + + + org.apache.maven.plugins + maven-deploy-plugin + + true + + + + + org.codehaus.mojo + exec-maven-plugin + + + gradle-package + prepare-package + + ${gradle.executable} + + clean + build + -PprojectVersion=${project.version} + -Ph2Version=${h2.version} + -Dmaven.repo.local=${settings.localRepository} + + + + exec + + + + gradle-clean + clean + + ${gradle.executable} + + clean + -PprojectVersion=${project.version} + -Ph2Version=${h2.version} + + + + exec + + + + + + + + + + release + + + performRelease + true + + + + + + org.codehaus.mojo + exec-maven-plugin + + + gradle-publish-to-plugin-portal + deploy + + ${gradle.executable} + + publishPlugins + publishPluginMavenPublicationToStagingRepository + -PprojectVersion=${project.version} + -Ph2Version=${h2.version} + -Dmaven.repo.local=${settings.localRepository} + -PmavenStagingDirectory=${local.staging.releases.repo.url} + + + + exec + + + + + + + + + + + diff --git a/gradle/settings.gradle b/gradle/settings.gradle new file mode 100644 index 0000000000..696921961c --- /dev/null +++ b/gradle/settings.gradle @@ -0,0 +1,10 @@ +/* + * This file was generated by the Gradle 'init' task. + * + * The settings file is used to specify which projects to include in your build. + * For more detailed information on multi-project builds, please refer to https://docs.gradle.org/8.8/userguide/multi_project_builds.html in the Gradle documentation. + */ + +rootProject.name = 'hibernate-tools-gradle' +include('plugin') +project( ':plugin' ).name = 'hibernate-tools-gradle' diff --git a/jbt/pom.xml b/jbt/pom.xml index 3fbfd24c27..dc985db51b 100644 --- a/jbt/pom.xml +++ b/jbt/pom.xml @@ -25,7 +25,7 @@ org.hibernate.tool hibernate-tools-parent - 6.5.0.Final + 6.6.27-SNAPSHOT hibernate-tools-orm-jbt @@ -35,6 +35,11 @@ Hibernate Tools ORM - JBoss Tools Adapter Hibernate Tools ORM - JBoss Tools Adapter + + + false + + com.h2database diff --git a/jbt/src/main/java/org/hibernate/tool/hbm2x/DAOExporter.java b/jbt/src/main/java/org/hibernate/tool/hbm2x/DAOExporter.java new file mode 100644 index 0000000000..263e564e9a --- /dev/null +++ b/jbt/src/main/java/org/hibernate/tool/hbm2x/DAOExporter.java @@ -0,0 +1,5 @@ +package org.hibernate.tool.hbm2x; + +import org.hibernate.tool.internal.export.dao.DaoExporter; + +public class DAOExporter extends DaoExporter {} diff --git a/jbt/src/main/java/org/hibernate/tool/hbm2x/DocExporter.java b/jbt/src/main/java/org/hibernate/tool/hbm2x/DocExporter.java new file mode 100644 index 0000000000..01ea56276e --- /dev/null +++ b/jbt/src/main/java/org/hibernate/tool/hbm2x/DocExporter.java @@ -0,0 +1,3 @@ +package org.hibernate.tool.hbm2x; + +public class DocExporter extends org.hibernate.tool.internal.export.doc.DocExporter {} diff --git a/jbt/src/main/java/org/hibernate/tool/hbm2x/GenericExporter.java b/jbt/src/main/java/org/hibernate/tool/hbm2x/GenericExporter.java new file mode 100644 index 0000000000..3ae36af92d --- /dev/null +++ b/jbt/src/main/java/org/hibernate/tool/hbm2x/GenericExporter.java @@ -0,0 +1,3 @@ +package org.hibernate.tool.hbm2x; + +public class GenericExporter extends org.hibernate.tool.internal.export.common.GenericExporter {} diff --git a/jbt/src/main/java/org/hibernate/tool/hbm2x/Hbm2DDLExporter.java b/jbt/src/main/java/org/hibernate/tool/hbm2x/Hbm2DDLExporter.java new file mode 100644 index 0000000000..ce5334e854 --- /dev/null +++ b/jbt/src/main/java/org/hibernate/tool/hbm2x/Hbm2DDLExporter.java @@ -0,0 +1,5 @@ +package org.hibernate.tool.hbm2x; + +import org.hibernate.tool.internal.export.ddl.DdlExporter; + +public class Hbm2DDLExporter extends DdlExporter {} diff --git a/jbt/src/main/java/org/hibernate/tool/hbm2x/QueryExporter.java b/jbt/src/main/java/org/hibernate/tool/hbm2x/QueryExporter.java new file mode 100644 index 0000000000..cb199780c0 --- /dev/null +++ b/jbt/src/main/java/org/hibernate/tool/hbm2x/QueryExporter.java @@ -0,0 +1,3 @@ +package org.hibernate.tool.hbm2x; + +public class QueryExporter extends org.hibernate.tool.internal.export.query.QueryExporter {} diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/ArtifactCollectorWrapper.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/ArtifactCollectorWrapper.java deleted file mode 100644 index a9097fb70e..0000000000 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/ArtifactCollectorWrapper.java +++ /dev/null @@ -1,15 +0,0 @@ -package org.hibernate.tool.orm.jbt.api; - -import java.io.File; -import java.util.Set; - -import org.hibernate.tool.api.export.ArtifactCollector; -import org.hibernate.tool.orm.jbt.wrp.Wrapper; - -public interface ArtifactCollectorWrapper extends Wrapper { - - default Set getFileTypes() { return ((ArtifactCollector)getWrappedObject()).getFileTypes(); } - default void formatFiles() { ((ArtifactCollector)getWrappedObject()).formatFiles(); } - default File[] getFiles(String string) { return ((ArtifactCollector)getWrappedObject()).getFiles(string); } - -} diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/Cfg2HbmToolWrapper.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/Cfg2HbmToolWrapper.java deleted file mode 100644 index 567ce63370..0000000000 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/Cfg2HbmToolWrapper.java +++ /dev/null @@ -1,40 +0,0 @@ -package org.hibernate.tool.orm.jbt.api; - -import org.hibernate.mapping.PersistentClass; -import org.hibernate.mapping.Property; -import org.hibernate.mapping.SimpleValue; -import org.hibernate.tool.internal.export.hbm.Cfg2HbmTool; -import org.hibernate.tool.internal.export.hbm.HBMTagForValueVisitor; -import org.hibernate.tool.orm.jbt.wrp.Wrapper; - -public interface Cfg2HbmToolWrapper extends Wrapper { - - default String getTag(PersistentClass pc) { - return ((Cfg2HbmTool)getWrappedObject()).getTag(pc); - } - default String getTag(Property p) { - if (p instanceof Wrapper) { - p = (Property)((Wrapper)p).getWrappedObject(); - } - PersistentClass persistentClass = p.getPersistentClass(); - if(persistentClass!=null) { - Property v = persistentClass.getVersion(); - if (v instanceof Wrapper) { - v = (Property)((Wrapper)v).getWrappedObject(); - } - if(v==p) { - String typeName = ((SimpleValue)p.getValue()).getTypeName(); - if("timestamp".equals(typeName) || "dbtimestamp".equals(typeName)) { - return "timestamp"; - } else { - return "version"; - } - } - } - String toolTag = (String) p.getValue().accept(HBMTagForValueVisitor.INSTANCE); - if ("component".equals(toolTag) && "embedded".equals(p.getPropertyAccessorName())){ - toolTag = "properties"; - } - return toolTag; - } -} diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/ClassMetadataWrapper.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/ClassMetadataWrapper.java deleted file mode 100644 index 346faaeb8a..0000000000 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/ClassMetadataWrapper.java +++ /dev/null @@ -1,25 +0,0 @@ -package org.hibernate.tool.orm.jbt.api; - -import org.hibernate.Session; -import org.hibernate.engine.spi.SharedSessionContractImplementor; -import org.hibernate.persister.entity.AbstractEntityPersister; -import org.hibernate.persister.entity.EntityPersister; -import org.hibernate.tool.orm.jbt.wrp.Wrapper; -import org.hibernate.type.Type; - -public interface ClassMetadataWrapper extends Wrapper { - - default String getEntityName() { return ((EntityPersister)getWrappedObject()).getEntityName(); } - default String getIdentifierPropertyName() { return ((EntityPersister)getWrappedObject()).getIdentifierPropertyName(); } - default String[] getPropertyNames() { return ((EntityPersister)getWrappedObject()).getPropertyNames(); } - default Type[] getPropertyTypes() { return ((EntityPersister)getWrappedObject()).getPropertyTypes(); } - default Class getMappedClass() { return ((EntityPersister)getWrappedObject()).getMappedClass(); } - default Type getIdentifierType() { return ((EntityPersister)getWrappedObject()).getIdentifierType(); } - default Object getPropertyValue(Object object, String name) { return ((EntityPersister)getWrappedObject()).getPropertyValue(object, name); } - default boolean hasIdentifierProperty() { return ((EntityPersister)getWrappedObject()).hasIdentifierProperty(); } - default Object getIdentifier(Object object, Session session) { return ((EntityPersister)getWrappedObject()).getIdentifier(object, (SharedSessionContractImplementor)session); } - default boolean isInstanceOfAbstractEntityPersister() { return (EntityPersister)getWrappedObject() instanceof AbstractEntityPersister; } - default Integer getPropertyIndexOrNull(String id) { return ((EntityPersister)getWrappedObject()).getEntityMetamodel().getPropertyIndexOrNull(id); } - default Object getTuplizerPropertyValue(Object entity, int i) { return ((EntityPersister)getWrappedObject()).getValue(entity, i); } - -} diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/CollectionMetadataWrapper.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/CollectionMetadataWrapper.java deleted file mode 100644 index ef272a5e7c..0000000000 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/CollectionMetadataWrapper.java +++ /dev/null @@ -1,11 +0,0 @@ -package org.hibernate.tool.orm.jbt.api; - -import org.hibernate.persister.collection.CollectionPersister; -import org.hibernate.tool.orm.jbt.wrp.Wrapper; -import org.hibernate.type.Type; - -public interface CollectionMetadataWrapper extends Wrapper { - - default Type getElementType() { return ((CollectionPersister)getWrappedObject()).getElementType(); } - -} diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/ColumnWrapper.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/ColumnWrapper.java deleted file mode 100644 index 71e873fe86..0000000000 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/ColumnWrapper.java +++ /dev/null @@ -1,41 +0,0 @@ -package org.hibernate.tool.orm.jbt.api; - -import org.hibernate.cfg.Configuration; -import org.hibernate.mapping.Column; -import org.hibernate.mapping.Value; -import org.hibernate.tool.orm.jbt.util.MetadataHelper; -import org.hibernate.tool.orm.jbt.wrp.Wrapper; - -public interface ColumnWrapper extends Wrapper { - - static final int DEFAULT_LENGTH = 255; - static final int DEFAULT_PRECISION = 19; - static final int DEFAULT_SCALE = 2; - - default String getName() { return ((Column)getWrappedObject()).getName(); } - default Integer getSqlTypeCode() { return ((Column)getWrappedObject()).getSqlTypeCode(); } - default String getSqlType() { return ((Column)getWrappedObject()).getSqlType(); } - default String getSqlType(Configuration configuration) { - return ((Column)getWrappedObject()).getSqlType(MetadataHelper.getMetadata(configuration)); - } - default long getLength() { - Long length = ((Column)getWrappedObject()).getLength(); - return length == null ? Integer.MIN_VALUE : length; - } - default int getDefaultLength() { return DEFAULT_LENGTH; } - default int getPrecision() { - Integer precision = ((Column)getWrappedObject()).getPrecision(); - return precision == null ? Integer.MIN_VALUE : precision; - } - default int getDefaultPrecision() { return DEFAULT_PRECISION; } - default int getScale() { - Integer scale = ((Column)getWrappedObject()).getScale(); - return scale == null ? Integer.MIN_VALUE : scale; - } - default int getDefaultScale() { return DEFAULT_SCALE; } - default boolean isNullable() { return ((Column)getWrappedObject()).isNullable(); } - default Value getValue() { return ((Column)getWrappedObject()).getValue(); } - default boolean isUnique() { return ((Column)getWrappedObject()).isUnique(); } - default void setSqlType(String sqlType) { ((Column)getWrappedObject()).setSqlType(sqlType); } - -} diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/ConfigurationWrapper.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/ConfigurationWrapper.java deleted file mode 100644 index 2d25d8f531..0000000000 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/ConfigurationWrapper.java +++ /dev/null @@ -1,111 +0,0 @@ -package org.hibernate.tool.orm.jbt.api; - -import java.io.File; -import java.util.Iterator; -import java.util.Properties; - -import org.hibernate.SessionFactory; -import org.hibernate.cfg.Configuration; -import org.hibernate.cfg.NamingStrategy; -import org.hibernate.mapping.PersistentClass; -import org.hibernate.mapping.Table; -import org.hibernate.tool.api.reveng.RevengStrategy; -import org.hibernate.tool.orm.jbt.util.JpaConfiguration; -import org.hibernate.tool.orm.jbt.util.NativeConfiguration; -import org.hibernate.tool.orm.jbt.util.RevengConfiguration; -import org.hibernate.tool.orm.jbt.wrp.Wrapper; -import org.w3c.dom.Document; -import org.xml.sax.EntityResolver; - -public interface ConfigurationWrapper extends Wrapper { - - default String getProperty(String property) { return ((Configuration)getWrappedObject()).getProperty(property); } - default ConfigurationWrapper addFile(File file) { ((Configuration)getWrappedObject()).addFile(file); return this; } - default void setProperty(String name, String value) { ((Configuration)getWrappedObject()).setProperty(name, value); } - default ConfigurationWrapper setProperties(Properties properties) { ((Configuration)getWrappedObject()).setProperties(properties); return this; } - default void setEntityResolver(EntityResolver entityResolver) { - Object wrappedObject = getWrappedObject(); - if (wrappedObject instanceof NativeConfiguration) ((NativeConfiguration)wrappedObject).setEntityResolver(entityResolver); - if (wrappedObject instanceof RevengConfiguration) ((RevengConfiguration)wrappedObject).setEntityResolver(entityResolver); - if (wrappedObject instanceof JpaConfiguration) ((JpaConfiguration)wrappedObject).setEntityResolver(entityResolver); - } - default void setNamingStrategy(NamingStrategy namingStrategy) { - Object wrappedObject = getWrappedObject(); - if (wrappedObject instanceof NativeConfiguration) ((NativeConfiguration)wrappedObject).setNamingStrategy(namingStrategy); - if (wrappedObject instanceof RevengConfiguration) ((RevengConfiguration)wrappedObject).setNamingStrategy(namingStrategy); - if (wrappedObject instanceof JpaConfiguration) ((JpaConfiguration)wrappedObject).setNamingStrategy(namingStrategy); - } - default Properties getProperties() { return ((Configuration)getWrappedObject()).getProperties(); } - default void addProperties(Properties properties) { ((Configuration)getWrappedObject()).addProperties(properties); } - default ConfigurationWrapper configure(Document document) { - Object wrappedObject = getWrappedObject(); - if (wrappedObject instanceof NativeConfiguration) ((NativeConfiguration)wrappedObject).configure(document); - if (wrappedObject instanceof RevengConfiguration) ((RevengConfiguration)wrappedObject).configure(document); - if (wrappedObject instanceof JpaConfiguration) ((JpaConfiguration)wrappedObject).configure(document); - return this; - } - default ConfigurationWrapper configure(File file) { ((Configuration)getWrappedObject()).configure(file); return this; } - default ConfigurationWrapper configure() { ((Configuration)getWrappedObject()).configure(); return this; } - default void addClass(Class clazz) { ((Configuration)getWrappedObject()).addClass(clazz); } - default void buildMappings() { - Object wrappedObject = getWrappedObject(); - if (wrappedObject instanceof NativeConfiguration) ((NativeConfiguration)wrappedObject).buildMappings(); - if (wrappedObject instanceof RevengConfiguration) ((RevengConfiguration)wrappedObject).buildMappings(); - if (wrappedObject instanceof JpaConfiguration) ((JpaConfiguration)wrappedObject).buildMappings(); - } - default SessionFactory buildSessionFactory() { return ((Configuration)getWrappedObject()).buildSessionFactory(); } - default Iterator getClassMappings() { - Object wrappedObject = getWrappedObject(); - if (wrappedObject instanceof NativeConfiguration) return ((NativeConfiguration)wrappedObject).getClassMappings(); - if (wrappedObject instanceof RevengConfiguration) return ((RevengConfiguration)wrappedObject).getClassMappings(); - if (wrappedObject instanceof JpaConfiguration) return ((JpaConfiguration)wrappedObject).getClassMappings(); - return null; - } - default void setPreferBasicCompositeIds(boolean b) { - Object wrappedObject = getWrappedObject(); - if (wrappedObject instanceof NativeConfiguration) ((NativeConfiguration)wrappedObject).setPreferBasicCompositeIds(b); - if (wrappedObject instanceof RevengConfiguration) ((RevengConfiguration)wrappedObject).setPreferBasicCompositeIds(b); - if (wrappedObject instanceof JpaConfiguration) ((JpaConfiguration)wrappedObject).setPreferBasicCompositeIds(b); - } - default void setReverseEngineeringStrategy(RevengStrategy strategy) { - Object wrappedObject = getWrappedObject(); - if (wrappedObject instanceof NativeConfiguration) ((NativeConfiguration)wrappedObject).setReverseEngineeringStrategy(strategy); - if (wrappedObject instanceof RevengConfiguration) ((RevengConfiguration)wrappedObject).setReverseEngineeringStrategy(strategy); - if (wrappedObject instanceof JpaConfiguration) ((JpaConfiguration)wrappedObject).setReverseEngineeringStrategy(strategy); - } - default void readFromJDBC() { - Object wrappedObject = getWrappedObject(); - if (wrappedObject instanceof NativeConfiguration) ((NativeConfiguration)wrappedObject).readFromJDBC(); - if (wrappedObject instanceof RevengConfiguration) ((RevengConfiguration)wrappedObject).readFromJDBC(); - if (wrappedObject instanceof JpaConfiguration) ((JpaConfiguration)wrappedObject).readFromJDBC(); - } - default PersistentClass getClassMapping(String string) { - Object wrappedObject = getWrappedObject(); - if (wrappedObject instanceof NativeConfiguration) return ((NativeConfiguration)wrappedObject).getClassMapping(string); - if (wrappedObject instanceof RevengConfiguration) return ((RevengConfiguration)wrappedObject).getClassMapping(string); - if (wrappedObject instanceof JpaConfiguration) return ((JpaConfiguration)wrappedObject).getClassMapping(string); - return null; - } - default NamingStrategy getNamingStrategy() { - Object wrappedObject = getWrappedObject(); - if (wrappedObject instanceof NativeConfiguration) return ((NativeConfiguration)wrappedObject).getNamingStrategy(); - if (wrappedObject instanceof RevengConfiguration) return ((RevengConfiguration)wrappedObject).getNamingStrategy(); - if (wrappedObject instanceof JpaConfiguration) return ((JpaConfiguration)wrappedObject).getNamingStrategy(); - return null; - } - default EntityResolver getEntityResolver() { - Object wrappedObject = getWrappedObject(); - if (wrappedObject instanceof NativeConfiguration) return ((NativeConfiguration)wrappedObject).getEntityResolver(); - if (wrappedObject instanceof RevengConfiguration) return ((RevengConfiguration)wrappedObject).getEntityResolver(); - if (wrappedObject instanceof JpaConfiguration) return ((JpaConfiguration)wrappedObject).getEntityResolver(); - return null; - } - default Iterator getTableMappings() { - Object wrappedObject = getWrappedObject(); - if (wrappedObject instanceof NativeConfiguration) return ((NativeConfiguration)wrappedObject).getTableMappings(); - if (wrappedObject instanceof RevengConfiguration) return ((RevengConfiguration)wrappedObject).getTableMappings(); - if (wrappedObject instanceof JpaConfiguration) return ((JpaConfiguration)wrappedObject).getTableMappings(); - return null; - } - -} diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/CriteriaWrapper.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/CriteriaWrapper.java deleted file mode 100644 index 34244aaba6..0000000000 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/CriteriaWrapper.java +++ /dev/null @@ -1,14 +0,0 @@ -package org.hibernate.tool.orm.jbt.api; - -import java.util.List; - -import org.hibernate.tool.orm.jbt.wrp.Wrapper; - -import jakarta.persistence.Query; - -public interface CriteriaWrapper extends Wrapper { - - default void setMaxResults(int intValue) { ((Query)getWrappedObject()).setMaxResults(intValue); } - default List list() { return ((Query)getWrappedObject()).getResultList(); } - -} diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/DdlExporterWrapper.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/DdlExporterWrapper.java deleted file mode 100644 index 856f32bf3e..0000000000 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/DdlExporterWrapper.java +++ /dev/null @@ -1,20 +0,0 @@ -package org.hibernate.tool.orm.jbt.api; - -import java.util.Properties; - -import org.hibernate.tool.api.export.ExporterConstants; -import org.hibernate.tool.internal.export.ddl.DdlExporter; -import org.hibernate.tool.orm.jbt.wrp.Wrapper; - -public interface DdlExporterWrapper extends Wrapper { - - default void setExport(boolean b) { - ((DdlExporter)getWrappedObject()).getProperties().put( - ExporterConstants.EXPORT_TO_DATABASE, b); - } - - default Properties getProperties() { - return ((DdlExporter)getWrappedObject()).getProperties(); - } - -} diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/EnvironmentWrapper.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/EnvironmentWrapper.java deleted file mode 100644 index 0eb05b77ae..0000000000 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/EnvironmentWrapper.java +++ /dev/null @@ -1,34 +0,0 @@ -package org.hibernate.tool.orm.jbt.api; - -import org.hibernate.cfg.Environment; -import org.hibernate.tool.orm.jbt.wrp.Wrapper; - -public interface EnvironmentWrapper extends Wrapper { - - default String getTransactionManagerStrategy() { return "hibernate.transaction.coordinator_class"; } - - default String getDriver() { return Environment.DRIVER; } - - default String getHBM2DDLAuto() { return Environment.HBM2DDL_AUTO; } - - default String getDialect() { return Environment.DIALECT; } - - default String getDataSource() { return Environment.DATASOURCE; } - - default String getConnectionProvider() { return Environment.CONNECTION_PROVIDER; } - - default String getURL() { return Environment.URL; } - - default String getUser() { return Environment.USER; } - - default String getPass() { return Environment.PASS; } - - default String getSessionFactoryName() { return Environment.SESSION_FACTORY_NAME; } - - default String getDefaultCatalog() { return Environment.DEFAULT_CATALOG; } - - default String getDefaultSchema() { return Environment.DEFAULT_SCHEMA; } - - default Class getWrappedClass() { return Environment.class; } - -} diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/ExporterWrapper.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/ExporterWrapper.java deleted file mode 100644 index 6f8623f9cb..0000000000 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/ExporterWrapper.java +++ /dev/null @@ -1,86 +0,0 @@ -package org.hibernate.tool.orm.jbt.api; - -import java.io.File; -import java.io.StringWriter; -import java.util.Properties; - -import org.hibernate.cfg.Configuration; -import org.hibernate.tool.api.export.Exporter; -import org.hibernate.tool.api.export.ExporterConstants; -import org.hibernate.tool.internal.export.cfg.CfgExporter; -import org.hibernate.tool.internal.export.common.GenericExporter; -import org.hibernate.tool.internal.export.ddl.DdlExporter; -import org.hibernate.tool.internal.export.query.QueryExporter; -import org.hibernate.tool.orm.jbt.util.ConfigurationMetadataDescriptor; -import org.hibernate.tool.orm.jbt.wrp.Wrapper; - -public interface ExporterWrapper extends Wrapper { - - default void setConfiguration(Configuration configuration) { - if (CfgExporter.class.isAssignableFrom(getWrappedObject().getClass())) { - ((CfgExporter)getWrappedObject()).setCustomProperties(configuration.getProperties()); - } - ((Exporter)getWrappedObject()).getProperties().put( - ExporterConstants.METADATA_DESCRIPTOR, - new ConfigurationMetadataDescriptor(configuration)); - } - - default void setArtifactCollector(ArtifactCollectorWrapper artifactCollectorWrapper) { - ((Exporter)getWrappedObject()).getProperties().put( - ExporterConstants.ARTIFACT_COLLECTOR, - artifactCollectorWrapper.getWrappedObject()); - } - - default void setOutputDirectory(File dir) { - ((Exporter)getWrappedObject()).getProperties().put(ExporterConstants.DESTINATION_FOLDER, dir); - } - - default void setTemplatePath(String[] templatePath) { - ((Exporter)getWrappedObject()).getProperties().put(ExporterConstants.TEMPLATE_PATH, templatePath); - } - - default void start() { - ((Exporter)getWrappedObject()).start(); - } - - default Properties getProperties() { - return ((Exporter)getWrappedObject()).getProperties(); - } - - default GenericExporter getGenericExporter() { - if (getWrappedObject() instanceof GenericExporter) { - return (GenericExporter)getWrappedObject(); - } else { - return null; - } - } - - default DdlExporter getHbm2DDLExporter() { - if (getWrappedObject() instanceof DdlExporter) { - return (DdlExporter)getWrappedObject(); - } else { - return null; - } - } - - default QueryExporter getQueryExporter() { - if (getWrappedObject() instanceof QueryExporter) { - return (QueryExporter)getWrappedObject(); - } else { - return null; - } - } - - default void setCustomProperties(Properties properties) { - if (getWrappedObject() instanceof CfgExporter) { - ((CfgExporter)getWrappedObject()).setCustomProperties(properties); - } - } - - default void setOutput(StringWriter stringWriter) { - if (getWrappedObject() instanceof CfgExporter) { - ((CfgExporter)getWrappedObject()).setOutput(stringWriter); - } - } - -} diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/ForeignKeyWrapper.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/ForeignKeyWrapper.java deleted file mode 100644 index bf525f37f0..0000000000 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/ForeignKeyWrapper.java +++ /dev/null @@ -1,23 +0,0 @@ -package org.hibernate.tool.orm.jbt.api; - -import java.util.Iterator; -import java.util.List; - -import org.hibernate.mapping.Column; -import org.hibernate.mapping.ForeignKey; -import org.hibernate.mapping.Table; -import org.hibernate.tool.orm.jbt.wrp.Wrapper; - -public interface ForeignKeyWrapper extends Wrapper { - - default Table getReferencedTable() { return ((ForeignKey)getWrappedObject()).getReferencedTable(); } - - default Iterator columnIterator() { return ((ForeignKey)getWrappedObject()).getColumns().iterator(); } - - default boolean isReferenceToPrimaryKey() { return ((ForeignKey)getWrappedObject()).isReferenceToPrimaryKey(); } - - default List getReferencedColumns() { return ((ForeignKey)getWrappedObject()).getReferencedColumns(); } - - default boolean containsColumn(Column column) { return ((ForeignKey)getWrappedObject()).containsColumn(column); } - -} diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/GenericExporterWrapper.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/GenericExporterWrapper.java deleted file mode 100644 index 0e9a1b9a1a..0000000000 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/GenericExporterWrapper.java +++ /dev/null @@ -1,34 +0,0 @@ -package org.hibernate.tool.orm.jbt.api; - -import org.hibernate.tool.api.export.ExporterConstants; -import org.hibernate.tool.internal.export.common.GenericExporter; -import org.hibernate.tool.orm.jbt.wrp.Wrapper; - -public interface GenericExporterWrapper extends Wrapper { - - default void setFilePattern(String filePattern) { - ((GenericExporter)getWrappedObject()).getProperties().setProperty( - ExporterConstants.FILE_PATTERN, filePattern); - } - - default void setTemplateName(String templateName) { - ((GenericExporter)getWrappedObject()).getProperties().setProperty( - ExporterConstants.TEMPLATE_NAME, templateName); - } - - default void setForEach(String forEach) { - ((GenericExporter)getWrappedObject()).getProperties().setProperty( - ExporterConstants.FOR_EACH, forEach); - } - - default String getFilePattern() { - return ((GenericExporter)getWrappedObject()).getProperties().getProperty( - ExporterConstants.FILE_PATTERN); - } - - default String getTemplateName() { - return ((GenericExporter)getWrappedObject()).getProperties().getProperty( - ExporterConstants.TEMPLATE_NAME); - } - -} diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/HbmExporterWrapper.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/HbmExporterWrapper.java deleted file mode 100644 index e0e78a9102..0000000000 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/HbmExporterWrapper.java +++ /dev/null @@ -1,34 +0,0 @@ -package org.hibernate.tool.orm.jbt.api; - -import java.io.File; -import java.util.Map; - -import org.hibernate.tool.api.export.ExporterConstants; -import org.hibernate.tool.internal.export.hbm.HbmExporter; -import org.hibernate.tool.internal.export.java.POJOClass; -import org.hibernate.tool.orm.jbt.internal.factory.HbmExporterWrapperFactory.HbmExporterExtension; -import org.hibernate.tool.orm.jbt.wrp.Wrapper; - -public interface HbmExporterWrapper extends Wrapper { - - default void start() { - ((HbmExporter)getWrappedObject()).start(); - } - - default File getOutputDirectory() { - return (File)((HbmExporter)getWrappedObject()).getProperties().get(ExporterConstants.DESTINATION_FOLDER); - } - - default void setOutputDirectory(File f) { - ((HbmExporter)getWrappedObject()).getProperties().put(ExporterConstants.DESTINATION_FOLDER, f); - } - - default void exportPOJO(Map map, Object pojoClass) { - ((HbmExporterExtension)getWrappedObject()).exportPOJO(map, (POJOClass)pojoClass); - } - - default void setExportPOJODelegate(Object delegate) { - ((HbmExporterExtension)getWrappedObject()).delegateExporter = delegate; - } - -} diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/HqlCodeAssistWrapper.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/HqlCodeAssistWrapper.java deleted file mode 100644 index 5ba3f2f388..0000000000 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/HqlCodeAssistWrapper.java +++ /dev/null @@ -1,16 +0,0 @@ -package org.hibernate.tool.orm.jbt.api; - -import org.hibernate.tool.orm.jbt.internal.factory.HqlCodeAssistWrapperFactory.HqlCodeAssistExtension; -import org.hibernate.tool.orm.jbt.internal.util.HqlCompletionRequestor; -import org.hibernate.tool.orm.jbt.wrp.Wrapper; - -public interface HqlCodeAssistWrapper extends Wrapper { - - default void codeComplete(String query, int position, Object handler) { - ((HqlCodeAssistExtension)getWrappedObject()).codeComplete( - query, - position, - new HqlCompletionRequestor(handler)); - } - -} diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/HqlCompletionProposalWrapper.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/HqlCompletionProposalWrapper.java deleted file mode 100644 index 7b53a6758b..0000000000 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/HqlCompletionProposalWrapper.java +++ /dev/null @@ -1,35 +0,0 @@ -package org.hibernate.tool.orm.jbt.api; - -import org.hibernate.mapping.Property; -import org.hibernate.tool.ide.completion.HQLCompletionProposal; -import org.hibernate.tool.orm.jbt.wrp.Wrapper; - -public interface HqlCompletionProposalWrapper extends Wrapper { - - default String getCompletion() { return ((HQLCompletionProposal)getWrappedObject()).getCompletion(); } - - default int getReplaceStart() { return ((HQLCompletionProposal)getWrappedObject()).getReplaceStart(); } - - default int getReplaceEnd() { return ((HQLCompletionProposal)getWrappedObject()).getReplaceEnd(); } - - default String getSimpleName() { return ((HQLCompletionProposal)getWrappedObject()).getSimpleName(); } - - default int getCompletionKind() { return ((HQLCompletionProposal)getWrappedObject()).getCompletionKind(); } - - default String getEntityName() { return ((HQLCompletionProposal)getWrappedObject()).getEntityName(); } - - default String getShortEntityName() { return ((HQLCompletionProposal)getWrappedObject()).getShortEntityName(); } - - default Property getProperty() { return ((HQLCompletionProposal)getWrappedObject()).getProperty(); } - - default int aliasRefKind() { return HQLCompletionProposal.ALIAS_REF; } - - default int entityNameKind() { return HQLCompletionProposal.ENTITY_NAME; } - - default int propertyKind() { return HQLCompletionProposal.PROPERTY; } - - default int keywordKind() { return HQLCompletionProposal.KEYWORD; } - - default int functionKind() { return HQLCompletionProposal.FUNCTION; } - -} diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/JoinWrapper.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/JoinWrapper.java deleted file mode 100644 index 3a4cd5a1de..0000000000 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/JoinWrapper.java +++ /dev/null @@ -1,15 +0,0 @@ -package org.hibernate.tool.orm.jbt.api; - -import java.util.Iterator; - -import org.hibernate.mapping.Join; -import org.hibernate.mapping.Property; -import org.hibernate.tool.orm.jbt.wrp.Wrapper; - -public interface JoinWrapper extends Wrapper { - - default Iterator getPropertyIterator() { - return ((Join)getWrappedObject()).getProperties().iterator(); - } - -} diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/NamingStrategyWrapper.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/NamingStrategyWrapper.java deleted file mode 100644 index ae59c4f4ee..0000000000 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/NamingStrategyWrapper.java +++ /dev/null @@ -1,50 +0,0 @@ -package org.hibernate.tool.orm.jbt.api; - -import org.hibernate.cfg.NamingStrategy; -import org.hibernate.tool.orm.jbt.wrp.Wrapper; - -public interface NamingStrategyWrapper extends Wrapper { - - default String collectionTableName( - String ownerEntity, - String ownerEntityTable, - String associatedEntity, - String associatedEntityTable, - String propertyName) { - return ((NamingStrategy)getWrappedObject()).collectionTableName( - ownerEntity, - ownerEntityTable, - associatedEntity, - associatedEntityTable, - propertyName); - } - - default String columnName(String name) { - return ((NamingStrategy)getWrappedObject()).columnName(name); - } - - default String propertyToColumnName(String name) { - return ((NamingStrategy)getWrappedObject()).propertyToColumnName(name); - } - - default String tableName(String name) { - return ((NamingStrategy)getWrappedObject()).tableName(name); - } - - default String joinKeyColumnName( - String primaryKeyColumnName, - String primaryTableName) { - return ((NamingStrategy)getWrappedObject()).joinKeyColumnName( - primaryKeyColumnName, - primaryTableName); - } - - default String classToTableName(String name) { - return ((NamingStrategy)getWrappedObject()).classToTableName(name); - } - - default String getStrategyClassName() { - return getWrappedObject().getClass().getName(); - } - -} diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/OverrideRepositoryWrapper.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/OverrideRepositoryWrapper.java deleted file mode 100644 index 851fb80d8b..0000000000 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/OverrideRepositoryWrapper.java +++ /dev/null @@ -1,24 +0,0 @@ -package org.hibernate.tool.orm.jbt.api; - -import java.io.File; - -import org.hibernate.tool.api.reveng.RevengStrategy; -import org.hibernate.tool.internal.reveng.strategy.OverrideRepository; -import org.hibernate.tool.internal.reveng.strategy.TableFilter; -import org.hibernate.tool.orm.jbt.wrp.Wrapper; - -public interface OverrideRepositoryWrapper extends Wrapper { - - default void addFile(File file) { - ((OverrideRepository)getWrappedObject()).addFile(file); - } - - default RevengStrategy getReverseEngineeringStrategy(RevengStrategy res) { - return ((OverrideRepository)getWrappedObject()).getReverseEngineeringStrategy(res); - } - - default void addTableFilter(TableFilter tf) { - ((OverrideRepository)getWrappedObject()).addTableFilter(tf); - } - -} diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/PersistentClassWrapper.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/PersistentClassWrapper.java deleted file mode 100644 index 2e1ca1f811..0000000000 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/PersistentClassWrapper.java +++ /dev/null @@ -1,88 +0,0 @@ -package org.hibernate.tool.orm.jbt.api; - -import java.util.Iterator; -import java.util.List; - -import org.hibernate.mapping.Join; -import org.hibernate.mapping.JoinedSubclass; -import org.hibernate.mapping.PersistentClass; -import org.hibernate.mapping.Property; -import org.hibernate.mapping.RootClass; -import org.hibernate.mapping.Subclass; -import org.hibernate.mapping.Table; -import org.hibernate.mapping.Value; -import org.hibernate.tool.orm.jbt.internal.factory.PersistentClassWrapperFactory.RootClassWrapperImpl; -import org.hibernate.tool.orm.jbt.util.SpecialRootClass; -import org.hibernate.tool.orm.jbt.wrp.Wrapper; - -public interface PersistentClassWrapper extends Wrapper { - - default PersistentClass getWrappedObject() { return (PersistentClass)this; } - default boolean isAssignableToRootClass() { return isInstanceOfRootClass(); } - default boolean isRootClass() { return getWrappedObject().getClass() == RootClassWrapperImpl.class; } - default boolean isInstanceOfRootClass() { return RootClass.class.isAssignableFrom(getWrappedObject().getClass()); } - default boolean isInstanceOfSubclass() { return Subclass.class.isAssignableFrom(getWrappedObject().getClass()); } - default boolean isInstanceOfJoinedSubclass() { return JoinedSubclass.class.isAssignableFrom(getWrappedObject().getClass()); } - default Property getProperty() { throw new RuntimeException("getProperty() is only allowed on SpecialRootClass"); } - default void setTable(Table table) { throw new RuntimeException("Method 'setTable(Table)' is not supported."); } - default void setIdentifier(Value value) { throw new RuntimeException("Method 'setIdentifier(Value)' can only be called on RootClass instances"); } - default void setKey(Value value) { throw new RuntimeException("setKey(Value) is only allowed on JoinedSubclass"); } - default boolean isInstanceOfSpecialRootClass() { return SpecialRootClass.class.isAssignableFrom(getWrappedObject().getClass()); } - default Property getParentProperty() { throw new RuntimeException("getParentProperty() is only allowed on SpecialRootClass"); } - default void setIdentifierProperty(Property property) { throw new RuntimeException("setIdentifierProperty(Property) is only allowed on RootClass instances"); } - default void setDiscriminator(Value value) { throw new RuntimeException("Method 'setDiscriminator(Value)' can only be called on RootClass instances"); } - default boolean isLazyPropertiesCacheable() { throw new RuntimeException("Method 'isLazyPropertiesCacheable()' can only be called on RootClass instances"); } - default Iterator getPropertyIterator() { return getProperties().iterator(); } - default Iterator getJoinIterator() { return getJoins().iterator(); } - default Iterator getSubclassIterator() { return getSubclasses().iterator(); } - default Iterator getPropertyClosureIterator() { return getPropertyClosure().iterator(); } - - String getEntityName(); - String getClassName(); - Property getIdentifierProperty(); - boolean hasIdentifierProperty(); - PersistentClass getRootClass(); - PersistentClass getSuperclass(); - Property getProperty(String name); - Table getTable(); - Boolean isAbstract(); - Value getDiscriminator(); - Value getIdentifier(); - Property getVersion(); - void setClassName(String name); - void setEntityName(String name); - void setDiscriminatorValue(String str); - void setAbstract(Boolean b); - void addProperty(Property p); - void setProxyInterfaceName(String name); - void setLazy(boolean b); - boolean isCustomDeleteCallable(); - boolean isCustomInsertCallable(); - boolean isCustomUpdateCallable(); - boolean isDiscriminatorInsertable(); - boolean isDiscriminatorValueNotNull(); - boolean isDiscriminatorValueNull(); - boolean isExplicitPolymorphism(); - boolean isForceDiscriminator(); - boolean isInherited(); - boolean isJoinedSubclass(); - boolean isLazy(); - boolean isMutable(); - boolean isPolymorphic(); - boolean isVersioned(); - int getBatchSize(); - String getCacheConcurrencyStrategy(); - String getCustomSQLDelete(); - String getCustomSQLInsert(); - String getCustomSQLUpdate(); - String getDiscriminatorValue(); - String getLoaderName(); - int getOptimisticLockMode(); - String getWhere(); - Table getRootTable(); - List getProperties(); - List getJoins(); - List getSubclasses(); - List getPropertyClosure(); - -} diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/PrimaryKeyWrapper.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/PrimaryKeyWrapper.java deleted file mode 100644 index 154ee555e0..0000000000 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/PrimaryKeyWrapper.java +++ /dev/null @@ -1,22 +0,0 @@ -package org.hibernate.tool.orm.jbt.api; - -import java.util.Iterator; -import java.util.List; - -import org.hibernate.mapping.Column; -import org.hibernate.mapping.PrimaryKey; -import org.hibernate.mapping.Table; -import org.hibernate.tool.orm.jbt.wrp.Wrapper; - -public interface PrimaryKeyWrapper extends Wrapper { - - default void addColumn(Column column) { ((PrimaryKey)getWrappedObject()).addColumn(column); } - default int getColumnSpan() { return ((PrimaryKey)getWrappedObject()).getColumnSpan(); } - default List getColumns() { return ((PrimaryKey)getWrappedObject()).getColumns(); } - default Column getColumn(int i) { return ((PrimaryKey)getWrappedObject()).getColumn(i); } - default Table getTable() { return ((PrimaryKey)getWrappedObject()).getTable(); } - default boolean containsColumn(Column column) { return ((PrimaryKey)getWrappedObject()).containsColumn(column); } - default Iterator columnIterator() { return getColumns().iterator(); } - default String getName() { return ((PrimaryKey)getWrappedObject()).getName(); } - -} diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/PropertyWrapper.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/PropertyWrapper.java deleted file mode 100644 index 2ece60f933..0000000000 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/PropertyWrapper.java +++ /dev/null @@ -1,36 +0,0 @@ -package org.hibernate.tool.orm.jbt.api; - -import org.hibernate.mapping.BasicValue; -import org.hibernate.mapping.PersistentClass; -import org.hibernate.mapping.Property; -import org.hibernate.mapping.Value; -import org.hibernate.tool.orm.jbt.wrp.Wrapper; -import org.hibernate.type.Type; - -public interface PropertyWrapper extends Wrapper { - - default Value getValue() { return ((Property)getWrappedObject()).getValue(); } - default void setName(String name) { ((Property)getWrappedObject()).setName(name); } - default void setPersistentClass(PersistentClass pc) { ((Property)getWrappedObject()).setPersistentClass(pc); } - default PersistentClass getPersistentClass() { return ((Property)getWrappedObject()).getPersistentClass(); } - default boolean isComposite() { return ((Property)getWrappedObject()).isComposite(); } - default String getPropertyAccessorName() { return ((Property)getWrappedObject()).getPropertyAccessorName(); } - default String getName() { return ((Property)getWrappedObject()).getName(); } - default Type getType() { - Value v = ((Property)getWrappedObject()).getValue(); - return v == null ? null : v.getType(); - } - default void setValue(BasicValue value) { ((Property)getWrappedObject()).setValue(value); } - default void setPropertyAccessorName(String s) { ((Property)getWrappedObject()).setPropertyAccessorName(s); } - default void setCascade(String s) { ((Property)getWrappedObject()).setCascade(s); } - default boolean isBackRef() { return ((Property)getWrappedObject()).isBackRef(); } - default boolean isSelectable() { return ((Property)getWrappedObject()).isSelectable(); } - default boolean isInsertable() { return ((Property)getWrappedObject()).isInsertable(); } - default boolean isUpdateable() { return ((Property)getWrappedObject()).isUpdateable(); } - default String getCascade() { return ((Property)getWrappedObject()).getCascade(); } - default boolean isLazy() { return ((Property)getWrappedObject()).isLazy(); } - default boolean isOptional() { return ((Property)getWrappedObject()).isOptional(); } - default boolean isNaturalIdentifier() { return ((Property)getWrappedObject()).isNaturalIdentifier(); } - default boolean isOptimisticLocked() { return ((Property)getWrappedObject()).isOptimisticLocked(); } - -} diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/QueryExporterWrapper.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/QueryExporterWrapper.java deleted file mode 100644 index 63603beba7..0000000000 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/QueryExporterWrapper.java +++ /dev/null @@ -1,14 +0,0 @@ -package org.hibernate.tool.orm.jbt.api; - -import java.util.List; - -import org.hibernate.tool.api.export.ExporterConstants; -import org.hibernate.tool.internal.export.query.QueryExporter; -import org.hibernate.tool.orm.jbt.wrp.Wrapper; - -public interface QueryExporterWrapper extends Wrapper { - - default void setQueries(List queries) { ((QueryExporter)getWrappedObject()).setQueries(queries); } - default void setFilename(String fileName) { ((QueryExporter)getWrappedObject()).getProperties().put(ExporterConstants.OUTPUT_FILE_NAME, fileName); } - -} \ No newline at end of file diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/QueryWrapper.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/QueryWrapper.java deleted file mode 100644 index 80f732f654..0000000000 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/QueryWrapper.java +++ /dev/null @@ -1,25 +0,0 @@ -package org.hibernate.tool.orm.jbt.api; - -import java.util.List; - -import org.hibernate.query.Query; -import org.hibernate.tool.orm.jbt.wrp.Wrapper; -import org.hibernate.type.Type; - -public interface QueryWrapper extends Wrapper { - - default List list() { return ((Query)getWrappedObject()).list(); } - default void setMaxResults(int i) { ((Query)getWrappedObject()).setMaxResults(i); } - default void setParameterList(String parameter, List list, Object anything) { - ((Query)getWrappedObject()).setParameterList(parameter, list); - } - default void setParameter(String parameter, Object value, Object anything) { - ((Query)getWrappedObject()).setParameter(parameter, value); - } - default void setParameter(int position, Object value, Object anything) { - ((Query)getWrappedObject()).setParameter(position, value); - } - default String[] getReturnAliases() { return new String[0]; } - default Type[] getReturnTypes() {return new Type[0]; } - -} diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/RevengSettingsWrapper.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/RevengSettingsWrapper.java deleted file mode 100644 index b0ed25a819..0000000000 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/RevengSettingsWrapper.java +++ /dev/null @@ -1,13 +0,0 @@ -package org.hibernate.tool.orm.jbt.api; - -import org.hibernate.tool.api.reveng.RevengSettings; -import org.hibernate.tool.orm.jbt.wrp.Wrapper; - -public interface RevengSettingsWrapper extends Wrapper { - - default void setDefaultPackageName(String s) { ((RevengSettings)getWrappedObject()).setDefaultPackageName(s); } - default void setDetectManyToMany(boolean b) { ((RevengSettings)getWrappedObject()).setDetectManyToMany(b); } - default void setDetectOneToOne(boolean b) { ((RevengSettings)getWrappedObject()).setDetectOneToOne(b); } - default void setDetectOptimisticLock(boolean b) { ((RevengSettings)getWrappedObject()).setDetectOptimisticLock(b); } - -} diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/RevengStrategyWrapper.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/RevengStrategyWrapper.java deleted file mode 100644 index 666a6d3ae6..0000000000 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/RevengStrategyWrapper.java +++ /dev/null @@ -1,11 +0,0 @@ -package org.hibernate.tool.orm.jbt.api; - -import org.hibernate.tool.api.reveng.RevengSettings; -import org.hibernate.tool.api.reveng.RevengStrategy; -import org.hibernate.tool.orm.jbt.wrp.Wrapper; - -public interface RevengStrategyWrapper extends Wrapper { - - default void setSettings(RevengSettings revengSettings) { ((RevengStrategy)getWrappedObject()).setSettings(revengSettings); } - -} diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/SchemaExportWrapper.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/SchemaExportWrapper.java deleted file mode 100644 index f99c6c9a99..0000000000 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/SchemaExportWrapper.java +++ /dev/null @@ -1,23 +0,0 @@ -package org.hibernate.tool.orm.jbt.api; - -import java.util.EnumSet; -import java.util.List; - -import org.hibernate.cfg.Configuration; -import org.hibernate.tool.hbm2ddl.SchemaExport; -import org.hibernate.tool.orm.jbt.util.MetadataHelper; -import org.hibernate.tool.orm.jbt.wrp.Wrapper; -import org.hibernate.tool.schema.TargetType; - -public interface SchemaExportWrapper extends Wrapper { - - Configuration getConfiguration(); - default void create() { ( - (SchemaExport)getWrappedObject()).create(EnumSet.of( - TargetType.DATABASE), - MetadataHelper.getMetadata(getConfiguration())); - } - @SuppressWarnings("unchecked") - default List getExceptions() { return ((SchemaExport)getWrappedObject()).getExceptions(); } - -} diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/SessionFactoryWrapper.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/SessionFactoryWrapper.java deleted file mode 100644 index fd4510be2f..0000000000 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/SessionFactoryWrapper.java +++ /dev/null @@ -1,45 +0,0 @@ -package org.hibernate.tool.orm.jbt.api; - -import java.util.HashMap; -import java.util.Map; - -import org.hibernate.Session; -import org.hibernate.SessionFactory; -import org.hibernate.engine.spi.SessionFactoryImplementor; -import org.hibernate.persister.collection.CollectionPersister; -import org.hibernate.persister.entity.EntityPersister; -import org.hibernate.tool.orm.jbt.wrp.CollectionPersisterWrapperFactory; -import org.hibernate.tool.orm.jbt.wrp.EntityPersisterWrapperFactory; -import org.hibernate.tool.orm.jbt.wrp.Wrapper; - -public interface SessionFactoryWrapper extends Wrapper { - - default void close() { ((SessionFactory)getWrappedObject()).close(); } - - default Map getAllClassMetadata() { - Map origin = ((SessionFactoryImplementor)getWrappedObject()).getMetamodel().entityPersisters(); - Map result = new HashMap(origin.size()); - for (String key : origin.keySet()) { - result.put(key, (EntityPersister)EntityPersisterWrapperFactory.create(origin.get(key))); - } - return result; - } - - default Map getAllCollectionMetadata() { - Map origin = ((SessionFactoryImplementor)getWrappedObject()).getMetamodel().collectionPersisters(); - Map result = new HashMap(origin.size()); - for (String key : origin.keySet()) { - result.put(key, (CollectionPersister)CollectionPersisterWrapperFactory.create(origin.get(key))); - } - return result; - } - - default Session openSession() { return ((SessionFactory)getWrappedObject()).openSession(); } - - default EntityPersister getClassMetadata(String s) { return getAllClassMetadata().get(s); } - - default EntityPersister getClassMetadata(Class c) { return getAllClassMetadata().get(c.getName()); } - - default CollectionPersister getCollectionMetadata(String s) { return getAllCollectionMetadata().get(s); } - -} diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/SessionWrapper.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/SessionWrapper.java deleted file mode 100644 index 412262fa2e..0000000000 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/SessionWrapper.java +++ /dev/null @@ -1,45 +0,0 @@ -package org.hibernate.tool.orm.jbt.api; - -import org.hibernate.Session; -import org.hibernate.SessionFactory; -import org.hibernate.query.Query; -import org.hibernate.tool.orm.jbt.wrp.Wrapper; - -import jakarta.persistence.criteria.CriteriaBuilder; -import jakarta.persistence.criteria.CriteriaQuery; -import jakarta.persistence.criteria.Root; - -public interface SessionWrapper extends Wrapper { - - default String getEntityName(Object o) { return ((Session)getWrappedObject()).getEntityName(o); } - - default SessionFactory getSessionFactory() { return ((Session)getWrappedObject()).getSessionFactory(); } - - default Query createQuery(String s) { return ((Session)getWrappedObject()).createQuery(s); } - - default boolean isOpen() { return ((Session)getWrappedObject()).isOpen(); } - - default void close() { ((Session)getWrappedObject()).close(); } - - default boolean contains(Object o) { - boolean result = false; - try { - result = ((Session)getWrappedObject()).contains(o); - } catch (IllegalArgumentException e) { - String message = e.getMessage(); - if (!(message.startsWith("Class '") && message.endsWith("' is not an entity class"))) { - throw e; - } - } - return result; - } - - default jakarta.persistence.Query createCriteria(Class c) { - CriteriaBuilder criteriaBuilder = ((Session)getWrappedObject()).getCriteriaBuilder(); - CriteriaQuery criteriaQuery = criteriaBuilder.createQuery(c); - Root root = criteriaQuery.from(c); - criteriaQuery.select(root); - return ((Session)getWrappedObject()).createQuery(criteriaQuery); - } - -} diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/TableFilterWrapper.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/TableFilterWrapper.java deleted file mode 100644 index 60f67f8af9..0000000000 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/TableFilterWrapper.java +++ /dev/null @@ -1,24 +0,0 @@ -package org.hibernate.tool.orm.jbt.api; - -import org.hibernate.tool.internal.reveng.strategy.TableFilter; -import org.hibernate.tool.orm.jbt.wrp.Wrapper; - -public interface TableFilterWrapper extends Wrapper { - - default void setExclude(boolean b) { ((TableFilter)getWrappedObject()).setExclude(b); } - - default void setMatchCatalog(String s) { ((TableFilter)getWrappedObject()).setMatchCatalog(s); } - - default void setMatchSchema(String s) { ((TableFilter)getWrappedObject()).setMatchSchema(s); } - - default void setMatchName(String s) { ((TableFilter)getWrappedObject()).setMatchName(s); } - - default Boolean getExclude() { return ((TableFilter)getWrappedObject()).getExclude(); } - - default String getMatchCatalog() { return ((TableFilter)getWrappedObject()).getMatchCatalog(); } - - default String getMatchSchema() { return ((TableFilter)getWrappedObject()).getMatchSchema(); } - - default String getMatchName() { return ((TableFilter)getWrappedObject()).getMatchName(); } - -} diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/TableWrapper.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/TableWrapper.java deleted file mode 100644 index fab97ebd9a..0000000000 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/TableWrapper.java +++ /dev/null @@ -1,41 +0,0 @@ -package org.hibernate.tool.orm.jbt.api; - -import java.util.Iterator; - -import org.hibernate.mapping.Column; -import org.hibernate.mapping.KeyValue; -import org.hibernate.mapping.PrimaryKey; -import org.hibernate.mapping.Table; -import org.hibernate.tool.orm.jbt.wrp.Wrapper; - -public interface TableWrapper extends Wrapper { - - default String getName() { return ((Table)getWrappedObject()).getName(); } - - default void addColumn(Column column) { ((Table)getWrappedObject()).addColumn(column); } - - default String getCatalog() { return ((Table)getWrappedObject()).getCatalog(); } - - default String getSchema() { return ((Table)getWrappedObject()).getSchema(); } - - default PrimaryKey getPrimaryKey() { return ((Table)getWrappedObject()).getPrimaryKey(); } - - default Iterator getColumnIterator() { return ((Table)getWrappedObject()).getColumns().iterator(); } - - default String getComment() { return ((Table)getWrappedObject()).getComment(); } - - default String getRowId() { return ((Table)getWrappedObject()).getRowId(); } - - default String getSubselect() { return ((Table)getWrappedObject()).getSubselect(); } - - default boolean hasDenormalizedTables() { return ((Table)getWrappedObject()).hasDenormalizedTables(); } - - default boolean isAbstract() { return ((Table)getWrappedObject()).isAbstract(); } - - default boolean isAbstractUnionTable() { return ((Table)getWrappedObject()).isAbstractUnionTable(); } - - default boolean isPhysicalTable() { return ((Table)getWrappedObject()).isPhysicalTable(); } - - default KeyValue getIdentifierValue() { return ((Table)getWrappedObject()).getIdentifierValue(); } - -} diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/TypeFactoryWrapper.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/TypeFactoryWrapper.java deleted file mode 100644 index 5490ab86cd..0000000000 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/TypeFactoryWrapper.java +++ /dev/null @@ -1,36 +0,0 @@ -package org.hibernate.tool.orm.jbt.api; - -import java.util.Map; - -import org.hibernate.tool.orm.jbt.internal.util.TypeRegistry; - -public interface TypeFactoryWrapper { - - default TypeWrapper getBooleanType() { return TypeRegistry.getType("boolean"); } - default TypeWrapper getByteType() { return TypeRegistry.getType("byte"); } - default TypeWrapper getBigIntegerType() { return TypeRegistry.getType("big_integer"); } - default TypeWrapper getShortType() { return TypeRegistry.getType("short"); } - default TypeWrapper getCalendarType() { return TypeRegistry.getType("calendar"); } - default TypeWrapper getCalendarDateType() { return TypeRegistry.getType("calendar_date"); } - default TypeWrapper getIntegerType() { return TypeRegistry.getType("integer"); } - default TypeWrapper getBigDecimalType() { return TypeRegistry.getType("big_decimal"); } - default TypeWrapper getCharacterType() { return TypeRegistry.getType("character"); } - default TypeWrapper getClassType() { return TypeRegistry.getType("class"); } - default TypeWrapper getCurrencyType() { return TypeRegistry.getType("currency"); } - default TypeWrapper getDateType() { return TypeRegistry.getType("date"); } - default TypeWrapper getDoubleType() { return TypeRegistry.getType("double"); } - default TypeWrapper getFloatType() { return TypeRegistry.getType("float"); } - default TypeWrapper getLocaleType() { return TypeRegistry.getType("locale"); } - default TypeWrapper getLongType() { return TypeRegistry.getType("long"); } - default TypeWrapper getStringType() { return TypeRegistry.getType("string"); } - default TypeWrapper getTextType() { return TypeRegistry.getType("text"); } - default TypeWrapper getTimeType() { return TypeRegistry.getType("time"); } - default TypeWrapper getTimestampType() { return TypeRegistry.getType("timestamp"); } - default TypeWrapper getTimezoneType() { return TypeRegistry.getType("timezone"); } - default TypeWrapper getTrueFalseType() { return TypeRegistry.getType("true_false"); } - default TypeWrapper getYesNoType() { return TypeRegistry.getType("true_false"); } - default TypeWrapper getNamedType(String name) { return TypeRegistry.getType(name); } - default TypeWrapper getBasicType(String name) { return getNamedType(name); } - default Map getTypeFormats() { return TypeRegistry.getTypeFormats(); } - -} diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/TypeWrapper.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/TypeWrapper.java deleted file mode 100644 index 8420865a83..0000000000 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/TypeWrapper.java +++ /dev/null @@ -1,125 +0,0 @@ -package org.hibernate.tool.orm.jbt.api; - -import java.text.SimpleDateFormat; -import java.util.Calendar; - -import org.hibernate.tool.orm.jbt.internal.util.PrimitiveHelper; -import org.hibernate.tool.orm.jbt.wrp.Wrapper; -import org.hibernate.type.BasicType; -import org.hibernate.type.CollectionType; -import org.hibernate.type.EntityType; -import org.hibernate.type.Type; -import org.hibernate.type.descriptor.java.CalendarJavaType; -import org.hibernate.type.descriptor.java.JavaType; - -public interface TypeWrapper extends Wrapper { - - default String toString(Object object) { - if (BasicType.class.isAssignableFrom(getWrappedObject().getClass())) { - JavaType javaType = ((BasicType)getWrappedObject()).getJavaTypeDescriptor(); - if (javaType instanceof CalendarJavaType && object instanceof Calendar) { - SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd"); - return simpleDateFormat.format(((Calendar)object).getTime()); - } else { - return ((JavaType)javaType).toString(object); - } - } else { - throw new UnsupportedOperationException( - "Class '" + - getWrappedObject().getClass().getName() + - "' does not support 'toString(Object)'." ); - } - } - - default String getName() { return ((Type)getWrappedObject()).getName(); } - - default Object fromStringValue(String stringValue) { - if (BasicType.class.isAssignableFrom(getWrappedObject().getClass())) { - return ((BasicType)getWrappedObject()).getJavaTypeDescriptor().fromString(stringValue); - } else { - throw new UnsupportedOperationException( - "Class '" + - getWrappedObject().getClass().getName() + - "' does not support 'fromStringValue(Object)'." ); - } - } - - default boolean isEntityType() { return ((Type)getWrappedObject()).isEntityType(); } - - default boolean isOneToOne() { - if (EntityType.class.isAssignableFrom(getWrappedObject().getClass())) { - return ((EntityType)getWrappedObject()).isOneToOne(); - } else { - throw new UnsupportedOperationException( - "Class '" + - getWrappedObject().getClass().getName() + - "' does not support 'isOneToOne()'." ); - } - } - - default boolean isAnyType() { return ((Type)getWrappedObject()).isAnyType(); } - - default boolean isComponentType() { return ((Type)getWrappedObject()).isComponentType(); } - - default boolean isCollectionType() { return ((Type)getWrappedObject()).isCollectionType(); } - - default String getAssociatedEntityName() { - if (isEntityType()) { - return ((EntityType)getWrappedObject()).getAssociatedEntityName(); - } else { - return null; - } - } - - default boolean isIntegerType() { - return Integer.class.isAssignableFrom(((Type)getWrappedObject()).getReturnedClass()); - } - - default boolean isArrayType() { - if (CollectionType.class.isAssignableFrom(getWrappedObject().getClass())) { - return ((CollectionType)getWrappedObject()).isArrayType(); - } else { - return false; - } - } - - default boolean isInstanceOfPrimitiveType() { - if (!(BasicType.class.isAssignableFrom(getWrappedObject().getClass()))) { - return false; - } - return PrimitiveHelper.isPrimitive(((BasicType)getWrappedObject()).getJavaType()); - } - - default Class getPrimitiveClass() { - if (!isInstanceOfPrimitiveType()) { - throw new UnsupportedOperationException( - "Class '" + - getWrappedObject().getClass().getName() + - "' does not support 'getPrimitiveClass()'."); - } else { - Class javaType = ((BasicType)getWrappedObject()).getJavaType(); - if (PrimitiveHelper.isPrimitiveWrapperClass(javaType)) { - return PrimitiveHelper.getPrimitiveClass(javaType); - } else { - return javaType; - } - } - } - - default String getRole() { - if (!isCollectionType()) { - throw new UnsupportedOperationException( - "Class '" + - getWrappedObject().getClass().getName() + - "' does not support 'getRole()'."); - } else { - return ((CollectionType)getWrappedObject()).getRole(); - } - } - - default String getReturnedClassName() { - return ((Type)getWrappedObject()).getReturnedClassName(); - } -} - - diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/factory/WrapperFactory.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/factory/WrapperFactory.java new file mode 100644 index 0000000000..7c8313b913 --- /dev/null +++ b/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/factory/WrapperFactory.java @@ -0,0 +1,200 @@ +package org.hibernate.tool.orm.jbt.api.factory; + +import java.io.File; +import java.util.Map; +import java.util.Properties; + +import org.hibernate.tool.orm.jbt.api.wrp.ConfigurationWrapper; +import org.hibernate.tool.orm.jbt.api.wrp.PersistentClassWrapper; +import org.hibernate.tool.orm.jbt.api.wrp.PropertyWrapper; +import org.hibernate.tool.orm.jbt.api.wrp.RevengStrategyWrapper; +import org.hibernate.tool.orm.jbt.api.wrp.TableWrapper; +import org.hibernate.tool.orm.jbt.api.wrp.ValueWrapper; +import org.hibernate.tool.orm.jbt.internal.factory.ArtifactCollectorWrapperFactory; +import org.hibernate.tool.orm.jbt.internal.factory.Cfg2HbmToolWrapperFactory; +import org.hibernate.tool.orm.jbt.internal.factory.ColumnWrapperFactory; +import org.hibernate.tool.orm.jbt.internal.factory.ConfigurationWrapperFactory; +import org.hibernate.tool.orm.jbt.internal.factory.DatabaseReaderWrapperFactory; +import org.hibernate.tool.orm.jbt.internal.factory.EnvironmentWrapperFactory; +import org.hibernate.tool.orm.jbt.internal.factory.ExporterWrapperFactory; +import org.hibernate.tool.orm.jbt.internal.factory.HbmExporterWrapperFactory; +import org.hibernate.tool.orm.jbt.internal.factory.HqlCodeAssistWrapperFactory; +import org.hibernate.tool.orm.jbt.internal.factory.HqlCompletionProposalWrapperFactory; +import org.hibernate.tool.orm.jbt.internal.factory.NamingStrategyWrapperFactory; +import org.hibernate.tool.orm.jbt.internal.factory.OverrideRepositoryWrapperFactory; +import org.hibernate.tool.orm.jbt.internal.factory.PersistentClassWrapperFactory; +import org.hibernate.tool.orm.jbt.internal.factory.PropertyWrapperFactory; +import org.hibernate.tool.orm.jbt.internal.factory.RevengSettingsWrapperFactory; +import org.hibernate.tool.orm.jbt.internal.factory.RevengStrategyWrapperFactory; +import org.hibernate.tool.orm.jbt.internal.factory.SchemaExportWrapperFactory; +import org.hibernate.tool.orm.jbt.internal.factory.TableFilterWrapperFactory; +import org.hibernate.tool.orm.jbt.internal.factory.TableWrapperFactory; +import org.hibernate.tool.orm.jbt.internal.factory.TypeFactoryWrapperFactory; +import org.hibernate.tool.orm.jbt.internal.factory.ValueWrapperFactory; + +public class WrapperFactory { + + private WrapperFactory() {} + + public static Object createArtifactCollectorWrapper() { + return ArtifactCollectorWrapperFactory.createArtifactCollectorWrapper(); + } + + public static Object createCfg2HbmWrapper() { + return Cfg2HbmToolWrapperFactory.createCfg2HbmToolWrapper(); + } + + public static Object createNamingStrategyWrapper(String namingStrategyClassName) { + return NamingStrategyWrapperFactory.createNamingStrategyWrapper(namingStrategyClassName); + } + + public static Object createOverrideRepositoryWrapper() { + return OverrideRepositoryWrapperFactory.createOverrideRepositoryWrapper(); + } + + public static Object createRevengStrategyWrapper(Object...objects) { + return RevengStrategyWrapperFactory.createRevengStrategyWrapper(objects); + } + + public static Object createRevengSettingsWrapper(Object revengStrategyWrapper) { + return RevengSettingsWrapperFactory.createRevengSettingsWrapper((RevengStrategyWrapper)revengStrategyWrapper); + } + + public static Object createNativeConfigurationWrapper() { + return ConfigurationWrapperFactory.createNativeConfigurationWrapper(); + } + + public static Object createRevengConfigurationWrapper() { + return ConfigurationWrapperFactory.createRevengConfigurationWrapper(); + } + + public static Object createJpaConfigurationWrapper(String persistenceUnit, Map properties) { + return ConfigurationWrapperFactory.createJpaConfigurationWrapper(persistenceUnit, properties); + } + + public static Object createColumnWrapper(String name) { + return ColumnWrapperFactory.createColumnWrapper(name); + } + + public static Object createRootClassWrapper() { + return PersistentClassWrapperFactory.createRootClassWrapper(); + } + + public static Object createSingleTableSubClassWrapper(Object persistentClassWrapper) { + return PersistentClassWrapperFactory.createSingleTableSubClassWrapper((PersistentClassWrapper)persistentClassWrapper); + } + + public static Object createJoinedTableSubClassWrapper(Object persistentClassWrapper) { + return PersistentClassWrapperFactory.createJoinedTableSubClassWrapper((PersistentClassWrapper)persistentClassWrapper); + } + + public static Object createSpecialRootClassWrapper(Object propertyWrapper) { + return PersistentClassWrapperFactory.createSpecialRootClassWrapper(((PropertyWrapper)propertyWrapper)); + } + + public static Object createPropertyWrapper() { + return PropertyWrapperFactory.createPropertyWrapper(); + } + + public static Object createHqlCompletionProposalWrapper(Object hqlCompletionProposal) { + return HqlCompletionProposalWrapperFactory.createHqlCompletionProposalWrapper(hqlCompletionProposal); + } + + public static Object createArrayWrapper(Object persistentClassWrapper) { + return ValueWrapperFactory.createArrayWrapper((PersistentClassWrapper)persistentClassWrapper); + } + + public static Object createBagWrapper(Object persistentClassWrapper) { + return ValueWrapperFactory.createBagWrapper((PersistentClassWrapper)persistentClassWrapper); + } + + public static Object createListWrapper(Object persistentClassWrapper) { + return ValueWrapperFactory.createListWrapper((PersistentClassWrapper)persistentClassWrapper); + } + + public static Object createDatabaseReaderWrapper(Properties properties, Object revengStrategyWrapper) { + return DatabaseReaderWrapperFactory.createDatabaseReaderWrapper( + properties, + (RevengStrategyWrapper)revengStrategyWrapper); + } + + public static Object createTableWrapper(String name) { + return TableWrapperFactory.createTableWrapper(name); + } + + public static Object createManyToOneWrapper(Object tableWrapper) { + return ValueWrapperFactory.createManyToOneWrapper((TableWrapper)tableWrapper); + } + + public static Object createMapWrapper(Object persistentClassWrapper) { + return ValueWrapperFactory.createMapWrapper((PersistentClassWrapper)persistentClassWrapper); + } + + public static Object createOneToManyWrapper(Object persistentClassWrapper) { + return ValueWrapperFactory.createOneToManyWrapper((PersistentClassWrapper)persistentClassWrapper); + } + + public static Object createOneToOneWrapper(Object persistentClassWrapper) { + return ValueWrapperFactory.createOneToOneWrapper((PersistentClassWrapper)persistentClassWrapper); + } + + public static Object createPrimitiveArrayWrapper(Object persistentClassWrapper) { + return ValueWrapperFactory.createPrimitiveArrayWrapper((PersistentClassWrapper)persistentClassWrapper); + } + + public static Object createSetWrapper(Object persistentClassWrapper) { + return ValueWrapperFactory.createSetWrapper((PersistentClassWrapper)persistentClassWrapper); + } + + public static Object createSimpleValueWrapper() { + return ValueWrapperFactory.createSimpleValueWrapper(); + } + + public static Object createComponentWrapper(Object persistentClassWrapper) { + return ValueWrapperFactory.createComponentWrapper((PersistentClassWrapper)persistentClassWrapper); + } + + public static Object createDependantValueWrapper(Object tableWrapper, Object valueWrapper) { + return ValueWrapperFactory.createDependantValueWrapper((TableWrapper)tableWrapper, (ValueWrapper)valueWrapper); + } + + public static Object createAnyValueWrapper(Object tableWrapper) { + return ValueWrapperFactory.createAnyValueWrapper((TableWrapper)tableWrapper); + } + + public static Object createIdentifierBagValueWrapper(Object persistentClassWrapper) { + return ValueWrapperFactory.createIdentifierBagValueWrapper((PersistentClassWrapper)persistentClassWrapper); + } + + public static Object createTableFilterWrapper() { + return TableFilterWrapperFactory.createTableFilterWrapper(); + } + + public static Object createTypeFactoryWrapper() { + return TypeFactoryWrapperFactory.createTypeFactoryWrapper(); + } + + public static Object createEnvironmentWrapper() { + return EnvironmentWrapperFactory.createEnvironmentWrapper(); + } + + public static Object createSchemaExport(Object configurationWrapper) { + return SchemaExportWrapperFactory.createSchemaExportWrapper( + (ConfigurationWrapper)configurationWrapper); + } + + public static Object createHbmExporterWrapper(Object configurationWrapper, File file) { + return HbmExporterWrapperFactory.createHbmExporterWrapper( + (ConfigurationWrapper)configurationWrapper, file); + } + + public static Object createExporterWrapper(String exporterClassName) { + return ExporterWrapperFactory.createExporterWrapper(exporterClassName); + } + + public static Object createHqlCodeAssistWrapper(Object configurationWrapper) { + return HqlCodeAssistWrapperFactory.createHqlCodeAssistWrapper( + (ConfigurationWrapper)configurationWrapper); + } + +} diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/wrp/ArtifactCollectorWrapper.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/wrp/ArtifactCollectorWrapper.java new file mode 100644 index 0000000000..63bb128277 --- /dev/null +++ b/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/wrp/ArtifactCollectorWrapper.java @@ -0,0 +1,12 @@ +package org.hibernate.tool.orm.jbt.api.wrp; + +import java.io.File; +import java.util.Set; + +public interface ArtifactCollectorWrapper extends Wrapper { + + Set getFileTypes(); + void formatFiles(); + File[] getFiles(String string); + +} diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/wrp/Cfg2HbmToolWrapper.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/wrp/Cfg2HbmToolWrapper.java new file mode 100644 index 0000000000..9cd19c74e1 --- /dev/null +++ b/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/wrp/Cfg2HbmToolWrapper.java @@ -0,0 +1,8 @@ +package org.hibernate.tool.orm.jbt.api.wrp; + +public interface Cfg2HbmToolWrapper extends Wrapper { + + String getTag(PersistentClassWrapper pcw); + String getTag(PropertyWrapper pw); + +} diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/wrp/ClassMetadataWrapper.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/wrp/ClassMetadataWrapper.java new file mode 100644 index 0000000000..b1fb9bde71 --- /dev/null +++ b/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/wrp/ClassMetadataWrapper.java @@ -0,0 +1,18 @@ +package org.hibernate.tool.orm.jbt.api.wrp; + +public interface ClassMetadataWrapper extends Wrapper { + + String getEntityName(); + String getIdentifierPropertyName(); + String[] getPropertyNames(); + TypeWrapper[] getPropertyTypes(); + Class getMappedClass(); + TypeWrapper getIdentifierType(); + Object getPropertyValue(Object object, String name); + boolean hasIdentifierProperty(); + Object getIdentifier(Object object, SessionWrapper session); + boolean isInstanceOfAbstractEntityPersister(); + Integer getPropertyIndexOrNull(String id); + Object getTuplizerPropertyValue(Object entity, int i); + +} diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/wrp/CollectionMetadataWrapper.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/wrp/CollectionMetadataWrapper.java new file mode 100644 index 0000000000..4a88b74d6e --- /dev/null +++ b/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/wrp/CollectionMetadataWrapper.java @@ -0,0 +1,7 @@ +package org.hibernate.tool.orm.jbt.api.wrp; + +public interface CollectionMetadataWrapper extends Wrapper { + + TypeWrapper getElementType(); + +} diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/wrp/ColumnWrapper.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/wrp/ColumnWrapper.java new file mode 100644 index 0000000000..b15f8c1506 --- /dev/null +++ b/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/wrp/ColumnWrapper.java @@ -0,0 +1,24 @@ +package org.hibernate.tool.orm.jbt.api.wrp; + +public interface ColumnWrapper extends Wrapper { + + static final int DEFAULT_LENGTH = 255; + static final int DEFAULT_PRECISION = 19; + static final int DEFAULT_SCALE = 2; + + String getName(); + Integer getSqlTypeCode(); + String getSqlType(); + String getSqlType(ConfigurationWrapper configurationWrapper); + long getLength(); + int getDefaultLength(); + int getPrecision(); + int getDefaultPrecision(); + int getScale(); + int getDefaultScale(); + boolean isNullable(); + ValueWrapper getValue(); + boolean isUnique(); + void setSqlType(String sqlType); + +} diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/wrp/ConfigurationWrapper.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/wrp/ConfigurationWrapper.java new file mode 100644 index 0000000000..1b966d4187 --- /dev/null +++ b/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/wrp/ConfigurationWrapper.java @@ -0,0 +1,35 @@ +package org.hibernate.tool.orm.jbt.api.wrp; + +import java.io.File; +import java.util.Iterator; +import java.util.Properties; + +import org.w3c.dom.Document; +import org.xml.sax.EntityResolver; + +public interface ConfigurationWrapper extends Wrapper { + + String getProperty(String property); + ConfigurationWrapper addFile(File file); + void setProperty(String name, String value); + ConfigurationWrapper setProperties(Properties properties); + void setEntityResolver(EntityResolver entityResolver); + void setNamingStrategy(NamingStrategyWrapper namingStrategy); + Properties getProperties(); + void addProperties(Properties properties); + ConfigurationWrapper configure(Document document); + ConfigurationWrapper configure(File file); + ConfigurationWrapper configure(); + void addClass(Class clazz); + void buildMappings(); + SessionFactoryWrapper buildSessionFactory(); + Iterator getClassMappings(); + void setPreferBasicCompositeIds(boolean b); + void setReverseEngineeringStrategy(RevengStrategyWrapper strategy); + void readFromJDBC(); + PersistentClassWrapper getClassMapping(String string); + NamingStrategyWrapper getNamingStrategy(); + EntityResolver getEntityResolver(); + Iterator getTableMappings(); + +} diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/wrp/CriteriaWrapper.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/wrp/CriteriaWrapper.java new file mode 100644 index 0000000000..d111b3ce1b --- /dev/null +++ b/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/wrp/CriteriaWrapper.java @@ -0,0 +1,10 @@ +package org.hibernate.tool.orm.jbt.api.wrp; + +import java.util.List; + +public interface CriteriaWrapper extends Wrapper { + + void setMaxResults(int intValue); + List list(); + +} diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/wrp/DatabaseReaderWrapper.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/wrp/DatabaseReaderWrapper.java new file mode 100644 index 0000000000..3a8b819600 --- /dev/null +++ b/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/wrp/DatabaseReaderWrapper.java @@ -0,0 +1,9 @@ +package org.hibernate.tool.orm.jbt.api.wrp; + +import java.util.List; +import java.util.Map; + +public interface DatabaseReaderWrapper extends Wrapper { + Map> collectDatabaseTables(); +} + diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/wrp/DdlExporterWrapper.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/wrp/DdlExporterWrapper.java new file mode 100644 index 0000000000..4cdd607628 --- /dev/null +++ b/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/wrp/DdlExporterWrapper.java @@ -0,0 +1,10 @@ +package org.hibernate.tool.orm.jbt.api.wrp; + +import java.util.Properties; + +public interface DdlExporterWrapper extends Wrapper { + + void setExport(boolean b); + Properties getProperties(); + +} diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/wrp/EnvironmentWrapper.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/wrp/EnvironmentWrapper.java new file mode 100644 index 0000000000..2c2647caa0 --- /dev/null +++ b/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/wrp/EnvironmentWrapper.java @@ -0,0 +1,31 @@ +package org.hibernate.tool.orm.jbt.api.wrp; + +public interface EnvironmentWrapper extends Wrapper { + + String getTransactionManagerStrategy(); + + String getDriver(); + + String getHBM2DDLAuto(); + + String getDialect(); + + String getDataSource(); + + String getConnectionProvider(); + + String getURL(); + + String getUser(); + + String getPass(); + + String getSessionFactoryName(); + + String getDefaultCatalog(); + + String getDefaultSchema(); + + Class getWrappedClass(); + +} diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/wrp/ExporterWrapper.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/wrp/ExporterWrapper.java new file mode 100644 index 0000000000..424b3023c3 --- /dev/null +++ b/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/wrp/ExporterWrapper.java @@ -0,0 +1,31 @@ +package org.hibernate.tool.orm.jbt.api.wrp; + +import java.io.File; +import java.io.StringWriter; +import java.util.Properties; + +public interface ExporterWrapper extends Wrapper { + + void setConfiguration(ConfigurationWrapper configuration); + + void setArtifactCollector(ArtifactCollectorWrapper artifactCollectorWrapper); + + void setOutputDirectory(File dir); + + void setTemplatePath(String[] templatePath); + + void start(); + + Properties getProperties(); + + GenericExporterWrapper getGenericExporter(); + + DdlExporterWrapper getHbm2DDLExporter(); + + QueryExporterWrapper getQueryExporter(); + + void setCustomProperties(Properties properties); + + void setOutput(StringWriter stringWriter); + +} diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/wrp/ForeignKeyWrapper.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/wrp/ForeignKeyWrapper.java new file mode 100644 index 0000000000..66dd9aabf4 --- /dev/null +++ b/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/wrp/ForeignKeyWrapper.java @@ -0,0 +1,18 @@ +package org.hibernate.tool.orm.jbt.api.wrp; + +import java.util.Iterator; +import java.util.List; + +public interface ForeignKeyWrapper extends Wrapper { + + TableWrapper getReferencedTable(); + + Iterator columnIterator(); + + boolean isReferenceToPrimaryKey(); + + List getReferencedColumns(); + + boolean containsColumn(ColumnWrapper column); + +} diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/wrp/GenericExporterWrapper.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/wrp/GenericExporterWrapper.java new file mode 100644 index 0000000000..e9a2f41742 --- /dev/null +++ b/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/wrp/GenericExporterWrapper.java @@ -0,0 +1,15 @@ +package org.hibernate.tool.orm.jbt.api.wrp; + +public interface GenericExporterWrapper extends Wrapper { + + void setFilePattern(String filePattern); + + void setTemplateName(String templateName) ; + + void setForEach(String forEach); + + String getFilePattern(); + + String getTemplateName(); + +} diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/wrp/HbmExporterWrapper.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/wrp/HbmExporterWrapper.java new file mode 100644 index 0000000000..4fc135a650 --- /dev/null +++ b/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/wrp/HbmExporterWrapper.java @@ -0,0 +1,18 @@ +package org.hibernate.tool.orm.jbt.api.wrp; + +import java.io.File; +import java.util.Map; + +public interface HbmExporterWrapper extends Wrapper { + + void start(); + + File getOutputDirectory(); + + void setOutputDirectory(File f); + + void exportPOJO(Map map, Object pojoClass); + + void setExportPOJODelegate(Object delegate); + +} diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/wrp/HqlCodeAssistWrapper.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/wrp/HqlCodeAssistWrapper.java new file mode 100644 index 0000000000..8132e2efd2 --- /dev/null +++ b/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/wrp/HqlCodeAssistWrapper.java @@ -0,0 +1,7 @@ +package org.hibernate.tool.orm.jbt.api.wrp; + +public interface HqlCodeAssistWrapper extends Wrapper { + + void codeComplete(String query, int position, Object handler); + +} diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/wrp/HqlCompletionProposalWrapper.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/wrp/HqlCompletionProposalWrapper.java new file mode 100644 index 0000000000..35171af1f6 --- /dev/null +++ b/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/wrp/HqlCompletionProposalWrapper.java @@ -0,0 +1,33 @@ +package org.hibernate.tool.orm.jbt.api.wrp; + +import org.hibernate.mapping.Property; + +public interface HqlCompletionProposalWrapper extends Wrapper { + + String getCompletion(); + + int getReplaceStart(); + + int getReplaceEnd(); + + String getSimpleName(); + + int getCompletionKind(); + + String getEntityName(); + + String getShortEntityName(); + + Property getProperty(); + + int aliasRefKind(); + + int entityNameKind(); + + int propertyKind(); + + int keywordKind(); + + int functionKind(); + +} diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/wrp/JoinWrapper.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/wrp/JoinWrapper.java new file mode 100644 index 0000000000..909bcb570c --- /dev/null +++ b/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/wrp/JoinWrapper.java @@ -0,0 +1,9 @@ +package org.hibernate.tool.orm.jbt.api.wrp; + +import java.util.Iterator; + +public interface JoinWrapper extends Wrapper { + + Iterator getPropertyIterator(); + +} diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/wrp/NamingStrategyWrapper.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/wrp/NamingStrategyWrapper.java new file mode 100644 index 0000000000..f40f1343c8 --- /dev/null +++ b/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/wrp/NamingStrategyWrapper.java @@ -0,0 +1,26 @@ +package org.hibernate.tool.orm.jbt.api.wrp; + +public interface NamingStrategyWrapper extends Wrapper { + + String collectionTableName( + String ownerEntity, + String ownerEntityTable, + String associatedEntity, + String associatedEntityTable, + String propertyName); + + String columnName(String name); + + String propertyToColumnName(String name); + + String tableName(String name); + + String joinKeyColumnName( + String primaryKeyColumnName, + String primaryTableName); + + String classToTableName(String name); + + String getStrategyClassName(); + +} diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/wrp/OverrideRepositoryWrapper.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/wrp/OverrideRepositoryWrapper.java new file mode 100644 index 0000000000..4d82c9b04c --- /dev/null +++ b/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/wrp/OverrideRepositoryWrapper.java @@ -0,0 +1,13 @@ +package org.hibernate.tool.orm.jbt.api.wrp; + +import java.io.File; + +public interface OverrideRepositoryWrapper extends Wrapper { + + void addFile(File file); + + RevengStrategyWrapper getReverseEngineeringStrategy(RevengStrategyWrapper res); + + void addTableFilter(TableFilterWrapper tf); + +} diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/wrp/PersistentClassWrapper.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/wrp/PersistentClassWrapper.java new file mode 100644 index 0000000000..531e9f1564 --- /dev/null +++ b/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/wrp/PersistentClassWrapper.java @@ -0,0 +1,74 @@ +package org.hibernate.tool.orm.jbt.api.wrp; + +import java.util.Iterator; +import java.util.List; + +public interface PersistentClassWrapper extends Wrapper { + + boolean isAssignableToRootClass(); + boolean isRootClass(); + boolean isInstanceOfRootClass(); + boolean isInstanceOfSubclass(); + boolean isInstanceOfJoinedSubclass(); + PropertyWrapper getProperty(); + void setTable(TableWrapper table); + void setIdentifier(ValueWrapper value); + void setKey(ValueWrapper value); + boolean isInstanceOfSpecialRootClass(); + PropertyWrapper getParentProperty(); + void setIdentifierProperty(PropertyWrapper property); + void setDiscriminator(ValueWrapper value); + boolean isLazyPropertiesCacheable(); + Iterator getPropertyIterator(); + Iterator getJoinIterator(); + Iterator getSubclassIterator(); + Iterator getPropertyClosureIterator(); + String getEntityName(); + String getClassName(); + PropertyWrapper getIdentifierProperty(); + boolean hasIdentifierProperty(); + PersistentClassWrapper getRootClass(); + PersistentClassWrapper getSuperclass(); + PropertyWrapper getProperty(String name); + TableWrapper getTable(); + Boolean isAbstract(); + ValueWrapper getDiscriminator(); + ValueWrapper getIdentifier(); + PropertyWrapper getVersion(); + void setClassName(String name); + void setEntityName(String name); + void setDiscriminatorValue(String str); + void setAbstract(Boolean b); + void addProperty(PropertyWrapper p); + void setProxyInterfaceName(String name); + void setLazy(boolean b); + boolean isCustomDeleteCallable(); + boolean isCustomInsertCallable(); + boolean isCustomUpdateCallable(); + boolean isDiscriminatorInsertable(); + boolean isDiscriminatorValueNotNull(); + boolean isDiscriminatorValueNull(); + boolean isExplicitPolymorphism(); + boolean isForceDiscriminator(); + boolean isInherited(); + boolean isJoinedSubclass(); + boolean isLazy(); + boolean isMutable(); + boolean isPolymorphic(); + boolean isVersioned(); + int getBatchSize(); + String getCacheConcurrencyStrategy(); + String getCustomSQLDelete(); + String getCustomSQLInsert(); + String getCustomSQLUpdate(); + String getDiscriminatorValue(); + String getLoaderName(); + int getOptimisticLockMode(); + String getWhere(); + TableWrapper getRootTable(); + List getProperties(); + List getJoins(); + List getSubclasses(); + List getPropertyClosure(); + +} diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/wrp/PrimaryKeyWrapper.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/wrp/PrimaryKeyWrapper.java new file mode 100644 index 0000000000..d24fc4c15b --- /dev/null +++ b/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/wrp/PrimaryKeyWrapper.java @@ -0,0 +1,17 @@ +package org.hibernate.tool.orm.jbt.api.wrp; + +import java.util.Iterator; +import java.util.List; + +public interface PrimaryKeyWrapper extends Wrapper { + + void addColumn(ColumnWrapper column); + int getColumnSpan(); + List getColumns(); + ColumnWrapper getColumn(int i); + TableWrapper getTable(); + boolean containsColumn(ColumnWrapper column); + Iterator columnIterator(); + String getName(); + +} diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/wrp/PropertyWrapper.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/wrp/PropertyWrapper.java new file mode 100644 index 0000000000..84d8d17acb --- /dev/null +++ b/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/wrp/PropertyWrapper.java @@ -0,0 +1,26 @@ +package org.hibernate.tool.orm.jbt.api.wrp; + +public interface PropertyWrapper extends Wrapper { + + ValueWrapper getValue(); + void setName(String name); + void setPersistentClass(PersistentClassWrapper pc); + PersistentClassWrapper getPersistentClass(); + boolean isComposite(); + String getPropertyAccessorName(); + String getName(); + TypeWrapper getType(); + void setValue(ValueWrapper value); + void setPropertyAccessorName(String s); + void setCascade(String s); + boolean isBackRef(); + boolean isSelectable(); + boolean isInsertable(); + boolean isUpdateable(); + String getCascade(); + boolean isLazy(); + boolean isOptional(); + boolean isNaturalIdentifier(); + boolean isOptimisticLocked(); + +} diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/wrp/QueryExporterWrapper.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/wrp/QueryExporterWrapper.java new file mode 100644 index 0000000000..dd39d6e34c --- /dev/null +++ b/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/wrp/QueryExporterWrapper.java @@ -0,0 +1,10 @@ +package org.hibernate.tool.orm.jbt.api.wrp; + +import java.util.List; + +public interface QueryExporterWrapper extends Wrapper { + + void setQueries(List queries); + void setFilename(String fileName); + +} \ No newline at end of file diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/wrp/QueryWrapper.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/wrp/QueryWrapper.java new file mode 100644 index 0000000000..7ae8e2b8ef --- /dev/null +++ b/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/wrp/QueryWrapper.java @@ -0,0 +1,15 @@ +package org.hibernate.tool.orm.jbt.api.wrp; + +import java.util.List; + +public interface QueryWrapper extends Wrapper { + + List list(); + void setMaxResults(int i); + void setParameterList(String parameter, List list, Object anything); + void setParameter(String parameter, Object value, Object anything); + void setParameter(int position, Object value, Object anything); + String[] getReturnAliases(); + TypeWrapper[] getReturnTypes(); + +} diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/wrp/RevengSettingsWrapper.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/wrp/RevengSettingsWrapper.java new file mode 100644 index 0000000000..86289b35d8 --- /dev/null +++ b/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/wrp/RevengSettingsWrapper.java @@ -0,0 +1,10 @@ +package org.hibernate.tool.orm.jbt.api.wrp; + +public interface RevengSettingsWrapper extends Wrapper { + + RevengSettingsWrapper setDefaultPackageName(String s); + RevengSettingsWrapper setDetectManyToMany(boolean b); + RevengSettingsWrapper setDetectOneToOne(boolean b); + RevengSettingsWrapper setDetectOptimisticLock(boolean b); + +} diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/wrp/RevengStrategyWrapper.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/wrp/RevengStrategyWrapper.java new file mode 100644 index 0000000000..4fb22eea4e --- /dev/null +++ b/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/wrp/RevengStrategyWrapper.java @@ -0,0 +1,7 @@ +package org.hibernate.tool.orm.jbt.api.wrp; + +public interface RevengStrategyWrapper extends Wrapper { + + void setSettings(RevengSettingsWrapper revengSettings); + +} diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/wrp/SchemaExportWrapper.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/wrp/SchemaExportWrapper.java new file mode 100644 index 0000000000..c36f0b8ebb --- /dev/null +++ b/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/wrp/SchemaExportWrapper.java @@ -0,0 +1,10 @@ +package org.hibernate.tool.orm.jbt.api.wrp; + +import java.util.List; + +public interface SchemaExportWrapper extends Wrapper { + + void create(); + List getExceptions(); + +} diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/wrp/SessionFactoryWrapper.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/wrp/SessionFactoryWrapper.java new file mode 100644 index 0000000000..ef631e4439 --- /dev/null +++ b/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/wrp/SessionFactoryWrapper.java @@ -0,0 +1,15 @@ +package org.hibernate.tool.orm.jbt.api.wrp; + +import java.util.Map; + +public interface SessionFactoryWrapper extends Wrapper { + + void close(); + Map getAllClassMetadata(); + Map getAllCollectionMetadata(); + SessionWrapper openSession(); + ClassMetadataWrapper getClassMetadata(String s); + ClassMetadataWrapper getClassMetadata(Class c); + CollectionMetadataWrapper getCollectionMetadata(String s); + +} diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/wrp/SessionWrapper.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/wrp/SessionWrapper.java new file mode 100644 index 0000000000..7b14bded34 --- /dev/null +++ b/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/wrp/SessionWrapper.java @@ -0,0 +1,13 @@ +package org.hibernate.tool.orm.jbt.api.wrp; + +public interface SessionWrapper extends Wrapper { + + String getEntityName(Object o) ; + SessionFactoryWrapper getSessionFactory(); + QueryWrapper createQuery(String s); + boolean isOpen(); + void close(); + boolean contains(Object o); + QueryWrapper createCriteria(Class c); + +} diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/wrp/TableFilterWrapper.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/wrp/TableFilterWrapper.java new file mode 100644 index 0000000000..071fd86e38 --- /dev/null +++ b/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/wrp/TableFilterWrapper.java @@ -0,0 +1,13 @@ +package org.hibernate.tool.orm.jbt.api.wrp; + +public interface TableFilterWrapper extends Wrapper { + + void setExclude(boolean b); + void setMatchCatalog(String s); + void setMatchSchema(String s); + void setMatchName(String s); + Boolean getExclude(); + String getMatchCatalog(); + String getMatchSchema(); + String getMatchName(); +} diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/wrp/TableWrapper.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/wrp/TableWrapper.java new file mode 100644 index 0000000000..b6737c5d15 --- /dev/null +++ b/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/wrp/TableWrapper.java @@ -0,0 +1,23 @@ +package org.hibernate.tool.orm.jbt.api.wrp; + +import java.util.Iterator; + +public interface TableWrapper extends Wrapper { + + String getName(); + void addColumn(ColumnWrapper column); + String getCatalog(); + String getSchema(); + PrimaryKeyWrapper getPrimaryKey(); + Iterator getColumnIterator(); + Iterator getForeignKeyIterator(); + String getComment(); + String getRowId(); + String getSubselect(); + boolean hasDenormalizedTables() ; + boolean isAbstract(); + boolean isAbstractUnionTable(); + boolean isPhysicalTable(); + ValueWrapper getIdentifierValue(); + +} diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/wrp/TypeFactoryWrapper.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/wrp/TypeFactoryWrapper.java new file mode 100644 index 0000000000..131540c9c7 --- /dev/null +++ b/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/wrp/TypeFactoryWrapper.java @@ -0,0 +1,34 @@ +package org.hibernate.tool.orm.jbt.api.wrp; + +import java.util.Map; + +public interface TypeFactoryWrapper extends Wrapper { + + TypeWrapper getBooleanType(); + TypeWrapper getByteType(); + TypeWrapper getBigIntegerType(); + TypeWrapper getShortType() ; + TypeWrapper getCalendarType(); + TypeWrapper getCalendarDateType(); + TypeWrapper getIntegerType(); + TypeWrapper getBigDecimalType(); + TypeWrapper getCharacterType(); + TypeWrapper getClassType(); + TypeWrapper getCurrencyType(); + TypeWrapper getDateType(); + TypeWrapper getDoubleType(); + TypeWrapper getFloatType(); + TypeWrapper getLocaleType(); + TypeWrapper getLongType(); + TypeWrapper getStringType(); + TypeWrapper getTextType(); + TypeWrapper getTimeType(); + TypeWrapper getTimestampType(); + TypeWrapper getTimezoneType(); + TypeWrapper getTrueFalseType(); + TypeWrapper getYesNoType(); + TypeWrapper getNamedType(String name); + TypeWrapper getBasicType(String name); + Map getTypeFormats(); + +} diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/wrp/TypeWrapper.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/wrp/TypeWrapper.java new file mode 100644 index 0000000000..28161496a9 --- /dev/null +++ b/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/wrp/TypeWrapper.java @@ -0,0 +1,23 @@ +package org.hibernate.tool.orm.jbt.api.wrp; + +public interface TypeWrapper extends Wrapper { + + String toString(Object object); + String getName(); + Object fromStringValue(String stringValue); + boolean isEntityType(); + boolean isOneToOne(); + boolean isAnyType(); + boolean isComponentType(); + boolean isCollectionType(); + String getAssociatedEntityName(); + boolean isIntegerType(); + boolean isArrayType(); + boolean isInstanceOfPrimitiveType(); + Class getPrimitiveClass(); + String getRole(); + String getReturnedClassName(); + +} + + diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/wrp/ValueWrapper.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/wrp/ValueWrapper.java new file mode 100644 index 0000000000..9cf16640ef --- /dev/null +++ b/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/wrp/ValueWrapper.java @@ -0,0 +1,60 @@ +package org.hibernate.tool.orm.jbt.api.wrp; + +import java.util.Iterator; +import java.util.Properties; + +public interface ValueWrapper extends Wrapper { + + boolean isSimpleValue(); + boolean isCollection(); + ValueWrapper getCollectionElement(); + boolean isOneToMany(); + boolean isManyToOne(); + boolean isOneToOne(); + boolean isMap(); + boolean isComponent(); + boolean isEmbedded(); + boolean isToOne(); + TableWrapper getTable(); + TypeWrapper getType(); + void setElement(ValueWrapper v); + void setCollectionTable(TableWrapper table); + void setTable(TableWrapper table); + boolean isList(); + void setIndex(ValueWrapper v); + void setTypeName(String s); + String getComponentClassName(); + Iterator getColumnIterator(); + boolean isTypeSpecified(); + TableWrapper getCollectionTable(); + ValueWrapper getKey(); + ValueWrapper getIndex(); + String getElementClassName(); + String getTypeName(); + boolean isDependantValue(); + boolean isAny(); + boolean isSet(); + boolean isPrimitiveArray(); + boolean isArray(); + boolean isIdentifierBag(); + boolean isBag(); + String getReferencedEntityName(); + String getEntityName(); + Iterator getPropertyIterator(); + void addColumn(ColumnWrapper column); + void setTypeParameters(Properties properties); + String getForeignKeyName(); + PersistentClassWrapper getOwner(); + ValueWrapper getElement(); + String getParentProperty(); + void setElementClassName(String name); + void setKey(ValueWrapper value); + void setFetchModeJoin(); + boolean isInverse(); + PersistentClassWrapper getAssociatedClass() ; + void setLazy(boolean b); + void setRole(String role); + void setReferencedEntityName(String name); + void setAssociatedClass(PersistentClassWrapper pc); + +} diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/wrp/Wrapper.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/wrp/Wrapper.java similarity index 64% rename from jbt/src/main/java/org/hibernate/tool/orm/jbt/wrp/Wrapper.java rename to jbt/src/main/java/org/hibernate/tool/orm/jbt/api/wrp/Wrapper.java index 6437acd77f..bcddaf031b 100644 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/wrp/Wrapper.java +++ b/jbt/src/main/java/org/hibernate/tool/orm/jbt/api/wrp/Wrapper.java @@ -1,7 +1,7 @@ -package org.hibernate.tool.orm.jbt.wrp; +package org.hibernate.tool.orm.jbt.api.wrp; public interface Wrapper { default Object getWrappedObject() { return this; } - + } diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/ArtifactCollectorWrapperFactory.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/ArtifactCollectorWrapperFactory.java index 5383a870fc..bd65a78bbb 100644 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/ArtifactCollectorWrapperFactory.java +++ b/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/ArtifactCollectorWrapperFactory.java @@ -1,16 +1,44 @@ package org.hibernate.tool.orm.jbt.internal.factory; +import java.io.File; +import java.util.Set; + import org.hibernate.tool.api.export.ArtifactCollector; import org.hibernate.tool.internal.export.common.DefaultArtifactCollector; -import org.hibernate.tool.orm.jbt.api.ArtifactCollectorWrapper; +import org.hibernate.tool.orm.jbt.api.wrp.ArtifactCollectorWrapper; +import org.hibernate.tool.orm.jbt.internal.wrp.AbstractWrapper; public class ArtifactCollectorWrapperFactory { public static ArtifactCollectorWrapper createArtifactCollectorWrapper() { - ArtifactCollector wrappedArtifactCollector = new DefaultArtifactCollector(); - return new ArtifactCollectorWrapper() { - @Override public ArtifactCollector getWrappedObject() { return wrappedArtifactCollector; } - }; + return new ArtifactCollectorWrapperImpl(); + } + + private static class ArtifactCollectorWrapperImpl + extends AbstractWrapper + implements ArtifactCollectorWrapper { + + private ArtifactCollector wrappedArtifactCollector = new DefaultArtifactCollector(); + + @Override + public ArtifactCollector getWrappedObject() { + return wrappedArtifactCollector; + } + + @Override + public Set getFileTypes() { + return ((ArtifactCollector)getWrappedObject()).getFileTypes(); + } + + @Override + public void formatFiles() { + ((ArtifactCollector)getWrappedObject()).formatFiles(); + } + + @Override + public File[] getFiles(String string) { + return ((ArtifactCollector)getWrappedObject()).getFiles(string); + } } } diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/Cfg2HbmToolWrapperFactory.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/Cfg2HbmToolWrapperFactory.java index 301a5818e4..bc90066848 100644 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/Cfg2HbmToolWrapperFactory.java +++ b/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/Cfg2HbmToolWrapperFactory.java @@ -1,15 +1,62 @@ package org.hibernate.tool.orm.jbt.internal.factory; +import org.hibernate.mapping.PersistentClass; +import org.hibernate.mapping.Property; +import org.hibernate.mapping.SimpleValue; +import org.hibernate.mapping.Value; import org.hibernate.tool.internal.export.hbm.Cfg2HbmTool; -import org.hibernate.tool.orm.jbt.api.Cfg2HbmToolWrapper; +import org.hibernate.tool.internal.export.hbm.HBMTagForValueVisitor; +import org.hibernate.tool.orm.jbt.api.wrp.Cfg2HbmToolWrapper; +import org.hibernate.tool.orm.jbt.api.wrp.PersistentClassWrapper; +import org.hibernate.tool.orm.jbt.api.wrp.PropertyWrapper; +import org.hibernate.tool.orm.jbt.api.wrp.Wrapper; +import org.hibernate.tool.orm.jbt.internal.wrp.AbstractWrapper; public class Cfg2HbmToolWrapperFactory { public static Cfg2HbmToolWrapper createCfg2HbmToolWrapper() { - Cfg2HbmTool wrappedCfg2HbmTool = new Cfg2HbmTool(); - return new Cfg2HbmToolWrapper() { - @Override public Cfg2HbmTool getWrappedObject() { return wrappedCfg2HbmTool; } - }; + return new Cfg2HbmToolWrapperImpl(); + } + + private static class Cfg2HbmToolWrapperImpl + extends AbstractWrapper + implements Cfg2HbmToolWrapper { + + private Cfg2HbmTool wrappedCfg2HbmTool = new Cfg2HbmTool(); + + @Override + public Cfg2HbmTool getWrappedObject() { + return wrappedCfg2HbmTool; + } + + public String getTag(PersistentClassWrapper pcw) { + return wrappedCfg2HbmTool.getTag((PersistentClass)pcw.getWrappedObject()); + } + + public String getTag(PropertyWrapper pw) { + PersistentClassWrapper persistentClassWrapper = pw.getPersistentClass(); + if(persistentClassWrapper!=null) { + Property v = (Property)persistentClassWrapper.getVersion().getWrappedObject(); + if(v==pw.getWrappedObject()) { + Value pwv = (Value)pw.getValue().getWrappedObject(); + if (pwv instanceof Wrapper) { + pwv = (Value)((Wrapper)pwv).getWrappedObject(); + } + String typeName = ((SimpleValue)pwv).getTypeName(); + if("timestamp".equals(typeName) || "dbtimestamp".equals(typeName)) { + return "timestamp"; + } else { + return "version"; + } + } + } + String toolTag = (String)((Value)pw.getValue().getWrappedObject()).accept(HBMTagForValueVisitor.INSTANCE); + if ("component".equals(toolTag) && "embedded".equals(pw.getPropertyAccessorName())){ + toolTag = "properties"; + } + return toolTag; + } + } } diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/ClassMetadataWrapperFactory.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/ClassMetadataWrapperFactory.java index 8c9c32bcb6..ae9c4262e3 100644 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/ClassMetadataWrapperFactory.java +++ b/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/ClassMetadataWrapperFactory.java @@ -1,14 +1,127 @@ package org.hibernate.tool.orm.jbt.internal.factory; +import org.hibernate.engine.spi.SharedSessionContractImplementor; +import org.hibernate.persister.entity.AbstractEntityPersister; import org.hibernate.persister.entity.EntityPersister; -import org.hibernate.tool.orm.jbt.api.ClassMetadataWrapper; +import org.hibernate.tool.orm.jbt.api.wrp.ClassMetadataWrapper; +import org.hibernate.tool.orm.jbt.api.wrp.SessionWrapper; +import org.hibernate.tool.orm.jbt.api.wrp.TypeWrapper; +import org.hibernate.tool.orm.jbt.internal.wrp.AbstractWrapper; +import org.hibernate.type.Type; public class ClassMetadataWrapperFactory { public static ClassMetadataWrapper createClassMetadataWrapper(final EntityPersister entityPersister) { - return new ClassMetadataWrapper() { - @Override public EntityPersister getWrappedObject() { return entityPersister; } - }; + return new ClassMetadataWrapperImpl(entityPersister); + } + + private static class ClassMetadataWrapperImpl + extends AbstractWrapper + implements ClassMetadataWrapper { + + private EntityPersister wrappedClassMetadata = null; + private TypeWrapper[] propertyTypeWrappers = null; + private TypeWrapper identifierTypeWrapper = null; + + private ClassMetadataWrapperImpl(EntityPersister entityPersister) { + wrappedClassMetadata = entityPersister; + } + + @Override + public EntityPersister getWrappedObject() { + return wrappedClassMetadata; + } + + @Override + public String getEntityName() { + return wrappedClassMetadata.getEntityName(); + + } + @Override + public String getIdentifierPropertyName() { + return wrappedClassMetadata.getIdentifierPropertyName(); + } + + @Override + public String[] getPropertyNames() { + return wrappedClassMetadata.getPropertyNames(); + } + + @Override + public TypeWrapper[] getPropertyTypes() { + if (propertyTypeWrappers == null) { + initPropertyTypeWrappers(); + } else { + syncPropertyTypeWrappers(); + } + return propertyTypeWrappers; + } + + @Override + public Class getMappedClass() { + return wrappedClassMetadata.getMappedClass(); + } + + @Override + public TypeWrapper getIdentifierType() { + Type identifierType = wrappedClassMetadata.getIdentifierType(); + if (identifierTypeWrapper == null || identifierTypeWrapper.getWrappedObject() != identifierType) { + identifierTypeWrapper = TypeWrapperFactory.createTypeWrapper(identifierType); + } + return identifierTypeWrapper; + } + + @Override + public Object getPropertyValue(Object object, String name) { + return wrappedClassMetadata.getPropertyValue(object, name); + } + + @Override + public boolean hasIdentifierProperty() { + return wrappedClassMetadata.hasIdentifierProperty(); + } + + @Override + public Object getIdentifier(Object object, SessionWrapper sessionWrapper) { + return wrappedClassMetadata.getIdentifier(object, (SharedSessionContractImplementor)sessionWrapper.getWrappedObject()); + } + + @Override + public boolean isInstanceOfAbstractEntityPersister() { + return getWrappedObject() instanceof AbstractEntityPersister; + } + + @Override + public Integer getPropertyIndexOrNull(String id) { + return wrappedClassMetadata.getEntityMetamodel().getPropertyIndexOrNull(id); + } + + @Override + public Object getTuplizerPropertyValue(Object entity, int i) { + return wrappedClassMetadata.getValue(entity, i); + } + + private void initPropertyTypeWrappers() { + Type[] propertyTypes = wrappedClassMetadata.getPropertyTypes(); + propertyTypeWrappers = new TypeWrapper[propertyTypes.length]; + for (int i = 0; i < propertyTypes.length; i++) { + propertyTypeWrappers[i] = TypeWrapperFactory.createTypeWrapper(propertyTypes[i]); + } + } + + private void syncPropertyTypeWrappers() { + Type[] propertyTypes = wrappedClassMetadata.getPropertyTypes(); + if (propertyTypeWrappers.length != propertyTypes.length) { + initPropertyTypeWrappers(); + } else { + for (int i = 0; i < propertyTypes.length; i++) { + if (propertyTypeWrappers[i].getWrappedObject() != propertyTypes[i]) { + propertyTypeWrappers[i] = TypeWrapperFactory.createTypeWrapper(propertyTypes[i]); + } + } + } + } + } } diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/CollectionMetadataWrapperFactory.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/CollectionMetadataWrapperFactory.java index 945ab11307..5ba8c8d6fc 100644 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/CollectionMetadataWrapperFactory.java +++ b/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/CollectionMetadataWrapperFactory.java @@ -1,14 +1,42 @@ package org.hibernate.tool.orm.jbt.internal.factory; import org.hibernate.persister.collection.CollectionPersister; -import org.hibernate.tool.orm.jbt.api.CollectionMetadataWrapper; +import org.hibernate.tool.orm.jbt.api.wrp.CollectionMetadataWrapper; +import org.hibernate.tool.orm.jbt.api.wrp.TypeWrapper; +import org.hibernate.tool.orm.jbt.internal.wrp.AbstractWrapper; +import org.hibernate.type.Type; public class CollectionMetadataWrapperFactory { public static CollectionMetadataWrapper createCollectionMetadataWrapper(final CollectionPersister collectionPersister) { - return new CollectionMetadataWrapper() { - @Override public CollectionPersister getWrappedObject() { return collectionPersister; } - }; + return new CollectionMetadataWrapperImpl(collectionPersister); + } + + private static class CollectionMetadataWrapperImpl + extends AbstractWrapper + implements CollectionMetadataWrapper { + + private CollectionPersister wrappedCollectionMetadata = null; + + private TypeWrapper elementTypeWrapper = null; + + private CollectionMetadataWrapperImpl(CollectionPersister collectionPersister) { + wrappedCollectionMetadata = collectionPersister; + } + + @Override + public CollectionPersister getWrappedObject() { + return wrappedCollectionMetadata; + } + + @Override + public TypeWrapper getElementType() { + Type elementType = getWrappedObject().getElementType(); + if (elementTypeWrapper == null || elementTypeWrapper.getWrappedObject() != elementType) { + elementTypeWrapper = TypeWrapperFactory.createTypeWrapper(elementType); + } + return elementTypeWrapper; + } } } diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/ColumnWrapperFactory.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/ColumnWrapperFactory.java index fb1104bab4..c5d35483b0 100644 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/ColumnWrapperFactory.java +++ b/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/ColumnWrapperFactory.java @@ -1,15 +1,126 @@ package org.hibernate.tool.orm.jbt.internal.factory; +import org.hibernate.cfg.Configuration; import org.hibernate.mapping.Column; -import org.hibernate.tool.orm.jbt.api.ColumnWrapper; +import org.hibernate.mapping.Value; +import org.hibernate.tool.orm.jbt.api.wrp.ColumnWrapper; +import org.hibernate.tool.orm.jbt.api.wrp.ConfigurationWrapper; +import org.hibernate.tool.orm.jbt.api.wrp.ValueWrapper; +import org.hibernate.tool.orm.jbt.internal.util.MetadataHelper; +import org.hibernate.tool.orm.jbt.internal.wrp.AbstractWrapper; public class ColumnWrapperFactory { - + public static ColumnWrapper createColumnWrapper(final String name) { - final Column wrappedColumn = new Column(name); - return new ColumnWrapper() { - @Override public Column getWrappedObject() { return wrappedColumn; } - }; + return new ColumnWrapperImpl(name); + } + + public static ColumnWrapper createColumnWrapper(final Column column) { + return new ColumnWrapperImpl(column); + } + + private static class ColumnWrapperImpl + extends AbstractWrapper + implements ColumnWrapper { + + private Column wrappedColumn = null; + + private ValueWrapper valueWrapper = null; + + private ColumnWrapperImpl(Column column) { + wrappedColumn = column; + } + + private ColumnWrapperImpl(String name) { + wrappedColumn = new Column(name); + } + + @Override + public Column getWrappedObject() { + return wrappedColumn; + } + + @Override + public String getName() { + return wrappedColumn.getName(); + } + + @Override + public Integer getSqlTypeCode() { + return wrappedColumn.getSqlTypeCode(); + } + + @Override + public String getSqlType() { + return wrappedColumn.getSqlType(); + } + + @Override + public String getSqlType(ConfigurationWrapper configurationWrapper) { + return wrappedColumn.getSqlType(MetadataHelper.getMetadata((Configuration)configurationWrapper.getWrappedObject())); + } + + @Override + public long getLength() { + Long length = wrappedColumn.getLength(); + return length == null ? Integer.MIN_VALUE : length; + } + + @Override + public int getDefaultLength() { + return DEFAULT_LENGTH; + } + + @Override + public int getPrecision() { + Integer precision = wrappedColumn.getPrecision(); + return precision == null ? Integer.MIN_VALUE : precision; + } + + @Override + public int getDefaultPrecision() { + return DEFAULT_PRECISION; + } + + @Override + public int getScale() { + Integer scale = wrappedColumn.getScale(); + return scale == null ? Integer.MIN_VALUE : scale; + } + + @Override + public int getDefaultScale() { + return DEFAULT_SCALE; + } + + @Override + public boolean isNullable() { + return wrappedColumn.isNullable(); + } + + @Override + public ValueWrapper getValue() { + Value v = wrappedColumn.getValue(); + if (valueWrapper == null || valueWrapper.getWrappedObject() != v) { + if (v != null) { + valueWrapper = ValueWrapperFactory.createValueWrapper(v); + } else { + valueWrapper = null; + } + } + return valueWrapper; + } + + @Override + public boolean isUnique() { + return wrappedColumn.isUnique(); + } + + @Override + public void setSqlType(String sqlType) { + wrappedColumn.setSqlType(sqlType); + } + } } diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/ConfigurationWrapperFactory.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/ConfigurationWrapperFactory.java index de2e5c903c..6a8d2fe1a5 100644 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/ConfigurationWrapperFactory.java +++ b/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/ConfigurationWrapperFactory.java @@ -1,14 +1,237 @@ package org.hibernate.tool.orm.jbt.internal.factory; +import java.io.File; +import java.util.Iterator; +import java.util.Map; +import java.util.Properties; + import org.hibernate.cfg.Configuration; -import org.hibernate.tool.orm.jbt.api.ConfigurationWrapper; +import org.hibernate.cfg.NamingStrategy; +import org.hibernate.mapping.PersistentClass; +import org.hibernate.mapping.Table; +import org.hibernate.tool.api.reveng.RevengStrategy; +import org.hibernate.tool.orm.jbt.api.wrp.ConfigurationWrapper; +import org.hibernate.tool.orm.jbt.api.wrp.NamingStrategyWrapper; +import org.hibernate.tool.orm.jbt.api.wrp.PersistentClassWrapper; +import org.hibernate.tool.orm.jbt.api.wrp.RevengStrategyWrapper; +import org.hibernate.tool.orm.jbt.api.wrp.SessionFactoryWrapper; +import org.hibernate.tool.orm.jbt.api.wrp.TableWrapper; +import org.hibernate.tool.orm.jbt.internal.util.ExtendedConfiguration; +import org.hibernate.tool.orm.jbt.internal.util.JpaConfiguration; +import org.hibernate.tool.orm.jbt.internal.util.NativeConfiguration; +import org.hibernate.tool.orm.jbt.internal.util.RevengConfiguration; +import org.hibernate.tool.orm.jbt.internal.wrp.AbstractWrapper; +import org.w3c.dom.Document; +import org.xml.sax.EntityResolver; public class ConfigurationWrapperFactory { - public static ConfigurationWrapper createConfigurationWrapper(final Configuration wrappedConfiguration) { - return new ConfigurationWrapper() { - @Override public Configuration getWrappedObject() { return wrappedConfiguration; } - }; + public static ConfigurationWrapper createNativeConfigurationWrapper() { + return createConfigurationWrapper(new NativeConfiguration()); + } + + public static ConfigurationWrapper createRevengConfigurationWrapper() { + return createConfigurationWrapper(new RevengConfiguration()); + } + + public static ConfigurationWrapper createJpaConfigurationWrapper(String persistenceUnit, Map properties) { + return new ConfigurationWrapperImpl(new JpaConfiguration(persistenceUnit, properties)); + } + + private static ConfigurationWrapper createConfigurationWrapper(final Configuration wrappedConfiguration) { + return new ConfigurationWrapperImpl(wrappedConfiguration); + } + + private static class ConfigurationWrapperImpl + extends AbstractWrapper + implements ConfigurationWrapper { + + private Configuration wrappedConfiguration = null; + + private NamingStrategyWrapper namingStrategyWrapper = null; + + private ConfigurationWrapperImpl(Configuration configuration) { + wrappedConfiguration = configuration; + } + + @Override + public Configuration getWrappedObject() { + return wrappedConfiguration; + } + + @Override + public String getProperty(String property) { + return wrappedConfiguration.getProperty(property); + } + + @Override + public ConfigurationWrapper addFile(File file) { + wrappedConfiguration.addFile(file); return this; + } + + @Override + public void setProperty(String name, String value) { + wrappedConfiguration.setProperty(name, value); + } + + @Override + public ConfigurationWrapper setProperties(Properties properties) { + wrappedConfiguration.setProperties(properties); return this; + } + + @Override + public void setEntityResolver(EntityResolver entityResolver) { + if (wrappedConfiguration instanceof ExtendedConfiguration) { + ((ExtendedConfiguration)wrappedConfiguration).setEntityResolver(entityResolver); + } + } + + @Override + public void setNamingStrategy(NamingStrategyWrapper namingStrategyWrapper) { + if (wrappedConfiguration instanceof ExtendedConfiguration) { + ((ExtendedConfiguration)wrappedConfiguration).setNamingStrategy((NamingStrategy)namingStrategyWrapper.getWrappedObject()); + } + } + + @Override + public Properties getProperties() { + return wrappedConfiguration.getProperties(); + } + + @Override + public void addProperties(Properties properties) { + wrappedConfiguration.addProperties(properties); + } + + @Override + public ConfigurationWrapper configure(Document document) { + if (wrappedConfiguration instanceof ExtendedConfiguration) { + ((ExtendedConfiguration)wrappedConfiguration).configure(document); + } + return this; + } + + @Override + public ConfigurationWrapper configure(File file) { + wrappedConfiguration.configure(file); + return this; + } + + @Override + public ConfigurationWrapper configure() { + wrappedConfiguration.configure(); + return this; + } + + @Override + public void addClass(Class clazz) { + wrappedConfiguration.addClass(clazz); + } + + @Override + public void buildMappings() { + if (wrappedConfiguration instanceof ExtendedConfiguration) { + ((ExtendedConfiguration)wrappedConfiguration).buildMappings(); + } + } + + @Override + public SessionFactoryWrapper buildSessionFactory() { + return SessionFactoryWrapperFactory.createSessionFactoryWrapper(((Configuration)getWrappedObject()).buildSessionFactory()); + } + + @Override + public Iterator getClassMappings() { + if (wrappedConfiguration instanceof ExtendedConfiguration) { + Iterator classMappings = ((ExtendedConfiguration)wrappedConfiguration).getClassMappings(); + return new Iterator() { + @Override + public boolean hasNext() { + return classMappings.hasNext(); + } + @Override + public PersistentClassWrapper next() { + return PersistentClassWrapperFactory.createPersistentClassWrapper(classMappings.next()); + } + }; + } + return null; + } + + @Override + public void setPreferBasicCompositeIds(boolean b) { + if (wrappedConfiguration instanceof ExtendedConfiguration) { + ((ExtendedConfiguration)wrappedConfiguration).setPreferBasicCompositeIds(b); + } + } + + @Override + public void setReverseEngineeringStrategy(RevengStrategyWrapper strategy) { + if (wrappedConfiguration instanceof ExtendedConfiguration) { + ((ExtendedConfiguration)wrappedConfiguration).setReverseEngineeringStrategy((RevengStrategy)strategy.getWrappedObject()); + } + } + + @Override + public void readFromJDBC() { + if (wrappedConfiguration instanceof ExtendedConfiguration) { + ((ExtendedConfiguration)wrappedConfiguration).readFromJDBC(); + } + } + + @Override + public PersistentClassWrapper getClassMapping(String string) { + if (wrappedConfiguration instanceof ExtendedConfiguration) { + PersistentClass classMapping = ((ExtendedConfiguration)wrappedConfiguration).getClassMapping(string); + if (classMapping != null) { + return PersistentClassWrapperFactory.createPersistentClassWrapper(classMapping); + } + } + return null; + } + + @Override + public NamingStrategyWrapper getNamingStrategy() { + NamingStrategy namingStrategy = null; + if (wrappedConfiguration instanceof ExtendedConfiguration) { + namingStrategy = ((ExtendedConfiguration)wrappedConfiguration).getNamingStrategy(); + } + if (namingStrategyWrapper == null || namingStrategyWrapper.getWrappedObject() != namingStrategy) { + if (namingStrategy == null) { + namingStrategyWrapper = null; + } else { + namingStrategyWrapper = NamingStrategyWrapperFactory.createNamingStrategyWrapper(namingStrategy); + } + } + return namingStrategyWrapper; + } + + @Override + public EntityResolver getEntityResolver() { + if (wrappedConfiguration instanceof ExtendedConfiguration) { + return ((ExtendedConfiguration)wrappedConfiguration).getEntityResolver(); + } + return null; + } + + @Override + public Iterator getTableMappings() { + if (wrappedConfiguration instanceof ExtendedConfiguration) { + Iterator
tableMappings = ((ExtendedConfiguration)wrappedConfiguration).getTableMappings(); + return new Iterator() { + @Override + public boolean hasNext() { + return tableMappings.hasNext(); + } + @Override + public TableWrapper next() { + return TableWrapperFactory.createTableWrapper(tableMappings.next()); + } + }; + } + return null; + } + } } diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/CriteriaWrapperFactory.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/CriteriaWrapperFactory.java index afd5fd6404..782ea2fc63 100644 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/CriteriaWrapperFactory.java +++ b/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/CriteriaWrapperFactory.java @@ -1,15 +1,43 @@ package org.hibernate.tool.orm.jbt.internal.factory; -import org.hibernate.tool.orm.jbt.api.CriteriaWrapper; +import java.util.List; + +import org.hibernate.tool.orm.jbt.api.wrp.CriteriaWrapper; +import org.hibernate.tool.orm.jbt.internal.wrp.AbstractWrapper; import jakarta.persistence.Query; public class CriteriaWrapperFactory { public static CriteriaWrapper createCriteriaWrapper(final Query wrappedCriteria) { - return new CriteriaWrapper() { - @Override public Query getWrappedObject() { return wrappedCriteria; } - }; + return new CriteriaWrapperImpl(wrappedCriteria); + } + + private static class CriteriaWrapperImpl + extends AbstractWrapper + implements CriteriaWrapper { + + private Query query = null; + + private CriteriaWrapperImpl(Query query) { + this.query = query; + } + + @Override + public Query getWrappedObject() { + return query; + } + + @Override + public void setMaxResults(int intValue) { + ((Query)getWrappedObject()).setMaxResults(intValue); + } + + @Override + public List list() { + return ((Query)getWrappedObject()).getResultList(); + } + } } diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/wrp/DatabaseReaderWrapperFactory.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/DatabaseReaderWrapperFactory.java similarity index 83% rename from jbt/src/main/java/org/hibernate/tool/orm/jbt/wrp/DatabaseReaderWrapperFactory.java rename to jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/DatabaseReaderWrapperFactory.java index c11807c4c4..86b2b2dde1 100644 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/wrp/DatabaseReaderWrapperFactory.java +++ b/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/DatabaseReaderWrapperFactory.java @@ -1,4 +1,4 @@ -package org.hibernate.tool.orm.jbt.wrp; +package org.hibernate.tool.orm.jbt.internal.factory; import java.util.ArrayList; import java.util.HashMap; @@ -20,20 +20,22 @@ import org.hibernate.tool.api.reveng.RevengStrategy; import org.hibernate.tool.internal.reveng.RevengMetadataCollector; import org.hibernate.tool.internal.reveng.reader.DatabaseReader; +import org.hibernate.tool.orm.jbt.api.wrp.DatabaseReaderWrapper; +import org.hibernate.tool.orm.jbt.api.wrp.RevengStrategyWrapper; +import org.hibernate.tool.orm.jbt.api.wrp.TableWrapper; +import org.hibernate.tool.orm.jbt.internal.wrp.AbstractWrapper; public class DatabaseReaderWrapperFactory { - + public static DatabaseReaderWrapper createDatabaseReaderWrapper( Properties properties, - RevengStrategy revengStrategy) { - return new DatabaseReaderWrapperImpl(properties, revengStrategy); - } - - static interface DatabaseReaderWrapper extends Wrapper { - Map> collectDatabaseTables(); + RevengStrategyWrapper revengStrategy) { + return new DatabaseReaderWrapperImpl(properties, (RevengStrategy)revengStrategy.getWrappedObject()); } - static class DatabaseReaderWrapperImpl implements DatabaseReaderWrapper { + static class DatabaseReaderWrapperImpl + extends AbstractWrapper + implements DatabaseReaderWrapper { DatabaseReader databaseReader = null; RevengMetadataCollector revengMetadataCollector = null; @@ -81,7 +83,7 @@ public Map> collectDatabaseTables() { list = new ArrayList(); result.put(qualifier, list); } - list.add(new DelegatingTableWrapperImpl(table)); + list.add(TableWrapperFactory.createTableWrapper(table)); } return result; } diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/DdlExporterWrapperFactory.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/DdlExporterWrapperFactory.java index db23f227f7..512ef782a2 100644 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/DdlExporterWrapperFactory.java +++ b/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/DdlExporterWrapperFactory.java @@ -1,14 +1,44 @@ package org.hibernate.tool.orm.jbt.internal.factory; +import java.util.Properties; + +import org.hibernate.tool.api.export.ExporterConstants; import org.hibernate.tool.internal.export.ddl.DdlExporter; -import org.hibernate.tool.orm.jbt.api.DdlExporterWrapper; +import org.hibernate.tool.orm.jbt.api.wrp.DdlExporterWrapper; +import org.hibernate.tool.orm.jbt.internal.wrp.AbstractWrapper; public class DdlExporterWrapperFactory { public static DdlExporterWrapper createDdlExporterWrapper(final DdlExporter wrappedDdlExporter) { - return new DdlExporterWrapper() { - @Override public DdlExporter getWrappedObject() { return wrappedDdlExporter; } - }; + return new DdlExporterWrapperImpl(wrappedDdlExporter); + } + + private static class DdlExporterWrapperImpl + extends AbstractWrapper + implements DdlExporterWrapper { + + private DdlExporter ddlExporter = null; + + private DdlExporterWrapperImpl(DdlExporter ddlExporter) { + this.ddlExporter = ddlExporter; + } + + @Override + public DdlExporter getWrappedObject() { + return ddlExporter; + } + + @Override + public void setExport(boolean b) { + ((DdlExporter)getWrappedObject()).getProperties().put( + ExporterConstants.EXPORT_TO_DATABASE, b); + } + + @Override + public Properties getProperties() { + return ((DdlExporter)getWrappedObject()).getProperties(); + } + } } diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/EnvironmentWrapperFactory.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/EnvironmentWrapperFactory.java index 07adf5e43c..c90560b782 100644 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/EnvironmentWrapperFactory.java +++ b/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/EnvironmentWrapperFactory.java @@ -1,13 +1,47 @@ package org.hibernate.tool.orm.jbt.internal.factory; -import org.hibernate.tool.orm.jbt.api.EnvironmentWrapper; +import org.hibernate.cfg.Environment; +import org.hibernate.tool.orm.jbt.api.wrp.EnvironmentWrapper; +import org.hibernate.tool.orm.jbt.internal.wrp.AbstractWrapper; public class EnvironmentWrapperFactory { - static EnvironmentWrapper ENVIRONMENT_WRAPPER_INSTANCE = new EnvironmentWrapper() {}; + static EnvironmentWrapper ENVIRONMENT_WRAPPER_INSTANCE = new EnvironmentWrapperImpl(); public static EnvironmentWrapper createEnvironmentWrapper() { return ENVIRONMENT_WRAPPER_INSTANCE; } + private static class EnvironmentWrapperImpl + extends AbstractWrapper + implements EnvironmentWrapper { + + @Override public String getTransactionManagerStrategy() { return "hibernate.transaction.coordinator_class"; } + + @Override public String getDriver() { return Environment.DRIVER; } + + @Override public String getHBM2DDLAuto() { return Environment.HBM2DDL_AUTO; } + + @Override public String getDialect() { return Environment.DIALECT; } + + @Override public String getDataSource() { return Environment.DATASOURCE; } + + @Override public String getConnectionProvider() { return Environment.CONNECTION_PROVIDER; } + + @Override public String getURL() { return Environment.URL; } + + @Override public String getUser() { return Environment.USER; } + + @Override public String getPass() { return Environment.PASS; } + + @Override public String getSessionFactoryName() { return Environment.SESSION_FACTORY_NAME; } + + @Override public String getDefaultCatalog() { return Environment.DEFAULT_CATALOG; } + + @Override public String getDefaultSchema() { return Environment.DEFAULT_SCHEMA; } + + @Override public Class getWrappedClass() { return Environment.class; } + + } + } diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/ExporterWrapperFactory.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/ExporterWrapperFactory.java index 224d067eee..8a9cace09b 100644 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/ExporterWrapperFactory.java +++ b/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/ExporterWrapperFactory.java @@ -1,29 +1,140 @@ package org.hibernate.tool.orm.jbt.internal.factory; +import java.io.File; +import java.io.StringWriter; +import java.util.Properties; + import org.hibernate.cfg.Configuration; import org.hibernate.tool.api.export.Exporter; import org.hibernate.tool.api.export.ExporterConstants; import org.hibernate.tool.internal.export.cfg.CfgExporter; -import org.hibernate.tool.orm.jbt.api.ExporterWrapper; -import org.hibernate.tool.orm.jbt.util.ConfigurationMetadataDescriptor; -import org.hibernate.tool.orm.jbt.util.DummyMetadataDescriptor; +import org.hibernate.tool.internal.export.common.GenericExporter; +import org.hibernate.tool.internal.export.ddl.DdlExporter; +import org.hibernate.tool.internal.export.query.QueryExporter; +import org.hibernate.tool.orm.jbt.api.wrp.ArtifactCollectorWrapper; +import org.hibernate.tool.orm.jbt.api.wrp.ConfigurationWrapper; +import org.hibernate.tool.orm.jbt.api.wrp.DdlExporterWrapper; +import org.hibernate.tool.orm.jbt.api.wrp.ExporterWrapper; +import org.hibernate.tool.orm.jbt.api.wrp.GenericExporterWrapper; +import org.hibernate.tool.orm.jbt.api.wrp.QueryExporterWrapper; +import org.hibernate.tool.orm.jbt.internal.util.ConfigurationMetadataDescriptor; +import org.hibernate.tool.orm.jbt.internal.util.DummyMetadataDescriptor; +import org.hibernate.tool.orm.jbt.internal.util.ReflectUtil; +import org.hibernate.tool.orm.jbt.internal.wrp.AbstractWrapper; public class ExporterWrapperFactory { + + public static ExporterWrapper createExporterWrapper(String className) { + Exporter wrappedExporter = (Exporter)ReflectUtil.createInstance(className); + return createExporterWrapper(wrappedExporter); + } - public static ExporterWrapper createExporterWrapper(final Exporter wrappedExporter) { - ExporterWrapper result = new ExporterWrapper() { - @Override public Exporter getWrappedObject() { return wrappedExporter; } - }; - if (CfgExporter.class.isAssignableFrom(wrappedExporter.getClass())) { - wrappedExporter.getProperties().put( + private static ExporterWrapper createExporterWrapper(final Exporter wrappedExporter) { + return new ExporterWrapperImpl(wrappedExporter); + } + + private static class ExporterWrapperImpl + extends AbstractWrapper + implements ExporterWrapper { + + private Exporter exporter = null; + + private ExporterWrapperImpl(Exporter exporter) { + this.exporter = exporter; + if (CfgExporter.class.isAssignableFrom(exporter.getClass())) { + exporter.getProperties().put( + ExporterConstants.METADATA_DESCRIPTOR, + new DummyMetadataDescriptor()); + } else { + exporter.getProperties().put( + ExporterConstants.METADATA_DESCRIPTOR, + new ConfigurationMetadataDescriptor(new Configuration())); + } + } + + @Override + public Exporter getWrappedObject() { + return exporter; + } + + @Override + public void setConfiguration(ConfigurationWrapper configuration) { + if (CfgExporter.class.isAssignableFrom(exporter.getClass())) { + ((CfgExporter)exporter).setCustomProperties(configuration.getProperties()); + } + exporter.getProperties().put( ExporterConstants.METADATA_DESCRIPTOR, - new DummyMetadataDescriptor()); - } else { - wrappedExporter.getProperties().put( - ExporterConstants.METADATA_DESCRIPTOR, - new ConfigurationMetadataDescriptor(new Configuration())); + new ConfigurationMetadataDescriptor((Configuration)configuration.getWrappedObject())); + } + + @Override + public void setArtifactCollector(ArtifactCollectorWrapper artifactCollectorWrapper) { + exporter.getProperties().put( + ExporterConstants.ARTIFACT_COLLECTOR, + artifactCollectorWrapper.getWrappedObject()); + } + + @Override + public void setOutputDirectory(File dir) { + exporter.getProperties().put(ExporterConstants.DESTINATION_FOLDER, dir); + } + + @Override + public void setTemplatePath(String[] templatePath) { + exporter.getProperties().put(ExporterConstants.TEMPLATE_PATH, templatePath); + } + + @Override + public void start() { + exporter.start(); + } + + @Override + public Properties getProperties() { + return exporter.getProperties(); + } + + @Override + public GenericExporterWrapper getGenericExporter() { + if (exporter instanceof GenericExporter) { + return GenericExporterWrapperFactory.createGenericExporterWrapper((GenericExporter)exporter); + } else { + return null; + } + } + + @Override + public DdlExporterWrapper getHbm2DDLExporter() { + if (exporter instanceof DdlExporter) { + return DdlExporterWrapperFactory.createDdlExporterWrapper((DdlExporter)exporter); + } else { + return null; + } + } + + @Override + public QueryExporterWrapper getQueryExporter() { + if (exporter instanceof QueryExporter) { + return QueryExporterWrapperFactory.createQueryExporterWrapper((QueryExporter)exporter); + } else { + return null; + } } - return result; + + @Override + public void setCustomProperties(Properties properties) { + if (exporter instanceof CfgExporter) { + ((CfgExporter)exporter).setCustomProperties(properties); + } + } + + @Override + public void setOutput(StringWriter stringWriter) { + if (exporter instanceof CfgExporter) { + ((CfgExporter)exporter).setOutput(stringWriter); + } + } + } } diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/ForeignKeyWrapperFactory.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/ForeignKeyWrapperFactory.java index d5d5e39381..c72623e8ef 100644 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/ForeignKeyWrapperFactory.java +++ b/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/ForeignKeyWrapperFactory.java @@ -1,14 +1,101 @@ package org.hibernate.tool.orm.jbt.internal.factory; +import java.util.ArrayList; +import java.util.Iterator; +import java.util.List; + +import org.hibernate.mapping.Column; import org.hibernate.mapping.ForeignKey; -import org.hibernate.tool.orm.jbt.api.ForeignKeyWrapper; +import org.hibernate.tool.orm.jbt.api.wrp.ColumnWrapper; +import org.hibernate.tool.orm.jbt.api.wrp.ForeignKeyWrapper; +import org.hibernate.tool.orm.jbt.api.wrp.TableWrapper; +import org.hibernate.tool.orm.jbt.internal.wrp.AbstractWrapper; public class ForeignKeyWrapperFactory { public static ForeignKeyWrapper createForeignKeyWrapper(final ForeignKey wrappedForeignKey) { - return new ForeignKeyWrapper() { - @Override public ForeignKey getWrappedObject() { return wrappedForeignKey; } - }; + return new ForeignKeyWrapperImpl(wrappedForeignKey); + } + + private static class ForeignKeyWrapperImpl + extends AbstractWrapper + implements ForeignKeyWrapper { + + private ForeignKey foreignKey = null; + + private List referencedColumns = null; + + private ForeignKeyWrapperImpl(ForeignKey foreignKey) { + this.foreignKey = foreignKey; + } + + @Override + public ForeignKey getWrappedObject() { + return foreignKey; + } + + @Override + public TableWrapper getReferencedTable() { + return TableWrapperFactory.createTableWrapper(foreignKey.getReferencedTable()); + } + + @Override + public Iterator columnIterator() { + Iterator columnIterator = foreignKey.getColumns().iterator(); + return new Iterator() { + @Override + public boolean hasNext() { + return columnIterator.hasNext(); + } + @Override + public ColumnWrapper next() { + return ColumnWrapperFactory.createColumnWrapper(columnIterator.next()); + } + }; + } + + @Override + public boolean isReferenceToPrimaryKey() { + return ((ForeignKey)getWrappedObject()).isReferenceToPrimaryKey(); + } + + @Override + public List getReferencedColumns() { + List columns = foreignKey.getReferencedColumns(); + if (referencedColumns == null) { + initReferencedColumns(columns); + } else { + if (columns == null) { + referencedColumns = null; + } else if (referencedColumns.size() != columns.size()) { + initReferencedColumns(columns); + } else { + syncReferencedColumns(columns); + } + } + return referencedColumns; + } + + @Override + public boolean containsColumn(ColumnWrapper column) { + return ((ForeignKey)getWrappedObject()).containsColumn((Column)column.getWrappedObject()); + } + + private void initReferencedColumns(List columns) { + referencedColumns = new ArrayList(columns.size()); + for (int i = 0; i < columns.size(); i++) { + referencedColumns.add(ColumnWrapperFactory.createColumnWrapper(columns.get(i))); + } + } + + private void syncReferencedColumns(List columns) { + for (int i = 0; i < columns.size(); i++) { + if (referencedColumns.get(i).getWrappedObject() != columns.get(i)) { + referencedColumns.set(i, ColumnWrapperFactory.createColumnWrapper(columns.get(i))); + } + } + } + } } diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/GenericExporterWrapperFactory.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/GenericExporterWrapperFactory.java index aab771b4cd..b28448a4e7 100644 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/GenericExporterWrapperFactory.java +++ b/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/GenericExporterWrapperFactory.java @@ -1,14 +1,61 @@ package org.hibernate.tool.orm.jbt.internal.factory; +import org.hibernate.tool.api.export.ExporterConstants; import org.hibernate.tool.internal.export.common.GenericExporter; -import org.hibernate.tool.orm.jbt.api.GenericExporterWrapper; +import org.hibernate.tool.orm.jbt.api.wrp.GenericExporterWrapper; +import org.hibernate.tool.orm.jbt.internal.wrp.AbstractWrapper; public class GenericExporterWrapperFactory { public static GenericExporterWrapper createGenericExporterWrapper(final GenericExporter wrappedGenericExporter) { - return new GenericExporterWrapper() { - @Override public GenericExporter getWrappedObject() { return wrappedGenericExporter; } - }; + return new GenericExporterWrapperImpl(wrappedGenericExporter); + } + + private static class GenericExporterWrapperImpl + extends AbstractWrapper + implements GenericExporterWrapper { + + private GenericExporter genericExporter = null; + + private GenericExporterWrapperImpl(GenericExporter genericExporter) { + this.genericExporter = genericExporter; + } + + @Override + public GenericExporter getWrappedObject() { + return genericExporter; + } + + @Override + public void setFilePattern(String filePattern) { + genericExporter.getProperties().setProperty( + ExporterConstants.FILE_PATTERN, filePattern); + } + + @Override + public void setTemplateName(String templateName) { + genericExporter.getProperties().setProperty( + ExporterConstants.TEMPLATE_NAME, templateName); + } + + @Override + public void setForEach(String forEach) { + genericExporter.getProperties().setProperty( + ExporterConstants.FOR_EACH, forEach); + } + + @Override + public String getFilePattern() { + return genericExporter.getProperties().getProperty( + ExporterConstants.FILE_PATTERN); + } + + @Override + public String getTemplateName() { + return genericExporter.getProperties().getProperty( + ExporterConstants.TEMPLATE_NAME); + } + } } diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/HbmExporterWrapperFactory.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/HbmExporterWrapperFactory.java index 11726d96f9..c29dbb9e64 100644 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/HbmExporterWrapperFactory.java +++ b/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/HbmExporterWrapperFactory.java @@ -6,21 +6,28 @@ import java.util.Map; import org.hibernate.cfg.Configuration; +import org.hibernate.tool.api.export.ExporterConstants; import org.hibernate.tool.internal.export.hbm.HbmExporter; import org.hibernate.tool.internal.export.java.POJOClass; -import org.hibernate.tool.orm.jbt.api.HbmExporterWrapper; -import org.hibernate.tool.orm.jbt.util.ConfigurationMetadataDescriptor; +import org.hibernate.tool.orm.jbt.api.wrp.ConfigurationWrapper; +import org.hibernate.tool.orm.jbt.api.wrp.HbmExporterWrapper; +import org.hibernate.tool.orm.jbt.internal.util.ConfigurationMetadataDescriptor; +import org.hibernate.tool.orm.jbt.internal.wrp.AbstractWrapper; public class HbmExporterWrapperFactory { - public static HbmExporterWrapper createHbmExporterWrapper(Configuration cfg, File f) { - final HbmExporterExtension wrappedHbmExporterExtension = new HbmExporterExtension(cfg, f); - return new HbmExporterWrapper() { - @Override public HbmExporter getWrappedObject() { return wrappedHbmExporterExtension; } - }; + public static HbmExporterWrapper createHbmExporterWrapper( + ConfigurationWrapper configurationWrapper, + File file) { + return createHbmExporterWrapper((Configuration)configurationWrapper.getWrappedObject(), file); } - public static class HbmExporterExtension extends HbmExporter { + private static HbmExporterWrapper createHbmExporterWrapper(Configuration cfg, File f) { + return new HbmExporterWrapperImpl(new HbmExporterExtension(cfg, f)) ; + } + + public static class HbmExporterExtension + extends HbmExporter { public Object delegateExporter = null; @@ -62,4 +69,48 @@ private void delegateExporterExportPOJO ( } } + private static class HbmExporterWrapperImpl + extends AbstractWrapper + implements HbmExporterWrapper { + + private HbmExporterExtension hbmExporterExtension; + + private HbmExporterWrapperImpl(HbmExporterExtension hbmExporterExtension) { + this.hbmExporterExtension = hbmExporterExtension; + } + + @Override + public HbmExporter getWrappedObject() { + return hbmExporterExtension; + } + + @Override + public void start() { + hbmExporterExtension.start(); + } + + @Override + public File getOutputDirectory() { + return (File)hbmExporterExtension.getProperties().get(ExporterConstants.DESTINATION_FOLDER); + } + + @Override + public void setOutputDirectory(File f) { + hbmExporterExtension.getProperties().put(ExporterConstants.DESTINATION_FOLDER, f); + } + + @Override + public void exportPOJO(Map map, Object pojoClass) { + hbmExporterExtension.exportPOJO(map, (POJOClass)pojoClass); + } + + @Override + public void setExportPOJODelegate(Object delegate) { + hbmExporterExtension.delegateExporter = delegate; + } + + + + } + } diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/HqlCodeAssistWrapperFactory.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/HqlCodeAssistWrapperFactory.java index 3e90f0a09c..b067195649 100644 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/HqlCodeAssistWrapperFactory.java +++ b/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/HqlCodeAssistWrapperFactory.java @@ -1,23 +1,47 @@ package org.hibernate.tool.orm.jbt.internal.factory; import org.hibernate.boot.Metadata; +import org.hibernate.cfg.Configuration; import org.hibernate.tool.ide.completion.HQLCodeAssist; -import org.hibernate.tool.orm.jbt.api.HqlCodeAssistWrapper; +import org.hibernate.tool.orm.jbt.api.wrp.ConfigurationWrapper; +import org.hibernate.tool.orm.jbt.api.wrp.HqlCodeAssistWrapper; +import org.hibernate.tool.orm.jbt.internal.util.HqlCompletionRequestor; +import org.hibernate.tool.orm.jbt.internal.util.MetadataHelper; +import org.hibernate.tool.orm.jbt.internal.wrp.AbstractWrapper; public class HqlCodeAssistWrapperFactory { - public static HqlCodeAssistWrapper createHqlCodeAssistWrapper(Metadata m) { - final HqlCodeAssistExtension wrappedHqlCodeAssistExtension = new HqlCodeAssistExtension(m); - return new HqlCodeAssistWrapper() { - @Override public HQLCodeAssist getWrappedObject() { return wrappedHqlCodeAssistExtension; } - }; + public static HqlCodeAssistWrapper createHqlCodeAssistWrapper(ConfigurationWrapper configurationWrapper) { + return createHqlCodeAssistWrapper( + MetadataHelper.getMetadata((Configuration)configurationWrapper.getWrappedObject())); } - public static class HqlCodeAssistExtension extends HQLCodeAssist { - public HqlCodeAssistExtension(Metadata m) { - super(m); + private static HqlCodeAssistWrapper createHqlCodeAssistWrapper(Metadata m) { + return new HqlCodeAssistWrapperImpl(m); + } + + private static class HqlCodeAssistWrapperImpl + extends AbstractWrapper + implements HqlCodeAssistWrapper { + + private HQLCodeAssist hqlCodeAssist = null; + + private HqlCodeAssistWrapperImpl(Metadata metadata) { + this.hqlCodeAssist = new HQLCodeAssist(metadata); + } + + @Override public HQLCodeAssist getWrappedObject() { + return hqlCodeAssist; } + @Override + public void codeComplete(String query, int position, Object handler) { + hqlCodeAssist.codeComplete( + query, + position, + new HqlCompletionRequestor(handler)); + } + } - + } diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/HqlCompletionProposalWrapperFactory.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/HqlCompletionProposalWrapperFactory.java index 8a74ee0022..a074885836 100644 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/HqlCompletionProposalWrapperFactory.java +++ b/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/HqlCompletionProposalWrapperFactory.java @@ -1,15 +1,69 @@ package org.hibernate.tool.orm.jbt.internal.factory; +import org.hibernate.mapping.Property; import org.hibernate.tool.ide.completion.HQLCompletionProposal; -import org.hibernate.tool.orm.jbt.api.HqlCompletionProposalWrapper; +import org.hibernate.tool.orm.jbt.api.wrp.HqlCompletionProposalWrapper; +import org.hibernate.tool.orm.jbt.internal.wrp.AbstractWrapper; public class HqlCompletionProposalWrapperFactory { public static HqlCompletionProposalWrapper createHqlCompletionProposalWrapper( - final HQLCompletionProposal wrappedCompletionProposal) { - return new HqlCompletionProposalWrapper() { - @Override public HQLCompletionProposal getWrappedObject() { return wrappedCompletionProposal; } - }; + final Object wrappedCompletionProposal) { + return new HqlCompletionProposalWrapperImpl((HQLCompletionProposal)wrappedCompletionProposal); + } + + private static class HqlCompletionProposalWrapperImpl + extends AbstractWrapper + implements HqlCompletionProposalWrapper { + + private HQLCompletionProposal hqlCompletionProposal = null; + + private HqlCompletionProposalWrapperImpl(HQLCompletionProposal hqlCompletionProposal) { + this.hqlCompletionProposal = hqlCompletionProposal; + } + + @Override + public HQLCompletionProposal getWrappedObject() { return hqlCompletionProposal; } + + @Override + public String getCompletion() { return hqlCompletionProposal.getCompletion(); } + + @Override + public int getReplaceStart() { return hqlCompletionProposal.getReplaceStart(); } + + @Override + public int getReplaceEnd() { return hqlCompletionProposal.getReplaceEnd(); } + + @Override + public String getSimpleName() { return hqlCompletionProposal.getSimpleName(); } + + @Override + public int getCompletionKind() { return hqlCompletionProposal.getCompletionKind(); } + + @Override + public String getEntityName() { return hqlCompletionProposal.getEntityName(); } + + @Override + public String getShortEntityName() { return hqlCompletionProposal.getShortEntityName(); } + + @Override + public Property getProperty() { return hqlCompletionProposal.getProperty(); } + + @Override + public int aliasRefKind() { return HQLCompletionProposal.ALIAS_REF; } + + @Override + public int entityNameKind() { return HQLCompletionProposal.ENTITY_NAME; } + + @Override + public int propertyKind() { return HQLCompletionProposal.PROPERTY; } + + @Override + public int keywordKind() { return HQLCompletionProposal.KEYWORD; } + + @Override + public int functionKind() { return HQLCompletionProposal.FUNCTION; } + } } diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/JoinWrapperFactory.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/JoinWrapperFactory.java index 58eee479a5..821c9a717e 100644 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/JoinWrapperFactory.java +++ b/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/JoinWrapperFactory.java @@ -1,14 +1,51 @@ package org.hibernate.tool.orm.jbt.internal.factory; +import java.util.Iterator; + import org.hibernate.mapping.Join; -import org.hibernate.tool.orm.jbt.api.JoinWrapper; +import org.hibernate.mapping.Property; +import org.hibernate.tool.orm.jbt.api.wrp.JoinWrapper; +import org.hibernate.tool.orm.jbt.api.wrp.PropertyWrapper; +import org.hibernate.tool.orm.jbt.internal.wrp.AbstractWrapper; public class JoinWrapperFactory { public static JoinWrapper createJoinWrapper(Join wrappedJoin) { - return new JoinWrapper() { - @Override public Join getWrappedObject() { return wrappedJoin; } - }; + return new JoinWrapperImpl(wrappedJoin); + } + + private static class JoinWrapperImpl + extends AbstractWrapper + implements JoinWrapper { + + private Join join = null; + + private JoinWrapperImpl(Join join) { + this.join = join; + } + + @Override + public Join getWrappedObject() { + return join; + } + + @Override + public Iterator getPropertyIterator() { + Iterator propertyIterator = join.getProperties().iterator(); + return new Iterator() { + @Override + public boolean hasNext() { + return propertyIterator.hasNext(); + } + + @Override + public PropertyWrapper next() { + return PropertyWrapperFactory.createPropertyWrapper(propertyIterator.next()); + } + + }; + } + } } diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/NamingStrategyWrapperFactory.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/NamingStrategyWrapperFactory.java index 765d4ab83f..6d7c2710fa 100644 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/NamingStrategyWrapperFactory.java +++ b/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/NamingStrategyWrapperFactory.java @@ -1,14 +1,84 @@ package org.hibernate.tool.orm.jbt.internal.factory; import org.hibernate.cfg.NamingStrategy; -import org.hibernate.tool.orm.jbt.api.NamingStrategyWrapper; +import org.hibernate.tool.orm.jbt.api.wrp.NamingStrategyWrapper; +import org.hibernate.tool.orm.jbt.internal.util.ReflectUtil; +import org.hibernate.tool.orm.jbt.internal.wrp.AbstractWrapper; public class NamingStrategyWrapperFactory { + + public static NamingStrategyWrapper createNamingStrategyWrapper(String className) { + return createNamingStrategyWrapper((NamingStrategy)ReflectUtil.createInstance(className)); + } + + static NamingStrategyWrapper createNamingStrategyWrapper(NamingStrategy wrappedNamingStrategy) { + return new NamingStrategyWrapperImpl(wrappedNamingStrategy); + } + + private static class NamingStrategyWrapperImpl + extends AbstractWrapper + implements NamingStrategyWrapper { + + private NamingStrategy namingStrategy = null; + + private NamingStrategyWrapperImpl(NamingStrategy namingStrategy) { + this.namingStrategy = namingStrategy; + } + + @Override + public NamingStrategy getWrappedObject() { + return namingStrategy; + } + + @Override + public String collectionTableName( + String ownerEntity, + String ownerEntityTable, + String associatedEntity, + String associatedEntityTable, + String propertyName) { + return ((NamingStrategy)getWrappedObject()).collectionTableName( + ownerEntity, + ownerEntityTable, + associatedEntity, + associatedEntityTable, + propertyName); + } + + @Override + public String columnName(String name) { + return ((NamingStrategy)getWrappedObject()).columnName(name); + } + + @Override + public String propertyToColumnName(String name) { + return ((NamingStrategy)getWrappedObject()).propertyToColumnName(name); + } + + @Override + public String tableName(String name) { + return ((NamingStrategy)getWrappedObject()).tableName(name); + } + + @Override + public String joinKeyColumnName( + String primaryKeyColumnName, + String primaryTableName) { + return ((NamingStrategy)getWrappedObject()).joinKeyColumnName( + primaryKeyColumnName, + primaryTableName); + } + + @Override + public String classToTableName(String name) { + return ((NamingStrategy)getWrappedObject()).classToTableName(name); + } + + @Override + public String getStrategyClassName() { + return getWrappedObject().getClass().getName(); + } - public static NamingStrategyWrapper createNamingStrategyWrapper(NamingStrategy wrappedNamingStrategy) { - return new NamingStrategyWrapper() { - @Override public NamingStrategy getWrappedObject() { return wrappedNamingStrategy; } - }; } } diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/OverrideRepositoryWrapperFactory.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/OverrideRepositoryWrapperFactory.java index 9d3dc32ba2..47f12ad37d 100644 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/OverrideRepositoryWrapperFactory.java +++ b/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/OverrideRepositoryWrapperFactory.java @@ -1,14 +1,56 @@ package org.hibernate.tool.orm.jbt.internal.factory; +import java.io.File; + +import org.hibernate.tool.api.reveng.RevengStrategy; import org.hibernate.tool.internal.reveng.strategy.OverrideRepository; -import org.hibernate.tool.orm.jbt.api.OverrideRepositoryWrapper; +import org.hibernate.tool.internal.reveng.strategy.TableFilter; +import org.hibernate.tool.orm.jbt.api.wrp.OverrideRepositoryWrapper; +import org.hibernate.tool.orm.jbt.api.wrp.RevengStrategyWrapper; +import org.hibernate.tool.orm.jbt.api.wrp.TableFilterWrapper; +import org.hibernate.tool.orm.jbt.internal.wrp.AbstractWrapper; public class OverrideRepositoryWrapperFactory { - public static OverrideRepositoryWrapper createOverrideRepositoryWrapper(OverrideRepository wrappedOverrideRepository) { - return new OverrideRepositoryWrapper() { - @Override public OverrideRepository getWrappedObject() { return wrappedOverrideRepository; } - }; + public static OverrideRepositoryWrapper createOverrideRepositoryWrapper() { + return createOverrideRepositoryWrapper(new OverrideRepository()); + } + + static OverrideRepositoryWrapper createOverrideRepositoryWrapper(OverrideRepository wrappedOverrideRepository) { + return new OverrideRepositoryWrapperImpl(wrappedOverrideRepository); } + private static class OverrideRepositoryWrapperImpl + extends AbstractWrapper + implements OverrideRepositoryWrapper { + + private OverrideRepository overrideRepository = null; + + private OverrideRepositoryWrapperImpl(OverrideRepository overrideRepository) { + this.overrideRepository = overrideRepository; + } + + @Override + public OverrideRepository getWrappedObject() { + return overrideRepository; + } + + @Override + public void addFile(File file) { + overrideRepository.addFile(file); + } + + @Override + public RevengStrategyWrapper getReverseEngineeringStrategy(RevengStrategyWrapper res) { + return RevengStrategyWrapperFactory.createRevengStrategyWrapper( + overrideRepository.getReverseEngineeringStrategy((RevengStrategy)res.getWrappedObject())); + } + + @Override + public void addTableFilter(TableFilterWrapper tf) { + overrideRepository.addTableFilter((TableFilter)tf.getWrappedObject()); + } + + } + } diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/PersistentClassWrapperFactory.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/PersistentClassWrapperFactory.java index d3bc693bb5..aeab01bbcb 100644 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/PersistentClassWrapperFactory.java +++ b/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/PersistentClassWrapperFactory.java @@ -1,183 +1,456 @@ package org.hibernate.tool.orm.jbt.internal.factory; -import java.lang.reflect.InvocationHandler; -import java.lang.reflect.InvocationTargetException; -import java.lang.reflect.Method; -import java.lang.reflect.Proxy; +import java.util.ArrayList; import java.util.Iterator; +import java.util.List; +import org.hibernate.mapping.Join; import org.hibernate.mapping.JoinedSubclass; import org.hibernate.mapping.KeyValue; import org.hibernate.mapping.PersistentClass; import org.hibernate.mapping.Property; import org.hibernate.mapping.RootClass; import org.hibernate.mapping.SingleTableSubclass; +import org.hibernate.mapping.Subclass; +import org.hibernate.mapping.Table; import org.hibernate.mapping.Value; -import org.hibernate.tool.orm.jbt.api.PersistentClassWrapper; -import org.hibernate.tool.orm.jbt.util.DummyMetadataBuildingContext; -import org.hibernate.tool.orm.jbt.util.SpecialRootClass; -import org.hibernate.tool.orm.jbt.wrp.PropertyWrapperFactory; -import org.hibernate.tool.orm.jbt.wrp.PropertyWrapperFactory.PropertyWrapper; -import org.hibernate.tool.orm.jbt.wrp.ValueWrapperFactory; -import org.hibernate.tool.orm.jbt.wrp.Wrapper; +import org.hibernate.tool.orm.jbt.api.wrp.JoinWrapper; +import org.hibernate.tool.orm.jbt.api.wrp.PersistentClassWrapper; +import org.hibernate.tool.orm.jbt.api.wrp.PropertyWrapper; +import org.hibernate.tool.orm.jbt.api.wrp.TableWrapper; +import org.hibernate.tool.orm.jbt.api.wrp.ValueWrapper; +import org.hibernate.tool.orm.jbt.internal.util.DummyMetadataBuildingContext; +import org.hibernate.tool.orm.jbt.internal.util.SpecialRootClass; +import org.hibernate.tool.orm.jbt.internal.wrp.AbstractWrapper; public class PersistentClassWrapperFactory { public static PersistentClassWrapper createRootClassWrapper() { - return new RootClassWrapperImpl(); + return createPersistentClassWrapper(new RootClass(DummyMetadataBuildingContext.INSTANCE)); } - public static PersistentClassWrapper createSingleTableSubclassWrapper(PersistentClassWrapper superClassWrapper) { - return new SingleTableSubclassWrapperImpl(superClassWrapper.getWrappedObject()); + public static Object createSingleTableSubClassWrapper(PersistentClassWrapper persistentClassWrapper) { + PersistentClass pc = (PersistentClass)persistentClassWrapper.getWrappedObject(); + SingleTableSubclass sts = new SingleTableSubclass(pc, DummyMetadataBuildingContext.INSTANCE); + return createPersistentClassWrapper(sts); } - - public static PersistentClassWrapper createJoinedSubclassWrapper(PersistentClassWrapper superClassWrapper) { - return new JoinedSubclassWrapperImpl(superClassWrapper.getWrappedObject()); + + public static Object createJoinedTableSubClassWrapper(PersistentClassWrapper persistentClassWrapper) { + PersistentClass pc = (PersistentClass)persistentClassWrapper.getWrappedObject(); + JoinedSubclass js = new JoinedSubclass(pc, DummyMetadataBuildingContext.INSTANCE); + return createPersistentClassWrapper(js); } - - public static PersistentClassWrapper createSpecialRootClassWrapper(PropertyWrapper property) { - return new SpecialRootClassWrapperImpl(property.getWrappedObject()); + + public static Object createSpecialRootClassWrapper(PropertyWrapper propertyWrapper) { + Property p = (Property)propertyWrapper.getWrappedObject(); + SpecialRootClass src = new SpecialRootClass(p); + return createPersistentClassWrapper(src); } - - public static PersistentClassWrapper createPersistentClassWrapper(PersistentClassWrapper persistentClassWrapper) { - return (PersistentClassWrapper)Proxy.newProxyInstance( - PersistentClassWrapperFactory.class.getClassLoader(), - new Class[] { PersistentClassWrapper.class }, - new PersistentClassWrapperInvocationHandler( - persistentClassWrapper)); + + public static PersistentClassWrapper createPersistentClassWrapper(PersistentClass wrappedPersistentClass) { + return new PersistentClassWrapperImpl(wrappedPersistentClass); } - static class PersistentClassWrapperInvocationHandler implements InvocationHandler { + private static class PersistentClassWrapperImpl + extends AbstractWrapper + implements PersistentClassWrapper { - private PersistentClassWrapper wrapper = null; - - public PersistentClassWrapperInvocationHandler(PersistentClassWrapper wrapper) { - this.wrapper = wrapper; + private PersistentClass persistentClass = null; + + private PersistentClassWrapperImpl(PersistentClass persistentClass) { + this.persistentClass = persistentClass; } @Override - public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { - try { - return method.invoke(wrapper, args); - } catch (InvocationTargetException t) { - throw t.getTargetException(); + public PersistentClass getWrappedObject() { + return persistentClass; + } + + @Override + public boolean isAssignableToRootClass() { + return isInstanceOfRootClass(); + } + + @Override + public boolean isRootClass() { + return persistentClass.getClass() == RootClass.class; + } + + @Override + public boolean isInstanceOfRootClass() { + return RootClass.class.isAssignableFrom(persistentClass.getClass()); + } + + @Override + public boolean isInstanceOfSubclass() { + return Subclass.class.isAssignableFrom(persistentClass.getClass()); + } + + @Override + public boolean isInstanceOfJoinedSubclass() { + return JoinedSubclass.class.isAssignableFrom(persistentClass.getClass()); + } + + @Override + public PropertyWrapper getProperty() { + if (!isInstanceOfSpecialRootClass()) { + throw new RuntimeException("getProperty() is only allowed on SpecialRootClass"); + } else { + Property p = ((SpecialRootClass)persistentClass).getProperty(); + return p == null ? null : PropertyWrapperFactory.createPropertyWrapper(p); } - } - - } - - public static class RootClassWrapperImpl extends RootClass implements PersistentClassWrapper { - public RootClassWrapperImpl() { - super(DummyMetadataBuildingContext.INSTANCE); } + @Override - public Value getDiscriminator() { - return wrapValueIfNeeded(super.getDiscriminator()); + public void setTable(TableWrapper tableWrapper) { + Table table = tableWrapper == null ? null : (Table)tableWrapper.getWrappedObject(); + if (isInstanceOfRootClass()) { + ((RootClass)persistentClass).setTable(table); + } else if (isInstanceOfJoinedSubclass()) { + ((JoinedSubclass)persistentClass).setTable(table); + } else if (isInstanceOfSpecialRootClass()) { + ((SpecialRootClass)persistentClass).setTable(table); + } else { + throw new RuntimeException("Method 'setTable(Table)' is not supported."); + } } + @Override - public KeyValue getIdentifier() { - return (KeyValue)wrapValueIfNeeded(super.getIdentifier()); + public void setIdentifier(ValueWrapper value) { + if (!isInstanceOfRootClass()) { + throw new RuntimeException("Method 'setIdentifier(Value)' can only be called on RootClass instances"); + } else { + } + ((RootClass)persistentClass).setIdentifier(value == null ? null : (KeyValue)value.getWrappedObject()); } + @Override - public void setIdentifier(Value v) { - if (v instanceof Wrapper) { - v = (Value)((Wrapper)v).getWrappedObject(); - } - super.setIdentifier(((KeyValue)v)); + public void setKey(ValueWrapper value) { + if (!isInstanceOfJoinedSubclass()) { + throw new RuntimeException("setKey(Value) is only allowed on JoinedSubclass"); + } + ((JoinedSubclass)persistentClass).setKey(value == null ? null : (KeyValue)value.getWrappedObject()); } - } - - public static class SingleTableSubclassWrapperImpl - extends SingleTableSubclass - implements PersistentClassWrapper { - public SingleTableSubclassWrapperImpl(PersistentClass superclass) { - super(superclass, DummyMetadataBuildingContext.INSTANCE); + + @Override + public boolean isInstanceOfSpecialRootClass() { + return SpecialRootClass.class.isAssignableFrom(persistentClass.getClass()); } - } - - public static class JoinedSubclassWrapperImpl - extends JoinedSubclass - implements PersistentClassWrapper { - public JoinedSubclassWrapperImpl(PersistentClass superclass) { - super(superclass, DummyMetadataBuildingContext.INSTANCE); + + @Override + public PropertyWrapper getParentProperty() { + if (!isInstanceOfSpecialRootClass()) { + throw new RuntimeException("getParentProperty() is only allowed on SpecialRootClass"); + } else { + Property p = ((SpecialRootClass)persistentClass).getParentProperty(); + return p == null ? null : PropertyWrapperFactory.createPropertyWrapper(p); + } } + @Override - public void setKey(Value v) { - if (v instanceof Wrapper) { - v = (Value)((Wrapper)v).getWrappedObject(); - } - super.setKey(((KeyValue)v)); + public void setIdentifierProperty(PropertyWrapper p) { + if (!isInstanceOfRootClass()) { + throw new RuntimeException("setIdentifierProperty(Property) is only allowed on RootClass instances"); + } + ((RootClass)persistentClass).setIdentifierProperty(p == null ? null : (Property)p.getWrappedObject()); } - } - - public static class SpecialRootClassWrapperImpl - extends SpecialRootClass - implements PersistentClassWrapper { - public SpecialRootClassWrapperImpl(Property property) { - super(property); + + @Override + public void setDiscriminator(ValueWrapper value) { + if (!isInstanceOfRootClass()) { + throw new RuntimeException("Method 'setDiscriminator(Value)' can only be called on RootClass instances"); + } + ((RootClass)persistentClass).setDiscriminator(value == null ? null : (Value)value.getWrappedObject()); + } + + @Override + public boolean isLazyPropertiesCacheable() { + if (!isInstanceOfRootClass()) { + throw new RuntimeException("Method 'isLazyPropertiesCacheable()' can only be called on RootClass instances"); + } + return ((RootClass)persistentClass).isLazyPropertiesCacheable(); + } + + @Override + public Iterator getPropertyIterator() { + return getProperties().iterator(); + } + + @Override + public Iterator getJoinIterator() { + return getJoins().iterator(); } + @Override - public Value getDiscriminator() { - return wrapValueIfNeeded(super.getDiscriminator()); + public Iterator getSubclassIterator() { + return getSubclasses().iterator(); } + @Override - public KeyValue getIdentifier() { - return (KeyValue)wrapValueIfNeeded(super.getIdentifier()); + public Iterator getPropertyClosureIterator() { + return getPropertyClosure().iterator(); } + @Override - public void setIdentifier(Value v) { - if (v instanceof Wrapper) { - v = (Value)((Wrapper)v).getWrappedObject(); - } - super.setIdentifier(((KeyValue)v)); + public String getEntityName() { + return persistentClass.getEntityName(); } + @Override - public Property getProperty() { - return wrapPropertyIfNeeded(super.getProperty()); + public String getClassName() { + return persistentClass.getClassName(); } + @Override - public Property getParentProperty() { - return wrapPropertyIfNeeded(super.getParentProperty()); + public PropertyWrapper getIdentifierProperty() { + Property p = persistentClass.getIdentifierProperty(); + return p == null ? null : PropertyWrapperFactory.createPropertyWrapper(p); } - @Override - public Iterator getPropertyIterator() { - final Iterator iterator = getProperties().iterator(); - return new Iterator() { - @Override - public boolean hasNext() { - return iterator.hasNext(); - } - @Override - public Property next() { - return wrapPropertyIfNeeded(iterator.next()); - } - - }; + + @Override + public boolean hasIdentifierProperty() { + return persistentClass.hasIdentifierProperty(); } - @Override - public Iterator getPropertyClosureIterator() { - final Iterator iterator = getPropertyClosure().iterator(); - return new Iterator() { - @Override - public boolean hasNext() { - return iterator.hasNext(); - } - @Override - public Property next() { - return wrapPropertyIfNeeded(iterator.next()); - } - - }; + + @Override + public PersistentClassWrapper getRootClass() { + PersistentClass pc = persistentClass.getRootClass(); + return pc == null ? null : PersistentClassWrapperFactory.createPersistentClassWrapper(pc); } - } - - private static Value wrapValueIfNeeded(Value v) { - return (v != null) && !(v instanceof Wrapper) ? ValueWrapperFactory.createValueWrapper(v) : v; - } - - private static Property wrapPropertyIfNeeded(Property p) { - return (p != null) && !(p instanceof Wrapper) ? PropertyWrapperFactory.createPropertyWrapper(p) : p; + @Override + public PersistentClassWrapper getSuperclass() { + PersistentClass pc = persistentClass.getSuperclass(); + return pc == null ? null : PersistentClassWrapperFactory.createPersistentClassWrapper(pc); + } + + @Override + public PropertyWrapper getProperty(String name) { + Property p = persistentClass.getProperty(name); + return p == null ? null : PropertyWrapperFactory.createPropertyWrapper(p); + } + + @Override + public TableWrapper getTable() { + Table t = persistentClass.getTable(); + return t == null ? null : TableWrapperFactory.createTableWrapper(t); + } + + @Override + public Boolean isAbstract() { + return persistentClass.isAbstract(); + } + + @Override + public ValueWrapper getDiscriminator() { + Value v = persistentClass.getDiscriminator(); + return v == null ? null : ValueWrapperFactory.createValueWrapper(v); + } + + @Override + public ValueWrapper getIdentifier() { + Value v = persistentClass.getIdentifier(); + return v == null ? null : ValueWrapperFactory.createValueWrapper(v); + } + + @Override + public PropertyWrapper getVersion() { + Property p = persistentClass.getVersion(); + return p == null ? null : PropertyWrapperFactory.createPropertyWrapper(p); + } + + @Override + public void setClassName(String name) { + persistentClass.setClassName(name); + } + + @Override + public void setEntityName(String name) { + persistentClass.setEntityName(name); + } + + @Override + public void setDiscriminatorValue(String str) { + persistentClass.setDiscriminatorValue(str); + } + + @Override + public void setAbstract(Boolean b) { + persistentClass.setAbstract(b); + } + + @Override + public void addProperty(PropertyWrapper p) { + persistentClass.addProperty((Property)p.getWrappedObject()); + } + + @Override + public void setProxyInterfaceName(String name) { + persistentClass.setProxyInterfaceName(name); + } + + @Override + public void setLazy(boolean b) { + persistentClass.setLazy(b); + } + + @Override + public boolean isCustomDeleteCallable() { + return persistentClass.isCustomDeleteCallable(); + } + + @Override + public boolean isCustomInsertCallable() { + return persistentClass.isCustomInsertCallable(); + } + + @Override + public boolean isCustomUpdateCallable() { + return persistentClass.isCustomUpdateCallable(); + } + + @Override + public boolean isDiscriminatorInsertable() { + return persistentClass.isDiscriminatorInsertable(); + } + + @Override + public boolean isDiscriminatorValueNotNull() { + return persistentClass.isDiscriminatorValueNotNull(); + } + + @Override + public boolean isDiscriminatorValueNull() { + return persistentClass.isDiscriminatorValueNull(); + } + + @Override + public boolean isExplicitPolymorphism() { + return persistentClass.isExplicitPolymorphism(); + } + + @Override + public boolean isForceDiscriminator() { + return persistentClass.isForceDiscriminator(); + } + + @Override + public boolean isInherited() { + return persistentClass.isInherited(); + } + + @Override + public boolean isJoinedSubclass() { + return persistentClass.isJoinedSubclass(); + } + + @Override + public boolean isLazy() { + return persistentClass.isLazy(); + } + + @Override + public boolean isMutable() { + return persistentClass.isMutable(); + } + + @Override + public boolean isPolymorphic() { + return persistentClass.isPolymorphic(); + } + + @Override + public boolean isVersioned() { + return persistentClass.isVersioned(); + } + + @Override + public int getBatchSize() { + return persistentClass.getBatchSize(); + } + + @Override + public String getCacheConcurrencyStrategy() { + return persistentClass.getCacheConcurrencyStrategy(); + } + + @Override + public String getCustomSQLDelete() { + return persistentClass.getCustomSQLDelete(); + } + + @Override + public String getCustomSQLInsert() { + return persistentClass.getCustomSQLInsert(); + } + + @Override + public String getCustomSQLUpdate() { + return persistentClass.getCustomSQLUpdate(); + } + + @Override + public String getDiscriminatorValue() { + return persistentClass.getDiscriminatorValue(); + } + + @Override + public String getLoaderName() { + return persistentClass.getLoaderName(); + } + + @Override + public int getOptimisticLockMode() { + return persistentClass.getOptimisticLockMode(); + } + + @Override + public String getWhere() { + return persistentClass.getWhere(); + } + + @Override + public TableWrapper getRootTable() { + Table t = persistentClass.getRootTable(); + return t == null ? null : TableWrapperFactory.createTableWrapper(t); + } + + @Override + public List getProperties() { + List result = new ArrayList(); + for (Property p : persistentClass.getProperties()) { + result.add(PropertyWrapperFactory.createPropertyWrapper(p)); + } + return result; + } + + @Override + public List getJoins() { + List result = new ArrayList(); + for (Join j : persistentClass.getJoins()) { + result.add(JoinWrapperFactory.createJoinWrapper(j)); + } + return result; + } + + @Override + public List getSubclasses() { + List result = new ArrayList(); + for (Subclass s : persistentClass.getSubclasses()) { + result.add(PersistentClassWrapperFactory.createPersistentClassWrapper(s)); + } + return result; + } + + @Override + public List getPropertyClosure() { + List result = new ArrayList(); + for (Property p : persistentClass.getPropertyClosure()) { + result.add(PropertyWrapperFactory.createPropertyWrapper(p)); + } + return result; + } + } } diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/PrimaryKeyWrapperFactory.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/PrimaryKeyWrapperFactory.java index f9d64d2ef3..9548100b5e 100644 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/PrimaryKeyWrapperFactory.java +++ b/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/PrimaryKeyWrapperFactory.java @@ -1,14 +1,83 @@ package org.hibernate.tool.orm.jbt.internal.factory; +import java.util.ArrayList; +import java.util.Iterator; +import java.util.List; + +import org.hibernate.mapping.Column; import org.hibernate.mapping.PrimaryKey; -import org.hibernate.tool.orm.jbt.api.PrimaryKeyWrapper; +import org.hibernate.mapping.Table; +import org.hibernate.tool.orm.jbt.api.wrp.ColumnWrapper; +import org.hibernate.tool.orm.jbt.api.wrp.PrimaryKeyWrapper; +import org.hibernate.tool.orm.jbt.api.wrp.TableWrapper; +import org.hibernate.tool.orm.jbt.internal.wrp.AbstractWrapper; public class PrimaryKeyWrapperFactory { public static PrimaryKeyWrapper createPrimaryKeyWrapper(PrimaryKey wrappedPrimaryKey) { - return new PrimaryKeyWrapper() { - @Override public PrimaryKey getWrappedObject() { return wrappedPrimaryKey; } - }; + return new PrimaryKeyWrapperImpl(wrappedPrimaryKey); + } + + private static class PrimaryKeyWrapperImpl + extends AbstractWrapper + implements PrimaryKeyWrapper { + + private PrimaryKey primaryKey = null; + + private PrimaryKeyWrapperImpl(PrimaryKey primaryKey) { + this.primaryKey = primaryKey; + } + + @Override + public PrimaryKey getWrappedObject() { + return primaryKey; + } + + @Override + public void addColumn(ColumnWrapper column) { + primaryKey.addColumn((Column)column.getWrappedObject()); + } + + @Override + public int getColumnSpan() { + return primaryKey.getColumnSpan(); + } + + @Override + public List getColumns() { + List result = new ArrayList(); + for (Column c : primaryKey.getColumns()) { + result.add(ColumnWrapperFactory.createColumnWrapper(c)); + } + return result; + } + + @Override + public ColumnWrapper getColumn(int i) { + return ColumnWrapperFactory.createColumnWrapper(primaryKey.getColumn(i)); + } + + @Override + public TableWrapper getTable() { + Table t = primaryKey.getTable(); + return t == null ? null : TableWrapperFactory.createTableWrapper(t); + } + + @Override + public boolean containsColumn(ColumnWrapper column) { + return primaryKey.containsColumn((Column)column.getWrappedObject()); + } + + @Override + public Iterator columnIterator() { + return getColumns().iterator(); + } + + @Override + public String getName() { + return primaryKey.getName(); + } + } } diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/PropertyWrapperFactory.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/PropertyWrapperFactory.java index 870841e8f4..5e260e6247 100644 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/PropertyWrapperFactory.java +++ b/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/PropertyWrapperFactory.java @@ -1,14 +1,148 @@ package org.hibernate.tool.orm.jbt.internal.factory; +import org.hibernate.mapping.PersistentClass; import org.hibernate.mapping.Property; -import org.hibernate.tool.orm.jbt.api.PropertyWrapper; +import org.hibernate.mapping.Value; +import org.hibernate.tool.orm.jbt.api.wrp.PersistentClassWrapper; +import org.hibernate.tool.orm.jbt.api.wrp.PropertyWrapper; +import org.hibernate.tool.orm.jbt.api.wrp.TypeWrapper; +import org.hibernate.tool.orm.jbt.api.wrp.ValueWrapper; +import org.hibernate.tool.orm.jbt.internal.wrp.AbstractWrapper; +import org.hibernate.type.Type; public class PropertyWrapperFactory { - public static PropertyWrapper createPropertyWrapper(Property wrappedProperty) { - return new PropertyWrapper() { - @Override public Property getWrappedObject() { return wrappedProperty; } - }; + public static PropertyWrapper createPropertyWrapper() { + return createPropertyWrapper(new Property()); } + static PropertyWrapper createPropertyWrapper(Property wrappedProperty) { + return new PropertyWrapperImpl(wrappedProperty); + } + + private static class PropertyWrapperImpl + extends AbstractWrapper + implements PropertyWrapper { + + private Property property = null; + + private PropertyWrapperImpl(Property property) { + this.property = property; + } + + @Override + public Property getWrappedObject() { + return property; + } + + @Override + public ValueWrapper getValue() { + Value v = property.getValue(); + return v == null ? null : ValueWrapperFactory.createValueWrapper(v); + } + + @Override + public void setName(String name) { + property.setName(name); + } + + @Override + public void setPersistentClass(PersistentClassWrapper pc) { + property.setPersistentClass(pc == null ? null : (PersistentClass)pc.getWrappedObject()); + } + + @Override + public PersistentClassWrapper getPersistentClass() { + PersistentClass pc = property.getPersistentClass(); + return pc == null ? null : PersistentClassWrapperFactory.createPersistentClassWrapper(pc); + } + + @Override + public boolean isComposite() { + return property.isComposite(); + } + + @Override + public String getPropertyAccessorName() { + return property.getPropertyAccessorName(); + } + + @Override + public String getName() { + return property.getName(); + } + + @Override + public TypeWrapper getType() { + Type t = null; + Value v = ((Property)getWrappedObject()).getValue(); + if (v != null) { + t = v.getType(); + } + return t == null ? null : TypeWrapperFactory.createTypeWrapper(t); + } + + @Override + public void setValue(ValueWrapper value) { + property.setValue(value == null ? null : (Value)value.getWrappedObject()); + } + + @Override + public void setPropertyAccessorName(String s) { + property.setPropertyAccessorName(s); + } + + @Override + public void setCascade(String s) { + property.setCascade(s); + } + + @Override + public boolean isBackRef() { + return property.isBackRef(); + } + + @Override + public boolean isSelectable() { + return property.isSelectable(); + } + + @Override + public boolean isInsertable() { + return property.isInsertable(); + } + + @Override + public boolean isUpdateable() { + return property.isUpdateable(); + } + + @Override + public String getCascade() { + return property.getCascade(); + } + + @Override + public boolean isLazy() { + return property.isLazy(); + } + + @Override + public boolean isOptional() { + return property.isOptional(); + } + + @Override + public boolean isNaturalIdentifier() { + return property.isNaturalIdentifier(); + } + + @Override + public boolean isOptimisticLocked() { + return property.isOptimisticLocked(); + } + + + } + } diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/QueryExporterWrapperFactory.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/QueryExporterWrapperFactory.java index 5b4b6b1c7c..6b6d9731af 100644 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/QueryExporterWrapperFactory.java +++ b/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/QueryExporterWrapperFactory.java @@ -1,14 +1,43 @@ package org.hibernate.tool.orm.jbt.internal.factory; +import java.util.List; + +import org.hibernate.tool.api.export.ExporterConstants; import org.hibernate.tool.internal.export.query.QueryExporter; -import org.hibernate.tool.orm.jbt.api.QueryExporterWrapper; +import org.hibernate.tool.orm.jbt.api.wrp.QueryExporterWrapper; +import org.hibernate.tool.orm.jbt.internal.wrp.AbstractWrapper; public class QueryExporterWrapperFactory { public static QueryExporterWrapper createQueryExporterWrapper(QueryExporter wrappedQueryExporter) { - return new QueryExporterWrapper() { - @Override public QueryExporter getWrappedObject() { return wrappedQueryExporter; } - }; + return new QueryExporterWrapperImpl(wrappedQueryExporter); + } + + private static class QueryExporterWrapperImpl + extends AbstractWrapper + implements QueryExporterWrapper { + + private QueryExporter queryExporter = null; + + private QueryExporterWrapperImpl(QueryExporter queryExporter) { + this.queryExporter = queryExporter; + } + + @Override + public QueryExporter getWrappedObject() { + return queryExporter; + } + + @Override + public void setQueries(List queries) { + queryExporter.setQueries(queries); + } + + @Override + public void setFilename(String fileName) { + queryExporter.getProperties().put(ExporterConstants.OUTPUT_FILE_NAME, fileName); + } + } } diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/QueryWrapperFactory.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/QueryWrapperFactory.java index 63b394c25e..391d6cbe6a 100644 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/QueryWrapperFactory.java +++ b/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/QueryWrapperFactory.java @@ -1,14 +1,68 @@ package org.hibernate.tool.orm.jbt.internal.factory; +import java.util.List; + import org.hibernate.query.Query; -import org.hibernate.tool.orm.jbt.api.QueryWrapper; +import org.hibernate.tool.orm.jbt.api.wrp.QueryWrapper; +import org.hibernate.tool.orm.jbt.api.wrp.TypeWrapper; +import org.hibernate.tool.orm.jbt.internal.wrp.AbstractWrapper; public class QueryWrapperFactory { public static QueryWrapper createQueryWrapper(Query wrappedQuery) { - return new QueryWrapper() { - @Override public Query getWrappedObject() { return wrappedQuery; } - }; + return new QueryWrapperImpl(wrappedQuery); + } + + private static class QueryWrapperImpl + extends AbstractWrapper + implements QueryWrapper { + + private Query query = null; + + private QueryWrapperImpl(Query query) { + this.query = query; + } + + @Override + public Query getWrappedObject() { + return query; + } + + @Override + public List list() { + return query.list(); + } + + @Override + public void setMaxResults(int i) { + query.setMaxResults(i); + } + + @Override + public void setParameterList(String parameter, List list, Object anything) { + query.setParameterList(parameter, list); + } + + @Override + public void setParameter(String parameter, Object value, Object anything) { + query.setParameter(parameter, value); + } + + @Override + public void setParameter(int position, Object value, Object anything) { + query.setParameter(position, value); + } + + @Override + public String[] getReturnAliases() { + return new String[0]; + } + + @Override + public TypeWrapper[] getReturnTypes() { + return new TypeWrapper[0]; + } + } } diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/RevengSettingsWrapperFactory.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/RevengSettingsWrapperFactory.java index 334c3ed059..feff6b1186 100644 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/RevengSettingsWrapperFactory.java +++ b/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/RevengSettingsWrapperFactory.java @@ -1,14 +1,64 @@ package org.hibernate.tool.orm.jbt.internal.factory; import org.hibernate.tool.api.reveng.RevengSettings; -import org.hibernate.tool.orm.jbt.api.RevengSettingsWrapper; +import org.hibernate.tool.api.reveng.RevengStrategy; +import org.hibernate.tool.orm.jbt.api.wrp.RevengSettingsWrapper; +import org.hibernate.tool.orm.jbt.api.wrp.RevengStrategyWrapper; +import org.hibernate.tool.orm.jbt.internal.wrp.AbstractWrapper; public class RevengSettingsWrapperFactory { + + public static RevengSettingsWrapper createRevengSettingsWrapper(RevengStrategyWrapper revengStrategyWrapper) { + RevengStrategy revengStrategy = + revengStrategyWrapper == null ? + null : (RevengStrategy)revengStrategyWrapper.getWrappedObject(); + RevengSettings wrappedRevengSettings = new RevengSettings(revengStrategy); + return createRevengSettingsWrapper(wrappedRevengSettings); + } + + static RevengSettingsWrapper createRevengSettingsWrapper(RevengSettings wrappedRevengSettings) { + return new RevengSettingsWrapperImpl(wrappedRevengSettings); + } + + private static class RevengSettingsWrapperImpl + extends AbstractWrapper + implements RevengSettingsWrapper { + + private RevengSettings revengSettings = null; + + private RevengSettingsWrapperImpl(RevengSettings revengSettings) { + this.revengSettings = revengSettings; + } + + @Override + public RevengSettings getWrappedObject() { + return revengSettings; + } + + @Override + public RevengSettingsWrapper setDefaultPackageName(String s) { + revengSettings.setDefaultPackageName(s); + return this; + } + + @Override + public RevengSettingsWrapper setDetectManyToMany(boolean b) { + revengSettings.setDetectManyToMany(b); + return this; + } + + @Override + public RevengSettingsWrapper setDetectOneToOne(boolean b) { + revengSettings.setDetectOneToOne(b); + return this; + } + + @Override + public RevengSettingsWrapper setDetectOptimisticLock(boolean b) { + revengSettings.setDetectOptimisticLock(b); + return this; + } - public static RevengSettingsWrapper createRevengSettingsWrapper(RevengSettings wrappedRevengSettings) { - return new RevengSettingsWrapper() { - @Override public RevengSettings getWrappedObject() { return wrappedRevengSettings; } - }; } } diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/RevengStrategyWrapperFactory.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/RevengStrategyWrapperFactory.java index 9a6870dacf..841feaadc1 100644 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/RevengStrategyWrapperFactory.java +++ b/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/RevengStrategyWrapperFactory.java @@ -1,14 +1,78 @@ package org.hibernate.tool.orm.jbt.internal.factory; +import java.lang.reflect.Constructor; + +import org.hibernate.tool.api.reveng.RevengSettings; import org.hibernate.tool.api.reveng.RevengStrategy; -import org.hibernate.tool.orm.jbt.api.RevengStrategyWrapper; +import org.hibernate.tool.internal.reveng.strategy.DefaultStrategy; +import org.hibernate.tool.orm.jbt.api.wrp.RevengSettingsWrapper; +import org.hibernate.tool.orm.jbt.api.wrp.RevengStrategyWrapper; +import org.hibernate.tool.orm.jbt.api.wrp.Wrapper; +import org.hibernate.tool.orm.jbt.internal.util.ReflectUtil; +import org.hibernate.tool.orm.jbt.internal.wrp.AbstractWrapper; public class RevengStrategyWrapperFactory { - public static RevengStrategyWrapper createRevengStrategyWrapper(RevengStrategy wrappedRevengStrategy) { - return new RevengStrategyWrapper() { - @Override public RevengStrategy getWrappedObject() { return wrappedRevengStrategy; } - }; + public static RevengStrategyWrapper createRevengStrategyWrapper(Object...objects) { + RevengStrategy wrappedRevengStrategy = null; + if (objects.length == 0) { + wrappedRevengStrategy = createDefaultStrategy(); + } else if (objects.length == 2) { + wrappedRevengStrategy = createDelegatingStrategy((String)objects[0], (RevengStrategy)((Wrapper)objects[1]).getWrappedObject()); + } else { + throw new RuntimeException("RevengStrategyWrapperFactory#create has either 0 or 2 arguments"); + } + return createRevengStrategyWrapper(wrappedRevengStrategy); + } + + private static RevengStrategy createDefaultStrategy() { + return new DefaultStrategy(); + } + + private static RevengStrategy createDelegatingStrategy(String strategyClassName, RevengStrategy delegate) { + Class revengStrategyClass = ReflectUtil.lookupClass(strategyClassName); + Constructor constructor = null; + for (Constructor c : revengStrategyClass.getConstructors()) { + if (c.getParameterCount() == 1 && + c.getParameterTypes()[0].isAssignableFrom(RevengStrategy.class)) { + constructor = c; + break; + } + } + if (constructor != null) { + return (RevengStrategy)ReflectUtil.createInstance( + strategyClassName, + new Class[] { RevengStrategy.class }, + new Object[] { delegate }); + } else { + return (RevengStrategy)ReflectUtil.createInstance(strategyClassName); + } + } + + static RevengStrategyWrapper createRevengStrategyWrapper(RevengStrategy wrappedRevengStrategy) { + return new RevengStrategyWrapperImpl(wrappedRevengStrategy); + } + + private static class RevengStrategyWrapperImpl + extends AbstractWrapper + implements RevengStrategyWrapper { + + private RevengStrategy revengStrategy = null; + + private RevengStrategyWrapperImpl(RevengStrategy revengStrategy) { + this.revengStrategy = revengStrategy; + } + + @Override + public RevengStrategy getWrappedObject() { + return revengStrategy; + } + + @Override + public void setSettings(RevengSettingsWrapper revengSettings) { + revengStrategy.setSettings((RevengSettings)revengSettings.getWrappedObject()); + } + } } diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/SchemaExportWrapperFactory.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/SchemaExportWrapperFactory.java index 337ada218d..6f72ec55cb 100644 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/SchemaExportWrapperFactory.java +++ b/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/SchemaExportWrapperFactory.java @@ -1,18 +1,61 @@ package org.hibernate.tool.orm.jbt.internal.factory; +import java.util.EnumSet; +import java.util.List; + import org.hibernate.cfg.Configuration; import org.hibernate.tool.hbm2ddl.SchemaExport; -import org.hibernate.tool.orm.jbt.api.SchemaExportWrapper; +import org.hibernate.tool.orm.jbt.api.wrp.ConfigurationWrapper; +import org.hibernate.tool.orm.jbt.api.wrp.SchemaExportWrapper; +import org.hibernate.tool.orm.jbt.internal.util.MetadataHelper; +import org.hibernate.tool.orm.jbt.internal.wrp.AbstractWrapper; +import org.hibernate.tool.schema.TargetType; public class SchemaExportWrapperFactory { + + public static SchemaExportWrapper createSchemaExportWrapper(ConfigurationWrapper configurationWrapper) { + SchemaExport schemaExport = new SchemaExport(); + return createSchemaExportWrapper( + schemaExport, + (Configuration)configurationWrapper.getWrappedObject()); + } - public static SchemaExportWrapper createSchemaExportWrapper( + private static SchemaExportWrapper createSchemaExportWrapper( SchemaExport wrappedSchemaExport, Configuration configuration) { - return new SchemaExportWrapper() { - @Override public SchemaExport getWrappedObject() { return wrappedSchemaExport; } - @Override public Configuration getConfiguration() { return configuration; } - }; + return new SchemaExportWrapperImpl(wrappedSchemaExport, configuration); + } + + private static class SchemaExportWrapperImpl + extends AbstractWrapper + implements SchemaExportWrapper { + + private Configuration configuration = null; + private SchemaExport schemaExport = null; + + private SchemaExportWrapperImpl(SchemaExport se, Configuration c) { + this.configuration = c; + this.schemaExport = se; + } + + @Override + public SchemaExport getWrappedObject() { + return schemaExport; + } + + @Override + public void create() { + schemaExport.create(EnumSet.of( + TargetType.DATABASE), + MetadataHelper.getMetadata(configuration)); + } + + @SuppressWarnings("unchecked") + @Override + public List getExceptions() { + return schemaExport.getExceptions(); + } + } } diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/SessionFactoryWrapperFactory.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/SessionFactoryWrapperFactory.java index 2a1e29416f..aa280358cf 100644 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/SessionFactoryWrapperFactory.java +++ b/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/SessionFactoryWrapperFactory.java @@ -1,14 +1,86 @@ package org.hibernate.tool.orm.jbt.internal.factory; +import java.util.HashMap; +import java.util.Map; + +import org.hibernate.Session; import org.hibernate.SessionFactory; -import org.hibernate.tool.orm.jbt.api.SessionFactoryWrapper; +import org.hibernate.engine.spi.SessionFactoryImplementor; +import org.hibernate.persister.collection.CollectionPersister; +import org.hibernate.persister.entity.EntityPersister; +import org.hibernate.tool.orm.jbt.api.wrp.ClassMetadataWrapper; +import org.hibernate.tool.orm.jbt.api.wrp.CollectionMetadataWrapper; +import org.hibernate.tool.orm.jbt.api.wrp.SessionFactoryWrapper; +import org.hibernate.tool.orm.jbt.api.wrp.SessionWrapper; +import org.hibernate.tool.orm.jbt.internal.wrp.AbstractWrapper; public class SessionFactoryWrapperFactory { public static SessionFactoryWrapper createSessionFactoryWrapper(SessionFactory sessionFactory) { - return new SessionFactoryWrapper() { - @Override public SessionFactory getWrappedObject() { return sessionFactory; } - }; + return new SessionFactoryWrapperImpl(sessionFactory); + } + + private static class SessionFactoryWrapperImpl + extends AbstractWrapper + implements SessionFactoryWrapper { + + private SessionFactory sessionFactory = null; + + private SessionFactoryWrapperImpl(SessionFactory sessionFactory) { + this.sessionFactory = sessionFactory; + } + + @Override + public SessionFactory getWrappedObject() { + return sessionFactory; + } + + @Override + public void close() { + sessionFactory.close(); + } + + @Override + public Map getAllClassMetadata() { + Map origin = ((SessionFactoryImplementor)sessionFactory).getMetamodel().entityPersisters(); + Map result = new HashMap(origin.size()); + for (String key : origin.keySet()) { + result.put(key, ClassMetadataWrapperFactory.createClassMetadataWrapper(origin.get(key))); + } + return result; + } + + @Override + public Map getAllCollectionMetadata() { + Map origin = ((SessionFactoryImplementor)sessionFactory).getMetamodel().collectionPersisters(); + Map result = new HashMap(origin.size()); + for (String key : origin.keySet()) { + result.put(key, CollectionMetadataWrapperFactory.createCollectionMetadataWrapper(origin.get(key))); + } + return result; + } + + @Override + public SessionWrapper openSession() { + Session s = sessionFactory.openSession(); + return s == null ? null : SessionWrapperFactory.createSessionWrapper(s); + } + + @Override + public ClassMetadataWrapper getClassMetadata(String s) { + return getAllClassMetadata().get(s); + } + + @Override + public ClassMetadataWrapper getClassMetadata(Class c) { + return getAllClassMetadata().get(c.getName()); + } + + @Override + public CollectionMetadataWrapper getCollectionMetadata(String s) { + return getAllCollectionMetadata().get(s); + } + } } diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/SessionWrapperFactory.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/SessionWrapperFactory.java index 30a58f5c7d..756f656edd 100644 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/SessionWrapperFactory.java +++ b/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/SessionWrapperFactory.java @@ -1,14 +1,88 @@ package org.hibernate.tool.orm.jbt.internal.factory; import org.hibernate.Session; -import org.hibernate.tool.orm.jbt.api.SessionWrapper; +import org.hibernate.SessionFactory; +import org.hibernate.query.Query; +import org.hibernate.tool.orm.jbt.api.wrp.QueryWrapper; +import org.hibernate.tool.orm.jbt.api.wrp.SessionFactoryWrapper; +import org.hibernate.tool.orm.jbt.api.wrp.SessionWrapper; +import org.hibernate.tool.orm.jbt.internal.wrp.AbstractWrapper; + +import jakarta.persistence.criteria.CriteriaBuilder; +import jakarta.persistence.criteria.CriteriaQuery; +import jakarta.persistence.criteria.Root; public class SessionWrapperFactory { public static SessionWrapper createSessionWrapper(Session wrappedSession) { - return new SessionWrapper() { - @Override public Session getWrappedObject() { return wrappedSession; } - }; + return new SessionWrapperImpl(wrappedSession); + } + + private static class SessionWrapperImpl + extends AbstractWrapper + implements SessionWrapper { + + private Session session = null; + + private SessionWrapperImpl(Session session) { + this.session = session; + } + + @Override + public Session getWrappedObject() { + return session; + } + + @Override + public String getEntityName(Object o) { + return session.getEntityName(o); + } + + @Override + public SessionFactoryWrapper getSessionFactory() { + SessionFactory sf = session.getSessionFactory(); + return sf == null ? null : SessionFactoryWrapperFactory.createSessionFactoryWrapper(sf); + } + + @Override + public QueryWrapper createQuery(String s) { + org.hibernate.query.Query query = session.createQuery(s); + return QueryWrapperFactory.createQueryWrapper(query); + } + + @Override + public boolean isOpen() { + return session.isOpen(); + } + + @Override + public void close() { + session.close(); + } + + @Override + public boolean contains(Object o) { + boolean result = false; + try { + result = session.contains(o); + } catch (IllegalArgumentException e) { + String message = e.getMessage(); + if (!(message.startsWith("Class '") && message.endsWith("' is not an entity class"))) { + throw e; + } + } + return result; + } + + @Override + public QueryWrapper createCriteria(Class c) { + CriteriaBuilder criteriaBuilder = session.getCriteriaBuilder(); + CriteriaQuery criteriaQuery = criteriaBuilder.createQuery(c); + criteriaQuery.select((Root)criteriaQuery.from(c)); + Query query = ((Session)getWrappedObject()).createQuery(criteriaQuery); + return QueryWrapperFactory.createQueryWrapper(query); + } + } } diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/TableFilterWrapperFactory.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/TableFilterWrapperFactory.java index 0d7df57e51..f96f533c6e 100644 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/TableFilterWrapperFactory.java +++ b/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/TableFilterWrapperFactory.java @@ -1,14 +1,74 @@ package org.hibernate.tool.orm.jbt.internal.factory; import org.hibernate.tool.internal.reveng.strategy.TableFilter; -import org.hibernate.tool.orm.jbt.api.TableFilterWrapper; +import org.hibernate.tool.orm.jbt.api.wrp.TableFilterWrapper; +import org.hibernate.tool.orm.jbt.internal.wrp.AbstractWrapper; public class TableFilterWrapperFactory { + + public static TableFilterWrapper createTableFilterWrapper() { + return createTableFilterWrapper(new TableFilter()); + } + + private static TableFilterWrapper createTableFilterWrapper(TableFilter wrappedTableFilter) { + return new TableFilterWrapperImpl(wrappedTableFilter); + } + + private static class TableFilterWrapperImpl + extends AbstractWrapper + implements TableFilterWrapper { + + private TableFilter tableFilter = null; + + private TableFilterWrapperImpl(TableFilter tableFilter) { + this.tableFilter = tableFilter; + } + + @Override + public TableFilter getWrappedObject() { + return tableFilter; + } + + @Override + public void setExclude(boolean b) { + tableFilter.setExclude(b); + } + + @Override + public void setMatchCatalog(String s) { + tableFilter.setMatchCatalog(s); + } + + @Override + public void setMatchSchema(String s) { + tableFilter.setMatchSchema(s); + } + + @Override + public void setMatchName(String s) { + tableFilter.setMatchName(s); + } + + @Override + public Boolean getExclude() { + return tableFilter.getExclude(); + } + + @Override + public String getMatchCatalog() { + return tableFilter.getMatchCatalog(); + } + + @Override + public String getMatchSchema() { + return tableFilter.getMatchSchema(); + } + + @Override + public String getMatchName() { + return tableFilter.getMatchName(); + } - public static TableFilterWrapper createTableFilterWrapper(TableFilter wrappedTableFilter) { - return new TableFilterWrapper() { - @Override public TableFilter getWrappedObject() { return wrappedTableFilter; } - }; } } diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/TableWrapperFactory.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/TableWrapperFactory.java index 629f0cd092..eef2284966 100644 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/TableWrapperFactory.java +++ b/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/TableWrapperFactory.java @@ -1,14 +1,149 @@ package org.hibernate.tool.orm.jbt.internal.factory; +import java.util.Iterator; + +import org.hibernate.mapping.Column; +import org.hibernate.mapping.ForeignKey; +import org.hibernate.mapping.PrimaryKey; import org.hibernate.mapping.Table; -import org.hibernate.tool.orm.jbt.api.TableWrapper; +import org.hibernate.mapping.Value; +import org.hibernate.tool.orm.jbt.api.wrp.ColumnWrapper; +import org.hibernate.tool.orm.jbt.api.wrp.ForeignKeyWrapper; +import org.hibernate.tool.orm.jbt.api.wrp.PrimaryKeyWrapper; +import org.hibernate.tool.orm.jbt.api.wrp.TableWrapper; +import org.hibernate.tool.orm.jbt.api.wrp.ValueWrapper; +import org.hibernate.tool.orm.jbt.internal.wrp.AbstractWrapper; public class TableWrapperFactory { - public static TableWrapper createTableWrapper(Table wrappedTable) { - return new TableWrapper() { - @Override public Table getWrappedObject() { return wrappedTable; } - }; + public static TableWrapper createTableWrapper(String name) { + Table t = new Table("Hibernate Tools", name); + t.setPrimaryKey(new PrimaryKey(t)); + return TableWrapperFactory.createTableWrapper(t); + } + + static TableWrapper createTableWrapper(Table wrappedTable) { + return new TableWrapperImpl(wrappedTable); + } + + private static class TableWrapperImpl + extends AbstractWrapper + implements TableWrapper { + + private Table table = null; + + private TableWrapperImpl(Table table) { + this.table = table; + } + + @Override + public Table getWrappedObject() { + return table; + } + + @Override + public String getName() { + return table.getName(); + } + + @Override + public void addColumn(ColumnWrapper column) { + table.addColumn((Column)column.getWrappedObject()); + } + + @Override + public String getCatalog() { + return table.getCatalog(); + } + + @Override + public String getSchema() { + return table.getSchema(); + } + + @Override + public PrimaryKeyWrapper getPrimaryKey() { + PrimaryKey pk = table.getPrimaryKey(); + return pk == null ? null : PrimaryKeyWrapperFactory.createPrimaryKeyWrapper(pk); + } + + @Override + public Iterator getColumnIterator() { + Iterator iterator = table.getColumns().iterator(); + return new Iterator() { + @Override + public boolean hasNext() { + return iterator.hasNext(); + } + @Override + public ColumnWrapper next() { + return ColumnWrapperFactory.createColumnWrapper(iterator.next()); + } + + }; + } + + @Override + public Iterator getForeignKeyIterator() { + Iterator iterator = table.getForeignKeys().values().iterator(); + return new Iterator() { + @Override + public boolean hasNext() { + return iterator.hasNext(); + } + @Override + public ForeignKeyWrapper next() { + return ForeignKeyWrapperFactory.createForeignKeyWrapper(iterator.next()); + } + + }; + } + + @Override + public String getComment() { + return table.getComment(); + } + + @Override + public String getRowId() { + return table.getRowId(); + } + + @Override + public String getSubselect() { + return table.getSubselect(); + } + + @Override + public boolean hasDenormalizedTables() { + return table.hasDenormalizedTables(); + } + + @Override + public boolean isAbstract() { + return table.isAbstract(); + } + + @Override + public boolean isAbstractUnionTable() { + return table.isAbstractUnionTable(); + } + + @Override + public boolean isPhysicalTable() { + return table.isPhysicalTable(); + } + + @Override + public ValueWrapper getIdentifierValue() { + // Method 'Table#getIdentifierValue()' has been removed starting from Hibernate 6.6.0.CR1 + // Value v = table.getIdentifierValue(); + // return v == null ? null : ValueWrapperFactory.createValueWrapper(v); + return null; + } + + + } } diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/TypeFactoryWrapperFactory.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/TypeFactoryWrapperFactory.java index 57832466e1..a642e13034 100644 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/TypeFactoryWrapperFactory.java +++ b/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/TypeFactoryWrapperFactory.java @@ -1,13 +1,51 @@ package org.hibernate.tool.orm.jbt.internal.factory; -import org.hibernate.tool.orm.jbt.api.TypeFactoryWrapper; +import java.util.Map; + +import org.hibernate.tool.orm.jbt.api.wrp.TypeFactoryWrapper; +import org.hibernate.tool.orm.jbt.api.wrp.TypeWrapper; +import org.hibernate.tool.orm.jbt.internal.util.TypeRegistry; +import org.hibernate.tool.orm.jbt.internal.wrp.AbstractWrapper; public class TypeFactoryWrapperFactory { - private static TypeFactoryWrapper INSTANCE = new TypeFactoryWrapper() {}; + private static TypeFactoryWrapper INSTANCE = new TypeFactoryWrapperImpl(); public static TypeFactoryWrapper createTypeFactoryWrapper() { return INSTANCE; } + + private static class TypeFactoryWrapperImpl + extends AbstractWrapper + implements TypeFactoryWrapper { + + @Override public TypeWrapper getBooleanType() { return TypeRegistry.getType("boolean"); } + @Override public TypeWrapper getByteType() { return TypeRegistry.getType("byte"); } + @Override public TypeWrapper getBigIntegerType() { return TypeRegistry.getType("big_integer"); } + @Override public TypeWrapper getShortType() { return TypeRegistry.getType("short"); } + @Override public TypeWrapper getCalendarType() { return TypeRegistry.getType("calendar"); } + @Override public TypeWrapper getCalendarDateType() { return TypeRegistry.getType("calendar_date"); } + @Override public TypeWrapper getIntegerType() { return TypeRegistry.getType("integer"); } + @Override public TypeWrapper getBigDecimalType() { return TypeRegistry.getType("big_decimal"); } + @Override public TypeWrapper getCharacterType() { return TypeRegistry.getType("character"); } + @Override public TypeWrapper getClassType() { return TypeRegistry.getType("class"); } + @Override public TypeWrapper getCurrencyType() { return TypeRegistry.getType("currency"); } + @Override public TypeWrapper getDateType() { return TypeRegistry.getType("date"); } + @Override public TypeWrapper getDoubleType() { return TypeRegistry.getType("double"); } + @Override public TypeWrapper getFloatType() { return TypeRegistry.getType("float"); } + @Override public TypeWrapper getLocaleType() { return TypeRegistry.getType("locale"); } + @Override public TypeWrapper getLongType() { return TypeRegistry.getType("long"); } + @Override public TypeWrapper getStringType() { return TypeRegistry.getType("string"); } + @Override public TypeWrapper getTextType() { return TypeRegistry.getType("text"); } + @Override public TypeWrapper getTimeType() { return TypeRegistry.getType("time"); } + @Override public TypeWrapper getTimestampType() { return TypeRegistry.getType("timestamp"); } + @Override public TypeWrapper getTimezoneType() { return TypeRegistry.getType("timezone"); } + @Override public TypeWrapper getTrueFalseType() { return TypeRegistry.getType("true_false"); } + @Override public TypeWrapper getYesNoType() { return TypeRegistry.getType("yes_no"); } + @Override public TypeWrapper getNamedType(String name) { return TypeRegistry.getType(name); } + @Override public TypeWrapper getBasicType(String name) { return getNamedType(name); } + @Override public Map getTypeFormats() { return TypeRegistry.getTypeFormats(); } + + } } diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/TypeWrapperFactory.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/TypeWrapperFactory.java index ad4af223f5..f50b260fe9 100644 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/TypeWrapperFactory.java +++ b/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/TypeWrapperFactory.java @@ -1,14 +1,171 @@ package org.hibernate.tool.orm.jbt.internal.factory; -import org.hibernate.tool.orm.jbt.api.TypeWrapper; +import java.text.SimpleDateFormat; +import java.util.Calendar; + +import org.hibernate.tool.orm.jbt.api.wrp.TypeWrapper; +import org.hibernate.tool.orm.jbt.internal.util.PrimitiveHelper; +import org.hibernate.tool.orm.jbt.internal.wrp.AbstractWrapper; +import org.hibernate.type.BasicType; +import org.hibernate.type.CollectionType; +import org.hibernate.type.EntityType; import org.hibernate.type.Type; +import org.hibernate.type.descriptor.java.CalendarJavaType; +import org.hibernate.type.descriptor.java.JavaType; public class TypeWrapperFactory { public static TypeWrapper createTypeWrapper(Type wrappedType) { - return new TypeWrapper() { - @Override public Type getWrappedObject() { return wrappedType; } - }; + return new TypeWrapperImpl(wrappedType); + } + + private static class TypeWrapperImpl + extends AbstractWrapper + implements TypeWrapper { + + private Type type = null; + + private TypeWrapperImpl(Type type) { + this.type = type; + } + + @Override + public Type getWrappedObject() { + return type; + } + + @Override + public String toString(Object object) { + if (BasicType.class.isAssignableFrom(getWrappedObject().getClass())) { + JavaType javaType = ((BasicType)type).getJavaTypeDescriptor(); + if (javaType instanceof CalendarJavaType && object instanceof Calendar) { + SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd"); + return simpleDateFormat.format(((Calendar)object).getTime()); + } else { + return ((JavaType)javaType).toString(object); + } + } else { + throw new UnsupportedOperationException( + "Class '" + + type.getClass().getName() + + "' does not support 'toString(Object)'." ); + } + } + + @Override + public String getName() { + return type.getName(); + } + + @Override + public Object fromStringValue(String stringValue) { + if (BasicType.class.isAssignableFrom(type.getClass())) { + return ((BasicType)type).getJavaTypeDescriptor().fromString(stringValue); + } else { + throw new UnsupportedOperationException( + "Class '" + + type.getClass().getName() + + "' does not support 'fromStringValue(Object)'." ); + } + } + + @Override + public boolean isEntityType() { + return type.isEntityType(); + } + + @Override + public boolean isOneToOne() { + if (EntityType.class.isAssignableFrom(type.getClass())) { + return ((EntityType)type).isOneToOne(); + } else { + throw new UnsupportedOperationException( + "Class '" + + type.getClass().getName() + + "' does not support 'isOneToOne()'." ); + } + } + + @Override + public boolean isAnyType() { + return type.isAnyType(); + } + + @Override + public boolean isComponentType() { + return type.isComponentType(); + } + + @Override + public boolean isCollectionType() { + return type.isCollectionType(); + } + + @Override + public String getAssociatedEntityName() { + if (isEntityType()) { + return ((EntityType)type).getAssociatedEntityName(); + } else { + return null; + } + } + + @Override + public boolean isIntegerType() { + return Integer.class.isAssignableFrom(type.getReturnedClass()); + } + + @Override + public boolean isArrayType() { + if (CollectionType.class.isAssignableFrom(type.getClass())) { + return ((CollectionType)type).isArrayType(); + } else { + return false; + } + } + + @Override + public boolean isInstanceOfPrimitiveType() { + if (!(BasicType.class.isAssignableFrom(type.getClass()))) { + return false; + } + return PrimitiveHelper.isPrimitive(((BasicType)type).getJavaType()); + } + + @Override + public Class getPrimitiveClass() { + if (!isInstanceOfPrimitiveType()) { + throw new UnsupportedOperationException( + "Class '" + + type.getClass().getName() + + "' does not support 'getPrimitiveClass()'."); + } else { + Class javaType = ((BasicType)type).getJavaType(); + if (PrimitiveHelper.isPrimitiveWrapperClass(javaType)) { + return PrimitiveHelper.getPrimitiveClass(javaType); + } else { + return javaType; + } + } + } + + @Override + public String getRole() { + if (!isCollectionType()) { + throw new UnsupportedOperationException( + "Class '" + + type.getClass().getName() + + "' does not support 'getRole()'."); + } else { + return ((CollectionType)type).getRole(); + } + } + + @Override + public String getReturnedClassName() { + return type.getReturnedClassName(); + } + } } diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/ValueWrapperFactory.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/ValueWrapperFactory.java new file mode 100644 index 0000000000..85d41b9872 --- /dev/null +++ b/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/factory/ValueWrapperFactory.java @@ -0,0 +1,580 @@ +package org.hibernate.tool.orm.jbt.internal.factory; + +import java.util.Iterator; +import java.util.Properties; + +import org.hibernate.FetchMode; +import org.hibernate.mapping.Any; +import org.hibernate.mapping.Array; +import org.hibernate.mapping.Bag; +import org.hibernate.mapping.BasicValue; +import org.hibernate.mapping.Collection; +import org.hibernate.mapping.Column; +import org.hibernate.mapping.Component; +import org.hibernate.mapping.DependantValue; +import org.hibernate.mapping.Fetchable; +import org.hibernate.mapping.IdentifierBag; +import org.hibernate.mapping.IndexedCollection; +import org.hibernate.mapping.KeyValue; +import org.hibernate.mapping.List; +import org.hibernate.mapping.ManyToOne; +import org.hibernate.mapping.Map; +import org.hibernate.mapping.OneToMany; +import org.hibernate.mapping.OneToOne; +import org.hibernate.mapping.PersistentClass; +import org.hibernate.mapping.PrimitiveArray; +import org.hibernate.mapping.Property; +import org.hibernate.mapping.Selectable; +import org.hibernate.mapping.Set; +import org.hibernate.mapping.SimpleValue; +import org.hibernate.mapping.Table; +import org.hibernate.mapping.ToOne; +import org.hibernate.mapping.Value; +import org.hibernate.tool.orm.jbt.api.wrp.ColumnWrapper; +import org.hibernate.tool.orm.jbt.api.wrp.PersistentClassWrapper; +import org.hibernate.tool.orm.jbt.api.wrp.PropertyWrapper; +import org.hibernate.tool.orm.jbt.api.wrp.TableWrapper; +import org.hibernate.tool.orm.jbt.api.wrp.TypeWrapper; +import org.hibernate.tool.orm.jbt.api.wrp.ValueWrapper; +import org.hibernate.tool.orm.jbt.internal.util.DummyMetadataBuildingContext; +import org.hibernate.tool.orm.jbt.internal.wrp.AbstractWrapper; + +public class ValueWrapperFactory { + + public static ValueWrapper createArrayWrapper(PersistentClassWrapper persistentClassWrapper) { + return createValueWrapper( + new Array( + DummyMetadataBuildingContext.INSTANCE, + (PersistentClass)persistentClassWrapper.getWrappedObject())); + } + + public static ValueWrapper createBagWrapper(PersistentClassWrapper persistentClassWrapper) { + return createValueWrapper( + new Bag( + DummyMetadataBuildingContext.INSTANCE, + (PersistentClass)persistentClassWrapper.getWrappedObject())); + } + + public static ValueWrapper createListWrapper(PersistentClassWrapper persistentClassWrapper) { + return createValueWrapper( + new List( + DummyMetadataBuildingContext.INSTANCE, + (PersistentClass)persistentClassWrapper.getWrappedObject())); + } + + public static ValueWrapper createManyToOneWrapper(TableWrapper tableWrapper) { + return createValueWrapper( + new ManyToOne( + DummyMetadataBuildingContext.INSTANCE, + (Table)tableWrapper.getWrappedObject())); + } + + public static ValueWrapper createMapWrapper(PersistentClassWrapper persistentClassWrapper) { + return createValueWrapper( + new org.hibernate.mapping.Map( + DummyMetadataBuildingContext.INSTANCE, + (PersistentClass)persistentClassWrapper.getWrappedObject())); + } + + public static ValueWrapper createOneToManyWrapper(PersistentClassWrapper persistentClassWrapper) { + return createValueWrapper( + new OneToMany( + DummyMetadataBuildingContext.INSTANCE, + (PersistentClass)persistentClassWrapper.getWrappedObject())); + } + + public static ValueWrapper createOneToOneWrapper(PersistentClassWrapper persistentClassWrapper) { + PersistentClass pc = (PersistentClass)persistentClassWrapper.getWrappedObject(); + return createValueWrapper( + new OneToOne( + DummyMetadataBuildingContext.INSTANCE, + pc.getTable(), + pc)); + } + + public static ValueWrapper createPrimitiveArrayWrapper(PersistentClassWrapper persistentClassWrapper) { + return createValueWrapper( + new PrimitiveArray( + DummyMetadataBuildingContext.INSTANCE, + (PersistentClass)persistentClassWrapper.getWrappedObject())); + } + + public static ValueWrapper createSetWrapper(PersistentClassWrapper persistentClassWrapper) { + return createValueWrapper( + new Set( + DummyMetadataBuildingContext.INSTANCE, + (PersistentClass)persistentClassWrapper.getWrappedObject())); + } + + public static ValueWrapper createSimpleValueWrapper() { + return createValueWrapper(new BasicValue(DummyMetadataBuildingContext.INSTANCE)); + } + + public static ValueWrapper createComponentWrapper(PersistentClassWrapper persistentClassWrapper) { + return createValueWrapper( + new Component( + DummyMetadataBuildingContext.INSTANCE, + (PersistentClass)persistentClassWrapper.getWrappedObject())); + } + + public static ValueWrapper createDependantValueWrapper(TableWrapper tableWrapper, ValueWrapper valueWrapper) { + return createValueWrapper( + new DependantValue( + DummyMetadataBuildingContext.INSTANCE, + (Table)tableWrapper.getWrappedObject(), + (KeyValue)valueWrapper.getWrappedObject())); + } + + public static ValueWrapper createAnyValueWrapper(TableWrapper tableWrapper) { + return createValueWrapper( + new Any( + DummyMetadataBuildingContext.INSTANCE, + (Table)tableWrapper.getWrappedObject())); + } + + public static ValueWrapper createIdentifierBagValueWrapper(PersistentClassWrapper persistentClassWrapper) { + return createValueWrapper( + new IdentifierBag( + DummyMetadataBuildingContext.INSTANCE, + (PersistentClass)persistentClassWrapper.getWrappedObject())); + } + + public static ValueWrapper createValueWrapper(Value wrappedArrayValue) { + return new ValueWrapperImpl(wrappedArrayValue); + } + + private static class ValueWrapperImpl + extends AbstractWrapper + implements ValueWrapper { + + private Value value = null; + + private ValueWrapperImpl(Value value) { + this.value = value; + } + + @Override + public Value getWrappedObject() { + return value; + } + + @Override + public boolean isSimpleValue() { + return value.isSimpleValue(); + } + + @Override + public boolean isCollection() { + return Collection.class.isAssignableFrom(value.getClass()); } + + @Override + public ValueWrapper getCollectionElement() { + if (isCollection()) { + Value v = ((Collection)value).getElement(); + if (v != null) return ValueWrapperFactory.createValueWrapper(v); + } + return null; + } + + @Override + public boolean isOneToMany() { + return OneToMany.class.isAssignableFrom(value.getClass()); + } + + @Override + public boolean isManyToOne() { + return ManyToOne.class.isAssignableFrom(value.getClass()); + } + + @Override + public boolean isOneToOne() { + return OneToOne.class.isAssignableFrom(value.getClass()); + } + + @Override + public boolean isMap() { + return Map.class.isAssignableFrom(value.getClass()); + } + + @Override + public boolean isComponent() { + return Component.class.isAssignableFrom(value.getClass()); + } + + @Override + public boolean isEmbedded() { + if (isComponent()) { + return ((Component)value).isEmbedded(); + } + return false; + } + + @Override + public boolean isToOne() { + return ToOne.class.isAssignableFrom(value.getClass()); + } + + + @Override + public TableWrapper getTable() { + return value.getTable() == null ? null : TableWrapperFactory.createTableWrapper(value.getTable()); + } + + @Override + public TypeWrapper getType() { + return value.getType() == null ? null : TypeWrapperFactory.createTypeWrapper(value.getType()); + } + + @Override + public void setElement(ValueWrapper v) { + if (isCollection()) { + ((Collection)value).setElement((Value)v.getWrappedObject()); + } + } + + @Override + public void setCollectionTable(TableWrapper table) { + if (isCollection()) { + Table t = table == null ? null : (Table)table.getWrappedObject(); + ((Collection)value).setCollectionTable(t); + } + } + + @Override + public void setTable(TableWrapper table) { + if (isSimpleValue()) { + Table t = table == null ? null : (Table)table.getWrappedObject(); + ((SimpleValue)value).setTable(t); + } + } + + @Override + public boolean isList() { + return List.class.isAssignableFrom(value.getClass()); + } + + @Override + public void setIndex(ValueWrapper v) { + if (IndexedCollection.class.isAssignableFrom(value.getClass())) { + Value val = v == null ? null : (Value)v.getWrappedObject(); + ((IndexedCollection)value).setIndex(val); + } + } + + @Override + public void setTypeName(String s) { + if (isCollection()) { + ((Collection)value).setTypeName(s); + } else if (isSimpleValue()) { + ((SimpleValue)value).setTypeName(s); + } + } + + @Override + public String getComponentClassName() { + if ((isComponent())) { + return ((Component)value).getComponentClassName(); + } + return null; + } + + @Override + public Iterator getColumnIterator() { + Iterator iterator = value.getSelectables().iterator(); + return new Iterator() { + @Override + public boolean hasNext() { + return iterator.hasNext(); + } + @Override + public ColumnWrapper next() { + return ColumnWrapperFactory.createColumnWrapper((Column)iterator.next()); + } + + }; + } + + @Override + public boolean isTypeSpecified() { + if (isSimpleValue()) { + return ((SimpleValue)value).isTypeSpecified(); + } else { + throw new UnsupportedOperationException("Class '" + value.getClass().getName() + "' does not support 'isTypeSpecified()'." ); + } + } + + @Override + public TableWrapper getCollectionTable() { + if (isCollection()) { + Table t = ((Collection)value).getCollectionTable(); + return t == null ? null : TableWrapperFactory.createTableWrapper(t); + } else { + return null; + } + } + + @Override + public ValueWrapper getKey() { + if (isCollection()) { + Value v = ((Collection)value).getKey(); + return v == null ? null : ValueWrapperFactory.createValueWrapper(v); + } else { + throw new UnsupportedOperationException("Class '" + value.getClass().getName() + "' does not support 'getKey()'." ); + } + } + + @Override + public ValueWrapper getIndex() { + if (IndexedCollection.class.isAssignableFrom(value.getClass())) { + Value v = ((IndexedCollection)value).getIndex(); + return v == null ? null : ValueWrapperFactory.createValueWrapper(v); + } else { + return null; + } + } + + @Override + public String getElementClassName() { + if (Array.class.isAssignableFrom(value.getClass())) { + return ((Array)value).getElementClassName(); + } else { + throw new UnsupportedOperationException("Class '" + value.getClass().getName() + "' does not support 'getElementClassName()'." ); + } + } + + @Override + public String getTypeName() { + if (isCollection()) { + return ((Collection)value).getTypeName(); + } else if (isSimpleValue()) { + return ((SimpleValue)value).getTypeName(); + } else { + return null; + } + } + + @Override + public boolean isDependantValue() { + return DependantValue.class.isAssignableFrom(value.getClass()); + } + + @Override + public boolean isAny() { + return Any.class.isAssignableFrom(value.getClass()); + } + + @Override + public boolean isSet() { + return Set.class.isAssignableFrom(value.getClass()); + } + + @Override + public boolean isPrimitiveArray() { + return PrimitiveArray.class.isAssignableFrom(value.getClass()); + } + + @Override + public boolean isArray() { + return Array.class.isAssignableFrom(value.getClass()); + } + + @Override + public boolean isIdentifierBag() { + return IdentifierBag.class.isAssignableFrom(value.getClass()); + } + + @Override + public boolean isBag() { + return Bag.class.isAssignableFrom(value.getClass()); + } + + @Override + public String getReferencedEntityName() { + if (isManyToOne() || isOneToOne()) { + return ((ToOne)value).getReferencedEntityName(); + } else if (isOneToMany()) { + return ((OneToMany)value).getReferencedEntityName(); + } else { + throw new UnsupportedOperationException("Class '" + value.getClass().getName() + "' does not support 'getReferencedEntityName()'." ); + } + } + + @Override + public String getEntityName() { + if (isOneToOne()) { + return ((OneToOne)value).getEntityName(); + } else { + throw new UnsupportedOperationException("Class '" + value.getClass().getName() + "' does not support 'getEntityName()'." ); } + } + + @Override + public Iterator getPropertyIterator() { + if (isComponent()) { + Iterator iterator = ((Component)value).getProperties().iterator(); + return new Iterator() { + @Override + public boolean hasNext() { + return iterator.hasNext(); + } + @Override + public PropertyWrapper next() { + return PropertyWrapperFactory.createPropertyWrapper(iterator.next()); + } + }; + } else { + throw new UnsupportedOperationException("Class '" + value.getClass().getName() + "' does not support 'getPropertyIterator()'." ); + } + } + + @Override + public void addColumn(ColumnWrapper column) { + if (isSimpleValue() && column != null) { + ((SimpleValue)value).addColumn((Column)column.getWrappedObject()); + } else { + throw new UnsupportedOperationException("Class '" + value.getClass().getName() + "' does not support 'addColumn(Column)'." ); + } + } + + @Override + public void setTypeParameters(Properties properties) { + if (isCollection()) { + ((Collection)value).setTypeParameters(properties); + } else if (isSimpleValue()) { + ((SimpleValue)value).setTypeParameters(properties); + } else { + throw new UnsupportedOperationException("Class '" + value.getClass().getName() + "' does not support 'setTypeParameters(Properties)'." ); + } + } + + @Override + public String getForeignKeyName() { + if (isSimpleValue()) { + return ((SimpleValue)value).getForeignKeyName(); + } else { + throw new UnsupportedOperationException("Class '" + value.getClass().getName() + "' does not support 'getForeignKeyName()'." ); + } + } + + @Override + public PersistentClassWrapper getOwner() { + PersistentClass owner = null; + if (isCollection()) { + owner = ((Collection)value).getOwner(); + return owner == null ? null : PersistentClassWrapperFactory.createPersistentClassWrapper(owner); + } else if (isComponent()) { + owner = ((Component)value).getOwner(); + return owner == null ? null : PersistentClassWrapperFactory.createPersistentClassWrapper(owner); + } else { + throw new UnsupportedOperationException("Class '" + value.getClass().getName() + "' does not support 'getOwner()'." ); + } + } + + @Override + public ValueWrapper getElement() { + if (isCollection()) { + Value v = ((Collection)value).getElement(); + return v == null ? null : ValueWrapperFactory.createValueWrapper(v); + } else { + return null; + } + } + + @Override + public String getParentProperty() { + if (isComponent()) { + return ((Component)value).getParentProperty(); + } else { + throw new UnsupportedOperationException("Class '" + value.getClass().getName() + "' does not support 'getParentProperty()'." ); + } + } + + @Override + public void setElementClassName(String name) { + if (isArray()) { + ((Array)value).setElementClassName(name); + } else { + throw new UnsupportedOperationException("Class '" + value.getClass().getName() + "' does not support 'setElementClassName(String)'." ); + } + } + + @Override + public void setKey(ValueWrapper v) { + if (isCollection()) { + KeyValue val = v == null ? null : (KeyValue)v.getWrappedObject(); + ((Collection)value).setKey(val); + } else { + throw new UnsupportedOperationException("Class '" + v.getClass().getName() + "' does not support 'setKey(KeyValue)'." ); + } + } + + @Override + public void setFetchModeJoin() { + if (Fetchable.class.isAssignableFrom(value.getClass())) { + ((Fetchable)value).setFetchMode(FetchMode.JOIN); + } else { + throw new UnsupportedOperationException("Class '" + value.getClass().getName() + "' does not support 'setFetchModeJoin()'." ); + } + } + + @Override + public boolean isInverse() { + if (isCollection()) { + return ((Collection)value).isInverse(); + } else { + throw new UnsupportedOperationException("Class '" + value.getClass().getName() + "' does not support 'isInverse()'." ); + } + } + + @Override + public PersistentClassWrapper getAssociatedClass() { + if (isOneToMany()) { + PersistentClass pc = ((OneToMany)value).getAssociatedClass(); + return pc == null ? null : PersistentClassWrapperFactory.createPersistentClassWrapper(pc); + } else { + throw new UnsupportedOperationException("Class '" + value.getClass().getName() + "' does not support 'getAssociatedClass()'." ); + } + } + + @Override + public void setLazy(boolean b) { + if (Fetchable.class.isAssignableFrom(value.getClass())) { + ((Fetchable)value).setLazy(b); + } else if (isAny()) { + ((Any)value).setLazy(b); + + } else { + throw new UnsupportedOperationException("Class '" + value.getClass().getName() + "' does not support 'setLazy(boolean)'." ); + } + } + + @Override + public void setRole(String role) { + if (isCollection()) { + ((Collection)value).setRole(role); + } else { + throw new UnsupportedOperationException("Class '" + value.getClass().getName() + "' does not support 'setRole(String)'." ); + } + } + + @Override + public void setReferencedEntityName(String name) { + if (isToOne()) { + ((ToOne)value).setReferencedEntityName(name); + } else if (isOneToMany()) { + ((OneToMany)value).setReferencedEntityName(name); + } else { + throw new UnsupportedOperationException("Class '" + value.getClass().getName() + "' does not support 'setReferencedEntityName(String)'." ); + } + } + @Override + public void setAssociatedClass(PersistentClassWrapper pcw) { + if (isOneToMany()) { + PersistentClass pc = pcw == null ? null : (PersistentClass)pcw.getWrappedObject(); + ((OneToMany)value).setAssociatedClass(pc); + } else { + throw new UnsupportedOperationException("Class '" + value.getClass().getName() + "' does not support 'setAssociatedClass(PersistentClass)'." ); + } + } + } + +} diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/util/ConfigurationMetadataDescriptor.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/util/ConfigurationMetadataDescriptor.java similarity index 92% rename from jbt/src/main/java/org/hibernate/tool/orm/jbt/util/ConfigurationMetadataDescriptor.java rename to jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/util/ConfigurationMetadataDescriptor.java index f3e0ce7807..3a1a452e4c 100644 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/util/ConfigurationMetadataDescriptor.java +++ b/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/util/ConfigurationMetadataDescriptor.java @@ -1,4 +1,4 @@ -package org.hibernate.tool.orm.jbt.util; +package org.hibernate.tool.orm.jbt.internal.util; import java.util.Properties; diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/util/DelegatingPersistentClassWrapperImpl.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/util/DelegatingPersistentClassWrapperImpl.java deleted file mode 100644 index 453786a4b4..0000000000 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/util/DelegatingPersistentClassWrapperImpl.java +++ /dev/null @@ -1,294 +0,0 @@ -package org.hibernate.tool.orm.jbt.internal.util; - -import java.util.Iterator; - -import org.hibernate.mapping.Join; -import org.hibernate.mapping.KeyValue; -import org.hibernate.mapping.PersistentClass; -import org.hibernate.mapping.Property; -import org.hibernate.mapping.RootClass; -import org.hibernate.mapping.Subclass; -import org.hibernate.mapping.Table; -import org.hibernate.mapping.Value; -import org.hibernate.tool.orm.jbt.api.PersistentClassWrapper; -import org.hibernate.tool.orm.jbt.util.DummyMetadataBuildingContext; -import org.hibernate.tool.orm.jbt.wrp.DelegatingTableWrapperImpl; -import org.hibernate.tool.orm.jbt.wrp.PropertyWrapperFactory; -import org.hibernate.tool.orm.jbt.wrp.ValueWrapperFactory; -import org.hibernate.tool.orm.jbt.wrp.Wrapper; - -public class DelegatingPersistentClassWrapperImpl extends RootClass implements PersistentClassWrapper { - - private PersistentClass delegate = null; - - public DelegatingPersistentClassWrapperImpl(PersistentClass pc) { - super(DummyMetadataBuildingContext.INSTANCE); - delegate = pc; - } - - @Override - public PersistentClass getWrappedObject() { - return delegate; - } - - @Override - public String getEntityName() { - return delegate.getEntityName(); - } - - @Override - public String getClassName() { - return delegate.getClassName(); - } - - @Override - public Property getIdentifierProperty() { - return wrapPropertyIfNeeded(delegate.getIdentifierProperty()); - } - - @Override - public boolean hasIdentifierProperty() { - return delegate.hasIdentifierProperty(); - } - - @Override - public RootClass getRootClass() { - RootClass result = delegate.getRootClass(); - if (result == delegate) { - return this; - } else { - return result == null ? null : new DelegatingPersistentClassWrapperImpl(result); - } - } - - @Override - public Iterator getPropertyClosureIterator() { - return getPropertyIterator(); - } - - @Override - public PersistentClass getSuperclass() { - return delegate.getSuperclass(); - } - - @Override - public Iterator getPropertyIterator() { - final Iterator iterator = delegate.getProperties().iterator(); - return new Iterator() { - @Override - public boolean hasNext() { - return iterator.hasNext(); - } - @Override - public Property next() { - return PropertyWrapperFactory.createPropertyWrapper(iterator.next()); - } - - }; - } - - @Override - public Property getProperty(String name) { - return wrapPropertyIfNeeded(delegate.getProperty(name)); - } - - @Override - public Table getTable() { - Table result = delegate.getTable(); - return result == null ? null : new DelegatingTableWrapperImpl(result); - } - - @Override - public Boolean isAbstract() { - return delegate.isAbstract(); - } - - @Override - public Value getDiscriminator() { - return wrapValueIfNeeded(delegate.getDiscriminator()); - } - - @Override - public KeyValue getIdentifier() { - return (KeyValue)wrapValueIfNeeded(delegate.getIdentifier()); - } - - @Override - public Iterator getJoinIterator() { - return delegate.getJoins().iterator(); - } - - @Override - public Property getVersion() { - return wrapPropertyIfNeeded(delegate.getVersion()); - } - - @Override - public void setClassName(String name) { - delegate.setClassName(name); - } - - @Override - public void setEntityName(String name) { - delegate.setEntityName(name); - } - - @Override - public void setDiscriminatorValue(String str) { - delegate.setDiscriminatorValue(str); - } - - @Override - public void setAbstract(Boolean b) { - delegate.setAbstract(b); - } - - @Override - public void addProperty(Property p) { - delegate.addProperty(p); - } - - @Override - public void setProxyInterfaceName(String name) { - delegate.setProxyInterfaceName(name); - } - - @Override - public void setLazy(boolean b) { - delegate.setLazy(b); - } - - @Override - public Iterator getSubclassIterator() { - return delegate.getSubclasses().iterator(); - } - - @Override - public boolean isCustomDeleteCallable() { - return delegate.isCustomDeleteCallable(); - } - - @Override - public boolean isCustomInsertCallable() { - return delegate.isCustomInsertCallable(); - } - - @Override - public boolean isCustomUpdateCallable() { - return delegate.isCustomUpdateCallable(); - } - - @Override - public boolean isDiscriminatorInsertable() { - return delegate.isDiscriminatorInsertable(); - } - - @Override - public boolean isDiscriminatorValueNotNull() { - return delegate.isDiscriminatorValueNotNull(); - } - - @Override - public boolean isDiscriminatorValueNull() { - return delegate.isDiscriminatorValueNull(); - } - - @Override - public boolean isExplicitPolymorphism() { - return delegate.isExplicitPolymorphism(); - } - - @Override - public boolean isForceDiscriminator() { - return delegate.isForceDiscriminator(); - } - - @Override - public boolean isInherited() { - return delegate.isInherited(); - } - - @Override - public boolean isJoinedSubclass() { - return delegate.isJoinedSubclass(); - } - - @Override - public boolean isLazy() { - return delegate.isLazy(); - } - - @Override - public boolean isMutable() { - return delegate.isMutable(); - } - - @Override - public boolean isPolymorphic() { - return delegate.isPolymorphic(); - } - - @Override - public boolean isVersioned() { - return delegate.isVersioned(); - } - - @Override - public int getBatchSize() { - return delegate.getBatchSize(); - } - - @Override - public String getCacheConcurrencyStrategy() { - return delegate.getCacheConcurrencyStrategy(); - } - - @Override - public String getCustomSQLDelete() { - return delegate.getCustomSQLDelete(); - } - - @Override - public String getCustomSQLInsert() { - return delegate.getCustomSQLInsert(); - } - - @Override - public String getCustomSQLUpdate() { - return delegate.getCustomSQLUpdate(); - } - - @Override - public String getDiscriminatorValue() { - return delegate.getDiscriminatorValue(); - } - - @Override - public String getLoaderName() { - return delegate.getLoaderName(); - } - - @Override - public int getOptimisticLockMode() { - return delegate.getOptimisticLockMode(); - } - - @Override - public String getWhere() { - return delegate.getWhere(); - } - - @Override - public Table getRootTable() { - return delegate.getRootTable(); - } - - - private static Value wrapValueIfNeeded(Value v) { - return (v != null) && !(v instanceof Wrapper) ? ValueWrapperFactory.createValueWrapper(v) : v; - } - - private static Property wrapPropertyIfNeeded(Property p) { - return (p != null) && !(p instanceof Wrapper) ? PropertyWrapperFactory.createPropertyWrapper(p) : p; - } -} diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/util/DummyMetadataBuildingContext.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/util/DummyMetadataBuildingContext.java similarity index 97% rename from jbt/src/main/java/org/hibernate/tool/orm/jbt/util/DummyMetadataBuildingContext.java rename to jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/util/DummyMetadataBuildingContext.java index a8469af132..e5224924d6 100644 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/util/DummyMetadataBuildingContext.java +++ b/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/util/DummyMetadataBuildingContext.java @@ -1,4 +1,4 @@ -package org.hibernate.tool.orm.jbt.util; +package org.hibernate.tool.orm.jbt.internal.util; import org.hibernate.boot.internal.BootstrapContextImpl; import org.hibernate.boot.internal.InFlightMetadataCollectorImpl; diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/util/DummyMetadataDescriptor.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/util/DummyMetadataDescriptor.java similarity index 95% rename from jbt/src/main/java/org/hibernate/tool/orm/jbt/util/DummyMetadataDescriptor.java rename to jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/util/DummyMetadataDescriptor.java index 061b59d922..119201134b 100644 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/util/DummyMetadataDescriptor.java +++ b/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/util/DummyMetadataDescriptor.java @@ -1,4 +1,4 @@ -package org.hibernate.tool.orm.jbt.util; +package org.hibernate.tool.orm.jbt.internal.util; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/util/ExtendedConfiguration.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/util/ExtendedConfiguration.java new file mode 100644 index 0000000000..4bb70b2a95 --- /dev/null +++ b/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/util/ExtendedConfiguration.java @@ -0,0 +1,39 @@ +package org.hibernate.tool.orm.jbt.internal.util; + +import java.util.Iterator; + +import org.hibernate.cfg.Configuration; +import org.hibernate.cfg.NamingStrategy; +import org.hibernate.mapping.PersistentClass; +import org.hibernate.mapping.Table; +import org.hibernate.tool.api.reveng.RevengStrategy; +import org.w3c.dom.Document; +import org.xml.sax.EntityResolver; + +public interface ExtendedConfiguration { + + void setEntityResolver(EntityResolver entityResolver); + + void setNamingStrategy(NamingStrategy namingStrategy); + + Configuration configure(Document document); + + void buildMappings(); + + Iterator getClassMappings(); + + void setPreferBasicCompositeIds(boolean b); + + void setReverseEngineeringStrategy(RevengStrategy strategy); + + void readFromJDBC(); + + PersistentClass getClassMapping(String string); + + NamingStrategy getNamingStrategy(); + + EntityResolver getEntityResolver(); + + Iterator
getTableMappings(); + +} diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/util/HibernateToolsPersistenceProvider.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/util/HibernateToolsPersistenceProvider.java similarity index 84% rename from jbt/src/main/java/org/hibernate/tool/orm/jbt/util/HibernateToolsPersistenceProvider.java rename to jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/util/HibernateToolsPersistenceProvider.java index b14ff56224..1184bd3b05 100644 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/util/HibernateToolsPersistenceProvider.java +++ b/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/util/HibernateToolsPersistenceProvider.java @@ -1,4 +1,4 @@ -package org.hibernate.tool.orm.jbt.util; +package org.hibernate.tool.orm.jbt.internal.util; import java.util.Map; @@ -7,7 +7,7 @@ public class HibernateToolsPersistenceProvider extends HibernatePersistenceProvider { - static EntityManagerFactoryBuilderImpl createEntityManagerFactoryBuilder( + public static EntityManagerFactoryBuilderImpl createEntityManagerFactoryBuilder( final String persistenceUnit, final Map properties) { return new HibernateToolsPersistenceProvider() diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/util/JpaConfiguration.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/util/JpaConfiguration.java similarity index 84% rename from jbt/src/main/java/org/hibernate/tool/orm/jbt/util/JpaConfiguration.java rename to jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/util/JpaConfiguration.java index ff6a3e7b47..cc7235b535 100644 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/util/JpaConfiguration.java +++ b/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/util/JpaConfiguration.java @@ -1,4 +1,4 @@ -package org.hibernate.tool.orm.jbt.util; +package org.hibernate.tool.orm.jbt.internal.util; import java.io.File; import java.util.Iterator; @@ -14,17 +14,17 @@ import org.hibernate.mapping.PersistentClass; import org.hibernate.mapping.Table; import org.hibernate.tool.api.reveng.RevengStrategy; -import org.hibernate.tool.orm.jbt.internal.util.DelegatingPersistentClassWrapperImpl; -import org.hibernate.tool.orm.jbt.wrp.SessionFactoryWrapper; +import org.hibernate.tool.orm.jbt.api.wrp.SessionFactoryWrapper; +import org.hibernate.tool.orm.jbt.internal.factory.SessionFactoryWrapperFactory; import org.w3c.dom.Document; import org.xml.sax.EntityResolver; import jakarta.persistence.EntityManagerFactory; -public class JpaConfiguration extends Configuration { +public class JpaConfiguration extends Configuration implements ExtendedConfiguration { Metadata metadata = null; - SessionFactoryWrapper sessionFactory; + SessionFactory sessionFactory; String persistenceUnit; @@ -134,23 +134,11 @@ public void setReverseEngineeringStrategy(RevengStrategy strategy) { } public Iterator getClassMappings() { - final Iterator iterator = getMetadata().getEntityBindings().iterator(); - return new Iterator() { - @Override - public boolean hasNext() { - return iterator.hasNext(); - } - @Override - public PersistentClass next() { - return new DelegatingPersistentClassWrapperImpl(iterator.next()); - } - - }; + return getMetadata().getEntityBindings().iterator(); } public PersistentClass getClassMapping(String name) { - PersistentClass pc = getMetadata().getEntityBinding(name); - return pc == null ? null : new DelegatingPersistentClassWrapperImpl(pc); + return getMetadata().getEntityBinding(name); } public Iterator
getTableMappings() { @@ -183,8 +171,7 @@ void initialize() { getProperties()); EntityManagerFactory entityManagerFactory = entityManagerFactoryBuilder.build(); - sessionFactory = new SessionFactoryWrapper( - (SessionFactoryImplementor)entityManagerFactory); + sessionFactory = (SessionFactory)entityManagerFactory; metadata = entityManagerFactoryBuilder.getMetadata(); getProperties().putAll(entityManagerFactory.getProperties()); } diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/util/JpaMappingFileHelper.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/util/JpaMappingFileHelper.java similarity index 93% rename from jbt/src/main/java/org/hibernate/tool/orm/jbt/util/JpaMappingFileHelper.java rename to jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/util/JpaMappingFileHelper.java index 6a48fd67b9..662a0d78fd 100644 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/util/JpaMappingFileHelper.java +++ b/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/util/JpaMappingFileHelper.java @@ -1,4 +1,4 @@ -package org.hibernate.tool.orm.jbt.util; +package org.hibernate.tool.orm.jbt.internal.util; import java.util.ArrayList; import java.util.List; diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/util/MetadataHelper.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/util/MetadataHelper.java similarity index 98% rename from jbt/src/main/java/org/hibernate/tool/orm/jbt/util/MetadataHelper.java rename to jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/util/MetadataHelper.java index b3a49a28e5..cd160265bc 100644 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/util/MetadataHelper.java +++ b/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/util/MetadataHelper.java @@ -1,4 +1,4 @@ -package org.hibernate.tool.orm.jbt.util; +package org.hibernate.tool.orm.jbt.internal.util; import java.lang.reflect.Field; import java.lang.reflect.InvocationTargetException; diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/util/MockConnectionProvider.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/util/MockConnectionProvider.java similarity index 99% rename from jbt/src/main/java/org/hibernate/tool/orm/jbt/util/MockConnectionProvider.java rename to jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/util/MockConnectionProvider.java index 7d76fd3a23..b6959051b6 100644 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/util/MockConnectionProvider.java +++ b/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/util/MockConnectionProvider.java @@ -1,4 +1,4 @@ -package org.hibernate.tool.orm.jbt.util; +package org.hibernate.tool.orm.jbt.internal.util; import java.sql.Array; import java.sql.Blob; diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/util/MockDialect.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/util/MockDialect.java similarity index 82% rename from jbt/src/main/java/org/hibernate/tool/orm/jbt/util/MockDialect.java rename to jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/util/MockDialect.java index 68d166e5de..8f4caba707 100644 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/util/MockDialect.java +++ b/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/util/MockDialect.java @@ -1,4 +1,4 @@ -package org.hibernate.tool.orm.jbt.util; +package org.hibernate.tool.orm.jbt.internal.util; import org.hibernate.dialect.Dialect; import org.hibernate.dialect.SimpleDatabaseVersion; diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/util/NativeConfiguration.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/util/NativeConfiguration.java similarity index 82% rename from jbt/src/main/java/org/hibernate/tool/orm/jbt/util/NativeConfiguration.java rename to jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/util/NativeConfiguration.java index e4afaccb21..b7331a2796 100644 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/util/NativeConfiguration.java +++ b/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/util/NativeConfiguration.java @@ -1,4 +1,4 @@ -package org.hibernate.tool.orm.jbt.util; +package org.hibernate.tool.orm.jbt.internal.util; import java.io.File; import java.io.FileWriter; @@ -12,7 +12,6 @@ import javax.xml.transform.dom.DOMSource; import javax.xml.transform.stream.StreamResult; -import org.hibernate.SessionFactory; import org.hibernate.boot.Metadata; import org.hibernate.boot.MetadataSources; import org.hibernate.cfg.Configuration; @@ -20,12 +19,10 @@ import org.hibernate.mapping.PersistentClass; import org.hibernate.mapping.Table; import org.hibernate.tool.api.reveng.RevengStrategy; -import org.hibernate.tool.orm.jbt.internal.util.DelegatingPersistentClassWrapperImpl; -import org.hibernate.tool.orm.jbt.wrp.SessionFactoryWrapper; import org.w3c.dom.Document; import org.xml.sax.EntityResolver; -public class NativeConfiguration extends Configuration { +public class NativeConfiguration extends Configuration implements ExtendedConfiguration { @SuppressWarnings("unused") private EntityResolver entityResolver = null; @@ -91,23 +88,11 @@ public void buildMappings() { } public Iterator getClassMappings() { - final Iterator iterator = getMetadata().getEntityBindings().iterator(); - return new Iterator() { - @Override - public boolean hasNext() { - return iterator.hasNext(); - } - @Override - public PersistentClass next() { - return new DelegatingPersistentClassWrapperImpl(iterator.next()); - } - - }; + return getMetadata().getEntityBindings().iterator(); } public PersistentClass getClassMapping(String name) { - PersistentClass pc = getMetadata().getEntityBinding(name); - return pc == null ? null : new DelegatingPersistentClassWrapperImpl(pc); + return getMetadata().getEntityBinding(name); } public Iterator
getTableMappings() { @@ -139,11 +124,6 @@ public Metadata getMetadata() { return metadata; } - @Override - public SessionFactory buildSessionFactory() { - return new SessionFactoryWrapper(super.buildSessionFactory()); - } - private void buildMetadata() { MetadataSources metadataSources = MetadataHelper.getMetadataSources(this); getStandardServiceRegistryBuilder().applySettings(getProperties()); diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/util/ReflectUtil.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/util/ReflectUtil.java similarity index 97% rename from jbt/src/main/java/org/hibernate/tool/orm/jbt/util/ReflectUtil.java rename to jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/util/ReflectUtil.java index 365c69c1c7..7224dd178a 100644 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/util/ReflectUtil.java +++ b/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/util/ReflectUtil.java @@ -1,4 +1,4 @@ -package org.hibernate.tool.orm.jbt.util; +package org.hibernate.tool.orm.jbt.internal.util; import java.lang.reflect.Constructor; diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/util/RevengConfiguration.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/util/RevengConfiguration.java similarity index 86% rename from jbt/src/main/java/org/hibernate/tool/orm/jbt/util/RevengConfiguration.java rename to jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/util/RevengConfiguration.java index b6151ba7a4..aab6925c3d 100644 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/util/RevengConfiguration.java +++ b/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/util/RevengConfiguration.java @@ -1,4 +1,4 @@ -package org.hibernate.tool.orm.jbt.util; +package org.hibernate.tool.orm.jbt.internal.util; import java.io.File; import java.util.Collections; @@ -13,11 +13,10 @@ import org.hibernate.tool.api.metadata.MetadataConstants; import org.hibernate.tool.api.metadata.MetadataDescriptorFactory; import org.hibernate.tool.api.reveng.RevengStrategy; -import org.hibernate.tool.orm.jbt.internal.util.DelegatingPersistentClassWrapperImpl; import org.w3c.dom.Document; import org.xml.sax.EntityResolver; -public class RevengConfiguration extends Configuration { +public class RevengConfiguration extends Configuration implements ExtendedConfiguration { RevengStrategy revengStrategy; Metadata metadata; @@ -53,17 +52,7 @@ public void readFromJDBC() { public Iterator getClassMappings() { if (metadata != null) { - final Iterator iterator = metadata.getEntityBindings().iterator(); - return new Iterator() { - @Override - public boolean hasNext() { - return iterator.hasNext(); - } - @Override - public PersistentClass next() { - return new DelegatingPersistentClassWrapperImpl(iterator.next()); - } - }; + return metadata.getEntityBindings().iterator(); } else { return Collections.emptyIterator(); } @@ -74,7 +63,7 @@ public PersistentClass getClassMapping(String name) { if (metadata != null) { pc = metadata.getEntityBinding(name); } - return (pc != null) ? new DelegatingPersistentClassWrapperImpl(pc) : null; + return pc; } public Iterator
getTableMappings() { diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/util/SpecialRootClass.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/util/SpecialRootClass.java similarity index 96% rename from jbt/src/main/java/org/hibernate/tool/orm/jbt/util/SpecialRootClass.java rename to jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/util/SpecialRootClass.java index 6a40c0b202..b831a008ba 100644 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/util/SpecialRootClass.java +++ b/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/util/SpecialRootClass.java @@ -1,4 +1,4 @@ -package org.hibernate.tool.orm.jbt.util; +package org.hibernate.tool.orm.jbt.internal.util; import java.lang.reflect.Field; import java.util.Iterator; @@ -10,7 +10,7 @@ import org.hibernate.mapping.Property; import org.hibernate.mapping.RootClass; import org.hibernate.mapping.Value; -import org.hibernate.tool.orm.jbt.wrp.Wrapper; +import org.hibernate.tool.orm.jbt.api.wrp.Wrapper; public class SpecialRootClass extends RootClass { diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/util/TypeRegistry.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/util/TypeRegistry.java index e5480849d7..67eb6787a1 100644 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/util/TypeRegistry.java +++ b/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/util/TypeRegistry.java @@ -10,7 +10,7 @@ import java.util.Map; import java.util.TimeZone; -import org.hibernate.tool.orm.jbt.api.TypeWrapper; +import org.hibernate.tool.orm.jbt.api.wrp.TypeWrapper; import org.hibernate.tool.orm.jbt.internal.factory.TypeWrapperFactory; import org.hibernate.type.BasicTypeRegistry; import org.hibernate.type.Type; diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/wrp/AbstractWrapper.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/wrp/AbstractWrapper.java new file mode 100644 index 0000000000..27a7c3f28d --- /dev/null +++ b/jbt/src/main/java/org/hibernate/tool/orm/jbt/internal/wrp/AbstractWrapper.java @@ -0,0 +1,14 @@ +package org.hibernate.tool.orm.jbt.internal.wrp; + +import org.hibernate.tool.orm.jbt.api.wrp.Wrapper; + +public abstract class AbstractWrapper implements Wrapper { + + @Override + public boolean equals(Object o) { + if (o == null) return false; + if (!Wrapper.class.isAssignableFrom(o.getClass())) return false; + return getWrappedObject().equals(((Wrapper)o).getWrappedObject()); + } + +} diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/wrp/CollectionPersisterWrapperFactory.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/wrp/CollectionPersisterWrapperFactory.java deleted file mode 100644 index 51a4505707..0000000000 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/wrp/CollectionPersisterWrapperFactory.java +++ /dev/null @@ -1,41 +0,0 @@ -package org.hibernate.tool.orm.jbt.wrp; - -import java.lang.reflect.InvocationHandler; -import java.lang.reflect.Method; -import java.lang.reflect.Proxy; - -import org.hibernate.persister.collection.CollectionPersister; - -public class CollectionPersisterWrapperFactory { - - public static Object create(CollectionPersister delegate) { - return Proxy.newProxyInstance( - CollectionPersisterWrapperFactory.class.getClassLoader(), - new Class[] { CollectionPersisterWrapper.class }, - new CollectionPersisterInvocationHandler(delegate)); - } - - static interface CollectionPersisterWrapper extends CollectionPersister, Wrapper {} - - static class CollectionPersisterInvocationHandler implements InvocationHandler { - - private CollectionPersister delegate; - - private CollectionPersisterInvocationHandler(CollectionPersister delegate) { - this.delegate = delegate; - } - - @Override - public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { - if ("getWrappedObject".equals(method.getName())) { - return delegate; - } else if ("getElementType".equals(method.getName())) { - return TypeWrapperFactory.createTypeWrapper(delegate.getElementType()); - } else { - return method.invoke(delegate, args); - } - } - - } - -} diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/wrp/ColumnWrapper.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/wrp/ColumnWrapper.java deleted file mode 100644 index 406e851d07..0000000000 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/wrp/ColumnWrapper.java +++ /dev/null @@ -1,26 +0,0 @@ -package org.hibernate.tool.orm.jbt.wrp; - -import org.hibernate.cfg.Configuration; -import org.hibernate.mapping.Column; -import org.hibernate.mapping.Value; - - -public interface ColumnWrapper extends Wrapper { - - @Override Column getWrappedObject(); - String getName(); - Integer getSqlTypeCode(); - String getSqlType(); - Long getLength(); - int getDefaultLength(); - Integer getPrecision(); - int getDefaultPrecision(); - Integer getScale(); - int getDefaultScale(); - boolean isNullable(); - Value getValue(); - boolean isUnique(); - String getSqlType(Configuration configuration); - void setSqlType(String sqlType); - -} diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/wrp/ConfigurationWrapperFactory.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/wrp/ConfigurationWrapperFactory.java deleted file mode 100644 index e3d04585cb..0000000000 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/wrp/ConfigurationWrapperFactory.java +++ /dev/null @@ -1,112 +0,0 @@ -package org.hibernate.tool.orm.jbt.wrp; - -import java.io.File; -import java.lang.reflect.InvocationHandler; -import java.lang.reflect.InvocationTargetException; -import java.lang.reflect.Method; -import java.lang.reflect.Proxy; -import java.util.Iterator; -import java.util.Map; -import java.util.Properties; - -import org.hibernate.SessionFactory; -import org.hibernate.cfg.Configuration; -import org.hibernate.cfg.NamingStrategy; -import org.hibernate.mapping.PersistentClass; -import org.hibernate.mapping.Table; -import org.hibernate.tool.api.reveng.RevengStrategy; -import org.hibernate.tool.orm.jbt.util.JpaConfiguration; -import org.hibernate.tool.orm.jbt.util.NativeConfiguration; -import org.hibernate.tool.orm.jbt.util.RevengConfiguration; -import org.w3c.dom.Document; -import org.xml.sax.EntityResolver; - -public class ConfigurationWrapperFactory { - - public static ConfigurationWrapper createNativeConfigurationWrapper() { - return (ConfigurationWrapper)Proxy.newProxyInstance( - ConfigurationWrapperFactory.class.getClassLoader(), - new Class[] { ConfigurationWrapper.class }, - new ConfigurationWrapperInvocationHandler(new NativeConfigurationWrapperImpl())); - } - - public static ConfigurationWrapper createRevengConfigurationWrapper() { - return (ConfigurationWrapper)Proxy.newProxyInstance( - ConfigurationWrapperFactory.class.getClassLoader(), - new Class[] { ConfigurationWrapper.class }, - new ConfigurationWrapperInvocationHandler(new RevengConfigurationWrapperImpl())); - } - - public static ConfigurationWrapper createJpaConfigurationWrapper( - String persistenceUnit, Map properties) { - return (ConfigurationWrapper)Proxy.newProxyInstance( - ConfigurationWrapperFactory.class.getClassLoader(), - new Class[] { ConfigurationWrapper.class }, - new ConfigurationWrapperInvocationHandler( - new JpaConfigurationWrapperImpl(persistenceUnit, properties))); - } - - static interface ConfigurationWrapper extends Wrapper { - @Override default Configuration getWrappedObject() { return (Configuration)this; } - String getProperty(String name); - Configuration addFile(File file); - Configuration setProperty(String name, String value); - Configuration setProperties(Properties properties); - void setEntityResolver(EntityResolver testResolver); - void setNamingStrategy(NamingStrategy namingStrategy); - Properties getProperties(); - Configuration addProperties(Properties testProperties); - Configuration configure(Document document); - Configuration configure(File cfgXmlFile); - Configuration configure(); - Configuration addClass(Class class1); - void buildMappings(); - SessionFactory buildSessionFactory(); - Iterator getClassMappings(); - void setPreferBasicCompositeIds(boolean b); - void setReverseEngineeringStrategy(RevengStrategy reverseEngineeringStrategy); - void readFromJDBC(); - PersistentClass getClassMapping(String string); - NamingStrategy getNamingStrategy(); - EntityResolver getEntityResolver(); - Iterator
getTableMappings(); - } - - static class ConfigurationWrapperInvocationHandler implements InvocationHandler { - - private ConfigurationWrapper configurationWrapper = null; - - public ConfigurationWrapperInvocationHandler(ConfigurationWrapper wrapper) { - configurationWrapper = wrapper; - } - - @Override - public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { - try { - return method.invoke(configurationWrapper, args); - } catch (InvocationTargetException t) { - throw t.getTargetException(); - } - } - - } - - static class NativeConfigurationWrapperImpl - extends NativeConfiguration - implements ConfigurationWrapper { - } - - static class RevengConfigurationWrapperImpl - extends RevengConfiguration - implements ConfigurationWrapper { - } - - static class JpaConfigurationWrapperImpl - extends JpaConfiguration - implements ConfigurationWrapper { - public JpaConfigurationWrapperImpl(String persistenceUnit, Map properties) { - super(persistenceUnit, properties); - } - } - -} diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/wrp/CriteriaWrapperFactory.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/wrp/CriteriaWrapperFactory.java deleted file mode 100644 index 9ce727e29a..0000000000 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/wrp/CriteriaWrapperFactory.java +++ /dev/null @@ -1,41 +0,0 @@ -package org.hibernate.tool.orm.jbt.wrp; - -import java.lang.reflect.InvocationHandler; -import java.lang.reflect.Method; -import java.lang.reflect.Proxy; -import java.util.List; - -import jakarta.persistence.Query; - -public class CriteriaWrapperFactory { - - public static Query createCriteriaWrapper(Query target) { - return (Query)Proxy.newProxyInstance( - CriteriaWrapperFactory.class.getClassLoader(), - new Class[] { CriteriaExtension.class }, - new CriteriaInvocationHandler(target)); - } - - static interface CriteriaExtension extends Query { - List list(); - } - - static class CriteriaInvocationHandler implements InvocationHandler { - - Query target = null; - - private CriteriaInvocationHandler(Query target) { - this.target = target; - } - - @Override - public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { - if ("list".equals(method.getName())) { - return target.getResultList(); - } - return method.invoke(target, args); - } - - } - -} diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/wrp/DdlExporterWrapperFactory.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/wrp/DdlExporterWrapperFactory.java deleted file mode 100644 index 43230afaee..0000000000 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/wrp/DdlExporterWrapperFactory.java +++ /dev/null @@ -1,57 +0,0 @@ -package org.hibernate.tool.orm.jbt.wrp; - -import java.lang.reflect.InvocationHandler; -import java.lang.reflect.Method; -import java.lang.reflect.Proxy; -import java.util.Properties; - -import org.hibernate.tool.api.export.ExporterConstants; -import org.hibernate.tool.internal.export.ddl.DdlExporter; - -public class DdlExporterWrapperFactory { - - public static DdlExporterWrapper create(DdlExporter wrappedExporter) { - return (DdlExporterWrapper)Proxy.newProxyInstance( - GenericExporterWrapperFactory.class.getClassLoader(), - new Class[] { DdlExporterWrapper.class }, - new DdlExporterInvocationHandler(wrappedExporter)); - } - - private static class DdlExporterInvocationHandler implements InvocationHandler { - - private DdlExporterWrapper exporterWrapper = null; - - private DdlExporterInvocationHandler(DdlExporter wrappedExporter) { - this.exporterWrapper = new DdlExporterWrapperImpl(wrappedExporter); - } - - @Override - public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { - return method.invoke(exporterWrapper, args); - } - - } - - static interface DdlExporterWrapper extends Wrapper { - @Override DdlExporter getWrappedObject(); - default void setExport(boolean b) { - getWrappedObject().getProperties().put(ExporterConstants.EXPORT_TO_DATABASE, b); - } - default Properties getProperties() { - return getWrappedObject().getProperties(); - } - - } - - static class DdlExporterWrapperImpl implements DdlExporterWrapper { - private DdlExporter delegateDdlExporter = null; - private DdlExporterWrapperImpl(DdlExporter wrappedExporter) { - delegateDdlExporter = wrappedExporter; - } - @Override - public DdlExporter getWrappedObject() { - return delegateDdlExporter; - } - } - -} diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/wrp/DelegatingColumnWrapperImpl.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/wrp/DelegatingColumnWrapperImpl.java deleted file mode 100644 index a954cbe84e..0000000000 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/wrp/DelegatingColumnWrapperImpl.java +++ /dev/null @@ -1,137 +0,0 @@ -package org.hibernate.tool.orm.jbt.wrp; - -import java.util.HashMap; -import java.util.Map; - -import org.hibernate.boot.Metadata; -import org.hibernate.boot.internal.MetadataImpl; -import org.hibernate.cfg.AvailableSettings; -import org.hibernate.cfg.Configuration; -import org.hibernate.dialect.Dialect; -import org.hibernate.engine.jdbc.dialect.spi.DialectFactory; -import org.hibernate.mapping.Column; -import org.hibernate.mapping.Value; -import org.hibernate.tool.orm.jbt.util.MetadataHelper; -import org.hibernate.type.spi.TypeConfiguration; - -public class DelegatingColumnWrapperImpl extends Column implements ColumnWrapper { - - private static final int DEFAULT_LENGTH = 255; - private static final int DEFAULT_PRECISION = 19; - private static final int DEFAULT_SCALE = 2; - - private Column delegate = null; - - public DelegatingColumnWrapperImpl(Column c) { - super(c.getName()); - delegate = c; - } - - @Override - public Column getWrappedObject() { - return delegate; - } - - @Override - public String getSqlType(Configuration configuration) { - Metadata metadata = MetadataHelper.getMetadata(configuration); - TypeConfiguration tc = ((MetadataImpl)metadata).getTypeConfiguration(); - return delegate.getSqlType(tc, buildDialect(configuration), metadata); - } - - @Override - public Long getLength() { - Long length = delegate.getLength(); - return length == null ? Integer.MIN_VALUE : length.longValue(); - } - - @Override - public int getDefaultLength() { - return DEFAULT_LENGTH; - } - - @Override - public Integer getPrecision() { - Integer precision = delegate.getPrecision(); - return precision == null ? Integer.MIN_VALUE : precision.intValue(); - } - - @Override - public int getDefaultPrecision() { - return DEFAULT_PRECISION; - } - - @Override - public Integer getScale() { - Integer scale = delegate.getScale(); - return scale == null ? Integer.MIN_VALUE : scale.intValue(); - } - - @Override - public int getDefaultScale() { - return DEFAULT_SCALE; - } - - @Override - public Value getValue() { - Value val = delegate.getValue(); - if (val != null) { - val = ValueWrapperFactory.createValueWrapper(val); - } - return val; - } - - @Override - public String getName() { - return delegate.getName(); - } - - @Override - public Integer getSqlTypeCode() { - return delegate.getSqlTypeCode(); - } - - @Override - public String getSqlType() { - return delegate.getSqlType(); - } - - @Override - public boolean isNullable() { - return delegate.isNullable(); - } - - @Override - public boolean isUnique() { - return delegate.isUnique(); - } - - @Override - public void setSqlType(String sqlType) { - delegate.setSqlType(sqlType); - } - - @Override - public boolean equals(Object o) { - if (!(o instanceof DelegatingColumnWrapperImpl)) { - return false; - } else { - return ((DelegatingColumnWrapperImpl)o).getWrappedObject().equals(delegate); - } - } - - - private Dialect buildDialect(Configuration configuration) { - Map dialectPropertyMap = new HashMap(); - dialectPropertyMap.put( - AvailableSettings.DIALECT, - configuration.getProperty(AvailableSettings.DIALECT)); - DialectFactory df = configuration - .getStandardServiceRegistryBuilder() - .build() - .getService(DialectFactory.class); - return df.buildDialect(dialectPropertyMap, null); - } - - -} diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/wrp/DelegatingForeignKeyWrapperImpl.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/wrp/DelegatingForeignKeyWrapperImpl.java deleted file mode 100644 index 3bf0dceedc..0000000000 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/wrp/DelegatingForeignKeyWrapperImpl.java +++ /dev/null @@ -1,48 +0,0 @@ -package org.hibernate.tool.orm.jbt.wrp; - -import java.util.Iterator; -import java.util.List; - -import org.hibernate.mapping.Column; -import org.hibernate.mapping.ForeignKey; -import org.hibernate.mapping.Table; - -public class DelegatingForeignKeyWrapperImpl extends ForeignKey implements ForeignKeyWrapper { - - private ForeignKey delegate = null; - - public DelegatingForeignKeyWrapperImpl(ForeignKey fk) { - delegate = fk; - } - - @Override - public ForeignKey getWrappedObject() { - return delegate; - } - - @Override - public Iterator columnIterator() { - return delegate.getColumns().iterator(); - } - - @Override - public Table getReferencedTable() { - Table result = delegate.getReferencedTable(); - return result == null ? null : new DelegatingTableWrapperImpl(result); - } - - @Override - public boolean isReferenceToPrimaryKey() { - return delegate.isReferenceToPrimaryKey(); - } - - @Override - public List getReferencedColumns() { - return delegate.getReferencedColumns(); - } - - @Override - public boolean containsColumn(Column column) { - return delegate.containsColumn(column); - } -} diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/wrp/DelegatingPrimaryKeyWrapperImpl.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/wrp/DelegatingPrimaryKeyWrapperImpl.java deleted file mode 100644 index 58d8d9fc2b..0000000000 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/wrp/DelegatingPrimaryKeyWrapperImpl.java +++ /dev/null @@ -1,27 +0,0 @@ -package org.hibernate.tool.orm.jbt.wrp; - -import java.util.Iterator; - -import org.hibernate.mapping.Column; -import org.hibernate.mapping.PrimaryKey; - -public class DelegatingPrimaryKeyWrapperImpl extends PrimaryKey implements PrimaryKeyWrapper { - - private PrimaryKey delegate = null; - - public DelegatingPrimaryKeyWrapperImpl(PrimaryKey pk) { - super(pk.getTable()); - delegate = pk; - } - - @Override - public PrimaryKey getWrappedObject() { - return delegate; - } - - @Override - public Iterator columnIterator() { - return delegate.getColumns().iterator(); - } - -} diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/wrp/DelegatingTableWrapperImpl.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/wrp/DelegatingTableWrapperImpl.java deleted file mode 100644 index e9381b8b83..0000000000 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/wrp/DelegatingTableWrapperImpl.java +++ /dev/null @@ -1,121 +0,0 @@ -package org.hibernate.tool.orm.jbt.wrp; - -import java.util.Iterator; - -import org.hibernate.mapping.Column; -import org.hibernate.mapping.ForeignKey; -import org.hibernate.mapping.KeyValue; -import org.hibernate.mapping.PrimaryKey; -import org.hibernate.mapping.Table; - -public class DelegatingTableWrapperImpl extends Table implements TableWrapper{ - - private Table delegate = null; - - public DelegatingTableWrapperImpl(Table t) { - delegate = t; - } - - @Override - public Table getWrappedObject() { - return delegate; - } - - @Override - public KeyValue getIdentifierValue() { - KeyValue result = delegate.getIdentifierValue(); - return result == null ? null : (KeyValue)ValueWrapperFactory.createValueWrapper(result); - } - - @Override - public String getName() { - return delegate.getName(); - } - - @Override - public void addColumn(Column column) { - delegate.addColumn(column); - } - - @Override - public String getCatalog() { - return delegate.getCatalog(); - } - - @Override - public String getSchema() { - return delegate.getSchema(); - } - - @Override - public PrimaryKey getPrimaryKey() { - PrimaryKey result = delegate.getPrimaryKey(); - return result == null ? null : new DelegatingPrimaryKeyWrapperImpl(result); - } - - @Override - public Iterator getColumnIterator() { - final Iterator iterator = delegate.getColumns().iterator(); - return new Iterator() { - @Override - public boolean hasNext() { - return iterator.hasNext(); - } - @Override - public Column next() { - return new DelegatingColumnWrapperImpl(iterator.next()); - } - }; - } - - @Override - public Iterator getForeignKeyIterator() { - Iterator iterator = delegate.getForeignKeyIterator(); - return new Iterator() { - @Override - public boolean hasNext() { - return iterator.hasNext(); - } - @Override - public ForeignKey next() { - return new DelegatingForeignKeyWrapperImpl(iterator.next()); - } - }; - } - - @Override - public String getComment() { - return delegate.getComment(); - } - - @Override - public String getRowId() { - return delegate.getRowId(); - } - - @Override - public String getSubselect() { - return delegate.getSubselect(); - } - - @Override - public boolean hasDenormalizedTables() { - return delegate.hasDenormalizedTables(); - } - - @Override - public boolean isAbstract() { - return delegate.isAbstract(); - } - - @Override - public boolean isAbstractUnionTable() { - return delegate.isAbstractUnionTable(); - } - - @Override - public boolean isPhysicalTable() { - return delegate.isPhysicalTable(); - } - -} diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/wrp/EntityPersisterWrapperFactory.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/wrp/EntityPersisterWrapperFactory.java deleted file mode 100644 index 91c7b3fc80..0000000000 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/wrp/EntityPersisterWrapperFactory.java +++ /dev/null @@ -1,84 +0,0 @@ -package org.hibernate.tool.orm.jbt.wrp; - -import java.lang.reflect.InvocationHandler; -import java.lang.reflect.Method; -import java.lang.reflect.Proxy; - -import org.hibernate.persister.entity.EntityPersister; -import org.hibernate.tool.orm.jbt.wrp.TypeWrapperFactory.TypeWrapper; -import org.hibernate.type.Type; - -public class EntityPersisterWrapperFactory { - - public static Object create(EntityPersister delegate) { - return Proxy.newProxyInstance( - EntityPersisterWrapperFactory.class.getClassLoader(), - new Class[] { EntityPersisterWrapper.class }, - new EntityPersisterInvocationHandler(delegate)); - } - - static interface EntityPersisterExtension extends Wrapper { - @Override EntityPersister getWrappedObject(); - default boolean isInstanceOfAbstractEntityPersister() { return true; } - default Object getTuplizerPropertyValue(Object entity, int i) { - return getWrappedObject().getValue(entity, i); - } - default Integer getPropertyIndexOrNull(String propertyName) { - return getWrappedObject().getEntityMetamodel().getPropertyIndexOrNull(propertyName); - } - } - - static interface EntityPersisterWrapper extends EntityPersister, EntityPersisterExtension {} - - static class EntityPersisterInvocationHandler implements InvocationHandler, EntityPersisterExtension { - - private EntityPersister delegate; - - private EntityPersisterInvocationHandler(EntityPersister delegate) { - this.delegate = delegate; - } - - @Override - public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { - if (isEntityPersisterExtensionMethod(method)) { - return method.invoke(this, args); - } else if ("getPropertyTypes".equals(method.getName())) { - return getPropertyTypes(); - } else if ("getIdentifierType".equals(method.getName())) { - return TypeWrapperFactory.createTypeWrapper(delegate.getIdentifierType()); - } else { - return method.invoke(delegate, args); - } - } - - @Override - public EntityPersister getWrappedObject() { - return delegate; - } - - private TypeWrapper[] getPropertyTypes() { - Type[] types = getWrappedObject().getPropertyTypes(); - if (types != null) { - TypeWrapper[] result = new TypeWrapper[types.length]; - for (int i = 0; i < types.length; i++) { - result[i] = TypeWrapperFactory.createTypeWrapper(types[i]); - } - return result; - } - return null; - } - } - - private static boolean isEntityPersisterExtensionMethod(Method m) { - boolean result = true; - try { - EntityPersisterExtension.class.getMethod(m.getName(), m.getParameterTypes()); - } catch (NoSuchMethodException e) { - result = false; - } catch (SecurityException e) { - throw new RuntimeException(e); - } - return result; - } - -} diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/wrp/ExporterWrapperFactory.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/wrp/ExporterWrapperFactory.java deleted file mode 100644 index c83899b230..0000000000 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/wrp/ExporterWrapperFactory.java +++ /dev/null @@ -1,130 +0,0 @@ -package org.hibernate.tool.orm.jbt.wrp; - -import java.io.File; -import java.io.StringWriter; -import java.lang.reflect.InvocationHandler; -import java.lang.reflect.Method; -import java.lang.reflect.Proxy; -import java.util.Properties; - -import org.hibernate.cfg.Configuration; -import org.hibernate.tool.api.export.ArtifactCollector; -import org.hibernate.tool.api.export.Exporter; -import org.hibernate.tool.api.export.ExporterConstants; -import org.hibernate.tool.internal.export.cfg.CfgExporter; -import org.hibernate.tool.internal.export.common.GenericExporter; -import org.hibernate.tool.internal.export.ddl.DdlExporter; -import org.hibernate.tool.internal.export.query.QueryExporter; -import org.hibernate.tool.orm.jbt.api.ArtifactCollectorWrapper; -import org.hibernate.tool.orm.jbt.util.ConfigurationMetadataDescriptor; -import org.hibernate.tool.orm.jbt.util.DummyMetadataDescriptor; -import org.hibernate.tool.orm.jbt.util.ReflectUtil; -import org.hibernate.tool.orm.jbt.wrp.DdlExporterWrapperFactory.DdlExporterWrapper; -import org.hibernate.tool.orm.jbt.wrp.GenericExporterWrapperFactory.GenericExporterWrapper; -import org.hibernate.tool.orm.jbt.wrp.QueryExporterWrapperFactory.QueryExporterWrapper; - -public class ExporterWrapperFactory { - - public static ExporterWrapper create(String className) { - ExporterWrapper result = (ExporterWrapper)Proxy.newProxyInstance( - ExporterWrapperFactory.class.getClassLoader(), - new Class[] { ExporterWrapper.class }, - new ExporterInvocationHandler(className)); - Exporter wrappedExporter = result.getWrappedObject(); - if (CfgExporter.class.isAssignableFrom(wrappedExporter.getClass())) { - wrappedExporter.getProperties().put( - ExporterConstants.METADATA_DESCRIPTOR, - new DummyMetadataDescriptor()); - } else { - wrappedExporter.getProperties().put( - ExporterConstants.METADATA_DESCRIPTOR, - new ConfigurationMetadataDescriptor(new Configuration())); - } - return result; - } - - private static class ExporterInvocationHandler implements InvocationHandler { - - private ExporterWrapper exporterWrapper = null; - - private ExporterInvocationHandler(String className) { - this.exporterWrapper = new ExporterWrapperImpl(className); - } - - @Override - public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { - return method.invoke(exporterWrapper, args); - } - - } - - static interface ExporterWrapper extends Wrapper { - @Override Exporter getWrappedObject(); - default void setConfiguration(Configuration configuration) { - if (CfgExporter.class.isAssignableFrom(getWrappedObject().getClass())) { - ((CfgExporter)getWrappedObject()).setCustomProperties(configuration.getProperties()); - } - getProperties().put( - ExporterConstants.METADATA_DESCRIPTOR, - new ConfigurationMetadataDescriptor(configuration)); - } - default void setArtifactCollector(ArtifactCollectorWrapper artifactCollectorWrapper) { - getProperties().put(ExporterConstants.ARTIFACT_COLLECTOR, artifactCollectorWrapper.getWrappedObject()); - } - default void setOutputDirectory(File dir) { - getProperties().put(ExporterConstants.DESTINATION_FOLDER, dir); - } - default void setTemplatePath(String[] templatePath) { - getProperties().put(ExporterConstants.TEMPLATE_PATH, templatePath); - } - default void start() { - getWrappedObject().start(); - } - default Properties getProperties() { - return getWrappedObject().getProperties(); - } - default GenericExporterWrapper getGenericExporter() { - if (getWrappedObject() instanceof GenericExporter) { - return GenericExporterWrapperFactory.create((GenericExporter)getWrappedObject()); - } else { - return null; - } - } - default DdlExporterWrapper getHbm2DDLExporter() { - if (getWrappedObject() instanceof DdlExporter) { - return DdlExporterWrapperFactory.create((DdlExporter)getWrappedObject()); - } else { - return null; - } - } - default QueryExporterWrapper getQueryExporter() { - if (getWrappedObject() instanceof QueryExporter) { - return QueryExporterWrapperFactory.create((QueryExporter)getWrappedObject()); - } else { - return null; - } - } - default void setCustomProperties(Properties properties) { - if (getWrappedObject() instanceof CfgExporter) { - ((CfgExporter)getWrappedObject()).setCustomProperties(properties); - } - } - default void setOutput(StringWriter stringWriter) { - if (getWrappedObject() instanceof CfgExporter) { - ((CfgExporter)getWrappedObject()).setOutput(stringWriter); - } - } - } - - static class ExporterWrapperImpl implements ExporterWrapper { - private Exporter delegateExporter = null; - private ExporterWrapperImpl(String className) { - delegateExporter = (Exporter)ReflectUtil.createInstance(className); - } - @Override - public Exporter getWrappedObject() { - return delegateExporter; - } - } - -} diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/wrp/ForeignKeyWrapper.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/wrp/ForeignKeyWrapper.java deleted file mode 100644 index e9c67774a7..0000000000 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/wrp/ForeignKeyWrapper.java +++ /dev/null @@ -1,19 +0,0 @@ -package org.hibernate.tool.orm.jbt.wrp; - -import java.util.Iterator; -import java.util.List; - -import org.hibernate.mapping.Column; -import org.hibernate.mapping.ForeignKey; -import org.hibernate.mapping.Table; - -public interface ForeignKeyWrapper extends Wrapper { - - @Override ForeignKey getWrappedObject(); - Table getReferencedTable(); - Iterator columnIterator(); - boolean isReferenceToPrimaryKey(); - List getReferencedColumns(); - boolean containsColumn(Column column); - -} diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/wrp/ForeignKeyWrapperFactory.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/wrp/ForeignKeyWrapperFactory.java deleted file mode 100644 index 54ac6bdeae..0000000000 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/wrp/ForeignKeyWrapperFactory.java +++ /dev/null @@ -1,82 +0,0 @@ -package org.hibernate.tool.orm.jbt.wrp; - -import java.lang.reflect.InvocationHandler; -import java.lang.reflect.InvocationTargetException; -import java.lang.reflect.Method; -import java.lang.reflect.Proxy; -import java.util.Iterator; -import java.util.List; - -import org.hibernate.mapping.Column; -import org.hibernate.mapping.ForeignKey; -import org.hibernate.mapping.Table; - -public class ForeignKeyWrapperFactory { - - public static ForeignKeyWrapper createForeinKeyWrapper(ForeignKey foreignKey) { - return (ForeignKeyWrapper)Proxy.newProxyInstance( - ForeignKeyWrapper.class.getClassLoader(), - new Class[] { ForeignKeyWrapper.class }, - new ForeignKeyWrapperInvocationHandler(foreignKey)); - } - - static interface ForeignKeyExtension extends Wrapper { - default Iterator columnIterator() { - return ((ForeignKey)getWrappedObject()).getColumns().iterator(); - } - default Table getReferencedTable() { - return ((ForeignKey)getWrappedObject()).getReferencedTable(); - } - default boolean isReferenceToPrimaryKey() { - return ((ForeignKey)getWrappedObject()).isReferenceToPrimaryKey(); - } - default List getReferencedColumns() { - return ((ForeignKey)getWrappedObject()).getReferencedColumns(); - } - default boolean containsColumn(Column column) { - return ((ForeignKey)getWrappedObject()).containsColumn(column); - } - } - - static interface ForeignKeyWrapper extends ForeignKeyExtension {} - - private static class ForeignKeyWrapperInvocationHandler implements ForeignKeyExtension, InvocationHandler { - - private ForeignKey extendedForeignKey = null; - - private ForeignKeyWrapperInvocationHandler(ForeignKey foreignKey) { - extendedForeignKey = foreignKey; - } - - @Override - public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { - try { - Method foreignKeyClassMethod = lookupMethodInForeignKeyClass(extendedForeignKey, method); - if (foreignKeyClassMethod != null) { - return foreignKeyClassMethod.invoke(extendedForeignKey, args); - } else { - return method.invoke(this, args); - } - } catch (InvocationTargetException e) { - throw e.getTargetException(); - } - } - - @Override - public ForeignKey getWrappedObject() { - return extendedForeignKey; - } - - } - - private static Method lookupMethodInForeignKeyClass(ForeignKey foreignKey, Method method) { - try { - return foreignKey - .getClass() - .getMethod(method.getName(), method.getParameterTypes()); - } catch (NoSuchMethodException e) { - return null; - } - } - -} diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/wrp/GenericExporterWrapperFactory.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/wrp/GenericExporterWrapperFactory.java deleted file mode 100644 index 0f8dce0d10..0000000000 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/wrp/GenericExporterWrapperFactory.java +++ /dev/null @@ -1,64 +0,0 @@ -package org.hibernate.tool.orm.jbt.wrp; - -import java.lang.reflect.InvocationHandler; -import java.lang.reflect.Method; -import java.lang.reflect.Proxy; - -import org.hibernate.tool.api.export.ExporterConstants; -import org.hibernate.tool.internal.export.common.GenericExporter; - -public class GenericExporterWrapperFactory { - - public static GenericExporterWrapper create(GenericExporter wrappedExporter) { - return (GenericExporterWrapper)Proxy.newProxyInstance( - GenericExporterWrapperFactory.class.getClassLoader(), - new Class[] { GenericExporterWrapper.class }, - new GenericExporterInvocationHandler(wrappedExporter)); - } - - private static class GenericExporterInvocationHandler implements InvocationHandler { - - private GenericExporterWrapper exporterWrapper = null; - - private GenericExporterInvocationHandler(GenericExporter wrappedExporter) { - this.exporterWrapper = new GenericExporterWrapperImpl(wrappedExporter); - } - - @Override - public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { - return method.invoke(exporterWrapper, args); - } - - } - - static interface GenericExporterWrapper extends Wrapper { - @Override GenericExporter getWrappedObject(); - default void setFilePattern(String filePattern) { - getWrappedObject().getProperties().setProperty(ExporterConstants.FILE_PATTERN, filePattern); - } - default void setTemplateName(String templateName) { - getWrappedObject().getProperties().setProperty(ExporterConstants.TEMPLATE_NAME, templateName); - } - default void setForEach(String forEach) { - getWrappedObject().getProperties().setProperty(ExporterConstants.FOR_EACH, forEach); - } - default String getFilePattern() { - return getWrappedObject().getProperties().getProperty(ExporterConstants.FILE_PATTERN); - } - default String getTemplateName() { - return getWrappedObject().getProperties().getProperty(ExporterConstants.TEMPLATE_NAME); - } - } - - static class GenericExporterWrapperImpl implements GenericExporterWrapper { - private GenericExporter delegateGenericExporter = null; - private GenericExporterWrapperImpl(GenericExporter wrappedExporter) { - delegateGenericExporter = wrappedExporter; - } - @Override - public GenericExporter getWrappedObject() { - return delegateGenericExporter; - } - } - -} diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/wrp/HbmExporterWrapper.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/wrp/HbmExporterWrapper.java deleted file mode 100644 index f05db3420c..0000000000 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/wrp/HbmExporterWrapper.java +++ /dev/null @@ -1,76 +0,0 @@ -package org.hibernate.tool.orm.jbt.wrp; - -import java.io.File; -import java.lang.reflect.InvocationTargetException; -import java.lang.reflect.Method; -import java.util.Map; - -import org.hibernate.cfg.Configuration; -import org.hibernate.tool.api.export.ExporterConstants; -import org.hibernate.tool.internal.export.hbm.HbmExporter; -import org.hibernate.tool.internal.export.java.POJOClass; -import org.hibernate.tool.orm.jbt.util.ConfigurationMetadataDescriptor; - -public class HbmExporterWrapper extends HbmExporter { - - private Object delegateExporter; - - public HbmExporterWrapper(Configuration cfg, File file) { - getProperties().put( - METADATA_DESCRIPTOR, - new ConfigurationMetadataDescriptor(cfg)); - if (file != null) { - getProperties().put(OUTPUT_FILE_NAME, file); - } - } - - public void setDelegate(Object delegate) { - delegateExporter = delegate; - } - - public void superExportPOJO(Map map, POJOClass pojoClass) { - super.exportPOJO(map, pojoClass); - } - - @Override - public File getOutputDirectory() { - return super.getOutputDirectory(); - } - - public void setOutputDirectory(File file) { - getProperties().put(ExporterConstants.DESTINATION_FOLDER, file); - } - - public void setExportPOJODelegate(Object delegate) { - setDelegate(delegate); - } - - @SuppressWarnings({ "rawtypes", "unchecked" }) - @Override - public void exportPOJO(Map map, POJOClass pojoClass) { - if (delegateExporter == null) { - super.exportPOJO(map, pojoClass); - } else { - delegateExporterExportPOJO( - (Map)map, - pojoClass, - pojoClass.getQualifiedDeclarationName()); - } - } - - private void delegateExporterExportPOJO ( - Map map, - POJOClass pojoClass, - String qualifiedDeclarationName) { - try { - Method method = delegateExporter - .getClass() - .getDeclaredMethod("exportPojo", Map.class, Object.class, String.class); - method.setAccessible(true); - method.invoke(delegateExporter, map, pojoClass, qualifiedDeclarationName); - } catch (NoSuchMethodException | SecurityException | IllegalAccessException | IllegalArgumentException | InvocationTargetException e) { - throw new RuntimeException(e); - } - } - -} diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/wrp/HqlCodeAssistWrapper.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/wrp/HqlCodeAssistWrapper.java deleted file mode 100644 index 2397885366..0000000000 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/wrp/HqlCodeAssistWrapper.java +++ /dev/null @@ -1,62 +0,0 @@ -package org.hibernate.tool.orm.jbt.wrp; - -import java.lang.reflect.Method; - -import org.hibernate.boot.Metadata; -import org.hibernate.tool.ide.completion.HQLCodeAssist; -import org.hibernate.tool.ide.completion.HQLCompletionProposal; -import org.hibernate.tool.ide.completion.IHQLCompletionRequestor; - -public class HqlCodeAssistWrapper extends HQLCodeAssist { - - public HqlCodeAssistWrapper(Metadata metadata) { - super(metadata); - } - - public void codeComplete(String query, int position, Object handler) { - super.codeComplete(query, position, new HqlCompletionRequestorAdapter(handler));; - } - - private static class HqlCompletionRequestorAdapter implements IHQLCompletionRequestor { - - private Object handler = null; - private Method acceptMethod = null; - private Method completionFailureMethod = null; - - private HqlCompletionRequestorAdapter(Object handler) { - this.handler = handler; - acceptMethod = lookupMethod("accept", Object.class); - completionFailureMethod = lookupMethod("completionFailure", String.class); - } - - @Override - public boolean accept(HQLCompletionProposal proposal) { - try { - return (boolean)acceptMethod.invoke(handler, proposal); - } catch (Throwable t) { - throw new RuntimeException(t); - } - } - - @Override - public void completionFailure(String errorMessage) { - try { - completionFailureMethod.invoke(handler, errorMessage); - } catch (Throwable t) { - throw new RuntimeException(t); - } - } - - private Method lookupMethod(String name, Class argumentClass) { - Method result = null; - try { - result = handler.getClass().getMethod(name, new Class[] { argumentClass }); - } catch (Throwable t) { - throw new RuntimeException(t); - } - return result; - } - - } - -} diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/wrp/HqlCompletionProposalWrapperFactory.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/wrp/HqlCompletionProposalWrapperFactory.java deleted file mode 100644 index 7a8ae9dc33..0000000000 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/wrp/HqlCompletionProposalWrapperFactory.java +++ /dev/null @@ -1,31 +0,0 @@ -package org.hibernate.tool.orm.jbt.wrp; - -import org.hibernate.mapping.Property; -import org.hibernate.tool.ide.completion.HQLCompletionProposal; - -public class HqlCompletionProposalWrapperFactory { - - public static HqlCompletionProposalWrapper createHqlCompletionProposalWrapper( - HQLCompletionProposal hqlCompletionProposalTarget) { - return new HqlCompletionProposalWrapper() { - public Object getWrappedObject() { return hqlCompletionProposalTarget; } - }; - } - - public static interface HqlCompletionProposalWrapper extends Wrapper { - default String getCompletion() { return ((HQLCompletionProposal)getWrappedObject()).getCompletion(); } - default int getReplaceStart() { return ((HQLCompletionProposal)getWrappedObject()).getReplaceStart(); } - default int getReplaceEnd() { return ((HQLCompletionProposal)getWrappedObject()).getReplaceEnd(); } - default String getSimpleName() { return ((HQLCompletionProposal)getWrappedObject()).getSimpleName(); } - default int getCompletionKind() { return ((HQLCompletionProposal)getWrappedObject()).getCompletionKind(); } - default String getEntityName() { return ((HQLCompletionProposal)getWrappedObject()).getEntityName(); } - default String getShortEntityName() { return ((HQLCompletionProposal)getWrappedObject()).getShortEntityName(); } - default Property getProperty() { return ((HQLCompletionProposal)getWrappedObject()).getProperty(); } - default int aliasRefKind() { return HQLCompletionProposal.ALIAS_REF; } - default int entityNameKind() { return HQLCompletionProposal.ENTITY_NAME; } - default int propertyKind() { return HQLCompletionProposal.PROPERTY; } - default int keywordKind() { return HQLCompletionProposal.KEYWORD; } - default int functionKind() { return HQLCompletionProposal.FUNCTION; } - } - -} diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/wrp/NamingStrategyWrapperFactory.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/wrp/NamingStrategyWrapperFactory.java deleted file mode 100644 index 0f9a70257b..0000000000 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/wrp/NamingStrategyWrapperFactory.java +++ /dev/null @@ -1,43 +0,0 @@ -package org.hibernate.tool.orm.jbt.wrp; - -import java.lang.reflect.InvocationHandler; -import java.lang.reflect.Method; -import java.lang.reflect.Proxy; - -import org.hibernate.cfg.NamingStrategy; -import org.hibernate.tool.orm.jbt.util.ReflectUtil; - -public class NamingStrategyWrapperFactory { - - public static Object create(String className) { - Object delegate = ReflectUtil.createInstance(className); - return Proxy.newProxyInstance( - NamingStrategyWrapperFactory.class.getClassLoader(), - new Class[] { NamingStrategy.class , StrategyClassNameProvider.class }, - new NamingStrategyInvocationHandler(delegate)); - } - - private static class NamingStrategyInvocationHandler implements InvocationHandler { - - private Object delegate = null; - - private NamingStrategyInvocationHandler(Object delegate) { - this.delegate = delegate; - } - - @Override - public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { - if (method.getName().equals("getStrategyClassName")) { - return delegate.getClass().getName(); - } else { - return method.invoke(delegate, args); - } - } - - } - - static interface StrategyClassNameProvider { - public String getStrategyClassName(); - } - -} diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/wrp/PrimaryKeyWrapper.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/wrp/PrimaryKeyWrapper.java deleted file mode 100644 index 6847583469..0000000000 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/wrp/PrimaryKeyWrapper.java +++ /dev/null @@ -1,22 +0,0 @@ -package org.hibernate.tool.orm.jbt.wrp; - -import java.util.Iterator; -import java.util.List; - -import org.hibernate.mapping.Column; -import org.hibernate.mapping.PrimaryKey; -import org.hibernate.mapping.Table; - -public interface PrimaryKeyWrapper extends Wrapper { - - @Override PrimaryKey getWrappedObject(); - void addColumn(Column column); - int getColumnSpan(); - List getColumns(); - Column getColumn(int i); - Table getTable(); - boolean containsColumn(Column column); - Iterator columnIterator(); - String getName(); - -} diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/wrp/PrimaryKeyWrapperFactory.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/wrp/PrimaryKeyWrapperFactory.java deleted file mode 100644 index ecbad1b995..0000000000 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/wrp/PrimaryKeyWrapperFactory.java +++ /dev/null @@ -1,61 +0,0 @@ -package org.hibernate.tool.orm.jbt.wrp; - -import java.lang.reflect.InvocationHandler; -import java.lang.reflect.InvocationTargetException; -import java.lang.reflect.Method; -import java.lang.reflect.Proxy; -import java.util.Iterator; -import java.util.List; - -import org.hibernate.mapping.Column; -import org.hibernate.mapping.PrimaryKey; -import org.hibernate.mapping.Table; - -public class PrimaryKeyWrapperFactory { - - public static PrimaryKeyWrapper createForeinKeyWrapper(PrimaryKey primaryKey) { - return (PrimaryKeyWrapper)Proxy.newProxyInstance( - PrimaryKeyWrapper.class.getClassLoader(), - new Class[] { PrimaryKeyWrapper.class }, - new PrimaryKeyWrapperInvocationHandler(primaryKey)); - } - - static interface PrimaryKeyWrapper extends Wrapper { - @Override PrimaryKey getWrappedObject(); - default void addColumn(Column column) { getWrappedObject().addColumn(column); } - default int getColumnSpan() { return getWrappedObject().getColumnSpan(); } - default List getColumns() { return getWrappedObject().getColumns(); } - default Column getColumn(int i) { return getWrappedObject().getColumn(i); } - default Table getTable() { return getWrappedObject().getTable(); } - default boolean containsColumn(Column column) { return getWrappedObject().containsColumn(column); } - default Iterator columnIterator() { - return getWrappedObject().getColumns().iterator(); - } - default String getName() { return getWrappedObject().getName(); } - } - - private static class PrimaryKeyWrapperInvocationHandler implements PrimaryKeyWrapper, InvocationHandler { - - private PrimaryKey wrappedPrimaryKey = null; - - private PrimaryKeyWrapperInvocationHandler(PrimaryKey primaryKey) { - wrappedPrimaryKey = primaryKey; - } - - @Override - public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { - try { - return method.invoke(this, args); - } catch (InvocationTargetException e) { - throw e.getTargetException(); - } - } - - @Override - public PrimaryKey getWrappedObject() { - return wrappedPrimaryKey; - } - - } - -} diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/wrp/PropertyWrapperFactory.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/wrp/PropertyWrapperFactory.java deleted file mode 100644 index 572acbdc67..0000000000 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/wrp/PropertyWrapperFactory.java +++ /dev/null @@ -1,160 +0,0 @@ -package org.hibernate.tool.orm.jbt.wrp; - -import org.hibernate.mapping.PersistentClass; -import org.hibernate.mapping.Property; -import org.hibernate.mapping.Value; -import org.hibernate.tool.orm.jbt.wrp.TypeWrapperFactory.TypeWrapper; -import org.hibernate.type.Type; - -public class PropertyWrapperFactory { - - public static Property createPropertyWrapper(Property wrappedProperty) { - return new DelegatingPropertyWrapperImpl(wrappedProperty); - } - - public static interface PropertyWrapper extends Wrapper{ - @Override Property getWrappedObject(); - Value getValue(); - Type getType(); - void setName(String name); - void setPersistentClass(PersistentClass pc); - PersistentClass getPersistentClass(); - boolean isComposite(); - String getPropertyAccessorName(); - String getName(); - void setValue(Value value); - void setPropertyAccessorName(String name); - void setCascade(String c); - boolean isBackRef(); - boolean isSelectable(); - boolean isUpdateable(); - String getCascade(); - boolean isLazy(); - boolean isOptional(); - boolean isNaturalIdentifier(); - boolean isOptimisticLocked(); - boolean isInsertable(); - } - - static class DelegatingPropertyWrapperImpl extends Property implements PropertyWrapper { - - private Property delegate = null; - - public DelegatingPropertyWrapperImpl(Property p) { - delegate = p; - } - - @Override - public Property getWrappedObject() { - return delegate; - } - - @Override - public Type getType() { - TypeWrapper result = null; - if (getWrappedObject().getValue() != null) { - Type t = getWrappedObject().getType(); - result = t == null ? null : TypeWrapperFactory.createTypeWrapper(t); - } - return result; - } - - @Override - public Value getValue() { - Value v = getWrappedObject().getValue(); - return v == null ? null : ValueWrapperFactory.createValueWrapper(v); - } - - @Override - public void setName(String name) { - getWrappedObject().setName(name); - } - - @Override - public void setPersistentClass(PersistentClass pc) { - getWrappedObject().setPersistentClass(pc); - } - - @Override - public PersistentClass getPersistentClass() { - return getWrappedObject().getPersistentClass(); - } - - @Override - public boolean isComposite() { - return getWrappedObject().isComposite(); - } - - @Override - public String getPropertyAccessorName() { - return getWrappedObject().getPropertyAccessorName(); - } - - @Override - public String getName() { - return getWrappedObject().getName(); - } - - @Override - public void setValue(Value value) { - getWrappedObject().setValue(value); - } - - @Override - public void setPropertyAccessorName(String name) { - getWrappedObject().setPropertyAccessorName(name); - } - - @Override - public void setCascade(String c) { - getWrappedObject().setCascade(c); - } - - @Override - public boolean isBackRef() { - return getWrappedObject().isBackRef(); - } - - @Override - public boolean isSelectable() { - return getWrappedObject().isSelectable(); - } - - @Override - public boolean isUpdateable() { - return getWrappedObject().isUpdateable(); - } - - @Override - public String getCascade() { - return getWrappedObject().getCascade(); - } - - @Override - public boolean isLazy() { - return getWrappedObject().isLazy(); - } - - @Override - public boolean isOptional() { - return getWrappedObject().isOptional(); - } - - @Override - public boolean isNaturalIdentifier() { - return getWrappedObject().isNaturalIdentifier(); - } - - @Override - public boolean isOptimisticLocked() { - return getWrappedObject().isOptimisticLocked(); - } - - @Override - public boolean isInsertable() { - return getWrappedObject().isInsertable(); - } - - } - -} diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/wrp/QueryExporterWrapperFactory.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/wrp/QueryExporterWrapperFactory.java deleted file mode 100644 index 0692733957..0000000000 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/wrp/QueryExporterWrapperFactory.java +++ /dev/null @@ -1,56 +0,0 @@ -package org.hibernate.tool.orm.jbt.wrp; - -import java.lang.reflect.InvocationHandler; -import java.lang.reflect.Method; -import java.lang.reflect.Proxy; -import java.util.List; - -import org.hibernate.tool.api.export.ExporterConstants; -import org.hibernate.tool.internal.export.query.QueryExporter; - -public class QueryExporterWrapperFactory { - - public static QueryExporterWrapper create(QueryExporter wrappedExporter) { - return (QueryExporterWrapper)Proxy.newProxyInstance( - GenericExporterWrapperFactory.class.getClassLoader(), - new Class[] { QueryExporterWrapper.class }, - new QueryExporterInvocationHandler(wrappedExporter)); - } - - private static class QueryExporterInvocationHandler implements InvocationHandler { - - private QueryExporterWrapper exporterWrapper = null; - - private QueryExporterInvocationHandler(QueryExporter wrappedExporter) { - this.exporterWrapper = new QueryExporterWrapperImpl(wrappedExporter); - } - - @Override - public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { - return method.invoke(exporterWrapper, args); - } - - } - - static interface QueryExporterWrapper extends Wrapper { - @Override QueryExporter getWrappedObject(); - default void setQueries(List queries) { - getWrappedObject().setQueries(queries); - } - default void setFilename(String fileName) { - getWrappedObject().getProperties().put(ExporterConstants.OUTPUT_FILE_NAME, fileName); - } - } - - static class QueryExporterWrapperImpl implements QueryExporterWrapper { - private QueryExporter delegateQueryExporter = null; - private QueryExporterWrapperImpl(QueryExporter wrappedExporter) { - delegateQueryExporter = wrappedExporter; - } - @Override - public QueryExporter getWrappedObject() { - return delegateQueryExporter; - } - } - -} diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/wrp/QueryWrapperFactory.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/wrp/QueryWrapperFactory.java deleted file mode 100644 index bc6b09b2ce..0000000000 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/wrp/QueryWrapperFactory.java +++ /dev/null @@ -1,84 +0,0 @@ -package org.hibernate.tool.orm.jbt.wrp; - -import java.lang.reflect.InvocationHandler; -import java.lang.reflect.Method; -import java.lang.reflect.Proxy; -import java.util.List; - -import org.hibernate.query.Query; -import org.hibernate.query.spi.QueryImplementor; -import org.hibernate.type.Type; - -public class QueryWrapperFactory { - - @SuppressWarnings({ "unchecked", "rawtypes" }) - public static QueryWrapper createQueryWrapper(Query query) { - return (QueryWrapper)Proxy.newProxyInstance( - QueryWrapperFactory.class.getClassLoader(), - new Class[] { QueryWrapper.class }, - new QueryWrapperInvocationHandler(query)); - } - - static interface QueryExtension extends Wrapper { - @Override Query getWrappedObject(); - void setParameterList(String name, List list, Object anything); - void setParameter(String string, Object value, Object anything); - void setParameter(int i, Object value, Object anything); - default String[] getReturnAliases() { return new String[0]; } - default Type[] getReturnTypes() { return new Type[0]; } - } - - - static interface QueryWrapper extends QueryExtension, QueryImplementor {} - - private static class QueryWrapperInvocationHandler implements InvocationHandler, QueryExtension { - - private Query query = null; - - private QueryWrapperInvocationHandler(Query q) { - query = q; - } - - @Override - public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { - if (isQueryExtensionMethod(method)) { - return method.invoke(this, args); - } else { - return method.invoke(query, args); - } - } - - @Override - public void setParameterList(String name, List list, Object anything) { - query.setParameterList(name, list); - } - - @Override - public void setParameter(String name, Object value, Object anything) { - query.setParameter(name, value); -; } - - @Override - public void setParameter(int position, Object value, Object anything) { - query.setParameter(position, value); - } - - @Override - public Query getWrappedObject() { return query; } - - - } - - private static boolean isQueryExtensionMethod(Method m) { - boolean result = true; - try { - QueryExtension.class.getMethod(m.getName(), m.getParameterTypes()); - } catch (NoSuchMethodException e) { - result = false; - } catch (SecurityException e) { - throw new RuntimeException(e); - } - return result; - } - -} diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/wrp/RevengStrategyWrapperFactory.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/wrp/RevengStrategyWrapperFactory.java deleted file mode 100644 index 08b944342f..0000000000 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/wrp/RevengStrategyWrapperFactory.java +++ /dev/null @@ -1,45 +0,0 @@ -package org.hibernate.tool.orm.jbt.wrp; - -import java.lang.reflect.Constructor; - -import org.hibernate.tool.api.reveng.RevengStrategy; -import org.hibernate.tool.internal.reveng.strategy.DefaultStrategy; -import org.hibernate.tool.orm.jbt.util.ReflectUtil; - -public class RevengStrategyWrapperFactory { - - public static Object create(Object...objects) { - if (objects.length == 0) { - return createDefault(); - } else if (objects.length == 2) { - return create((String)objects[0], objects[1]); - } else { - throw new RuntimeException("RevengStrategyWrapperFactory#create has either 0 or 2 arguments"); - } - } - - private static Object createDefault() { - return new DefaultStrategy(); - } - - private static Object create(String strategyClassName, Object delegate) { - Class revengStrategyClass = ReflectUtil.lookupClass(strategyClassName); - Constructor constructor = null; - for (Constructor c : revengStrategyClass.getConstructors()) { - if (c.getParameterCount() == 1 && - c.getParameterTypes()[0].isAssignableFrom(RevengStrategy.class)) { - constructor = c; - break; - } - } - if (constructor != null) { - return (RevengStrategy)ReflectUtil.createInstance( - strategyClassName, - new Class[] { RevengStrategy.class }, - new Object[] { delegate }); - } else { - return (RevengStrategy)ReflectUtil.createInstance(strategyClassName); - } - } - -} diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/wrp/SchemaExportWrapper.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/wrp/SchemaExportWrapper.java deleted file mode 100644 index 469ce7ebba..0000000000 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/wrp/SchemaExportWrapper.java +++ /dev/null @@ -1,24 +0,0 @@ -package org.hibernate.tool.orm.jbt.wrp; - -import java.util.EnumSet; - -import org.hibernate.cfg.Configuration; -import org.hibernate.tool.hbm2ddl.SchemaExport; -import org.hibernate.tool.orm.jbt.util.MetadataHelper; -import org.hibernate.tool.schema.TargetType; - -public class SchemaExportWrapper extends SchemaExport { - - private Configuration configuration = null; - - public SchemaExportWrapper(Configuration configuration) { - this.configuration = configuration; - } - - public void create() { - create(EnumSet.of( - TargetType.DATABASE), - MetadataHelper.getMetadata(configuration)); - } - -} \ No newline at end of file diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/wrp/SessionFactoryWrapper.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/wrp/SessionFactoryWrapper.java deleted file mode 100644 index ad233abcc4..0000000000 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/wrp/SessionFactoryWrapper.java +++ /dev/null @@ -1,54 +0,0 @@ -package org.hibernate.tool.orm.jbt.wrp; - -import java.util.HashMap; -import java.util.Map; - -import org.hibernate.SessionFactory; -import org.hibernate.engine.spi.SessionFactoryDelegatingImpl; -import org.hibernate.engine.spi.SessionFactoryImplementor; -import org.hibernate.engine.spi.SessionImplementor; -import org.hibernate.persister.collection.CollectionPersister; -import org.hibernate.persister.entity.EntityPersister; - -public class SessionFactoryWrapper extends SessionFactoryDelegatingImpl { - - public SessionFactoryWrapper(SessionFactory delegate) { - super((SessionFactoryImplementor)delegate); - } - - @Override - public SessionImplementor openSession() { - return SessionWrapperFactory.createSessionWrapper(this, super.openSession()); - } - - public Map getAllClassMetadata() { - Map origin = getMetamodel().entityPersisters(); - Map result = new HashMap(origin.size()); - for (String key : origin.keySet()) { - result.put(key, (EntityPersister)EntityPersisterWrapperFactory.create(origin.get(key))); - } - return result; - } - - public Map getAllCollectionMetadata() { - Map origin = getMetamodel().collectionPersisters(); - Map result = new HashMap(origin.size()); - for (String key : origin.keySet()) { - result.put(key, (CollectionPersister)CollectionPersisterWrapperFactory.create(origin.get(key))); - } - return result; - } - - public EntityPersister getClassMetadata(String string) { - return getAllClassMetadata().get(string); - } - - public EntityPersister getClassMetadata(Class clazz) { - return getClassMetadata(clazz.getName()); - } - - public CollectionPersister getCollectionMetadata(String string) { - return getAllCollectionMetadata().get(string); - } - -} diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/wrp/SessionWrapperFactory.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/wrp/SessionWrapperFactory.java deleted file mode 100644 index a86a7b5e30..0000000000 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/wrp/SessionWrapperFactory.java +++ /dev/null @@ -1,99 +0,0 @@ -package org.hibernate.tool.orm.jbt.wrp; - -import java.lang.reflect.InvocationHandler; -import java.lang.reflect.Method; -import java.lang.reflect.Proxy; - -import org.hibernate.engine.spi.SessionDelegatorBaseImpl; -import org.hibernate.engine.spi.SessionFactoryImplementor; -import org.hibernate.engine.spi.SessionImplementor; -import org.hibernate.tool.orm.jbt.wrp.QueryWrapperFactory.QueryWrapper; - -import jakarta.persistence.Query; -import jakarta.persistence.criteria.CriteriaBuilder; -import jakarta.persistence.criteria.CriteriaQuery; -import jakarta.persistence.criteria.Root; - -public class SessionWrapperFactory { - - public static SessionWrapper createSessionWrapper( - SessionFactoryImplementor sessionFactory, - SessionImplementor session) { - return (SessionWrapper)Proxy.newProxyInstance( - SessionWrapperFactory.class.getClassLoader(), - new Class[] { SessionWrapper.class }, - new SessionWrapperInvocationHandler( - new SessionWrapperImpl(sessionFactory, session))); - } - - static interface SessionWrapper extends SessionImplementor, Wrapper { - Query createCriteria(Class persistentClass); - } - - private static class SessionWrapperInvocationHandler implements InvocationHandler { - - private SessionImplementor session = null; - - private SessionWrapperInvocationHandler(SessionImplementor session) { - this.session = session; - } - - @Override - public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { - return method.invoke(session, args); - } - - } - - @SuppressWarnings("serial") - private static class SessionWrapperImpl extends SessionDelegatorBaseImpl implements SessionWrapper { - - private SessionFactoryImplementor sessionFactory; - - public SessionWrapperImpl(SessionFactoryImplementor sessionFactory, SessionImplementor delegate) { - super(delegate); - this.sessionFactory = sessionFactory; - } - - @Override - public SessionFactoryImplementor getSessionFactory() { - return sessionFactory; - } - - @Override - public SessionImplementor getWrappedObject() { - return delegate(); - } - - @SuppressWarnings({ "rawtypes", "unchecked" }) - @Override - public Query createCriteria(Class persistentClass) { - CriteriaBuilder criteriaBuilder = delegate().getCriteriaBuilder(); - CriteriaQuery criteriaQuery = criteriaBuilder.createQuery(persistentClass); - Root root = criteriaQuery.from(persistentClass); - criteriaQuery.select(root); - return CriteriaWrapperFactory.createCriteriaWrapper(delegate().createQuery(criteriaQuery)); - } - - @Override - public QueryWrapper createQuery(String queryString) { - return QueryWrapperFactory.createQueryWrapper(delegate().createQuery(queryString, null)); - } - - @Override - public boolean contains(Object o) { - boolean result = false; - try { - result = delegate().contains(o); - } catch (IllegalArgumentException e) { - String message = e.getMessage(); - if (!(message.startsWith("Class '") && message.endsWith("' is not an entity class"))) { - throw e; - } - } - return result; - } - - } - -} diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/wrp/TableWrapper.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/wrp/TableWrapper.java deleted file mode 100644 index 860c02c8b1..0000000000 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/wrp/TableWrapper.java +++ /dev/null @@ -1,28 +0,0 @@ -package org.hibernate.tool.orm.jbt.wrp; - -import java.util.Iterator; - -import org.hibernate.mapping.Column; -import org.hibernate.mapping.ForeignKey; -import org.hibernate.mapping.PrimaryKey; -import org.hibernate.mapping.Value; - -public interface TableWrapper extends Wrapper { - - String getName(); - void addColumn(Column column); - String getCatalog(); - String getSchema(); - PrimaryKey getPrimaryKey(); - Iterator getColumnIterator(); - Iterator getForeignKeyIterator(); - String getComment(); - String getRowId(); - String getSubselect(); - boolean hasDenormalizedTables(); - boolean isAbstract(); - boolean isAbstractUnionTable(); - boolean isPhysicalTable(); - Value getIdentifierValue(); - -} diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/wrp/TypeFactoryWrapper.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/wrp/TypeFactoryWrapper.java deleted file mode 100644 index 6900f8d2a7..0000000000 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/wrp/TypeFactoryWrapper.java +++ /dev/null @@ -1,210 +0,0 @@ -package org.hibernate.tool.orm.jbt.wrp; - -import java.math.BigDecimal; -import java.math.BigInteger; -import java.util.Currency; -import java.util.Date; -import java.util.GregorianCalendar; -import java.util.HashMap; -import java.util.Locale; -import java.util.Map; -import java.util.TimeZone; - -import org.hibernate.tool.orm.jbt.wrp.TypeWrapperFactory.TypeWrapper; -import org.hibernate.type.BasicTypeRegistry; -import org.hibernate.type.Type; -import org.hibernate.type.spi.TypeConfiguration; - -public class TypeFactoryWrapper { - - public static final TypeFactoryWrapper INSTANCE = new TypeFactoryWrapper(); - - private static Map TYPE_REGISTRY = null; - private static final BasicTypeRegistry BASIC_TYPE_REGISTRY = new TypeConfiguration().getBasicTypeRegistry(); - - private Map typeFormats = null; - - private TypeFactoryWrapper() { - } - - public TypeWrapper getBooleanType() { - return typeRegistry().get("boolean"); - } - - public TypeWrapper getByteType() { - return typeRegistry().get("byte"); - } - - public TypeWrapper getBigIntegerType() { - return typeRegistry().get("big_integer"); - } - - public TypeWrapper getShortType() { - return typeRegistry().get("short"); - } - - public TypeWrapper getCalendarType() { - return typeRegistry().get("calendar"); - } - - public TypeWrapper getCalendarDateType() { - return typeRegistry().get("calendar_date"); - } - - public TypeWrapper getIntegerType() { - return typeRegistry().get("integer"); - } - - public TypeWrapper getBigDecimalType() { - return typeRegistry().get("big_decimal"); - } - - public TypeWrapper getCharacterType() { - return typeRegistry().get("character"); - } - - public TypeWrapper getClassType() { - return typeRegistry().get("class"); - } - - public TypeWrapper getCurrencyType() { - return typeRegistry().get("currency"); - } - - public TypeWrapper getDateType() { - return typeRegistry().get("date"); - } - - public TypeWrapper getDoubleType() { - return typeRegistry().get("double"); - } - - public TypeWrapper getFloatType() { - return typeRegistry().get("float"); - } - - public TypeWrapper getLocaleType() { - return typeRegistry().get("locale"); - } - - public TypeWrapper getLongType() { - return typeRegistry().get("long"); - } - - public TypeWrapper getStringType() { - return typeRegistry().get("string"); - } - - public TypeWrapper getTextType() { - return typeRegistry().get("text"); - } - - public TypeWrapper getTimeType() { - return typeRegistry().get("time"); - } - - public TypeWrapper getTimestampType() { - return typeRegistry().get("timestamp"); - } - - public TypeWrapper getTimezoneType() { - return typeRegistry().get("timezone"); - } - - public TypeWrapper getTrueFalseType() { - return typeRegistry().get("true_false"); - } - - public TypeWrapper getYesNoType() { - return typeRegistry().get("yes_no"); - } - - public TypeWrapper getNamedType(String name) { - if (!typeRegistry().containsKey(name)) { - Type basicType = BASIC_TYPE_REGISTRY.getRegisteredType(name); - if (basicType != null) { - typeRegistry().put(name, TypeWrapperFactory.createTypeWrapper(basicType)); - } else { - typeRegistry().put(name, null); - } - } - return typeRegistry().get(name); - } - - public TypeWrapper getBasicType(String name) { - return getNamedType(name); - } - - public Map getTypeFormats() { - if (typeFormats == null) { - initializeTypeFormats(); - } - return typeFormats; - } - - protected void initializeTypeFormats() { - typeFormats = new HashMap<>(); - addTypeFormat(getBooleanType(), Boolean.TRUE); - addTypeFormat(getByteType(), Byte.valueOf((byte) 42)); - addTypeFormat(getBigIntegerType(), BigInteger.valueOf(42)); - addTypeFormat(getShortType(), Short.valueOf((short) 42)); - addTypeFormat(getCalendarType(), new GregorianCalendar()); - addTypeFormat(getCalendarDateType(), new GregorianCalendar()); - addTypeFormat(getIntegerType(), Integer.valueOf(42)); - addTypeFormat(getBigDecimalType(), new BigDecimal(42.0)); - addTypeFormat(getCharacterType(), Character.valueOf('h')); - addTypeFormat(getClassType(), Class.class); - addTypeFormat(getCurrencyType(), Currency.getInstance(Locale.getDefault())); - addTypeFormat(getDateType(), new Date()); - addTypeFormat(getDoubleType(), Double.valueOf(42.42)); - addTypeFormat(getFloatType(), Float.valueOf((float)42.42)); - addTypeFormat(getLocaleType(), Locale.getDefault()); - addTypeFormat(getLongType(), Long.valueOf(42)); - addTypeFormat(getStringType(), "a string"); //$NON-NLS-1$ - addTypeFormat(getTextType(), "a text"); //$NON-NLS-1$ - addTypeFormat(getTimeType(), new Date()); - addTypeFormat(getTimestampType(), new Date()); - addTypeFormat(getTimezoneType(), TimeZone.getDefault()); - addTypeFormat(getTrueFalseType(), Boolean.TRUE); - addTypeFormat(getYesNoType(), Boolean.TRUE); - } - - protected void addTypeFormat(TypeWrapper type, Object value) { - typeFormats.put(type, type.toString(value)); - } - - private static Map typeRegistry() { - if (TYPE_REGISTRY == null) { - createTypeRegistry(); - } - return TYPE_REGISTRY; - } - - private static void createTypeRegistry() { - TYPE_REGISTRY = new HashMap(); - TYPE_REGISTRY.put("boolean", TypeWrapperFactory.createTypeWrapper(BASIC_TYPE_REGISTRY.getRegisteredType("boolean"))); - TYPE_REGISTRY.put("byte", TypeWrapperFactory.createTypeWrapper(BASIC_TYPE_REGISTRY.getRegisteredType("byte"))); - TYPE_REGISTRY.put("big_integer", TypeWrapperFactory.createTypeWrapper(BASIC_TYPE_REGISTRY.getRegisteredType("big_integer"))); - TYPE_REGISTRY.put("short", TypeWrapperFactory.createTypeWrapper(BASIC_TYPE_REGISTRY.getRegisteredType("short"))); - TYPE_REGISTRY.put("calendar", TypeWrapperFactory.createTypeWrapper(BASIC_TYPE_REGISTRY.getRegisteredType("calendar"))); - TYPE_REGISTRY.put("calendar_date", TypeWrapperFactory.createTypeWrapper(BASIC_TYPE_REGISTRY.getRegisteredType("calendar_date"))); - TYPE_REGISTRY.put("integer", TypeWrapperFactory.createTypeWrapper(BASIC_TYPE_REGISTRY.getRegisteredType("integer"))); - TYPE_REGISTRY.put("big_decimal", TypeWrapperFactory.createTypeWrapper(BASIC_TYPE_REGISTRY.getRegisteredType("big_decimal"))); - TYPE_REGISTRY.put("character", TypeWrapperFactory.createTypeWrapper(BASIC_TYPE_REGISTRY.getRegisteredType("character"))); - TYPE_REGISTRY.put("class", TypeWrapperFactory.createTypeWrapper(BASIC_TYPE_REGISTRY.getRegisteredType("class"))); - TYPE_REGISTRY.put("currency", TypeWrapperFactory.createTypeWrapper(BASIC_TYPE_REGISTRY.getRegisteredType("currency"))); - TYPE_REGISTRY.put("date", TypeWrapperFactory.createTypeWrapper(BASIC_TYPE_REGISTRY.getRegisteredType("date"))); - TYPE_REGISTRY.put("double", TypeWrapperFactory.createTypeWrapper(BASIC_TYPE_REGISTRY.getRegisteredType("double"))); - TYPE_REGISTRY.put("float", TypeWrapperFactory.createTypeWrapper(BASIC_TYPE_REGISTRY.getRegisteredType("float"))); - TYPE_REGISTRY.put("locale", TypeWrapperFactory.createTypeWrapper(BASIC_TYPE_REGISTRY.getRegisteredType("locale"))); - TYPE_REGISTRY.put("long", TypeWrapperFactory.createTypeWrapper(BASIC_TYPE_REGISTRY.getRegisteredType("long"))); - TYPE_REGISTRY.put("string", TypeWrapperFactory.createTypeWrapper(BASIC_TYPE_REGISTRY.getRegisteredType("string"))); - TYPE_REGISTRY.put("text", TypeWrapperFactory.createTypeWrapper(BASIC_TYPE_REGISTRY.getRegisteredType("text"))); - TYPE_REGISTRY.put("time", TypeWrapperFactory.createTypeWrapper(BASIC_TYPE_REGISTRY.getRegisteredType("time"))); - TYPE_REGISTRY.put("timestamp", TypeWrapperFactory.createTypeWrapper(BASIC_TYPE_REGISTRY.getRegisteredType("timestamp"))); - TYPE_REGISTRY.put("timezone", TypeWrapperFactory.createTypeWrapper(BASIC_TYPE_REGISTRY.getRegisteredType("timezone"))); - TYPE_REGISTRY.put("true_false", TypeWrapperFactory.createTypeWrapper(BASIC_TYPE_REGISTRY.getRegisteredType("true_false"))); - TYPE_REGISTRY.put("yes_no", TypeWrapperFactory.createTypeWrapper(BASIC_TYPE_REGISTRY.getRegisteredType("yes_no"))); - } - -} diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/wrp/TypeWrapperFactory.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/wrp/TypeWrapperFactory.java deleted file mode 100644 index ce23205fa5..0000000000 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/wrp/TypeWrapperFactory.java +++ /dev/null @@ -1,163 +0,0 @@ -package org.hibernate.tool.orm.jbt.wrp; - -import java.lang.reflect.InvocationHandler; -import java.lang.reflect.InvocationTargetException; -import java.lang.reflect.Method; -import java.lang.reflect.Proxy; -import java.text.SimpleDateFormat; -import java.util.Calendar; -import java.util.Map; - -import org.hibernate.type.BasicType; -import org.hibernate.type.CollectionType; -import org.hibernate.type.Type; -import org.hibernate.type.descriptor.java.CalendarJavaType; -import org.hibernate.type.descriptor.java.JavaType; - -public class TypeWrapperFactory { - - public static TypeWrapper createTypeWrapper(Type wrappedType) { - return (TypeWrapper)Proxy.newProxyInstance( - TypeWrapperFactory.class.getClassLoader(), - new Class[] { TypeWrapper.class }, - new TypeWrapperInvocationHandler(wrappedType)); - } - - static interface TypeExtension extends Wrapper { - default public String toString(Object object) { - if (BasicType.class.isAssignableFrom(getWrappedObject().getClass())) { - JavaType javaType = ((BasicType)getWrappedObject()).getJavaTypeDescriptor(); - if (javaType instanceof CalendarJavaType && object instanceof Calendar) { - SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd"); - return simpleDateFormat.format(((Calendar)object).getTime()); - } else { - return javaType.toString(object); - } - } else { - throw new UnsupportedOperationException( - "Class '" + - getWrappedObject().getClass().getName() + - "' does not support 'toString(Object)'." ); - } - } - default Object fromStringValue(String stringValue) { - if (BasicType.class.isAssignableFrom(getWrappedObject().getClass())) { - return ((BasicType)getWrappedObject()).getJavaTypeDescriptor().fromString(stringValue); - } else { - throw new UnsupportedOperationException( - "Class '" + - getWrappedObject().getClass().getName() + - "' does not support 'fromStringValue(Object)'." ); - } - } - default boolean isOneToOne() { - throw new UnsupportedOperationException( - "Class '" + - getWrappedObject().getClass().getName() + - "' does not support 'isOneToOne()'." ); - } - default String getAssociatedEntityName() { - return null; - } - default boolean isIntegerType() { - return Integer.class.isAssignableFrom(((Type)getWrappedObject()).getReturnedClass()); - } - default boolean isArrayType() { - if (CollectionType.class.isAssignableFrom(getWrappedObject().getClass())) { - return ((CollectionType)getWrappedObject()).isArrayType(); - } else { - return false; - } - } - default boolean isInstanceOfPrimitiveType() { - if (!(BasicType.class.isAssignableFrom(getWrappedObject().getClass()))) { - return false; - } - return isPrimitive(((BasicType)getWrappedObject()).getJavaType()); - } - default Class getPrimitiveClass() { - if (!isInstanceOfPrimitiveType()) { - throw new UnsupportedOperationException( - "Class '" + - getWrappedObject().getClass().getName() + - "' does not support 'getPrimitiveClass()'."); - } else { - Class javaType = ((BasicType)getWrappedObject()).getJavaType(); - if (isPrimitiveWrapperClass(javaType)) { - return PRIMITIVE_CLASSES_MAP.get(javaType); - } else { - return javaType; - } - } - } - default String getRole() { - throw new UnsupportedOperationException( - "Class '" + - getWrappedObject().getClass().getName() + - "' does not support 'getRole()'."); - } - } - - static interface TypeWrapper extends Type, TypeExtension {} - - private static class TypeWrapperInvocationHandler implements TypeExtension, InvocationHandler { - - private Type extendedType = null; - - public TypeWrapperInvocationHandler(Type type) { - extendedType = type; - } - - @Override - public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { - try { - Method typeClassMethod = lookupMethodInTypeClass(extendedType, method); - if (typeClassMethod != null) { - return typeClassMethod.invoke(extendedType, args); - } else { - return method.invoke(this, args); - } - } catch (InvocationTargetException e) { - throw e.getTargetException(); - } - } - - @Override - public Type getWrappedObject() { - return extendedType; - } - - } - - private static Method lookupMethodInTypeClass(Type type, Method method) { - try { - return type - .getClass() - .getMethod(method.getName(), method.getParameterTypes()); - } catch (NoSuchMethodException e) { - return null; - } - } - - private static final Map, Class> PRIMITIVE_CLASSES_MAP = Map.of( - Integer.class, int.class, - Short.class, short.class, - Long.class, long.class, - Double.class, double.class, - Float.class, float.class, - Character.class, char.class, - Byte.class, byte.class, - Boolean.class, boolean.class); - - private static boolean isPrimitiveWrapperClass(Class candidateClass) { - return PRIMITIVE_CLASSES_MAP.keySet().contains(candidateClass); - } - - private static boolean isPrimitiveClass(Class candidateClass) { - return PRIMITIVE_CLASSES_MAP.values().contains(candidateClass); - } - - private static boolean isPrimitive(Class candidateClass) { - return isPrimitiveWrapperClass(candidateClass) || isPrimitiveClass(candidateClass); - } -} diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/wrp/ValueWrapperFactory.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/wrp/ValueWrapperFactory.java deleted file mode 100644 index 4c9a5325f3..0000000000 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/wrp/ValueWrapperFactory.java +++ /dev/null @@ -1,204 +0,0 @@ -package org.hibernate.tool.orm.jbt.wrp; - -import java.lang.reflect.InvocationHandler; -import java.lang.reflect.InvocationTargetException; -import java.lang.reflect.Method; -import java.lang.reflect.Proxy; -import java.util.Iterator; -import java.util.Properties; - -import org.hibernate.FetchMode; -import org.hibernate.mapping.Any; -import org.hibernate.mapping.Array; -import org.hibernate.mapping.Bag; -import org.hibernate.mapping.Collection; -import org.hibernate.mapping.Column; -import org.hibernate.mapping.Component; -import org.hibernate.mapping.DependantValue; -import org.hibernate.mapping.Fetchable; -import org.hibernate.mapping.IdentifierBag; -import org.hibernate.mapping.KeyValue; -import org.hibernate.mapping.List; -import org.hibernate.mapping.ManyToOne; -import org.hibernate.mapping.Map; -import org.hibernate.mapping.OneToMany; -import org.hibernate.mapping.OneToOne; -import org.hibernate.mapping.PersistentClass; -import org.hibernate.mapping.PrimitiveArray; -import org.hibernate.mapping.Property; -import org.hibernate.mapping.Selectable; -import org.hibernate.mapping.Set; -import org.hibernate.mapping.Table; -import org.hibernate.mapping.ToOne; -import org.hibernate.mapping.Value; -import org.hibernate.tool.orm.jbt.internal.util.DelegatingPersistentClassWrapperImpl; -import org.hibernate.type.Type; - -public class ValueWrapperFactory { - - public static ValueWrapper createValueWrapper(Value wrappedValue) { - return (ValueWrapper)Proxy.newProxyInstance( - ValueWrapperFactory.class.getClassLoader(), - new Class[] { ValueWrapper.class, KeyValue.class }, - new ValueWrapperInvocationHandler(wrappedValue)); - } - - static interface ValueExtension extends Wrapper { - default Value getWrappedObject() { return (Value)this; } - default boolean isCollection() { return Collection.class.isAssignableFrom(getWrappedObject().getClass()); } - default boolean isOneToMany() { return OneToMany.class.isAssignableFrom(getWrappedObject().getClass()); } - default boolean isManyToOne() { return ManyToOne.class.isAssignableFrom(getWrappedObject().getClass()); } - default boolean isOneToOne() { return OneToOne.class.isAssignableFrom(getWrappedObject().getClass()); } - default boolean isMap() { return Map.class.isAssignableFrom(getWrappedObject().getClass()); } - default boolean isList() { return List.class.isAssignableFrom(getWrappedObject().getClass()); } - default boolean isToOne() { return ToOne.class.isAssignableFrom(getWrappedObject().getClass()); } - default boolean isDependantValue() { return DependantValue.class.isAssignableFrom(getWrappedObject().getClass()); } - default boolean isAny() {return Any.class.isAssignableFrom(getWrappedObject().getClass()); } - default boolean isSet() {return Set.class.isAssignableFrom(getWrappedObject().getClass()); } - default boolean isPrimitiveArray() {return PrimitiveArray.class.isAssignableFrom(getWrappedObject().getClass()); } - default boolean isArray() {return Array.class.isAssignableFrom(getWrappedObject().getClass()); } - default boolean isIdentifierBag() {return IdentifierBag.class.isAssignableFrom(getWrappedObject().getClass()); } - default boolean isBag() {return Bag.class.isAssignableFrom(getWrappedObject().getClass()); } - default boolean isComponent() { return Component.class.isAssignableFrom(getWrappedObject().getClass()); } - default boolean isEmbedded() { return false; } - default Value getElement() { return null; } - default void setElement(Value element) {} - default void setTable(Table table) {} - default Table getCollectionTable() { return null; } - default void setCollectionTable(Table table) {} - default Value getCollectionElement() { return getElement(); } - default void setIndex(Value index) {} - default Value getIndex() { return null; } - default void setTypeName(String name) {} - default String getTypeName() { return null; } - default String getComponentClassName() { return null; } - default boolean isTypeSpecified() { throw new UnsupportedOperationException("Class '" + getWrappedObject().getClass().getName() + "' does not support 'isTypeSpecified()'." ); } - default KeyValue getKey() { throw new UnsupportedOperationException("Class '" + getWrappedObject().getClass().getName() + "' does not support 'getKey()'." ); } - default String getElementClassName() { throw new UnsupportedOperationException("Class '" + getWrappedObject().getClass().getName() + "' does not support 'getElementClassName()'." ); } - default String getReferencedEntityName() { throw new UnsupportedOperationException("Class '" + getWrappedObject().getClass().getName() + "' does not support 'getReferencedEntityName()'." ); } - default String getEntityName() { throw new UnsupportedOperationException("Class '" + getWrappedObject().getClass().getName() + "' does not support 'getEntityName()'." ); } - default String getForeignKeyName() { throw new UnsupportedOperationException("Class '" + getWrappedObject().getClass().getName() + "' does not support 'getForeignKeyName()'." ); } - default String getParentProperty() { throw new UnsupportedOperationException("Class '" + getWrappedObject().getClass().getName() + "' does not support 'getParentProperty()'." ); } - default PersistentClass getOwner() { throw new UnsupportedOperationException("Class '" + getWrappedObject().getClass().getName() + "' does not support 'getOwner()'." ); } - default Iterator getPropertyIterator() { throw new UnsupportedOperationException("Class '" + getWrappedObject().getClass().getName() + "' does not support 'getPropertyIterator()'." ); } - default void addColumn(Column column) { throw new UnsupportedOperationException("Class '" + getWrappedObject().getClass().getName() + "' does not support 'addColumn(Column)'." ); } - default void setTypeParameters(Properties properties) { throw new UnsupportedOperationException("Class '" + getWrappedObject().getClass().getName() + "' does not support 'setTypeParameters(Properties)'." ); } - default void setElementClassName(String name) { throw new UnsupportedOperationException("Class '" + getWrappedObject().getClass().getName() + "' does not support 'setElementClassName(String)'." ); } - default void setKey(Value value) { - if (Collection.class.isAssignableFrom(getWrappedObject().getClass())) { - ((Collection)getWrappedObject()).setKey((KeyValue)value); - } else { - throw new UnsupportedOperationException("Class '" + getWrappedObject().getClass().getName() + "' does not support 'setKey(KeyValue)'." ); - } - } - default void setFetchModeJoin() { - if (Fetchable.class.isAssignableFrom(getWrappedObject().getClass())) { - ((Fetchable)getWrappedObject()).setFetchMode(FetchMode.JOIN); - } else { - throw new UnsupportedOperationException("Class '" + getWrappedObject().getClass().getName() + "' does not support 'setFetchModeJoin()'." ); - } - } - default boolean isInverse() { throw new UnsupportedOperationException("Class '" + getWrappedObject().getClass().getName() + "' does not support 'isInverse()'." ); } - default PersistentClass getAssociatedClass() { throw new UnsupportedOperationException("Class '" + getWrappedObject().getClass().getName() + "' does not support 'getAssociatedClass()'." ); } - default void setAssociatedClass(PersistentClass pc) { throw new UnsupportedOperationException("Class '" + getWrappedObject().getClass().getName() + "' does not support 'setAssociatedClass(PersistentClass)'." ); } - default void setLazy(boolean b) { - if (Fetchable.class.isAssignableFrom(getWrappedObject().getClass())) { - ((Fetchable)getWrappedObject()).setLazy(b);; - } else { - throw new UnsupportedOperationException("Class '" + getWrappedObject().getClass().getName() + "' does not support 'setLazy(boolean)'." ); } - } - default void setRole(String role) { throw new UnsupportedOperationException("Class '" + getWrappedObject().getClass().getName() + "' does not support 'setRole(String)'." ); } - default void setReferencedEntityName(String name) { throw new UnsupportedOperationException("Class '" + getWrappedObject().getClass().getName() + "' does not support 'setReferencedEntityName(String)'." ); } - default Iterator getColumnIterator() { - return getWrappedObject().getSelectables().iterator(); - } - } - - public static interface ValueWrapper extends KeyValue, ValueExtension {} - - - private static class ValueWrapperInvocationHandler implements ValueExtension, InvocationHandler { - - private Value extendedValue = null; - - public ValueWrapperInvocationHandler(Value value) { - extendedValue = value; - } - - @Override - public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { - Object result = null; - try { - Method valueClassMethod = lookupMethodInValueClass(extendedValue, method); - if (valueClassMethod != null) { - result = valueClassMethod.invoke(extendedValue, args); - if (result != null && Value.class.isAssignableFrom(method.getReturnType())) { - result = ValueWrapperFactory.createValueWrapper((Value)result); - } else if ("getPropertyIterator".equals(valueClassMethod.getName())) { - result = createWrappedPropertyIterator((Iterator)result); - } else if (result != null && "getAssociatedClass".equals(valueClassMethod.getName())) { - result = new DelegatingPersistentClassWrapperImpl((PersistentClass)result); - } else if (result != null && "getType".equals(method.getName())) { - result = TypeWrapperFactory.createTypeWrapper((Type)result); - } - } else { - result = method.invoke(this, args); - if (!"getWrappedObject".equals(method.getName()) - && result != null - && method.getReturnType().isAssignableFrom(Value.class)) { - result = ValueWrapperFactory.createValueWrapper((Value)result); - } - } - } catch (InvocationTargetException e) { - throw e.getTargetException(); - } - return result; - } - - @Override - public Value getWrappedObject() { - return extendedValue; - } - - @Override - public Value getElement() { - try { - return (Value)extendedValue.getClass().getMethod("getElement", new Class[] {}).invoke(extendedValue); - } catch (NoSuchMethodException e) { - // TODO for now return null, needs to be replaced by throwing UnsupportedOperationException - return null; - // throw new UnsupportedOperationException("Class '" + extendedValue.getClass().getName() + "' does not support 'isTypeSpecified()'." ); - } catch (InvocationTargetException e) { - throw new RuntimeException(e.getTargetException()); - } catch (IllegalAccessException e) { - throw new RuntimeException(e); - } - } - - } - - private static Method lookupMethodInValueClass(Value value, Method method) { - try { - return value - .getClass() - .getMethod(method.getName(), method.getParameterTypes()); - } catch (NoSuchMethodException e) { - return null; - } - } - - private static Iterator createWrappedPropertyIterator(Iterator iterator) { - if (iterator == null) return null; - return new Iterator() { - @Override - public boolean hasNext() { - return iterator.hasNext(); - } - @Override - public Property next() { - return PropertyWrapperFactory.createPropertyWrapper((Property)iterator.next()); - } - }; - } - -} diff --git a/jbt/src/main/java/org/hibernate/tool/orm/jbt/wrp/WrapperFactory.java b/jbt/src/main/java/org/hibernate/tool/orm/jbt/wrp/WrapperFactory.java deleted file mode 100644 index b68fe66ea1..0000000000 --- a/jbt/src/main/java/org/hibernate/tool/orm/jbt/wrp/WrapperFactory.java +++ /dev/null @@ -1,258 +0,0 @@ -package org.hibernate.tool.orm.jbt.wrp; - -import java.io.File; -import java.util.Map; -import java.util.Properties; - -import org.hibernate.cfg.Configuration; -import org.hibernate.mapping.Any; -import org.hibernate.mapping.Array; -import org.hibernate.mapping.Bag; -import org.hibernate.mapping.BasicValue; -import org.hibernate.mapping.Column; -import org.hibernate.mapping.Component; -import org.hibernate.mapping.DependantValue; -import org.hibernate.mapping.IdentifierBag; -import org.hibernate.mapping.KeyValue; -import org.hibernate.mapping.List; -import org.hibernate.mapping.ManyToOne; -import org.hibernate.mapping.OneToMany; -import org.hibernate.mapping.OneToOne; -import org.hibernate.mapping.PersistentClass; -import org.hibernate.mapping.PrimaryKey; -import org.hibernate.mapping.PrimitiveArray; -import org.hibernate.mapping.Property; -import org.hibernate.mapping.Set; -import org.hibernate.mapping.Table; -import org.hibernate.tool.api.reveng.RevengSettings; -import org.hibernate.tool.api.reveng.RevengStrategy; -import org.hibernate.tool.ide.completion.HQLCompletionProposal; -import org.hibernate.tool.internal.reveng.strategy.OverrideRepository; -import org.hibernate.tool.internal.reveng.strategy.TableFilter; -import org.hibernate.tool.orm.jbt.api.PersistentClassWrapper; -import org.hibernate.tool.orm.jbt.internal.factory.ArtifactCollectorWrapperFactory; -import org.hibernate.tool.orm.jbt.internal.factory.Cfg2HbmToolWrapperFactory; -import org.hibernate.tool.orm.jbt.internal.factory.EnvironmentWrapperFactory; -import org.hibernate.tool.orm.jbt.internal.factory.PersistentClassWrapperFactory; -import org.hibernate.tool.orm.jbt.util.DummyMetadataBuildingContext; -import org.hibernate.tool.orm.jbt.util.JpaConfiguration; -import org.hibernate.tool.orm.jbt.util.MetadataHelper; -import org.hibernate.tool.orm.jbt.util.NativeConfiguration; -import org.hibernate.tool.orm.jbt.util.RevengConfiguration; -import org.hibernate.tool.orm.jbt.wrp.PropertyWrapperFactory.PropertyWrapper; - -public class WrapperFactory { - - private WrapperFactory() {} - - public static Object createArtifactCollectorWrapper() { - return ArtifactCollectorWrapperFactory.createArtifactCollectorWrapper(); - } - - public static Object createCfg2HbmWrapper() { - return Cfg2HbmToolWrapperFactory.createCfg2HbmToolWrapper(); - } - - public static Object createNamingStrategyWrapper(String namingStrategyClassName) { - return NamingStrategyWrapperFactory.create(namingStrategyClassName); - } - - public static Object createOverrideRepositoryWrapper() { - return new OverrideRepository(); - } - - public static Object createRevengStrategyWrapper(Object...objects) { - return RevengStrategyWrapperFactory.create(objects); - } - - public static Object createRevengSettingsWrapper(Object revengStrategy) { - return new RevengSettings((RevengStrategy)(revengStrategy)); - } - - public static Object createNativeConfigurationWrapper() { - return new NativeConfiguration(); - } - - public static Object createRevengConfigurationWrapper() { - return new RevengConfiguration(); - } - - public static Object createJpaConfigurationWrapper( - String persistenceUnit, - Map properties) { - return new JpaConfiguration(persistenceUnit, properties); - } - - public static Object createColumnWrapper(String name) { - return new DelegatingColumnWrapperImpl(new Column(name)); - } - - public static Object createRootClassWrapper() { - return PersistentClassWrapperFactory.createRootClassWrapper(); - } - - public static Object createSingleTableSubClassWrapper(Object persistentClassWrapper) { - return PersistentClassWrapperFactory - .createSingleTableSubclassWrapper((PersistentClassWrapper)persistentClassWrapper); - } - - public static Object createJoinedTableSubClassWrapper(Object persistentClassWrapper) { - return PersistentClassWrapperFactory - .createJoinedSubclassWrapper((PersistentClassWrapper)persistentClassWrapper); - } - - public static Object createSpecialRootClassWrapper(Object propertyWrapper) { - return PersistentClassWrapperFactory - .createSpecialRootClassWrapper((PropertyWrapper)propertyWrapper); - } - - public static Object createPropertyWrapper() { - return PropertyWrapperFactory.createPropertyWrapper(new Property()); - } - - public static Object createHqlCompletionProposalWrapper(Object hqlCompletionProposalTarget) { - return HqlCompletionProposalWrapperFactory - .createHqlCompletionProposalWrapper( - (HQLCompletionProposal)hqlCompletionProposalTarget); - } - - public static Object createArrayWrapper(Object persistentClassWrapper) { - return ValueWrapperFactory.createValueWrapper( - new Array( - DummyMetadataBuildingContext.INSTANCE, - (PersistentClass)((Wrapper)persistentClassWrapper).getWrappedObject())); - } - - public static Object createBagWrapper(Object persistentClassWrapper) { - return ValueWrapperFactory.createValueWrapper( - new Bag( - DummyMetadataBuildingContext.INSTANCE, - (PersistentClass)((Wrapper)persistentClassWrapper).getWrappedObject())); - } - - public static Object createListWrapper(Object persistentClassWrapper) { - return ValueWrapperFactory.createValueWrapper( - new List( - DummyMetadataBuildingContext.INSTANCE, - (PersistentClass)((Wrapper)persistentClassWrapper).getWrappedObject())); - } - - public static Object createDatabaseReaderWrapper(Properties properties, Object revengStrategy) { - return DatabaseReaderWrapperFactory.createDatabaseReaderWrapper( - properties, - (RevengStrategy)revengStrategy); - } - - public static Object createTableWrapper(String name) { - Table t = new Table("Hibernate Tools", name); - t.setPrimaryKey(new PrimaryKey(t)); - DelegatingTableWrapperImpl result = new DelegatingTableWrapperImpl(t); - return result; - } - - public static Object createManyToOneWrapper(Object table) { - return ValueWrapperFactory.createValueWrapper( - new ManyToOne( - DummyMetadataBuildingContext.INSTANCE, - (Table)table)); - } - - public static Object createMapWrapper(Object persistentClassWrapper) { - return ValueWrapperFactory.createValueWrapper( - new org.hibernate.mapping.Map( - DummyMetadataBuildingContext.INSTANCE, - (PersistentClass)((Wrapper)persistentClassWrapper).getWrappedObject())); - } - - public static Object createOneToManyWrapper(Object persistentClassWrapper) { - return ValueWrapperFactory.createValueWrapper( - new OneToMany( - DummyMetadataBuildingContext.INSTANCE, - (PersistentClass)((Wrapper)persistentClassWrapper).getWrappedObject())); - } - - public static Object createOneToOneWrapper(Object persistentClassWrapper) { - PersistentClass pc = (PersistentClass)((Wrapper)persistentClassWrapper).getWrappedObject(); - return ValueWrapperFactory.createValueWrapper( - new OneToOne( - DummyMetadataBuildingContext.INSTANCE, - pc.getTable(), - pc)); - } - - public static Object createPrimitiveArrayWrapper(Object persistentClassWrapper) { - return ValueWrapperFactory.createValueWrapper( - new PrimitiveArray( - DummyMetadataBuildingContext.INSTANCE, - (PersistentClass)((Wrapper)persistentClassWrapper).getWrappedObject())); - } - - public static Object createSetWrapper(Object persistentClassWrapper) { - return ValueWrapperFactory.createValueWrapper( - new Set( - DummyMetadataBuildingContext.INSTANCE, - (PersistentClass)((Wrapper)persistentClassWrapper).getWrappedObject())); - } - - public static Object createSimpleValueWrapper() { - return ValueWrapperFactory.createValueWrapper(new BasicValue(DummyMetadataBuildingContext.INSTANCE)); - } - - public static Object createComponentWrapper(Object persistentClassWrapper) { - return ValueWrapperFactory.createValueWrapper( - new Component( - DummyMetadataBuildingContext.INSTANCE, - (PersistentClass)((Wrapper)persistentClassWrapper).getWrappedObject())); - } - - public static Object createDependantValueWrapper(Object table, Object valueWrapper) { - return ValueWrapperFactory.createValueWrapper( - new DependantValue( - DummyMetadataBuildingContext.INSTANCE, - (Table)table, - (KeyValue)((Wrapper)valueWrapper).getWrappedObject())); - } - - public static Object createAnyValueWrapper(Object table) { - return ValueWrapperFactory.createValueWrapper( - new Any( - DummyMetadataBuildingContext.INSTANCE, - (Table)table)); - } - - public static Object createIdentifierBagValueWrapper(Object persistentClassWrapper) { - return ValueWrapperFactory.createValueWrapper( - new IdentifierBag( - DummyMetadataBuildingContext.INSTANCE, - (PersistentClass)((Wrapper)persistentClassWrapper).getWrappedObject())); - } - - public static Object createTableFilterWrapper() { - return new TableFilter(); - } - - public static Object createTypeFactoryWrapper() { - return TypeFactoryWrapper.INSTANCE; - } - - public static Object createEnvironmentWrapper() { - return EnvironmentWrapperFactory.createEnvironmentWrapper(); - } - - public static Object createSchemaExport(Object configuration) { - return new SchemaExportWrapper((Configuration)configuration); - } - - public static Object createHbmExporterWrapper(Object configuration, File file) { - return new HbmExporterWrapper((Configuration)configuration, file); - } - - public static Object createExporterWrapper(String exporterClassName) { - return ExporterWrapperFactory.create(exporterClassName); - } - - public static Object createHqlCodeAssistWrapper(Object configuration) { - return new HqlCodeAssistWrapper(MetadataHelper.getMetadata((Configuration)configuration)); - } - -} diff --git a/jbt/src/test/java/org/hibernate/tool/hbm2x/ExportersPresenceTest.java b/jbt/src/test/java/org/hibernate/tool/hbm2x/ExportersPresenceTest.java new file mode 100644 index 0000000000..8da80187da --- /dev/null +++ b/jbt/src/test/java/org/hibernate/tool/hbm2x/ExportersPresenceTest.java @@ -0,0 +1,98 @@ +package org.hibernate.tool.hbm2x; + +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.fail; + +import org.junit.jupiter.api.Test; + +public class ExportersPresenceTest { + + @Test + public void testHbm2DDLExporter() { + try { + ClassLoader cl = getClass().getClassLoader(); + Class ddlExporterClass = cl.loadClass("org.hibernate.tool.hbm2x.Hbm2DDLExporter"); + assertNotNull(ddlExporterClass); + } catch (Throwable t) { + fail(t); + } + } + + @Test + public void testPOJOExporter() { + try { + ClassLoader cl = getClass().getClassLoader(); + Class pojoExporterClass = cl.loadClass("org.hibernate.tool.hbm2x.POJOExporter"); + assertNotNull(pojoExporterClass); + } catch (Throwable t) { + fail(t); + } + } + + @Test + public void testHibernateMappingExporter() { + try { + ClassLoader cl = getClass().getClassLoader(); + Class hibernateMappingExporterClass = cl.loadClass("org.hibernate.tool.hbm2x.HibernateMappingExporter"); + assertNotNull(hibernateMappingExporterClass); + } catch (Throwable t) { + fail(t); + } + } + + @Test + public void testDAOExporter() { + try { + ClassLoader cl = getClass().getClassLoader(); + Class daoExporterClass = cl.loadClass("org.hibernate.tool.hbm2x.DAOExporter"); + assertNotNull(daoExporterClass); + } catch (Throwable t) { + fail(t); + } + } + + @Test + public void testGenericExporter() { + try { + ClassLoader cl = getClass().getClassLoader(); + Class genericExporterClass = cl.loadClass("org.hibernate.tool.hbm2x.GenericExporter"); + assertNotNull(genericExporterClass); + } catch (Throwable t) { + fail(t); + } + } + + @Test + public void testHibernateConfigurationExporter() { + try { + ClassLoader cl = getClass().getClassLoader(); + Class hibernateConfigurationExporterClass = cl.loadClass("org.hibernate.tool.hbm2x.HibernateConfigurationExporter"); + assertNotNull(hibernateConfigurationExporterClass); + } catch (Throwable t) { + fail(t); + } + } + + @Test + public void testQueryExporter() { + try { + ClassLoader cl = getClass().getClassLoader(); + Class hibernateConfigurationExporterClass = cl.loadClass("org.hibernate.tool.hbm2x.QueryExporter"); + assertNotNull(hibernateConfigurationExporterClass); + } catch (Throwable t) { + fail(t); + } + } + + @Test + public void testDocExporter() { + try { + ClassLoader cl = getClass().getClassLoader(); + Class docExporterClass = cl.loadClass("org.hibernate.tool.hbm2x.DocExporter"); + assertNotNull(docExporterClass); + } catch (Throwable t) { + fail(t); + } + } + +} diff --git a/jbt/src/test/java/org/hibernate/tool/orm/jbt/wrp/WrapperFactoryTest.java b/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/factory/WrapperFactoryTest.java similarity index 66% rename from jbt/src/test/java/org/hibernate/tool/orm/jbt/wrp/WrapperFactoryTest.java rename to jbt/src/test/java/org/hibernate/tool/orm/jbt/api/factory/WrapperFactoryTest.java index fde491df23..fbdfaf72ee 100644 --- a/jbt/src/test/java/org/hibernate/tool/orm/jbt/wrp/WrapperFactoryTest.java +++ b/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/factory/WrapperFactoryTest.java @@ -1,4 +1,4 @@ -package org.hibernate.tool.orm.jbt.wrp; +package org.hibernate.tool.orm.jbt.api.factory; import static org.junit.jupiter.api.Assertions.assertEquals; @@ -15,10 +15,10 @@ import org.hibernate.boot.Metadata; import org.hibernate.cfg.Configuration; import org.hibernate.cfg.DefaultNamingStrategy; -import org.hibernate.cfg.NamingStrategy; import org.hibernate.mapping.Any; import org.hibernate.mapping.Array; import org.hibernate.mapping.Bag; +import org.hibernate.mapping.Column; import org.hibernate.mapping.Component; import org.hibernate.mapping.DependantValue; import org.hibernate.mapping.IdentifierBag; @@ -45,23 +45,38 @@ import org.hibernate.tool.ide.completion.HQLCompletionProposal; import org.hibernate.tool.internal.export.ddl.DdlExporter; import org.hibernate.tool.internal.export.hbm.Cfg2HbmTool; +import org.hibernate.tool.internal.export.hbm.HbmExporter; import org.hibernate.tool.internal.reveng.strategy.DefaultStrategy; import org.hibernate.tool.internal.reveng.strategy.DelegatingStrategy; import org.hibernate.tool.internal.reveng.strategy.OverrideRepository; import org.hibernate.tool.internal.reveng.strategy.TableFilter; -import org.hibernate.tool.orm.jbt.api.PersistentClassWrapper; -import org.hibernate.tool.orm.jbt.internal.factory.PersistentClassWrapperFactory; -import org.hibernate.tool.orm.jbt.util.ConfigurationMetadataDescriptor; -import org.hibernate.tool.orm.jbt.util.JpaConfiguration; -import org.hibernate.tool.orm.jbt.util.MetadataHelper; -import org.hibernate.tool.orm.jbt.util.NativeConfiguration; -import org.hibernate.tool.orm.jbt.util.RevengConfiguration; -import org.hibernate.tool.orm.jbt.util.SpecialRootClass; -import org.hibernate.tool.orm.jbt.wrp.DatabaseReaderWrapperFactory.DatabaseReaderWrapper; -import org.hibernate.tool.orm.jbt.wrp.ExporterWrapperFactory.ExporterWrapper; -import org.hibernate.tool.orm.jbt.wrp.HqlCompletionProposalWrapperFactory.HqlCompletionProposalWrapper; -import org.hibernate.tool.orm.jbt.wrp.PropertyWrapperFactory.PropertyWrapper; -import org.hibernate.tool.orm.jbt.wrp.ValueWrapperFactory.ValueWrapper; +import org.hibernate.tool.orm.jbt.api.wrp.ColumnWrapper; +import org.hibernate.tool.orm.jbt.api.wrp.ConfigurationWrapper; +import org.hibernate.tool.orm.jbt.api.wrp.DatabaseReaderWrapper; +import org.hibernate.tool.orm.jbt.api.wrp.ExporterWrapper; +import org.hibernate.tool.orm.jbt.api.wrp.HqlCodeAssistWrapper; +import org.hibernate.tool.orm.jbt.api.wrp.HqlCompletionProposalWrapper; +import org.hibernate.tool.orm.jbt.api.wrp.NamingStrategyWrapper; +import org.hibernate.tool.orm.jbt.api.wrp.OverrideRepositoryWrapper; +import org.hibernate.tool.orm.jbt.api.wrp.PersistentClassWrapper; +import org.hibernate.tool.orm.jbt.api.wrp.PropertyWrapper; +import org.hibernate.tool.orm.jbt.api.wrp.RevengSettingsWrapper; +import org.hibernate.tool.orm.jbt.api.wrp.RevengStrategyWrapper; +import org.hibernate.tool.orm.jbt.api.wrp.SchemaExportWrapper; +import org.hibernate.tool.orm.jbt.api.wrp.TableFilterWrapper; +import org.hibernate.tool.orm.jbt.api.wrp.TableWrapper; +import org.hibernate.tool.orm.jbt.api.wrp.TypeFactoryWrapper; +import org.hibernate.tool.orm.jbt.api.wrp.Wrapper; +import org.hibernate.tool.orm.jbt.internal.factory.ConfigurationWrapperFactory; +import org.hibernate.tool.orm.jbt.internal.factory.RevengStrategyWrapperFactory; +import org.hibernate.tool.orm.jbt.internal.factory.TableWrapperFactory; +import org.hibernate.tool.orm.jbt.internal.util.ConfigurationMetadataDescriptor; +import org.hibernate.tool.orm.jbt.internal.util.DummyMetadataBuildingContext; +import org.hibernate.tool.orm.jbt.internal.util.JpaConfiguration; +import org.hibernate.tool.orm.jbt.internal.util.MetadataHelper; +import org.hibernate.tool.orm.jbt.internal.util.NativeConfiguration; +import org.hibernate.tool.orm.jbt.internal.util.RevengConfiguration; +import org.hibernate.tool.orm.jbt.internal.util.SpecialRootClass; import org.junit.jupiter.api.Test; public class WrapperFactoryTest { @@ -88,11 +103,9 @@ public void testCreateCfg2HbmWrapper() { public void testCreateNamingStrategyWrapper() { Object namingStrategyWrapper = WrapperFactory.createNamingStrategyWrapper(DefaultNamingStrategy.class.getName()); assertNotNull(namingStrategyWrapper); - assertTrue(namingStrategyWrapper instanceof NamingStrategyWrapperFactory.StrategyClassNameProvider); - assertEquals( - ((NamingStrategyWrapperFactory.StrategyClassNameProvider)namingStrategyWrapper).getStrategyClassName(), - DefaultNamingStrategy.class.getName()); - assertTrue(namingStrategyWrapper instanceof NamingStrategy); + assertTrue(namingStrategyWrapper instanceof NamingStrategyWrapper); + Object wrappedNamingStrategy = ((NamingStrategyWrapper)namingStrategyWrapper).getWrappedObject(); + assertTrue(wrappedNamingStrategy instanceof DefaultNamingStrategy); namingStrategyWrapper = null; assertNull(namingStrategyWrapper); try { @@ -108,7 +121,9 @@ public void testCreateNamingStrategyWrapper() { public void testCreateOverrideRepositoryWrapper() { Object overrideRepositoryWrapper = WrapperFactory.createOverrideRepositoryWrapper(); assertNotNull(overrideRepositoryWrapper); - assertTrue(overrideRepositoryWrapper instanceof OverrideRepository); + assertTrue(overrideRepositoryWrapper instanceof OverrideRepositoryWrapper); + Object wrappedOverrideRepository = ((Wrapper)overrideRepositoryWrapper).getWrappedObject(); + assertTrue(wrappedOverrideRepository instanceof OverrideRepository); } @Test @@ -118,55 +133,66 @@ public void testCreateRevengStrategyWrapper() throws Exception { Object reverseEngineeringStrategyWrapper = WrapperFactory .createRevengStrategyWrapper(); assertNotNull(reverseEngineeringStrategyWrapper); - assertTrue(reverseEngineeringStrategyWrapper instanceof DefaultStrategy); - reverseEngineeringStrategyWrapper = null; - assertNull(reverseEngineeringStrategyWrapper); - RevengStrategy delegate = new TestRevengStrategy(); + assertTrue(reverseEngineeringStrategyWrapper instanceof Wrapper); + assertTrue(((Wrapper)reverseEngineeringStrategyWrapper).getWrappedObject() instanceof DefaultStrategy); + RevengStrategyWrapper delegate = (RevengStrategyWrapper)reverseEngineeringStrategyWrapper; reverseEngineeringStrategyWrapper = WrapperFactory .createRevengStrategyWrapper( TestDelegatingStrategy.class.getName(), delegate); assertNotNull(reverseEngineeringStrategyWrapper); - assertTrue(reverseEngineeringStrategyWrapper instanceof TestDelegatingStrategy); - assertSame(delegateField.get(reverseEngineeringStrategyWrapper), delegate); + assertTrue(reverseEngineeringStrategyWrapper instanceof Wrapper); + assertTrue(((Wrapper)reverseEngineeringStrategyWrapper).getWrappedObject() instanceof TestDelegatingStrategy); + assertSame( + delegateField.get(((Wrapper)reverseEngineeringStrategyWrapper).getWrappedObject()), + delegate.getWrappedObject()); } @Test public void testCreateRevengSettingsWrapper() { Object reverseEngineeringSettingsWrapper = null; - RevengStrategy strategy = new DefaultStrategy(); + RevengStrategyWrapper strategy = RevengStrategyWrapperFactory.createRevengStrategyWrapper(); reverseEngineeringSettingsWrapper = WrapperFactory.createRevengSettingsWrapper(strategy); assertNotNull(reverseEngineeringSettingsWrapper); - assertTrue(reverseEngineeringSettingsWrapper instanceof RevengSettings); - assertSame(strategy, ((RevengSettings)reverseEngineeringSettingsWrapper).getRootStrategy()); + assertTrue(reverseEngineeringSettingsWrapper instanceof RevengSettingsWrapper); + RevengSettings revengSettings = (RevengSettings)((RevengSettingsWrapper)reverseEngineeringSettingsWrapper).getWrappedObject(); + assertSame(strategy.getWrappedObject(), revengSettings.getRootStrategy()); } @Test public void testCreateNativeConfigurationWrapper() { Object configurationWrapper = WrapperFactory.createNativeConfigurationWrapper(); assertNotNull(configurationWrapper); - assertTrue(configurationWrapper instanceof NativeConfiguration); + assertTrue(configurationWrapper instanceof ConfigurationWrapper); + Object wrappedConfiguration = ((ConfigurationWrapper)configurationWrapper).getWrappedObject(); + assertTrue(wrappedConfiguration instanceof NativeConfiguration); } @Test public void testCreateRevengConfigurationWrapper() { Object configurationWrapper = WrapperFactory.createRevengConfigurationWrapper(); assertNotNull(configurationWrapper); - assertTrue(configurationWrapper instanceof RevengConfiguration); + assertTrue(configurationWrapper instanceof ConfigurationWrapper); + Object wrappedConfiguration = ((ConfigurationWrapper)configurationWrapper).getWrappedObject(); + assertTrue(wrappedConfiguration instanceof RevengConfiguration); } @Test public void testCreateJpaConfigurationWrapper() { Object configurationWrapper = WrapperFactory.createJpaConfigurationWrapper(null, null); assertNotNull(configurationWrapper); - assertTrue(configurationWrapper instanceof JpaConfiguration); + assertTrue(configurationWrapper instanceof ConfigurationWrapper); + Object wrappedConfiguration = ((ConfigurationWrapper)configurationWrapper).getWrappedObject(); + assertTrue(wrappedConfiguration instanceof JpaConfiguration); } @Test public void testCreateColumnWrapper() { Object columnWrapper = WrapperFactory.createColumnWrapper(null); assertNotNull(columnWrapper); - assertTrue(columnWrapper instanceof DelegatingColumnWrapperImpl); + assertTrue(columnWrapper instanceof ColumnWrapper); + Object wrappedColumn = ((ColumnWrapper)columnWrapper).getWrappedObject(); + assertTrue(wrappedColumn instanceof Column); } @Test @@ -184,7 +210,7 @@ public void testCreateSingleTableSubclassWrapper() { rootClassWrapper); assertNotNull(singleTableSubclassWrapper); assertTrue(singleTableSubclassWrapper instanceof PersistentClassWrapper); - PersistentClass persistentClass = ((PersistentClassWrapper)singleTableSubclassWrapper).getWrappedObject(); + PersistentClass persistentClass = (PersistentClass)((PersistentClassWrapper)singleTableSubclassWrapper).getWrappedObject(); assertTrue(persistentClass instanceof SingleTableSubclass); assertSame( ((SingleTableSubclass)persistentClass).getRootClass(), @@ -198,7 +224,7 @@ public void testCreateJoinedSubclassWrapper() { rootClassWrapper); assertNotNull(joinedTableSubclassWrapper); assertTrue(joinedTableSubclassWrapper instanceof PersistentClassWrapper); - PersistentClass persistentClass = ((PersistentClassWrapper)joinedTableSubclassWrapper).getWrappedObject(); + PersistentClass persistentClass = (PersistentClass)((PersistentClassWrapper)joinedTableSubclassWrapper).getWrappedObject(); assertTrue(persistentClass instanceof JoinedSubclass); assertSame( ((JoinedSubclass)persistentClass).getRootClass(), @@ -211,10 +237,10 @@ public void testCreateSpecialRootClassWrapper() { Object specialRootClassWrapper = WrapperFactory.createSpecialRootClassWrapper(propertyWrapper); assertNotNull(specialRootClassWrapper); assertTrue(specialRootClassWrapper instanceof PersistentClassWrapper); - PersistentClass persistentClass = ((PersistentClassWrapper)specialRootClassWrapper).getWrappedObject(); + PersistentClass persistentClass = (PersistentClass)((PersistentClassWrapper)specialRootClassWrapper).getWrappedObject(); assertTrue(persistentClass instanceof SpecialRootClass); assertSame( - ((Wrapper)((SpecialRootClass)persistentClass).getProperty()).getWrappedObject(), + ((SpecialRootClass)persistentClass).getProperty(), ((Wrapper)propertyWrapper).getWrappedObject()); } @@ -240,7 +266,7 @@ public void testCreateArrayWrapper() { Object persistentClassWrapper = WrapperFactory.createRootClassWrapper(); PersistentClass persistentClassTarget = (PersistentClass)((Wrapper)persistentClassWrapper).getWrappedObject(); Object arrayWrapper = WrapperFactory.createArrayWrapper(persistentClassWrapper); - Value wrappedArray = ((ValueWrapper)arrayWrapper).getWrappedObject(); + Value wrappedArray = (Value)((Wrapper)arrayWrapper).getWrappedObject(); assertTrue(wrappedArray instanceof Array); assertSame(((Array)wrappedArray).getOwner(), persistentClassTarget); } @@ -250,7 +276,7 @@ public void testCreateBagWrapper() { Object persistentClassWrapper = WrapperFactory.createRootClassWrapper(); PersistentClass persistentClassTarget = (PersistentClass)((Wrapper)persistentClassWrapper).getWrappedObject(); Object bagWrapper = WrapperFactory.createBagWrapper(persistentClassWrapper); - Value wrappedBag = ((ValueWrapper)bagWrapper).getWrappedObject(); + Value wrappedBag = (Value)((Wrapper)bagWrapper).getWrappedObject(); assertTrue(wrappedBag instanceof Bag); assertSame(((Bag)wrappedBag).getOwner(), persistentClassTarget); } @@ -260,7 +286,7 @@ public void testCreateListWrapper() { Object persistentClassWrapper = WrapperFactory.createRootClassWrapper(); PersistentClass persistentClassTarget = (PersistentClass)((Wrapper)persistentClassWrapper).getWrappedObject(); Object listWrapper = WrapperFactory.createListWrapper(persistentClassWrapper); - Value wrappedList = ((ValueWrapper)listWrapper).getWrappedObject(); + Value wrappedList = (Value)((Wrapper)listWrapper).getWrappedObject(); assertTrue(wrappedList instanceof List); assertSame(((List)wrappedList).getOwner(), persistentClassTarget); } @@ -269,7 +295,7 @@ public void testCreateListWrapper() { public void testCreateDatabaseReaderWrapper() { Properties properties = new Properties(); properties.put("hibernate.connection.url", "jdbc:h2:mem:test"); - RevengStrategy strategy = new DefaultStrategy(); + RevengStrategyWrapper strategy = RevengStrategyWrapperFactory.createRevengStrategyWrapper(); Object databaseReaderWrapper = WrapperFactory.createDatabaseReaderWrapper( properties, strategy); assertNotNull(databaseReaderWrapper); @@ -289,9 +315,10 @@ public void testCreateTableWrapper() { @Test public void testCreateManyToOneWrapper() { - Table table = new Table("", "foo"); - Object manyToOneWrapper = WrapperFactory.createManyToOneWrapper(table); - Value wrappedManyToOne = ((ValueWrapper)manyToOneWrapper).getWrappedObject(); + TableWrapper tableWrapper = TableWrapperFactory.createTableWrapper("foo"); + Table table = (Table)tableWrapper.getWrappedObject(); + Object manyToOneWrapper = WrapperFactory.createManyToOneWrapper(tableWrapper); + Value wrappedManyToOne = (Value)((Wrapper)manyToOneWrapper).getWrappedObject(); assertTrue(wrappedManyToOne instanceof ManyToOne); assertSame(table, wrappedManyToOne.getTable()); } @@ -301,7 +328,7 @@ public void testCreateMapWrapper() { Object persistentClassWrapper = WrapperFactory.createRootClassWrapper(); PersistentClass persistentClassTarget = (PersistentClass)((Wrapper)persistentClassWrapper).getWrappedObject(); Object mapWrapper = WrapperFactory.createMapWrapper(persistentClassWrapper); - Value wrappedMap = ((ValueWrapper)mapWrapper).getWrappedObject(); + Value wrappedMap = (Value)((Wrapper)mapWrapper).getWrappedObject(); assertTrue(wrappedMap instanceof Map); assertSame(((Map)wrappedMap).getOwner(), persistentClassTarget); } @@ -310,23 +337,25 @@ public void testCreateMapWrapper() { public void testCreateOneToManyWrapper() { Object persistentClassWrapper = WrapperFactory.createRootClassWrapper(); PersistentClass persistentClassTarget = (PersistentClass)((Wrapper)persistentClassWrapper).getWrappedObject(); - Table tableWrapper = (Table)WrapperFactory.createTableWrapper("foo"); - ((RootClass)persistentClassTarget).setTable(tableWrapper); + TableWrapper tableWrapper = (TableWrapper)WrapperFactory.createTableWrapper("foo"); + ((RootClass)persistentClassTarget).setTable((Table)tableWrapper.getWrappedObject()); Object oneToManyWrapper = WrapperFactory.createOneToManyWrapper(persistentClassWrapper); - Value wrappedOneToMany = ((ValueWrapper)oneToManyWrapper).getWrappedObject(); + Value wrappedOneToMany = (Value)((Wrapper)oneToManyWrapper).getWrappedObject(); assertTrue(wrappedOneToMany instanceof OneToMany); - assertSame(((OneToMany)wrappedOneToMany).getTable(), tableWrapper); + assertSame(((OneToMany)wrappedOneToMany).getTable(), tableWrapper.getWrappedObject()); } @Test public void testCreateOneToOneWrapper() { - PersistentClassWrapper persistentClassWrapper = PersistentClassWrapperFactory.createRootClassWrapper(); - PersistentClass persistentClassTarget = persistentClassWrapper.getWrappedObject(); + RootClass rc = new RootClass(DummyMetadataBuildingContext.INSTANCE); + PersistentClassWrapper persistentClassWrapper = + org.hibernate.tool.orm.jbt.internal.factory.PersistentClassWrapperFactory.createPersistentClassWrapper(rc); + PersistentClass persistentClassTarget = (PersistentClass)persistentClassWrapper.getWrappedObject(); Table tableTarget = new Table("", "foo"); ((RootClass)persistentClassTarget).setTable(tableTarget); persistentClassTarget.setEntityName("bar"); Object oneToOneWrapper = WrapperFactory.createOneToOneWrapper(persistentClassWrapper); - Value wrappedOneToOne = ((ValueWrapper)oneToOneWrapper).getWrappedObject(); + Value wrappedOneToOne = (Value)((Wrapper)oneToOneWrapper).getWrappedObject(); assertTrue(wrappedOneToOne instanceof OneToOne); assertEquals(((OneToOne)wrappedOneToOne).getEntityName(), "bar"); assertSame(((OneToOne)wrappedOneToOne).getTable(), tableTarget); @@ -337,7 +366,7 @@ public void testCreatePrimitiveArrayWrapper() { Object persistentClassWrapper = WrapperFactory.createRootClassWrapper(); PersistentClass persistentClassTarget = (PersistentClass)((Wrapper)persistentClassWrapper).getWrappedObject(); Object primitiveArrayWrapper = WrapperFactory.createPrimitiveArrayWrapper(persistentClassWrapper); - Value wrappedPrimitiveArray = ((ValueWrapper)primitiveArrayWrapper).getWrappedObject(); + Value wrappedPrimitiveArray = (Value)((Wrapper)primitiveArrayWrapper).getWrappedObject(); assertTrue(wrappedPrimitiveArray instanceof PrimitiveArray); assertSame(((PrimitiveArray)wrappedPrimitiveArray).getOwner(), persistentClassTarget); } @@ -347,7 +376,7 @@ public void testCreateSetWrapper() { Object persistentClassWrapper = WrapperFactory.createRootClassWrapper(); PersistentClass persistentClassTarget = (PersistentClass)((Wrapper)persistentClassWrapper).getWrappedObject(); Object setWrapper = WrapperFactory.createSetWrapper(persistentClassWrapper); - Value wrappedSet = ((ValueWrapper)setWrapper).getWrappedObject(); + Value wrappedSet = (Value)((Wrapper)setWrapper).getWrappedObject(); assertTrue(wrappedSet instanceof Set); assertSame(((Set)wrappedSet).getOwner(), persistentClassTarget); } @@ -355,7 +384,7 @@ public void testCreateSetWrapper() { @Test public void testCreateSimpleValueWrapper() { Object simpleValueWrapper = WrapperFactory.createSimpleValueWrapper(); - Value wrappedSimpleValue = ((ValueWrapper)simpleValueWrapper).getWrappedObject(); + Value wrappedSimpleValue = (Value)((Wrapper)simpleValueWrapper).getWrappedObject(); assertTrue(wrappedSimpleValue instanceof SimpleValue); } @@ -364,17 +393,18 @@ public void testCreateComponentWrapper() { Object persistentClassWrapper = WrapperFactory.createRootClassWrapper(); PersistentClass persistentClassTarget = (PersistentClass)((Wrapper)persistentClassWrapper).getWrappedObject(); Object componentWrapper = WrapperFactory.createComponentWrapper(persistentClassWrapper); - Value wrappedComponent = ((ValueWrapper)componentWrapper).getWrappedObject(); + Value wrappedComponent = (Value)((Wrapper)componentWrapper).getWrappedObject(); assertTrue(wrappedComponent instanceof Component); assertSame(((Component)wrappedComponent).getOwner(), persistentClassTarget); } @Test public void testCreateDependantValueWrapper() { - Table tableTarget = new Table("", "foo"); + TableWrapper tableWrapper = TableWrapperFactory.createTableWrapper("foo"); + Table tableTarget = (Table)tableWrapper.getWrappedObject(); Object valueWrapper = WrapperFactory.createSimpleValueWrapper(); - Object dependantValueWrapper = WrapperFactory.createDependantValueWrapper(tableTarget, valueWrapper); - Value wrappedDependantValue = ((ValueWrapper)dependantValueWrapper).getWrappedObject(); + Object dependantValueWrapper = WrapperFactory.createDependantValueWrapper(tableWrapper, valueWrapper); + Value wrappedDependantValue = (Value)((Wrapper)dependantValueWrapper).getWrappedObject(); assertTrue(wrappedDependantValue instanceof DependantValue); assertSame(tableTarget, ((DependantValue)wrappedDependantValue).getTable()); assertSame( @@ -384,9 +414,10 @@ public void testCreateDependantValueWrapper() { @Test public void testCreateAnyValueWrapper() { - Table tableTarget = new Table("", "foo"); - Object anyValueWrapper = WrapperFactory.createAnyValueWrapper(tableTarget); - Value wrappedAnyValue = ((ValueWrapper)anyValueWrapper).getWrappedObject(); + TableWrapper tableWrapper = TableWrapperFactory.createTableWrapper("foo"); + Table tableTarget = (Table)tableWrapper.getWrappedObject(); + Object anyValueWrapper = WrapperFactory.createAnyValueWrapper(tableWrapper); + Value wrappedAnyValue = (Value)((Wrapper)anyValueWrapper).getWrappedObject(); assertTrue(wrappedAnyValue instanceof Any); assertSame(tableTarget, ((Any)wrappedAnyValue).getTable()); } @@ -396,7 +427,7 @@ public void testCreateIdentifierBagValueWrapper() { Object persistentClassWrapper = WrapperFactory.createRootClassWrapper(); PersistentClass persistentClassTarget = (PersistentClass)((Wrapper)persistentClassWrapper).getWrappedObject(); Object identifierBagValueWrapper = WrapperFactory.createIdentifierBagValueWrapper(persistentClassWrapper); - Value wrappedIdentifierBagValue = ((ValueWrapper)identifierBagValueWrapper).getWrappedObject(); + Value wrappedIdentifierBagValue = (Value)((Wrapper)identifierBagValueWrapper).getWrappedObject(); assertTrue(wrappedIdentifierBagValue instanceof IdentifierBag); assertSame(((IdentifierBag)wrappedIdentifierBagValue).getOwner(), persistentClassTarget); } @@ -405,13 +436,17 @@ public void testCreateIdentifierBagValueWrapper() { public void testCreateTableFilterWrapper() { Object tableFilterWrapper = WrapperFactory.createTableFilterWrapper(); assertNotNull(tableFilterWrapper); - assertTrue(tableFilterWrapper instanceof TableFilter); + assertTrue(tableFilterWrapper instanceof TableFilterWrapper); + Object wrappedTableFilter = ((Wrapper)tableFilterWrapper).getWrappedObject(); + assertTrue(wrappedTableFilter instanceof TableFilter); + } @Test public void testCreateTypeFactoryWrapper() { Object typeFactoryWrapper = WrapperFactory.createTypeFactoryWrapper(); - assertSame(TypeFactoryWrapper.INSTANCE, typeFactoryWrapper); + assertNotNull(typeFactoryWrapper); + assertTrue(typeFactoryWrapper instanceof TypeFactoryWrapper); } @Test @@ -421,30 +456,32 @@ public void testCreateEnvironmentWrapper() { @Test public void testCreateSchemaExport() throws Exception { - Configuration configuration = new Configuration(); - Object schemaExport = WrapperFactory.createSchemaExport(configuration); + ConfigurationWrapper configurationWrapper = + ConfigurationWrapperFactory.createNativeConfigurationWrapper(); + Object schemaExport = WrapperFactory.createSchemaExport(configurationWrapper); assertNotNull(schemaExport); assertTrue(schemaExport instanceof SchemaExportWrapper); - Field configurationField = SchemaExportWrapper.class.getDeclaredField("configuration"); + Field configurationField = schemaExport.getClass().getDeclaredField("configuration"); configurationField.setAccessible(true); - assertSame(configuration, configurationField.get(schemaExport)); + assertSame(configurationWrapper.getWrappedObject(), configurationField.get(schemaExport)); } @Test public void testCreateHbmExporterWrapper() throws Exception { - Configuration configuration = new Configuration(); + ConfigurationWrapper configuration = ConfigurationWrapperFactory.createNativeConfigurationWrapper(); File file = new File("foo"); Object hbmExporterWrapper = WrapperFactory.createHbmExporterWrapper(configuration, file); + HbmExporter wrappedHbmExporter = (HbmExporter)((Wrapper)hbmExporterWrapper).getWrappedObject(); assertNotNull(hbmExporterWrapper); - assertSame(file, ((HbmExporterWrapper)hbmExporterWrapper) - .getProperties().get(ExporterConstants.OUTPUT_FILE_NAME)); + assertSame(file, wrappedHbmExporter.getProperties().get(ExporterConstants.OUTPUT_FILE_NAME)); ConfigurationMetadataDescriptor descriptor = - (ConfigurationMetadataDescriptor)((HbmExporterWrapper)hbmExporterWrapper) - .getProperties().get(ExporterConstants.METADATA_DESCRIPTOR); + (ConfigurationMetadataDescriptor)wrappedHbmExporter + .getProperties() + .get(ExporterConstants.METADATA_DESCRIPTOR); assertNotNull(descriptor); Field configurationField = ConfigurationMetadataDescriptor.class.getDeclaredField("configuration"); configurationField.setAccessible(true); - assertSame(configuration, configurationField.get(descriptor)); + assertSame(configuration.getWrappedObject(), configurationField.get(descriptor)); } @Test @@ -456,14 +493,14 @@ public void testCreateExporterWrapper() { @Test public void testCreateHqlCodeAssistWrapper() throws Exception { - Configuration configuration = new NativeConfiguration(); - configuration.setProperty("hibernate.connection.url", "jdbc:h2:mem:test"); - Metadata metadata = MetadataHelper.getMetadata(configuration); - Object hqlCodeAssistWrapper = WrapperFactory.createHqlCodeAssistWrapper(configuration); + ConfigurationWrapper configurationWrapper = ConfigurationWrapperFactory.createNativeConfigurationWrapper(); + configurationWrapper.setProperty("hibernate.connection.url", "jdbc:h2:mem:test"); + Metadata metadata = MetadataHelper.getMetadata((Configuration)configurationWrapper.getWrappedObject()); + Object hqlCodeAssistWrapper = WrapperFactory.createHqlCodeAssistWrapper(configurationWrapper); assertTrue(hqlCodeAssistWrapper instanceof HqlCodeAssistWrapper); Field metadataField = HQLCodeAssist.class.getDeclaredField("metadata"); metadataField.setAccessible(true); - assertSame(metadata, metadataField.get(hqlCodeAssistWrapper)); + assertSame(metadata, metadataField.get(((Wrapper)hqlCodeAssistWrapper).getWrappedObject())); } diff --git a/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/ArtifactCollectorWrapperTest.java b/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/wrp/ArtifactCollectorWrapperTest.java similarity index 98% rename from jbt/src/test/java/org/hibernate/tool/orm/jbt/api/ArtifactCollectorWrapperTest.java rename to jbt/src/test/java/org/hibernate/tool/orm/jbt/api/wrp/ArtifactCollectorWrapperTest.java index fbb8a7496f..1e3e08a551 100644 --- a/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/ArtifactCollectorWrapperTest.java +++ b/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/wrp/ArtifactCollectorWrapperTest.java @@ -1,4 +1,4 @@ -package org.hibernate.tool.orm.jbt.api; +package org.hibernate.tool.orm.jbt.api.wrp; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertNotEquals; diff --git a/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/Cfg2HbmToolWrapperTest.java b/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/wrp/Cfg2HbmToolWrapperTest.java similarity index 56% rename from jbt/src/test/java/org/hibernate/tool/orm/jbt/api/Cfg2HbmToolWrapperTest.java rename to jbt/src/test/java/org/hibernate/tool/orm/jbt/api/wrp/Cfg2HbmToolWrapperTest.java index d26cc02895..cfd7fc607a 100644 --- a/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/Cfg2HbmToolWrapperTest.java +++ b/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/wrp/Cfg2HbmToolWrapperTest.java @@ -1,13 +1,14 @@ -package org.hibernate.tool.orm.jbt.api; +package org.hibernate.tool.orm.jbt.api.wrp; import static org.junit.jupiter.api.Assertions.assertEquals; import org.hibernate.mapping.BasicValue; -import org.hibernate.mapping.PersistentClass; import org.hibernate.mapping.Property; import org.hibernate.mapping.RootClass; import org.hibernate.tool.orm.jbt.internal.factory.Cfg2HbmToolWrapperFactory; -import org.hibernate.tool.orm.jbt.util.DummyMetadataBuildingContext; +import org.hibernate.tool.orm.jbt.internal.factory.PersistentClassWrapperFactory; +import org.hibernate.tool.orm.jbt.internal.factory.PropertyWrapperFactory; +import org.hibernate.tool.orm.jbt.internal.util.DummyMetadataBuildingContext; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; @@ -22,20 +23,22 @@ public void beforeEach() { @Test public void testGetTagPersistentClass() { - PersistentClass persistentClass = new RootClass(DummyMetadataBuildingContext.INSTANCE); - assertEquals("class", wrapper.getTag(persistentClass)); + PersistentClassWrapper persistentClassWrapper = PersistentClassWrapperFactory.createPersistentClassWrapper( + new RootClass(DummyMetadataBuildingContext.INSTANCE)); + assertEquals("class", wrapper.getTag(persistentClassWrapper)); } @Test public void testGetTagProperty() throws Exception { - Property property = new Property(); + PropertyWrapper propertyWrapper = PropertyWrapperFactory.createPropertyWrapper(); + Property property = (Property)propertyWrapper.getWrappedObject(); RootClass rc = new RootClass(DummyMetadataBuildingContext.INSTANCE); BasicValue basicValue = new BasicValue(DummyMetadataBuildingContext.INSTANCE); basicValue.setTypeName("foobar"); property.setValue(basicValue); property.setPersistentClass(rc); rc.setVersion(property); - assertEquals("version", wrapper.getTag(property)); + assertEquals("version", wrapper.getTag(propertyWrapper)); } } diff --git a/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/ClassMetadataWrapperTest.java b/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/wrp/ClassMetadataWrapperTest.java similarity index 84% rename from jbt/src/test/java/org/hibernate/tool/orm/jbt/api/ClassMetadataWrapperTest.java rename to jbt/src/test/java/org/hibernate/tool/orm/jbt/api/wrp/ClassMetadataWrapperTest.java index f72e18e9c1..73bf2bfb11 100644 --- a/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/ClassMetadataWrapperTest.java +++ b/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/wrp/ClassMetadataWrapperTest.java @@ -1,4 +1,4 @@ -package org.hibernate.tool.orm.jbt.api; +package org.hibernate.tool.orm.jbt.api.wrp; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertNotNull; @@ -13,17 +13,16 @@ import java.util.HashSet; import java.util.Set; -import org.hibernate.Session; import org.hibernate.SessionFactory; import org.hibernate.cfg.AvailableSettings; import org.hibernate.cfg.Configuration; import org.hibernate.engine.spi.SessionFactoryImplementor; import org.hibernate.persister.entity.EntityPersister; import org.hibernate.tool.orm.jbt.internal.factory.ClassMetadataWrapperFactory; -import org.hibernate.tool.orm.jbt.util.MockConnectionProvider; -import org.hibernate.tool.orm.jbt.util.MockDialect; +import org.hibernate.tool.orm.jbt.internal.factory.SessionWrapperFactory; +import org.hibernate.tool.orm.jbt.internal.util.MockConnectionProvider; +import org.hibernate.tool.orm.jbt.internal.util.MockDialect; import org.hibernate.type.CollectionType; -import org.hibernate.type.Type; import org.hibernate.type.internal.NamedBasicTypeImpl; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; @@ -40,7 +39,7 @@ public class ClassMetadataWrapperTest { ""; private static final String TEST_HBM_XML_STRING = - "" + + "" + " " + " " + " " + @@ -105,13 +104,13 @@ public void testGetPropertyNames() { @Test public void testGetPropertyTypes() { - Type[] types = classMetadataWrapper.getPropertyTypes(); + TypeWrapper[] types = classMetadataWrapper.getPropertyTypes(); assertEquals(1, types.length); - Type type = types[0]; + TypeWrapper type = types[0]; assertTrue(type.isCollectionType()); assertEquals( - "org.hibernate.tool.orm.jbt.api.ClassMetadataWrapperTest$Foo.bars", - ((CollectionType)type).getRole()); + "org.hibernate.tool.orm.jbt.api.wrp.ClassMetadataWrapperTest$Foo.bars", + ((CollectionType)type.getWrappedObject()).getRole()); } @Test @@ -121,10 +120,10 @@ public void testGetMappedClass() { @Test public void testGetIdentifierType() { - Type identifierType = classMetadataWrapper.getIdentifierType(); + TypeWrapper identifierType = classMetadataWrapper.getIdentifierType(); assertNotNull(identifierType); - assertTrue(identifierType instanceof NamedBasicTypeImpl); - assertSame("string", ((NamedBasicTypeImpl)identifierType).getName()); + assertTrue(identifierType.getWrappedObject() instanceof NamedBasicTypeImpl); + assertSame("string", ((NamedBasicTypeImpl)identifierType.getWrappedObject()).getName()); } @Test @@ -142,10 +141,10 @@ public void testHasIdentifierProperty() { @Test public void testGetIdentifier() { - Session session = sessionFactory.openSession(); + SessionWrapper sessionWrapper = SessionWrapperFactory.createSessionWrapper(sessionFactory.openSession()); Foo foo = new Foo(); foo.id = "bar"; - Object identifier = classMetadataWrapper.getIdentifier(foo, session); + Object identifier = classMetadataWrapper.getIdentifier(foo, sessionWrapper); assertSame("bar", identifier); } diff --git a/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/CollectionMetadataWrapperTest.java b/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/wrp/CollectionMetadataWrapperTest.java similarity index 92% rename from jbt/src/test/java/org/hibernate/tool/orm/jbt/api/CollectionMetadataWrapperTest.java rename to jbt/src/test/java/org/hibernate/tool/orm/jbt/api/wrp/CollectionMetadataWrapperTest.java index f0f6febf2a..7b84999dc0 100644 --- a/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/CollectionMetadataWrapperTest.java +++ b/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/wrp/CollectionMetadataWrapperTest.java @@ -1,4 +1,4 @@ -package org.hibernate.tool.orm.jbt.api; +package org.hibernate.tool.orm.jbt.api.wrp; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertNotNull; @@ -15,8 +15,8 @@ import org.hibernate.engine.spi.SessionFactoryImplementor; import org.hibernate.persister.collection.CollectionPersister; import org.hibernate.tool.orm.jbt.internal.factory.CollectionMetadataWrapperFactory; -import org.hibernate.tool.orm.jbt.util.MockConnectionProvider; -import org.hibernate.tool.orm.jbt.util.MockDialect; +import org.hibernate.tool.orm.jbt.internal.util.MockConnectionProvider; +import org.hibernate.tool.orm.jbt.internal.util.MockDialect; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.io.TempDir; @@ -32,7 +32,7 @@ public class CollectionMetadataWrapperTest { ""; private static final String TEST_HBM_XML_STRING = - "" + + "" + " " + " " + " " + diff --git a/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/ColumnWrapperTest.java b/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/wrp/ColumnWrapperTest.java similarity index 81% rename from jbt/src/test/java/org/hibernate/tool/orm/jbt/api/ColumnWrapperTest.java rename to jbt/src/test/java/org/hibernate/tool/orm/jbt/api/wrp/ColumnWrapperTest.java index da3b7f9210..7a00351faf 100644 --- a/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/ColumnWrapperTest.java +++ b/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/wrp/ColumnWrapperTest.java @@ -1,4 +1,4 @@ -package org.hibernate.tool.orm.jbt.api; +package org.hibernate.tool.orm.jbt.api.wrp; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertFalse; @@ -12,12 +12,12 @@ import java.lang.reflect.Proxy; import org.hibernate.cfg.AvailableSettings; -import org.hibernate.cfg.Configuration; import org.hibernate.mapping.Column; import org.hibernate.mapping.Value; import org.hibernate.tool.orm.jbt.internal.factory.ColumnWrapperFactory; -import org.hibernate.tool.orm.jbt.util.MockConnectionProvider; -import org.hibernate.tool.orm.jbt.util.MockDialect; +import org.hibernate.tool.orm.jbt.internal.factory.ConfigurationWrapperFactory; +import org.hibernate.tool.orm.jbt.internal.util.MockConnectionProvider; +import org.hibernate.tool.orm.jbt.internal.util.MockDialect; import org.hibernate.type.spi.TypeConfiguration; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; @@ -29,7 +29,7 @@ public class ColumnWrapperTest { @BeforeEach public void beforeEach() throws Exception { - columnWrapper = ColumnWrapperFactory.createColumnWrapper(null); + columnWrapper = ColumnWrapperFactory.createColumnWrapper((String)null); wrappedColumn = (Column)columnWrapper.getWrappedObject(); } @@ -59,13 +59,13 @@ public void testGetSqlType() { wrappedColumn.setSqlType("foobar"); assertEquals("foobar", columnWrapper.getSqlType()); // IColumn#getSqlType(IConfiguration) - columnWrapper = ColumnWrapperFactory.createColumnWrapper(null); + columnWrapper = ColumnWrapperFactory.createColumnWrapper((String)null); wrappedColumn = (Column)columnWrapper.getWrappedObject(); wrappedColumn.setValue(createValue()); - Configuration configuration = new Configuration(); - configuration.setProperty(AvailableSettings.DIALECT, MockDialect.class.getName()); - configuration.setProperty(AvailableSettings.CONNECTION_PROVIDER, MockConnectionProvider.class.getName()); - assertEquals("integer", columnWrapper.getSqlType(configuration)); + ConfigurationWrapper configurationWrapper = ConfigurationWrapperFactory.createNativeConfigurationWrapper(); + configurationWrapper.setProperty(AvailableSettings.DIALECT, MockDialect.class.getName()); + configurationWrapper.setProperty(AvailableSettings.CONNECTION_PROVIDER, MockConnectionProvider.class.getName()); + assertEquals("integer", columnWrapper.getSqlType(configurationWrapper)); } @Test @@ -117,12 +117,12 @@ public void testGetValue() { Value v = createValue(); assertNull(columnWrapper.getValue()); wrappedColumn.setValue(v); - Value value = columnWrapper.getValue(); - assertNotNull(value); - assertSame(value, v); + ValueWrapper valueWrapper = columnWrapper.getValue(); + assertNotNull(valueWrapper); + assertSame(valueWrapper.getWrappedObject(), v); wrappedColumn.setValue(null); - value = columnWrapper.getValue(); - assertNull(value); + valueWrapper = columnWrapper.getValue(); + assertNull(valueWrapper); } @Test diff --git a/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/ConfigurationWrapperTest.java b/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/wrp/ConfigurationWrapperTest.java similarity index 91% rename from jbt/src/test/java/org/hibernate/tool/orm/jbt/api/ConfigurationWrapperTest.java rename to jbt/src/test/java/org/hibernate/tool/orm/jbt/api/wrp/ConfigurationWrapperTest.java index ad41a0a826..1b5c5ee84c 100644 --- a/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/ConfigurationWrapperTest.java +++ b/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/wrp/ConfigurationWrapperTest.java @@ -1,4 +1,4 @@ -package org.hibernate.tool.orm.jbt.api; +package org.hibernate.tool.orm.jbt.api.wrp; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertFalse; @@ -24,7 +24,6 @@ import javax.xml.parsers.DocumentBuilderFactory; -import org.hibernate.SessionFactory; import org.hibernate.boot.Metadata; import org.hibernate.boot.MetadataSources; import org.hibernate.boot.jaxb.spi.Binding; @@ -32,17 +31,16 @@ import org.hibernate.cfg.DefaultNamingStrategy; import org.hibernate.cfg.NamingStrategy; import org.hibernate.mapping.PersistentClass; -import org.hibernate.mapping.Table; import org.hibernate.tool.api.reveng.RevengStrategy; -import org.hibernate.tool.internal.reveng.strategy.DefaultStrategy; import org.hibernate.tool.orm.jbt.internal.factory.ConfigurationWrapperFactory; -import org.hibernate.tool.orm.jbt.util.JpaConfiguration; -import org.hibernate.tool.orm.jbt.util.MetadataHelper; -import org.hibernate.tool.orm.jbt.util.MockConnectionProvider; -import org.hibernate.tool.orm.jbt.util.MockDialect; -import org.hibernate.tool.orm.jbt.util.NativeConfiguration; -import org.hibernate.tool.orm.jbt.util.RevengConfiguration; -import org.hibernate.tool.orm.jbt.wrp.SessionFactoryWrapper; +import org.hibernate.tool.orm.jbt.internal.factory.NamingStrategyWrapperFactory; +import org.hibernate.tool.orm.jbt.internal.factory.RevengStrategyWrapperFactory; +import org.hibernate.tool.orm.jbt.internal.util.JpaConfiguration; +import org.hibernate.tool.orm.jbt.internal.util.MetadataHelper; +import org.hibernate.tool.orm.jbt.internal.util.MockConnectionProvider; +import org.hibernate.tool.orm.jbt.internal.util.MockDialect; +import org.hibernate.tool.orm.jbt.internal.util.NativeConfiguration; +import org.hibernate.tool.orm.jbt.internal.util.RevengConfiguration; import org.junit.jupiter.api.AfterEach; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; @@ -58,7 +56,7 @@ public class ConfigurationWrapperTest { private static final String TEST_HBM_XML_STRING = - "" + + "" + " " + " " + " " + @@ -252,17 +250,19 @@ public void testSetEntityResolver() throws Exception { @Test public void testSetNamingStrategy() throws Exception { - NamingStrategy namingStrategy = new DefaultNamingStrategy(); + NamingStrategyWrapper namingStrategyWrapper = + NamingStrategyWrapperFactory.createNamingStrategyWrapper(DefaultNamingStrategy.class.getName()); + NamingStrategy namingStrategy = (NamingStrategy)namingStrategyWrapper.getWrappedObject(); // For native configuration Field namingStrategyField = wrappedNativeConfiguration.getClass().getDeclaredField("namingStrategy"); namingStrategyField.setAccessible(true); assertNull(namingStrategyField.get(wrappedNativeConfiguration)); - nativeConfigurationWrapper.setNamingStrategy(namingStrategy); + nativeConfigurationWrapper.setNamingStrategy(namingStrategyWrapper); assertNotNull(namingStrategyField.get(wrappedNativeConfiguration)); assertSame(namingStrategyField.get(wrappedNativeConfiguration), namingStrategy); // For reveng configuration try { - revengConfigurationWrapper.setNamingStrategy(namingStrategy); + revengConfigurationWrapper.setNamingStrategy(namingStrategyWrapper); fail(); } catch (RuntimeException e) { assertEquals( @@ -271,7 +271,7 @@ public void testSetNamingStrategy() throws Exception { } // For jpa configuration try { - jpaConfigurationWrapper.setNamingStrategy(namingStrategy); + jpaConfigurationWrapper.setNamingStrategy(namingStrategyWrapper); fail(); } catch (RuntimeException e) { assertEquals( @@ -339,7 +339,7 @@ public void testConfigureDocument() throws Exception { // For native configuration String fooClassName = - "org.hibernate.tool.orm.jbt.api.ConfigurationWrapperTest$Foo"; + "org.hibernate.tool.orm.jbt.api.wrp.ConfigurationWrapperTest$Foo"; Metadata metadata = MetadataHelper.getMetadata(wrappedNativeConfiguration); assertNull(metadata.getEntityBinding(fooClassName)); nativeConfigurationWrapper.configure(document); @@ -379,7 +379,7 @@ public void testConfigureFile() throws Exception { fileWriter.close(); String fooClassName = - "org.hibernate.tool.orm.jbt.api.ConfigurationWrapperTest$Foo"; + "org.hibernate.tool.orm.jbt.api.wrp.ConfigurationWrapperTest$Foo"; Metadata metadata = MetadataHelper.getMetadata(wrappedNativeConfiguration); assertNull(metadata.getEntityBinding(fooClassName)); Field metadataField = NativeConfiguration.class.getDeclaredField("metadata"); @@ -427,7 +427,7 @@ public void testConfigureDefault() throws Exception { // For native configuration String fooClassName = - "org.hibernate.tool.orm.jbt.api.ConfigurationWrapperTest$Foo"; + "org.hibernate.tool.orm.jbt.api.wrp.ConfigurationWrapperTest$Foo"; Metadata metadata = MetadataHelper.getMetadata(wrappedNativeConfiguration); assertNull(metadata.getEntityBinding(fooClassName)); Field metadataField = NativeConfiguration.class.getDeclaredField("metadata"); @@ -458,10 +458,10 @@ public void testConfigureDefault() throws Exception { @Test public void testAddClass() throws Exception { - String fooHbmXmlFilePath = "org/hibernate/tool/orm/jbt/api/"; + String fooHbmXmlFilePath = "org/hibernate/tool/orm/jbt/api/wrp"; String fooHbmXmlFileName = "ConfigurationWrapperTest$Foo.hbm.xml"; String fooClassName = - "org.hibernate.tool.orm.jbt.api.ConfigurationWrapperTest$Foo"; + "org.hibernate.tool.orm.jbt.api.wrp.ConfigurationWrapperTest$Foo"; URL url = getClass().getProtectionDomain().getCodeSource().getLocation(); File hbmXmlFileDir = new File(new File(url.toURI()),fooHbmXmlFilePath); hbmXmlFileDir.deleteOnExit(); @@ -528,7 +528,7 @@ public void testBuildMappings() throws Exception { @Test public void testBuildSessionFactory() throws Throwable { // For native configuration - SessionFactory sessionFactory = + SessionFactoryWrapper sessionFactory = nativeConfigurationWrapper.buildSessionFactory(); assertNotNull(sessionFactory); assertTrue(sessionFactory instanceof SessionFactoryWrapper); @@ -552,10 +552,10 @@ public void testBuildSessionFactory() throws Throwable { @Test public void testGetClassMappings() throws Exception { // For native configuration - String fooHbmXmlFilePath = "org/hibernate/tool/orm/jbt/api"; + String fooHbmXmlFilePath = "org/hibernate/tool/orm/jbt/api/wrp"; String fooHbmXmlFileName = "ConfigurationWrapperTest$Foo.hbm.xml"; String fooClassName = - "org.hibernate.tool.orm.jbt.api.ConfigurationWrapperTest$Foo"; + "org.hibernate.tool.orm.jbt.api.wrp.ConfigurationWrapperTest$Foo"; URL url = getClass().getProtectionDomain().getCodeSource().getLocation(); File hbmXmlFileDir = new File(new File(url.toURI()),fooHbmXmlFilePath); hbmXmlFileDir.deleteOnExit(); @@ -566,9 +566,9 @@ public void testGetClassMappings() throws Exception { fileWriter.write(TEST_HBM_XML_STRING); fileWriter.close(); wrappedNativeConfiguration.addClass(Foo.class); - Iterator classMappings = nativeConfigurationWrapper.getClassMappings(); + Iterator classMappings = nativeConfigurationWrapper.getClassMappings(); assertTrue(classMappings.hasNext()); - PersistentClass fooClassFacade = classMappings.next(); + PersistentClassWrapper fooClassFacade = classMappings.next(); assertSame(fooClassFacade.getEntityName(), fooClassName); classMappings = null; assertNull(classMappings); @@ -629,10 +629,11 @@ public void testSetPreferBasicCompositeIds() { @Test public void testSetReverseEngineeringStrategy() { - RevengStrategy reverseEngineeringStrategy = new DefaultStrategy(); + RevengStrategyWrapper revengStrategyWrapper = RevengStrategyWrapperFactory.createRevengStrategyWrapper(); + RevengStrategy reverseEngineeringStrategy = (RevengStrategy)revengStrategyWrapper.getWrappedObject(); // For native configuration try { - nativeConfigurationWrapper.setReverseEngineeringStrategy(reverseEngineeringStrategy); + nativeConfigurationWrapper.setReverseEngineeringStrategy(revengStrategyWrapper); fail(); } catch (RuntimeException e) { assertEquals( @@ -643,13 +644,13 @@ public void testSetReverseEngineeringStrategy() { assertNotSame( reverseEngineeringStrategy, ((RevengConfiguration)wrappedRevengConfiguration).getReverseEngineeringStrategy()); - revengConfigurationWrapper.setReverseEngineeringStrategy(reverseEngineeringStrategy); + revengConfigurationWrapper.setReverseEngineeringStrategy(revengStrategyWrapper); assertSame( reverseEngineeringStrategy, ((RevengConfiguration)wrappedRevengConfiguration).getReverseEngineeringStrategy()); // For jpa configuration try { - jpaConfigurationWrapper.setReverseEngineeringStrategy(reverseEngineeringStrategy); + jpaConfigurationWrapper.setReverseEngineeringStrategy(revengStrategyWrapper); fail(); } catch (RuntimeException e) { assertEquals( @@ -699,10 +700,10 @@ public void testReadFromJDBC() throws Exception { @Test public void testGetClassMapping() throws Exception { // For native configuration - String fooHbmXmlFilePath = "org/hibernate/tool/orm/jbt/api"; + String fooHbmXmlFilePath = "org/hibernate/tool/orm/jbt/api/wrp"; String fooHbmXmlFileName = "ConfigurationWrapperTest$Foo.hbm.xml"; String fooClassName = - "org.hibernate.tool.orm.jbt.api.ConfigurationWrapperTest$Foo"; + "org.hibernate.tool.orm.jbt.api.wrp.ConfigurationWrapperTest$Foo"; URL url = getClass().getProtectionDomain().getCodeSource().getLocation(); File hbmXmlFileDir = new File(new File(url.toURI()),fooHbmXmlFilePath); hbmXmlFileDir.deleteOnExit(); @@ -741,7 +742,7 @@ public void testGetNamingStrategy() { NamingStrategy namingStrategy = new DefaultNamingStrategy(); assertNull(nativeConfigurationWrapper.getNamingStrategy()); ((NativeConfiguration)wrappedNativeConfiguration).setNamingStrategy(namingStrategy); - assertSame(nativeConfigurationWrapper.getNamingStrategy(), namingStrategy); + assertSame(nativeConfigurationWrapper.getNamingStrategy().getWrappedObject(), namingStrategy); // For reveng configuration try { revengConfigurationWrapper.getNamingStrategy(); @@ -795,7 +796,7 @@ public void testGetEntityResolver() throws Exception { @Test public void testGetTableMappings() throws Exception { // For native configuration - String fooHbmXmlFilePath = "org/hibernate/tool/orm/jbt/api"; + String fooHbmXmlFilePath = "org/hibernate/tool/orm/jbt/api/wrp"; String fooHbmXmlFileName = "ConfigurationWrapperTest$Foo.hbm.xml"; URL url = getClass().getProtectionDomain().getCodeSource().getLocation(); File hbmXmlFileDir = new File(new File(url.toURI()),fooHbmXmlFilePath); @@ -807,9 +808,9 @@ public void testGetTableMappings() throws Exception { fileWriter.write(TEST_HBM_XML_STRING); fileWriter.close(); wrappedNativeConfiguration.addClass(Foo.class); - Iterator
tableMappings = nativeConfigurationWrapper.getTableMappings(); + Iterator tableMappings = nativeConfigurationWrapper.getTableMappings(); assertTrue(tableMappings.hasNext()); - Table fooTableFacade = tableMappings.next(); + TableWrapper fooTableFacade = tableMappings.next(); assertEquals(fooTableFacade.getName(), "ConfigurationWrapperTest$Foo"); tableMappings = null; assertNull(tableMappings); @@ -864,14 +865,14 @@ private void swapClassLoader() throws Exception { } private void initializeFacadesAndTargets() { - wrappedNativeConfiguration = new NativeConfiguration(); + nativeConfigurationWrapper = ConfigurationWrapperFactory.createNativeConfigurationWrapper(); + wrappedNativeConfiguration = (NativeConfiguration)nativeConfigurationWrapper.getWrappedObject(); wrappedNativeConfiguration.setProperty(AvailableSettings.DIALECT, MockDialect.class.getName()); wrappedNativeConfiguration.setProperty(AvailableSettings.CONNECTION_PROVIDER, MockConnectionProvider.class.getName()); - nativeConfigurationWrapper = ConfigurationWrapperFactory.createConfigurationWrapper(wrappedNativeConfiguration); - wrappedRevengConfiguration = new RevengConfiguration(); - revengConfigurationWrapper = ConfigurationWrapperFactory.createConfigurationWrapper(wrappedRevengConfiguration); - wrappedJpaConfiguration = new JpaConfiguration(null, null); - jpaConfigurationWrapper = ConfigurationWrapperFactory.createConfigurationWrapper(wrappedJpaConfiguration); + revengConfigurationWrapper = ConfigurationWrapperFactory.createRevengConfigurationWrapper(); + wrappedRevengConfiguration = (RevengConfiguration)revengConfigurationWrapper.getWrappedObject(); + jpaConfigurationWrapper = ConfigurationWrapperFactory.createJpaConfigurationWrapper(null, null); + wrappedJpaConfiguration = (JpaConfiguration)jpaConfigurationWrapper.getWrappedObject(); } } diff --git a/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/CriteriaWrapperTest.java b/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/wrp/CriteriaWrapperTest.java similarity index 97% rename from jbt/src/test/java/org/hibernate/tool/orm/jbt/api/CriteriaWrapperTest.java rename to jbt/src/test/java/org/hibernate/tool/orm/jbt/api/wrp/CriteriaWrapperTest.java index 1bfcb3a746..e71f38ad36 100644 --- a/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/CriteriaWrapperTest.java +++ b/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/wrp/CriteriaWrapperTest.java @@ -1,4 +1,4 @@ -package org.hibernate.tool.orm.jbt.api; +package org.hibernate.tool.orm.jbt.api.wrp; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertNotEquals; diff --git a/jbt/src/test/java/org/hibernate/tool/orm/jbt/wrp/DatabaseReaderWrapperFactoryTest.java b/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/wrp/DatabaseReaderWrapperTest.java similarity index 76% rename from jbt/src/test/java/org/hibernate/tool/orm/jbt/wrp/DatabaseReaderWrapperFactoryTest.java rename to jbt/src/test/java/org/hibernate/tool/orm/jbt/api/wrp/DatabaseReaderWrapperTest.java index 270e0b0725..f77ed0efcf 100644 --- a/jbt/src/test/java/org/hibernate/tool/orm/jbt/wrp/DatabaseReaderWrapperFactoryTest.java +++ b/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/wrp/DatabaseReaderWrapperTest.java @@ -1,4 +1,4 @@ -package org.hibernate.tool.orm.jbt.wrp; +package org.hibernate.tool.orm.jbt.api.wrp; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertNotNull; @@ -12,14 +12,12 @@ import java.util.Properties; import java.util.Set; -import org.hibernate.mapping.Table; -import org.hibernate.tool.internal.reveng.strategy.DefaultStrategy; -import org.hibernate.tool.orm.jbt.wrp.DatabaseReaderWrapperFactory.DatabaseReaderWrapper; -import org.hibernate.tool.orm.jbt.wrp.DatabaseReaderWrapperFactory.DatabaseReaderWrapperImpl; +import org.hibernate.tool.orm.jbt.internal.factory.DatabaseReaderWrapperFactory; +import org.hibernate.tool.orm.jbt.internal.factory.RevengStrategyWrapperFactory; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; -public class DatabaseReaderWrapperFactoryTest { +public class DatabaseReaderWrapperTest { private DatabaseReaderWrapper databaseReaderWrapper = null; @@ -30,15 +28,13 @@ public void beforeEach() { databaseReaderWrapper = DatabaseReaderWrapperFactory .createDatabaseReaderWrapper( properties, - new DefaultStrategy()); + RevengStrategyWrapperFactory.createRevengStrategyWrapper()); } @Test public void testConstruction() { assertNotNull(databaseReaderWrapper); - assertTrue(databaseReaderWrapper instanceof DatabaseReaderWrapperImpl); - assertNotNull(((DatabaseReaderWrapperImpl)databaseReaderWrapper).databaseReader); - assertNotNull(((DatabaseReaderWrapperImpl)databaseReaderWrapper).revengMetadataCollector); + assertTrue(databaseReaderWrapper instanceof DatabaseReaderWrapper); } @Test diff --git a/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/DdlExporterWrapperTest.java b/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/wrp/DdlExporterWrapperTest.java similarity index 97% rename from jbt/src/test/java/org/hibernate/tool/orm/jbt/api/DdlExporterWrapperTest.java rename to jbt/src/test/java/org/hibernate/tool/orm/jbt/api/wrp/DdlExporterWrapperTest.java index 5c08a734e3..52b5b757da 100644 --- a/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/DdlExporterWrapperTest.java +++ b/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/wrp/DdlExporterWrapperTest.java @@ -1,4 +1,4 @@ -package org.hibernate.tool.orm.jbt.api; +package org.hibernate.tool.orm.jbt.api.wrp; import static org.junit.jupiter.api.Assertions.assertFalse; import static org.junit.jupiter.api.Assertions.assertNotNull; diff --git a/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/EnvironmentWrapperTest.java b/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/wrp/EnvironmentWrapperTest.java similarity index 98% rename from jbt/src/test/java/org/hibernate/tool/orm/jbt/api/EnvironmentWrapperTest.java rename to jbt/src/test/java/org/hibernate/tool/orm/jbt/api/wrp/EnvironmentWrapperTest.java index f27a41f5ad..8798f5f6ec 100644 --- a/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/EnvironmentWrapperTest.java +++ b/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/wrp/EnvironmentWrapperTest.java @@ -1,4 +1,4 @@ -package org.hibernate.tool.orm.jbt.api; +package org.hibernate.tool.orm.jbt.api.wrp; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertNotNull; diff --git a/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/ExporterWrapperTest.java b/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/wrp/ExporterWrapperTest.java similarity index 84% rename from jbt/src/test/java/org/hibernate/tool/orm/jbt/api/ExporterWrapperTest.java rename to jbt/src/test/java/org/hibernate/tool/orm/jbt/api/wrp/ExporterWrapperTest.java index 2e835ced56..a2a3c6474c 100644 --- a/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/ExporterWrapperTest.java +++ b/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/wrp/ExporterWrapperTest.java @@ -1,4 +1,4 @@ -package org.hibernate.tool.orm.jbt.api; +package org.hibernate.tool.orm.jbt.api.wrp; import static org.junit.jupiter.api.Assertions.assertFalse; import static org.junit.jupiter.api.Assertions.assertNotNull; @@ -21,11 +21,10 @@ import org.hibernate.tool.internal.export.ddl.DdlExporter; import org.hibernate.tool.internal.export.query.QueryExporter; import org.hibernate.tool.orm.jbt.internal.factory.ArtifactCollectorWrapperFactory; +import org.hibernate.tool.orm.jbt.internal.factory.ConfigurationWrapperFactory; import org.hibernate.tool.orm.jbt.internal.factory.ExporterWrapperFactory; -import org.hibernate.tool.orm.jbt.util.ConfigurationMetadataDescriptor; -import org.hibernate.tool.orm.jbt.util.DummyMetadataDescriptor; -import org.hibernate.tool.orm.jbt.wrp.Wrapper; -import org.hibernate.tool.orm.jbt.wrp.ExporterWrapperFactoryTest.TestExporter; +import org.hibernate.tool.orm.jbt.internal.util.ConfigurationMetadataDescriptor; +import org.hibernate.tool.orm.jbt.internal.util.DummyMetadataDescriptor; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; @@ -37,7 +36,8 @@ public class ExporterWrapperTest { @BeforeEach public void beforeEach() { wrappedExporter = new TestExporter(); - exporterWrapper = ExporterWrapperFactory.createExporterWrapper(wrappedExporter); + exporterWrapper = ExporterWrapperFactory.createExporterWrapper(TestExporter.class.getName()); + wrappedExporter = (Exporter)exporterWrapper.getWrappedObject(); } @Test @@ -50,7 +50,8 @@ public void testConstruction() { public void testSetConfiguration() throws Exception { Object metadataDescriptor = null; Properties properties = new Properties(); - Configuration configuration = new Configuration(); + ConfigurationWrapper configurationWrapper = ConfigurationWrapperFactory.createNativeConfigurationWrapper(); + Configuration configuration = (Configuration)configurationWrapper.getWrappedObject(); configuration.setProperties(properties); Field field = ConfigurationMetadataDescriptor.class.getDeclaredField("configuration"); field.setAccessible(true); @@ -59,19 +60,19 @@ public void testSetConfiguration() throws Exception { assertNotNull(metadataDescriptor); assertTrue(metadataDescriptor instanceof ConfigurationMetadataDescriptor); assertNotSame(configuration, field.get(metadataDescriptor)); - exporterWrapper.setConfiguration(configuration); + exporterWrapper.setConfiguration(configurationWrapper); metadataDescriptor = wrappedExporter.getProperties().get(ExporterConstants.METADATA_DESCRIPTOR); assertNotNull(metadataDescriptor); assertTrue(metadataDescriptor instanceof ConfigurationMetadataDescriptor); assertSame(configuration, field.get(metadataDescriptor)); // Now test with a CfgExporter - wrappedExporter = new CfgExporter(); - exporterWrapper = ExporterWrapperFactory.createExporterWrapper(wrappedExporter); + exporterWrapper = ExporterWrapperFactory.createExporterWrapper(CfgExporter.class.getName()); + wrappedExporter = (Exporter)exporterWrapper.getWrappedObject(); assertNotSame(properties, ((CfgExporter)exporterWrapper.getWrappedObject()).getCustomProperties()); metadataDescriptor = wrappedExporter.getProperties().get(ExporterConstants.METADATA_DESCRIPTOR); assertNotNull(metadataDescriptor); assertTrue(metadataDescriptor instanceof DummyMetadataDescriptor); - exporterWrapper.setConfiguration(configuration); + exporterWrapper.setConfiguration(configurationWrapper); assertSame(properties, ((CfgExporter)exporterWrapper.getWrappedObject()).getCustomProperties()); metadataDescriptor = wrappedExporter.getProperties().get(ExporterConstants.METADATA_DESCRIPTOR); assertNotNull(metadataDescriptor); @@ -127,11 +128,9 @@ public void testGetGenericExporter() { // TestExporter should not return a GenericExporterFacade instance assertNull(exporterWrapper.getGenericExporter()); // try now with a GenericExporter - exporterWrapper = ExporterWrapperFactory.createExporterWrapper(new GenericExporter()); - GenericExporter genericExporter = exporterWrapper.getGenericExporter(); - assertNotNull(genericExporter); - Object exporterTarget = ((Wrapper)exporterWrapper).getWrappedObject(); - assertSame(exporterTarget, genericExporter); + exporterWrapper = ExporterWrapperFactory.createExporterWrapper(GenericExporter.class.getName()); + GenericExporterWrapper genericExporterWrapper = exporterWrapper.getGenericExporter(); + assertSame(exporterWrapper.getWrappedObject(), genericExporterWrapper.getWrappedObject()); } @Test @@ -139,11 +138,9 @@ public void testGetHbm2DDlExporter() { // TestExporter should not return a GenericExporterFacade instance assertNull(exporterWrapper.getHbm2DDLExporter()); // try now with a DdlExporter - exporterWrapper = ExporterWrapperFactory.createExporterWrapper(new DdlExporter()); - DdlExporter ddlExporter = exporterWrapper.getHbm2DDLExporter(); - assertNotNull(ddlExporter); - Object exporterTarget = ((Wrapper)exporterWrapper).getWrappedObject(); - assertSame(exporterTarget, ddlExporter); + exporterWrapper = ExporterWrapperFactory.createExporterWrapper(DdlExporter.class.getName()); + DdlExporterWrapper ddlExporterWrapper = exporterWrapper.getHbm2DDLExporter(); + assertSame(exporterWrapper.getWrappedObject(), ddlExporterWrapper.getWrappedObject()); } @Test @@ -151,11 +148,9 @@ public void testGetQueryExporter() { // TestExporter should not return a GenericExporterFacade instance assertNull(exporterWrapper.getQueryExporter()); // try now with a QueryExporter - exporterWrapper = ExporterWrapperFactory.createExporterWrapper(new QueryExporter()); - QueryExporter queryExporter = exporterWrapper.getQueryExporter(); - assertNotNull(queryExporter); - Object exporterTarget = ((Wrapper)exporterWrapper).getWrappedObject(); - assertSame(exporterTarget, queryExporter); + exporterWrapper = ExporterWrapperFactory.createExporterWrapper(QueryExporter.class.getName()); + QueryExporterWrapper queryExporterWrapper = exporterWrapper.getQueryExporter(); + assertSame(exporterWrapper.getWrappedObject(), queryExporterWrapper.getWrappedObject()); } @Test @@ -167,7 +162,7 @@ public void testSetCustomProperties() { exporterWrapper.setCustomProperties(properties); assertNull(wrappedTestExporter.props); // try now with CfgExporter - exporterWrapper = ExporterWrapperFactory.createExporterWrapper(new CfgExporter()); + exporterWrapper = ExporterWrapperFactory.createExporterWrapper(CfgExporter.class.getName()); CfgExporter wrappedCfgExporter = (CfgExporter)exporterWrapper.getWrappedObject(); assertNotSame(properties, wrappedCfgExporter.getCustomProperties()); exporterWrapper.setCustomProperties(properties); @@ -183,7 +178,7 @@ public void testSetOutput() { exporterWrapper.setOutput(stringWriter); assertNull(wrappedTestExporter.output); // try now with CfgExporter - exporterWrapper = ExporterWrapperFactory.createExporterWrapper(new CfgExporter()); + exporterWrapper = ExporterWrapperFactory.createExporterWrapper(CfgExporter.class.getName()); CfgExporter wrappedCfgExporter = (CfgExporter)exporterWrapper.getWrappedObject(); assertNotSame(stringWriter, wrappedCfgExporter.getOutput()); exporterWrapper.setOutput(stringWriter); diff --git a/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/ForeignKeyWrapperTest.java b/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/wrp/ForeignKeyWrapperTest.java similarity index 74% rename from jbt/src/test/java/org/hibernate/tool/orm/jbt/api/ForeignKeyWrapperTest.java rename to jbt/src/test/java/org/hibernate/tool/orm/jbt/api/wrp/ForeignKeyWrapperTest.java index 4169f6b011..10c021ae73 100644 --- a/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/ForeignKeyWrapperTest.java +++ b/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/wrp/ForeignKeyWrapperTest.java @@ -1,4 +1,4 @@ -package org.hibernate.tool.orm.jbt.api; +package org.hibernate.tool.orm.jbt.api.wrp; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertFalse; @@ -13,6 +13,7 @@ import org.hibernate.mapping.Column; import org.hibernate.mapping.ForeignKey; import org.hibernate.mapping.Table; +import org.hibernate.tool.orm.jbt.internal.factory.ColumnWrapperFactory; import org.hibernate.tool.orm.jbt.internal.factory.ForeignKeyWrapperFactory; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; @@ -38,19 +39,19 @@ public void testConstruction() { public void testGetReferencedTable() { Table table = new Table(""); wrappedForeignKey.setReferencedTable(table); - Table t = foreignKeyWrapper.getReferencedTable(); - assertSame(t, table); + TableWrapper tableWrapper = foreignKeyWrapper.getReferencedTable(); + assertSame(tableWrapper.getWrappedObject(), table); } @Test public void testColumnIterator() { - Iterator iterator = foreignKeyWrapper.columnIterator(); + Iterator iterator = foreignKeyWrapper.columnIterator(); assertFalse(iterator.hasNext()); Column column = new Column(); wrappedForeignKey.addColumn(column); iterator = foreignKeyWrapper.columnIterator(); - Column c = iterator.next(); - assertSame(c, column); + ColumnWrapper columnWrapper = iterator.next(); + assertSame(columnWrapper.getWrappedObject(), column); assertFalse(iterator.hasNext()); } @@ -66,7 +67,7 @@ public void testIsReferenceToPrimaryKey() { @Test public void testGetReferencedColumns() { - List list = foreignKeyWrapper.getReferencedColumns(); + List list = foreignKeyWrapper.getReferencedColumns(); assertTrue(list.isEmpty()); Column column = new Column(); ArrayList columns = new ArrayList(); @@ -74,15 +75,16 @@ public void testGetReferencedColumns() { wrappedForeignKey.addReferencedColumns(columns); list = foreignKeyWrapper.getReferencedColumns(); assertEquals(1, list.size()); - assertSame(column, list.get(0)); + assertSame(column, list.get(0).getWrappedObject()); } @Test public void testContainsColumn() throws Exception { Column column = new Column("foo"); - assertFalse(foreignKeyWrapper.containsColumn(column)); + ColumnWrapper columnWrapper = ColumnWrapperFactory.createColumnWrapper(column); + assertFalse(foreignKeyWrapper.containsColumn(columnWrapper)); wrappedForeignKey.addColumn(column); - assertTrue(foreignKeyWrapper.containsColumn(column)); + assertTrue(foreignKeyWrapper.containsColumn(columnWrapper)); } } diff --git a/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/GenericExporterWrapperTest.java b/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/wrp/GenericExporterWrapperTest.java similarity index 98% rename from jbt/src/test/java/org/hibernate/tool/orm/jbt/api/GenericExporterWrapperTest.java rename to jbt/src/test/java/org/hibernate/tool/orm/jbt/api/wrp/GenericExporterWrapperTest.java index 2d7a0ec83a..bb93f3531d 100644 --- a/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/GenericExporterWrapperTest.java +++ b/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/wrp/GenericExporterWrapperTest.java @@ -1,4 +1,4 @@ -package org.hibernate.tool.orm.jbt.api; +package org.hibernate.tool.orm.jbt.api.wrp; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertNotNull; diff --git a/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/HbmExporterWrapperTest.java b/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/wrp/HbmExporterWrapperTest.java similarity index 94% rename from jbt/src/test/java/org/hibernate/tool/orm/jbt/api/HbmExporterWrapperTest.java rename to jbt/src/test/java/org/hibernate/tool/orm/jbt/api/wrp/HbmExporterWrapperTest.java index e5d0842e00..4a8ae6b45b 100644 --- a/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/HbmExporterWrapperTest.java +++ b/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/wrp/HbmExporterWrapperTest.java @@ -1,4 +1,4 @@ -package org.hibernate.tool.orm.jbt.api; +package org.hibernate.tool.orm.jbt.api.wrp; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertFalse; @@ -22,7 +22,6 @@ import java.util.Properties; import org.hibernate.boot.Metadata; -import org.hibernate.cfg.Configuration; import org.hibernate.cfg.Environment; import org.hibernate.mapping.BasicValue; import org.hibernate.mapping.Column; @@ -38,9 +37,10 @@ import org.hibernate.tool.internal.export.java.Cfg2JavaTool; import org.hibernate.tool.internal.export.java.EntityPOJOClass; import org.hibernate.tool.internal.export.java.POJOClass; +import org.hibernate.tool.orm.jbt.internal.factory.ConfigurationWrapperFactory; import org.hibernate.tool.orm.jbt.internal.factory.HbmExporterWrapperFactory; -import org.hibernate.tool.orm.jbt.util.ConfigurationMetadataDescriptor; -import org.hibernate.tool.orm.jbt.util.DummyMetadataBuildingContext; +import org.hibernate.tool.orm.jbt.internal.util.ConfigurationMetadataDescriptor; +import org.hibernate.tool.orm.jbt.internal.util.DummyMetadataBuildingContext; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.io.TempDir; @@ -50,7 +50,7 @@ public class HbmExporterWrapperTest { private HbmExporterWrapper hbmExporterWrapper = null; private HbmExporter wrappedHbmExporter = null; - private Configuration cfg = null; + private ConfigurationWrapper cfg = null; private File f = null; private boolean delegateHasExported = false; @@ -60,7 +60,7 @@ public class HbmExporterWrapperTest { @BeforeEach public void beforeEach() { - cfg = new Configuration(); + cfg = ConfigurationWrapperFactory.createNativeConfigurationWrapper(); f = new File(tempFolder, "foo"); hbmExporterWrapper = HbmExporterWrapperFactory.createHbmExporterWrapper(cfg, f); wrappedHbmExporter = (HbmExporter)hbmExporterWrapper.getWrappedObject(); @@ -78,7 +78,7 @@ public void testConstruction() throws Exception { assertNotNull(descriptor); Field configurationField = ConfigurationMetadataDescriptor.class.getDeclaredField("configuration"); configurationField.setAccessible(true); - assertSame(cfg, configurationField.get(descriptor)); + assertSame(cfg.getWrappedObject(), configurationField.get(descriptor)); } @Test diff --git a/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/HqlCodeAssistWrapperTest.java b/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/wrp/HqlCodeAssistWrapperTest.java similarity index 74% rename from jbt/src/test/java/org/hibernate/tool/orm/jbt/api/HqlCodeAssistWrapperTest.java rename to jbt/src/test/java/org/hibernate/tool/orm/jbt/api/wrp/HqlCodeAssistWrapperTest.java index fd99605bbc..d2d71f18ef 100644 --- a/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/HqlCodeAssistWrapperTest.java +++ b/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/wrp/HqlCodeAssistWrapperTest.java @@ -1,15 +1,15 @@ -package org.hibernate.tool.orm.jbt.api; +package org.hibernate.tool.orm.jbt.api.wrp; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertNotEquals; import static org.junit.jupiter.api.Assertions.assertNotNull; import static org.junit.jupiter.api.Assertions.assertNull; -import org.hibernate.boot.Metadata; -import org.hibernate.cfg.Configuration; +import java.lang.reflect.Field; + +import org.hibernate.tool.ide.completion.HQLCodeAssist; +import org.hibernate.tool.orm.jbt.internal.factory.ConfigurationWrapperFactory; import org.hibernate.tool.orm.jbt.internal.factory.HqlCodeAssistWrapperFactory; -import org.hibernate.tool.orm.jbt.util.MetadataHelper; -import org.hibernate.tool.orm.jbt.util.NativeConfiguration; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; @@ -19,10 +19,9 @@ public class HqlCodeAssistWrapperTest { @BeforeEach public void beforeEach() { - Configuration c = new NativeConfiguration(); + ConfigurationWrapper c = ConfigurationWrapperFactory.createNativeConfigurationWrapper(); c.setProperty("hibernate.connection.url", "jdbc:h2:mem:test"); - Metadata m = MetadataHelper.getMetadata(c); - hqlCodeAssistWrapper = HqlCodeAssistWrapperFactory.createHqlCodeAssistWrapper(m); + hqlCodeAssistWrapper = HqlCodeAssistWrapperFactory.createHqlCodeAssistWrapper(c); } @Test @@ -31,14 +30,16 @@ public void testConstruction() { } @Test - public void testCodeComplete() { + public void testCodeComplete() throws Exception { // First test the handler's 'accept' method TestCodeCompletionHandler completionHandler = new TestCodeCompletionHandler(); assertEquals(0, completionHandler.acceptCount); hqlCodeAssistWrapper.codeComplete("", 0, completionHandler); assertNotEquals(0, completionHandler.acceptCount); // Now try to invoke the handler's 'completionFailure' method - hqlCodeAssistWrapper = HqlCodeAssistWrapperFactory.createHqlCodeAssistWrapper(null); + Field f = hqlCodeAssistWrapper.getClass().getDeclaredField("hqlCodeAssist"); + f.setAccessible(true); + f.set(hqlCodeAssistWrapper, new HQLCodeAssist(null)); assertNull(completionHandler.errorMessage); hqlCodeAssistWrapper.codeComplete("FROM ", 5, completionHandler); assertNotNull(completionHandler.errorMessage); diff --git a/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/HqlCompletionProposalWrapperTest.java b/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/wrp/HqlCompletionProposalWrapperTest.java similarity index 98% rename from jbt/src/test/java/org/hibernate/tool/orm/jbt/api/HqlCompletionProposalWrapperTest.java rename to jbt/src/test/java/org/hibernate/tool/orm/jbt/api/wrp/HqlCompletionProposalWrapperTest.java index 6eb8845a29..f32be170ce 100644 --- a/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/HqlCompletionProposalWrapperTest.java +++ b/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/wrp/HqlCompletionProposalWrapperTest.java @@ -1,4 +1,4 @@ -package org.hibernate.tool.orm.jbt.api; +package org.hibernate.tool.orm.jbt.api.wrp; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertNotEquals; diff --git a/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/JoinWrapperTest.java b/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/wrp/JoinWrapperTest.java similarity index 83% rename from jbt/src/test/java/org/hibernate/tool/orm/jbt/api/JoinWrapperTest.java rename to jbt/src/test/java/org/hibernate/tool/orm/jbt/api/wrp/JoinWrapperTest.java index 2ebd52d678..8ccb0b2979 100644 --- a/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/JoinWrapperTest.java +++ b/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/wrp/JoinWrapperTest.java @@ -1,4 +1,4 @@ -package org.hibernate.tool.orm.jbt.api; +package org.hibernate.tool.orm.jbt.api.wrp; import static org.junit.jupiter.api.Assertions.assertFalse; import static org.junit.jupiter.api.Assertions.assertNotNull; @@ -32,14 +32,14 @@ public void testConstruction() { @Test public void testGetPropertyIterator() { - Iterator propertyIterator = joinWrapper.getPropertyIterator(); + Iterator propertyIterator = joinWrapper.getPropertyIterator(); assertFalse(propertyIterator.hasNext()); Property property = new Property(); wrappedJoin.addProperty(property); propertyIterator = joinWrapper.getPropertyIterator(); assertTrue(propertyIterator.hasNext()); - Property p = propertyIterator.next(); - assertSame(p, property); + PropertyWrapper p = propertyIterator.next(); + assertSame(p.getWrappedObject(), property); } } diff --git a/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/NamingStrategyWrapperTest.java b/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/wrp/NamingStrategyWrapperTest.java similarity index 93% rename from jbt/src/test/java/org/hibernate/tool/orm/jbt/api/NamingStrategyWrapperTest.java rename to jbt/src/test/java/org/hibernate/tool/orm/jbt/api/wrp/NamingStrategyWrapperTest.java index 105993a0a2..6d61d5c321 100644 --- a/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/NamingStrategyWrapperTest.java +++ b/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/wrp/NamingStrategyWrapperTest.java @@ -1,4 +1,4 @@ -package org.hibernate.tool.orm.jbt.api; +package org.hibernate.tool.orm.jbt.api.wrp; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertNotNull; @@ -17,7 +17,8 @@ public class NamingStrategyWrapperTest { @BeforeEach public void beforeEach() { wrappedNamingStrategy = new TestNamingStrategy(); - namingStrategyWrapper = NamingStrategyWrapperFactory.createNamingStrategyWrapper(wrappedNamingStrategy); + namingStrategyWrapper = NamingStrategyWrapperFactory.createNamingStrategyWrapper(TestNamingStrategy.class.getName()); + wrappedNamingStrategy = (NamingStrategy)((Wrapper)namingStrategyWrapper).getWrappedObject(); } @Test diff --git a/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/OverrideRepositoryWrapperTest.java b/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/wrp/OverrideRepositoryWrapperTest.java similarity index 78% rename from jbt/src/test/java/org/hibernate/tool/orm/jbt/api/OverrideRepositoryWrapperTest.java rename to jbt/src/test/java/org/hibernate/tool/orm/jbt/api/wrp/OverrideRepositoryWrapperTest.java index 838f20d686..c9000d121c 100644 --- a/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/OverrideRepositoryWrapperTest.java +++ b/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/wrp/OverrideRepositoryWrapperTest.java @@ -1,4 +1,4 @@ -package org.hibernate.tool.orm.jbt.api; +package org.hibernate.tool.orm.jbt.api.wrp; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertFalse; @@ -13,11 +13,12 @@ import org.hibernate.mapping.Table; import org.hibernate.tool.api.reveng.RevengStrategy; -import org.hibernate.tool.internal.reveng.strategy.DefaultStrategy; import org.hibernate.tool.internal.reveng.strategy.DelegatingStrategy; import org.hibernate.tool.internal.reveng.strategy.OverrideRepository; import org.hibernate.tool.internal.reveng.strategy.TableFilter; import org.hibernate.tool.orm.jbt.internal.factory.OverrideRepositoryWrapperFactory; +import org.hibernate.tool.orm.jbt.internal.factory.RevengStrategyWrapperFactory; +import org.hibernate.tool.orm.jbt.internal.factory.TableFilterWrapperFactory; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; @@ -37,8 +38,8 @@ public class OverrideRepositoryWrapperTest { @BeforeEach public void beforeEach() { - wrappedOverrideRepository = new OverrideRepository(); - overrideRepositoryWrapper = OverrideRepositoryWrapperFactory.createOverrideRepositoryWrapper(wrappedOverrideRepository); + overrideRepositoryWrapper = OverrideRepositoryWrapperFactory.createOverrideRepositoryWrapper(); + wrappedOverrideRepository = (OverrideRepository)overrideRepositoryWrapper.getWrappedObject(); } @Test @@ -72,22 +73,24 @@ public void testAddFile() throws Exception { @Test public void testGetReverseEngineeringStrategy() throws Exception { - RevengStrategy rev = new DefaultStrategy(); + RevengStrategyWrapper revWrapper = RevengStrategyWrapperFactory.createRevengStrategyWrapper(); + RevengStrategy rev = (RevengStrategy)revWrapper.getWrappedObject(); Field delegateField = DelegatingStrategy.class.getDeclaredField("delegate"); delegateField.setAccessible(true); - RevengStrategy delegatingStrategy = overrideRepositoryWrapper.getReverseEngineeringStrategy(rev); + RevengStrategyWrapper delegatingStrategy = overrideRepositoryWrapper.getReverseEngineeringStrategy(revWrapper); assertNotNull(delegatingStrategy); - assertSame(rev, delegateField.get(delegatingStrategy)); + assertSame(rev, delegateField.get(delegatingStrategy.getWrappedObject())); } @Test public void testAddTableFilter() throws Exception { - TableFilter tableFilter = new TableFilter(); + TableFilterWrapper tableFilterWrapper = TableFilterWrapperFactory.createTableFilterWrapper(); + TableFilter tableFilter = (TableFilter)tableFilterWrapper.getWrappedObject(); Field tableFiltersField = OverrideRepository.class.getDeclaredField("tableFilters"); tableFiltersField.setAccessible(true); List tableFilters = (List)tableFiltersField.get(wrappedOverrideRepository); assertTrue(tableFilters.isEmpty()); - overrideRepositoryWrapper.addTableFilter(tableFilter); + overrideRepositoryWrapper.addTableFilter(tableFilterWrapper); tableFilters = (List)tableFiltersField.get(wrappedOverrideRepository); assertSame(tableFilter, tableFilters.get(0)); } diff --git a/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/PersistentClassWrapperFactoryTest.java b/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/wrp/PersistentClassWrapperTest.java similarity index 85% rename from jbt/src/test/java/org/hibernate/tool/orm/jbt/api/PersistentClassWrapperFactoryTest.java rename to jbt/src/test/java/org/hibernate/tool/orm/jbt/api/wrp/PersistentClassWrapperTest.java index 96f013de0a..43be969a09 100644 --- a/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/PersistentClassWrapperFactoryTest.java +++ b/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/wrp/PersistentClassWrapperTest.java @@ -1,4 +1,4 @@ -package org.hibernate.tool.orm.jbt.api; +package org.hibernate.tool.orm.jbt.api.wrp; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertFalse; @@ -26,16 +26,15 @@ import org.hibernate.mapping.Table; import org.hibernate.mapping.Value; import org.hibernate.tool.orm.jbt.internal.factory.PersistentClassWrapperFactory; -import org.hibernate.tool.orm.jbt.util.DummyMetadataBuildingContext; -import org.hibernate.tool.orm.jbt.util.SpecialRootClass; -import org.hibernate.tool.orm.jbt.wrp.PropertyWrapperFactory.PropertyWrapper; -import org.hibernate.tool.orm.jbt.wrp.ValueWrapperFactory.ValueWrapper; -import org.hibernate.tool.orm.jbt.wrp.Wrapper; -import org.hibernate.tool.orm.jbt.wrp.WrapperFactory; +import org.hibernate.tool.orm.jbt.internal.factory.PropertyWrapperFactory; +import org.hibernate.tool.orm.jbt.internal.factory.TableWrapperFactory; +import org.hibernate.tool.orm.jbt.internal.factory.ValueWrapperFactory; +import org.hibernate.tool.orm.jbt.internal.util.DummyMetadataBuildingContext; +import org.hibernate.tool.orm.jbt.internal.util.SpecialRootClass; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; -public class PersistentClassWrapperFactoryTest { +public class PersistentClassWrapperTest { private PersistentClass rootClassTarget = null; private PersistentClassWrapper rootClassWrapper = null; @@ -50,16 +49,16 @@ public class PersistentClassWrapperFactoryTest { @BeforeEach public void beforeEach() throws Exception { - rootClassWrapper = PersistentClassWrapperFactory.createRootClassWrapper(); - rootClassTarget = rootClassWrapper.getWrappedObject(); - singleTableSubclassWrapper = PersistentClassWrapperFactory.createSingleTableSubclassWrapper(rootClassWrapper); - singleTableSubclassTarget = singleTableSubclassWrapper.getWrappedObject(); - joinedSubclassWrapper = PersistentClassWrapperFactory.createJoinedSubclassWrapper(rootClassWrapper); - joinedSubclassTarget = joinedSubclassWrapper.getWrappedObject(); - property = (PropertyWrapper)WrapperFactory.createPropertyWrapper(); - property.setPersistentClass(rootClassTarget); - specialRootClassWrapper = PersistentClassWrapperFactory.createSpecialRootClassWrapper(property); - specialRootClassTarget = specialRootClassWrapper.getWrappedObject(); + rootClassTarget = new RootClass(DummyMetadataBuildingContext.INSTANCE); + rootClassWrapper = PersistentClassWrapperFactory.createPersistentClassWrapper(rootClassTarget); + singleTableSubclassTarget = new SingleTableSubclass(rootClassTarget, DummyMetadataBuildingContext.INSTANCE); + singleTableSubclassWrapper = PersistentClassWrapperFactory.createPersistentClassWrapper(singleTableSubclassTarget); + joinedSubclassTarget = new JoinedSubclass(rootClassTarget, DummyMetadataBuildingContext.INSTANCE); + joinedSubclassWrapper = PersistentClassWrapperFactory.createPersistentClassWrapper(joinedSubclassTarget); + property = PropertyWrapperFactory.createPropertyWrapper(); + property.setPersistentClass(rootClassWrapper); + specialRootClassTarget = new SpecialRootClass((Property)property.getWrappedObject()); + specialRootClassWrapper = PersistentClassWrapperFactory.createPersistentClassWrapper(specialRootClassTarget); } @Test @@ -142,12 +141,12 @@ public void testGetIdentifierProperty() { assertNull(specialRootClassWrapper.getIdentifierProperty()); Property property = new Property(); ((RootClass)rootClassTarget).setIdentifierProperty(property); - assertSame(property, rootClassWrapper.getIdentifierProperty()); - assertSame(property, singleTableSubclassWrapper.getIdentifierProperty()); - assertSame(property, joinedSubclassWrapper.getIdentifierProperty()); + assertSame(property, rootClassWrapper.getIdentifierProperty().getWrappedObject()); + assertSame(property, singleTableSubclassWrapper.getIdentifierProperty().getWrappedObject()); + assertSame(property, joinedSubclassWrapper.getIdentifierProperty().getWrappedObject()); assertNull(specialRootClassWrapper.getIdentifierProperty()); ((RootClass)specialRootClassTarget).setIdentifierProperty(property); - assertSame(property, specialRootClassWrapper.getIdentifierProperty()); + assertSame(property, specialRootClassWrapper.getIdentifierProperty().getWrappedObject()); } @Test @@ -181,15 +180,15 @@ public void testIsInstanceOfSubclass() { @Test public void testGetRootClass() { - assertSame(rootClassWrapper.getRootClass(), rootClassTarget); - assertSame(singleTableSubclassWrapper.getRootClass(), rootClassTarget); - assertSame(joinedSubclassWrapper.getRootClass(), rootClassTarget); - assertSame(specialRootClassWrapper.getRootClass(), specialRootClassTarget); + assertSame(rootClassWrapper.getRootClass().getWrappedObject(), rootClassTarget); + assertSame(singleTableSubclassWrapper.getRootClass().getWrappedObject(), rootClassTarget); + assertSame(joinedSubclassWrapper.getRootClass().getWrappedObject(), rootClassTarget); + assertSame(specialRootClassWrapper.getRootClass().getWrappedObject(), specialRootClassTarget); } @Test public void testGetPropertyClosureIterator() { - Iterator propertyClosureIterator = rootClassWrapper.getPropertyClosureIterator(); + Iterator propertyClosureIterator = rootClassWrapper.getPropertyClosureIterator(); assertFalse(propertyClosureIterator.hasNext()); propertyClosureIterator = singleTableSubclassWrapper.getPropertyClosureIterator(); assertFalse(propertyClosureIterator.hasNext()); @@ -201,19 +200,19 @@ public void testGetPropertyClosureIterator() { rootClassTarget.addProperty(property); propertyClosureIterator = rootClassWrapper.getPropertyClosureIterator(); assertTrue(propertyClosureIterator.hasNext()); - assertSame(property, propertyClosureIterator.next()); + assertSame(property, propertyClosureIterator.next().getWrappedObject()); propertyClosureIterator = singleTableSubclassWrapper.getPropertyClosureIterator(); assertTrue(propertyClosureIterator.hasNext()); - assertSame(property, propertyClosureIterator.next()); + assertSame(property, propertyClosureIterator.next().getWrappedObject()); propertyClosureIterator = joinedSubclassWrapper.getPropertyClosureIterator(); assertTrue(propertyClosureIterator.hasNext()); - assertSame(property, propertyClosureIterator.next()); + assertSame(property, propertyClosureIterator.next().getWrappedObject()); propertyClosureIterator = specialRootClassWrapper.getPropertyClosureIterator(); assertFalse(propertyClosureIterator.hasNext()); specialRootClassTarget.addProperty(property); propertyClosureIterator = specialRootClassWrapper.getPropertyClosureIterator(); assertTrue(propertyClosureIterator.hasNext()); - assertSame(property, ((Wrapper)propertyClosureIterator.next()).getWrappedObject()); + assertSame(property, propertyClosureIterator.next().getWrappedObject()); } @Test @@ -226,7 +225,7 @@ public void testGetSuperclass() { @Test public void testGetPropertyIterator() { - Iterator propertyIterator = rootClassWrapper.getPropertyIterator(); + Iterator propertyIterator = rootClassWrapper.getPropertyIterator(); assertFalse(propertyIterator.hasNext()); propertyIterator = singleTableSubclassWrapper.getPropertyIterator(); assertFalse(propertyIterator.hasNext()); @@ -237,7 +236,7 @@ public void testGetPropertyIterator() { Property property = new Property(); rootClassTarget.addProperty(property); propertyIterator = rootClassWrapper.getPropertyIterator(); - assertSame(property, propertyIterator.next()); + assertSame(property, propertyIterator.next().getWrappedObject()); propertyIterator = singleTableSubclassWrapper.getPropertyIterator(); assertFalse(propertyIterator.hasNext()); singleTableSubclassTarget.addProperty(property); @@ -284,9 +283,9 @@ public void testGetProperty() { Property p = new Property(); p.setName("foo"); rootClassTarget.addProperty(p); - assertSame(p, rootClassWrapper.getProperty("foo")); - assertSame(p, singleTableSubclassWrapper.getProperty("foo")); - assertSame(p, joinedSubclassWrapper.getProperty("foo")); + assertSame(p, rootClassWrapper.getProperty("foo").getWrappedObject()); + assertSame(p, singleTableSubclassWrapper.getProperty("foo").getWrappedObject()); + assertSame(p, joinedSubclassWrapper.getProperty("foo").getWrappedObject()); try { specialRootClassWrapper.getProperty("foo"); fail(); @@ -296,7 +295,7 @@ public void testGetProperty() { t.getMessage()); } specialRootClassTarget.addProperty(p); - assertSame(p, specialRootClassWrapper.getProperty("foo")); + assertSame(p, specialRootClassWrapper.getProperty("foo").getWrappedObject()); try { rootClassWrapper.getProperty(); fail(); @@ -323,7 +322,7 @@ public void testGetProperty() { } assertSame( ((Wrapper)property).getWrappedObject(), - ((Wrapper)specialRootClassWrapper.getProperty()).getWrappedObject()); + specialRootClassWrapper.getProperty().getWrappedObject()); } @Test @@ -334,14 +333,14 @@ public void testGetTable() { assertNull(specialRootClassWrapper.getTable()); Table table = new Table("test"); ((RootClass)rootClassTarget).setTable(table); - assertSame(table, rootClassWrapper.getTable()); - assertSame(table, singleTableSubclassWrapper.getTable()); + assertSame(table, rootClassWrapper.getTable().getWrappedObject()); + assertSame(table, singleTableSubclassWrapper.getTable().getWrappedObject()); assertNull(joinedSubclassWrapper.getTable()); ((JoinedSubclass)joinedSubclassTarget).setTable(table); - assertSame(table, joinedSubclassWrapper.getTable()); + assertSame(table, joinedSubclassWrapper.getTable().getWrappedObject()); assertNull(specialRootClassWrapper.getTable()); ((RootClass)specialRootClassTarget).setTable(table); - assertSame(table, specialRootClassWrapper.getTable()); + assertSame(table, specialRootClassWrapper.getTable().getWrappedObject()); } @Test @@ -376,19 +375,11 @@ public void testGetDiscriminator() { assertNull(specialRootClassWrapper.getDiscriminator()); Value value = new BasicValue(DummyMetadataBuildingContext.INSTANCE); ((RootClass)rootClassTarget).setDiscriminator(value); - Value valueWrapper = rootClassWrapper.getDiscriminator(); - assertTrue(valueWrapper instanceof ValueWrapper); - assertSame(value, ((ValueWrapper)valueWrapper).getWrappedObject()); - valueWrapper = singleTableSubclassWrapper.getDiscriminator(); - assertTrue(valueWrapper instanceof ValueWrapper); - assertSame(value, ((ValueWrapper)valueWrapper).getWrappedObject()); - valueWrapper = joinedSubclassWrapper.getDiscriminator(); - assertTrue(valueWrapper instanceof ValueWrapper); - assertSame(value, ((ValueWrapper)valueWrapper).getWrappedObject()); + assertSame(value, rootClassWrapper.getDiscriminator().getWrappedObject()); + assertSame(value, singleTableSubclassWrapper.getDiscriminator().getWrappedObject()); + assertSame(value, joinedSubclassWrapper.getDiscriminator().getWrappedObject()); ((RootClass)specialRootClassTarget).setDiscriminator(value); - valueWrapper = specialRootClassWrapper.getDiscriminator(); - assertTrue(valueWrapper instanceof ValueWrapper); - assertSame(value, ((ValueWrapper)valueWrapper).getWrappedObject()); + assertSame(value, specialRootClassWrapper.getDiscriminator().getWrappedObject()); } @Test @@ -399,11 +390,11 @@ public void testGetIdentifier() { assertNull(specialRootClassWrapper.getIdentifier()); KeyValue value = new BasicValue(DummyMetadataBuildingContext.INSTANCE); ((RootClass)rootClassTarget).setIdentifier(value); - assertSame(value, ((Wrapper)rootClassWrapper.getIdentifier()).getWrappedObject()); - assertSame(value, ((Wrapper)singleTableSubclassWrapper.getIdentifier()).getWrappedObject()); - assertSame(value, ((Wrapper)joinedSubclassWrapper.getIdentifier()).getWrappedObject()); + assertSame(value, rootClassWrapper.getIdentifier().getWrappedObject()); + assertSame(value, singleTableSubclassWrapper.getIdentifier().getWrappedObject()); + assertSame(value, joinedSubclassWrapper.getIdentifier().getWrappedObject()); ((RootClass)specialRootClassTarget).setIdentifier(value); - assertSame(value, ((Wrapper)specialRootClassWrapper.getIdentifier()).getWrappedObject()); + assertSame(value, specialRootClassWrapper.getIdentifier().getWrappedObject()); } @Test @@ -414,17 +405,17 @@ public void testGetJoinIterator() { assertFalse(specialRootClassWrapper.getJoinIterator().hasNext()); Join join = new Join(); rootClassTarget.addJoin(join); - Iterator joinIterator = rootClassWrapper.getJoinIterator(); - assertSame(join, joinIterator.next()); + Iterator joinIterator = rootClassWrapper.getJoinIterator(); + assertSame(join, joinIterator.next().getWrappedObject()); singleTableSubclassTarget.addJoin(join); joinIterator = singleTableSubclassWrapper.getJoinIterator(); - assertSame(join, joinIterator.next()); + assertSame(join, joinIterator.next().getWrappedObject()); joinedSubclassTarget.addJoin(join); joinIterator = joinedSubclassWrapper.getJoinIterator(); - assertSame(join, joinIterator.next()); + assertSame(join, joinIterator.next().getWrappedObject()); specialRootClassTarget.addJoin(join); joinIterator = specialRootClassWrapper.getJoinIterator(); - assertSame(join, joinIterator.next()); + assertSame(join, joinIterator.next().getWrappedObject()); } @Test @@ -435,11 +426,11 @@ public void testGetVersion() { assertNull(specialRootClassWrapper.getVersion()); Property versionTarget = new Property(); ((RootClass)rootClassTarget).setVersion(versionTarget); - assertSame(versionTarget, rootClassWrapper.getVersion()); - assertSame(versionTarget, singleTableSubclassWrapper.getVersion()); - assertSame(versionTarget, joinedSubclassWrapper.getVersion()); + assertSame(versionTarget, rootClassWrapper.getVersion().getWrappedObject()); + assertSame(versionTarget, singleTableSubclassWrapper.getVersion().getWrappedObject()); + assertSame(versionTarget, joinedSubclassWrapper.getVersion().getWrappedObject()); ((RootClass)specialRootClassTarget).setVersion(versionTarget); - assertSame(versionTarget, specialRootClassWrapper.getVersion()); + assertSame(versionTarget, specialRootClassWrapper.getVersion().getWrappedObject()); } @Test @@ -548,9 +539,10 @@ public void testAddProperty() { "property [foo] not found on entity [null]", e.getMessage()); } - Property propertyTarget = new Property(); + PropertyWrapper propertyWrapper = PropertyWrapperFactory.createPropertyWrapper(); + Property propertyTarget = (Property)propertyWrapper.getWrappedObject(); propertyTarget.setName("foo"); - rootClassWrapper.addProperty(propertyTarget); + rootClassWrapper.addProperty(propertyWrapper); assertSame(rootClassTarget.getProperty("foo"), propertyTarget); assertSame(singleTableSubclassTarget.getProperty("foo"), propertyTarget); assertSame(joinedSubclassTarget.getProperty("foo"), propertyTarget); @@ -562,8 +554,8 @@ public void testAddProperty() { "property [foo] not found on entity [null]", e.getMessage()); } - specialRootClassWrapper.addProperty(propertyTarget); - assertSame(specialRootClassWrapper.getProperty("foo"), propertyTarget); + specialRootClassWrapper.addProperty(propertyWrapper); + assertSame(specialRootClassWrapper.getProperty("foo").getWrappedObject(), propertyTarget); } @Test @@ -576,49 +568,51 @@ public void testIsInstanceOfJoinedSubclass() { @Test public void testSetTable() { - Table table = new Table(""); + TableWrapper tableWrapper = TableWrapperFactory.createTableWrapper(""); + Table table = (Table)tableWrapper.getWrappedObject(); assertNull(rootClassTarget.getTable()); assertNull(singleTableSubclassTarget.getTable()); - rootClassWrapper.setTable(table); + rootClassWrapper.setTable(tableWrapper); assertSame(table, rootClassTarget.getTable()); assertSame(table, singleTableSubclassTarget.getTable()); try { - singleTableSubclassWrapper.setTable(new Table("")); + singleTableSubclassWrapper.setTable(tableWrapper); fail(); } catch (RuntimeException e) { assertEquals(e.getMessage(), "Method 'setTable(Table)' is not supported."); } assertNull(joinedSubclassTarget.getTable()); - joinedSubclassWrapper.setTable(table); + joinedSubclassWrapper.setTable(tableWrapper); assertSame(table, joinedSubclassTarget.getTable()); assertNull(specialRootClassTarget.getTable()); - specialRootClassWrapper.setTable(table); + specialRootClassWrapper.setTable(tableWrapper); assertSame(table, specialRootClassTarget.getTable()); } @Test public void testSetKey() { Value valueTarget = new BasicValue(DummyMetadataBuildingContext.INSTANCE); + ValueWrapper valueWrapper = ValueWrapperFactory.createValueWrapper(valueTarget); assertNull(rootClassTarget.getKey()); assertNull(singleTableSubclassTarget.getKey()); assertNull(joinedSubclassTarget.getKey()); assertNull(specialRootClassTarget.getKey()); try { - rootClassWrapper.setKey(valueTarget); + rootClassWrapper.setKey(valueWrapper); fail(); } catch (RuntimeException e) { assertEquals("setKey(Value) is only allowed on JoinedSubclass", e.getMessage()); } try { - singleTableSubclassWrapper.setKey(valueTarget); + singleTableSubclassWrapper.setKey(valueWrapper); fail(); } catch (RuntimeException e) { assertEquals("setKey(Value) is only allowed on JoinedSubclass", e.getMessage()); } - joinedSubclassWrapper.setKey(valueTarget); + joinedSubclassWrapper.setKey(valueWrapper); assertSame(valueTarget, joinedSubclassTarget.getKey()); try { - specialRootClassWrapper.setKey(valueTarget); + specialRootClassWrapper.setKey(valueWrapper); fail(); } catch (RuntimeException e) { assertEquals("setKey(Value) is only allowed on JoinedSubclass", e.getMessage()); @@ -657,32 +651,35 @@ public void testGetParentProperty() { PersistentClass pc = new RootClass(DummyMetadataBuildingContext.INSTANCE); Component component = new Component(DummyMetadataBuildingContext.INSTANCE, pc); component.setParentProperty("foo"); - PropertyWrapper property = (PropertyWrapper)WrapperFactory.createPropertyWrapper(); + PropertyWrapper propertyWrapper = PropertyWrapperFactory.createPropertyWrapper(); + Property property = (Property)propertyWrapper.getWrappedObject(); property.setValue(component); property.setPersistentClass(pc); - specialRootClassWrapper = PersistentClassWrapperFactory.createSpecialRootClassWrapper(property); - Property parentProperty = specialRootClassWrapper.getParentProperty(); + SpecialRootClass src = new SpecialRootClass(property); + specialRootClassWrapper = PersistentClassWrapperFactory.createPersistentClassWrapper(src); + PropertyWrapper parentProperty = specialRootClassWrapper.getParentProperty(); assertNotNull(parentProperty); assertEquals("foo", parentProperty.getName()); } @Test public void testSetIdentifierProperty() { - Property property = new Property(); + PropertyWrapper propertyWrapper = PropertyWrapperFactory.createPropertyWrapper(); + Property property = (Property)propertyWrapper.getWrappedObject(); assertNull(rootClassTarget.getIdentifierProperty()); - rootClassWrapper.setIdentifierProperty(property); + rootClassWrapper.setIdentifierProperty(propertyWrapper); assertSame(property, rootClassTarget.getIdentifierProperty()); assertNull(specialRootClassTarget.getIdentifierProperty()); - specialRootClassWrapper.setIdentifierProperty(property); + specialRootClassWrapper.setIdentifierProperty(propertyWrapper); assertSame(property, specialRootClassTarget.getIdentifierProperty()); try { - singleTableSubclassWrapper.setIdentifierProperty(property); + singleTableSubclassWrapper.setIdentifierProperty(propertyWrapper); fail(); } catch (RuntimeException e) { assertEquals("setIdentifierProperty(Property) is only allowed on RootClass instances", e.getMessage()); } try { - joinedSubclassWrapper.setIdentifierProperty(property); + joinedSubclassWrapper.setIdentifierProperty(propertyWrapper); fail(); } catch (RuntimeException e) { assertEquals("setIdentifierProperty(Property) is only allowed on RootClass instances", e.getMessage()); @@ -692,56 +689,58 @@ public void testSetIdentifierProperty() { @Test public void testSetIdentifier() { KeyValue valueTarget = new BasicValue(DummyMetadataBuildingContext.INSTANCE); + ValueWrapper valueWrapper = ValueWrapperFactory.createValueWrapper(valueTarget); assertNull(rootClassTarget.getIdentifier()); assertNull(singleTableSubclassTarget.getIdentifier()); assertNull(joinedSubclassTarget.getIdentifier()); - rootClassWrapper.setIdentifier(valueTarget); - assertSame(valueTarget, ((Wrapper)rootClassTarget.getIdentifier()).getWrappedObject()); - assertSame(valueTarget, ((Wrapper)singleTableSubclassTarget.getIdentifier()).getWrappedObject()); - assertSame(valueTarget, ((Wrapper)joinedSubclassTarget.getIdentifier()).getWrappedObject()); + rootClassWrapper.setIdentifier(valueWrapper); + assertSame(valueTarget, rootClassTarget.getIdentifier()); + assertSame(valueTarget, singleTableSubclassTarget.getIdentifier()); + assertSame(valueTarget, joinedSubclassTarget.getIdentifier()); try { - singleTableSubclassWrapper.setIdentifier(valueTarget); + singleTableSubclassWrapper.setIdentifier(valueWrapper); fail(); } catch (RuntimeException e) { assertEquals("Method 'setIdentifier(Value)' can only be called on RootClass instances", e.getMessage()); } try { - joinedSubclassWrapper.setIdentifier(valueTarget); + joinedSubclassWrapper.setIdentifier(valueWrapper); fail(); } catch (RuntimeException e) { assertEquals("Method 'setIdentifier(Value)' can only be called on RootClass instances", e.getMessage()); } assertNull(specialRootClassTarget.getIdentifier()); - specialRootClassWrapper.setIdentifier(valueTarget); - assertSame(valueTarget, ((Wrapper)specialRootClassTarget.getIdentifier()).getWrappedObject()); + specialRootClassWrapper.setIdentifier(valueWrapper); + assertSame(valueTarget, specialRootClassTarget.getIdentifier()); } @Test public void testSetDiscriminator() throws Exception { KeyValue valueTarget = new BasicValue(DummyMetadataBuildingContext.INSTANCE); + ValueWrapper valueWrapper = ValueWrapperFactory.createValueWrapper(valueTarget); assertNull(rootClassTarget.getDiscriminator()); assertNull(singleTableSubclassTarget.getDiscriminator()); assertNull(joinedSubclassTarget.getDiscriminator()); assertNull(specialRootClassTarget.getDiscriminator()); - rootClassWrapper.setDiscriminator(valueTarget); - assertSame(valueTarget, ((Wrapper)rootClassTarget.getDiscriminator()).getWrappedObject()); - assertSame(valueTarget, ((Wrapper)singleTableSubclassTarget.getDiscriminator()).getWrappedObject()); - assertSame(valueTarget, ((Wrapper)joinedSubclassTarget.getDiscriminator()).getWrappedObject()); + rootClassWrapper.setDiscriminator(valueWrapper); + assertSame(valueTarget, rootClassTarget.getDiscriminator()); + assertSame(valueTarget, singleTableSubclassTarget.getDiscriminator()); + assertSame(valueTarget, joinedSubclassTarget.getDiscriminator()); try { - singleTableSubclassWrapper.setDiscriminator(valueTarget); + singleTableSubclassWrapper.setDiscriminator(valueWrapper); fail(); } catch (RuntimeException e) { assertEquals("Method 'setDiscriminator(Value)' can only be called on RootClass instances", e.getMessage()); } try { - joinedSubclassWrapper.setDiscriminator(valueTarget); + joinedSubclassWrapper.setDiscriminator(valueWrapper); fail(); } catch (RuntimeException e) { assertEquals("Method 'setDiscriminator(Value)' can only be called on RootClass instances", e.getMessage()); } assertNull(specialRootClassTarget.getDiscriminator()); - specialRootClassWrapper.setDiscriminator(valueTarget); - assertSame(valueTarget, ((Wrapper)specialRootClassTarget.getDiscriminator()).getWrappedObject()); + specialRootClassWrapper.setDiscriminator(valueWrapper); + assertSame(valueTarget, specialRootClassTarget.getDiscriminator()); } @Test @@ -782,14 +781,14 @@ public void testSetLazy() { @Test public void testGetSubclassIterator() { - Iterator subclassIterator = rootClassWrapper.getSubclassIterator(); + Iterator subclassIterator = rootClassWrapper.getSubclassIterator(); assertFalse(subclassIterator.hasNext()); Subclass firstSubclass = new Subclass(rootClassTarget, DummyMetadataBuildingContext.INSTANCE); firstSubclass.setEntityName("first"); rootClassTarget.addSubclass(firstSubclass); subclassIterator = rootClassWrapper.getSubclassIterator(); assertTrue(subclassIterator.hasNext()); - assertSame(firstSubclass, subclassIterator.next()); + assertSame(firstSubclass, subclassIterator.next().getWrappedObject()); subclassIterator = singleTableSubclassWrapper.getSubclassIterator(); assertFalse(subclassIterator.hasNext()); Subclass secondSubclass = new Subclass(singleTableSubclassTarget, DummyMetadataBuildingContext.INSTANCE); @@ -797,7 +796,7 @@ public void testGetSubclassIterator() { singleTableSubclassTarget.addSubclass(secondSubclass); subclassIterator = singleTableSubclassWrapper.getSubclassIterator(); assertTrue(subclassIterator.hasNext()); - assertSame(secondSubclass, subclassIterator.next()); + assertSame(secondSubclass, subclassIterator.next().getWrappedObject()); subclassIterator = joinedSubclassWrapper.getSubclassIterator(); assertFalse(subclassIterator.hasNext()); Subclass thirdSubclass = new Subclass(joinedSubclassTarget, DummyMetadataBuildingContext.INSTANCE); @@ -805,7 +804,7 @@ public void testGetSubclassIterator() { joinedSubclassTarget.addSubclass(thirdSubclass); subclassIterator = joinedSubclassWrapper.getSubclassIterator(); assertTrue(subclassIterator.hasNext()); - assertSame(thirdSubclass, subclassIterator.next()); + assertSame(thirdSubclass, subclassIterator.next().getWrappedObject()); subclassIterator = specialRootClassWrapper.getSubclassIterator(); assertFalse(subclassIterator.hasNext()); Subclass fourthSubclass = new Subclass(joinedSubclassTarget, DummyMetadataBuildingContext.INSTANCE); @@ -813,7 +812,7 @@ public void testGetSubclassIterator() { specialRootClassTarget.addSubclass(fourthSubclass); subclassIterator = specialRootClassWrapper.getSubclassIterator(); assertTrue(subclassIterator.hasNext()); - assertSame(fourthSubclass, subclassIterator.next()); + assertSame(fourthSubclass, subclassIterator.next().getWrappedObject()); } @Test @@ -969,8 +968,8 @@ public void testIsInherited() { @Test public void testIsJoinedSubclass() { - rootClassWrapper.setTable(new Table("foo")); - joinedSubclassWrapper.setTable(new Table("oof")); + rootClassWrapper.setTable(TableWrapperFactory.createTableWrapper("foo")); + joinedSubclassWrapper.setTable(TableWrapperFactory.createTableWrapper("oof")); assertFalse(rootClassWrapper.isJoinedSubclass()); assertFalse(singleTableSubclassWrapper.isJoinedSubclass()); assertTrue(joinedSubclassWrapper.isJoinedSubclass()); @@ -1206,12 +1205,12 @@ public void testGetRootTable() throws Exception { assertNull(singleTableSubclassWrapper.getRootTable()); assertNull(joinedSubclassWrapper.getRootTable()); ((RootClass)rootClassTarget).setTable(tableTarget); - assertSame(tableTarget, rootClassWrapper.getRootTable()); - assertSame(tableTarget, singleTableSubclassWrapper.getRootTable()); - assertSame(tableTarget, joinedSubclassWrapper.getRootTable()); + assertSame(tableTarget, rootClassWrapper.getRootTable().getWrappedObject()); + assertSame(tableTarget, singleTableSubclassWrapper.getRootTable().getWrappedObject()); + assertSame(tableTarget, joinedSubclassWrapper.getRootTable().getWrappedObject()); assertNull(specialRootClassWrapper.getRootTable()); ((RootClass)specialRootClassTarget).setTable(tableTarget); - assertSame(tableTarget, specialRootClassWrapper.getRootTable()); + assertSame(tableTarget, specialRootClassWrapper.getRootTable().getWrappedObject()); } } diff --git a/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/PrimaryKeyWrapperTest.java b/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/wrp/PrimaryKeyWrapperTest.java similarity index 75% rename from jbt/src/test/java/org/hibernate/tool/orm/jbt/api/PrimaryKeyWrapperTest.java rename to jbt/src/test/java/org/hibernate/tool/orm/jbt/api/wrp/PrimaryKeyWrapperTest.java index 1f975e18d6..6f0ec7cc66 100644 --- a/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/PrimaryKeyWrapperTest.java +++ b/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/wrp/PrimaryKeyWrapperTest.java @@ -1,4 +1,4 @@ -package org.hibernate.tool.orm.jbt.api; +package org.hibernate.tool.orm.jbt.api.wrp; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertFalse; @@ -15,6 +15,7 @@ import org.hibernate.mapping.Column; import org.hibernate.mapping.PrimaryKey; import org.hibernate.mapping.Table; +import org.hibernate.tool.orm.jbt.internal.factory.ColumnWrapperFactory; import org.hibernate.tool.orm.jbt.internal.factory.PrimaryKeyWrapperFactory; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; @@ -39,8 +40,9 @@ public void testConstruction() { @Test public void testAddColumn() throws Exception { Column column = new Column("foo"); + ColumnWrapper columnWrapper = ColumnWrapperFactory.createColumnWrapper(column); assertTrue(wrappedPrimaryKey.getColumns().isEmpty()); - primaryKeyWrapper.addColumn(column); + primaryKeyWrapper.addColumn(columnWrapper); assertEquals(1, wrappedPrimaryKey.getColumns().size()); assertSame(column, wrappedPrimaryKey.getColumns().get(0)); } @@ -57,10 +59,10 @@ public void testGetColumns() throws Exception { Column column = new Column("foo"); assertTrue(primaryKeyWrapper.getColumns().isEmpty()); wrappedPrimaryKey.addColumn(column); - List columns = primaryKeyWrapper.getColumns(); + List columns = primaryKeyWrapper.getColumns(); assertNotNull(columns); assertEquals(1, columns.size()); - assertSame(column, columns.get(0)); + assertSame(column, columns.get(0).getWrappedObject()); } @Test @@ -73,25 +75,26 @@ public void testGetColumn() throws Exception { } Column column = new Column(); wrappedPrimaryKey.addColumn(column); - Column c = primaryKeyWrapper.getColumn(0); + ColumnWrapper c = primaryKeyWrapper.getColumn(0); assertNotNull(c); - assertSame(column, c); + assertSame(column, c.getWrappedObject()); } @Test public void testGetTable() throws Exception { Table table = new Table("foo"); - assertNotSame(table, primaryKeyWrapper.getTable()); + assertNotSame(table, primaryKeyWrapper.getTable().getWrappedObject()); wrappedPrimaryKey.setTable(table); - assertSame(table, primaryKeyWrapper.getTable()); + assertSame(table, primaryKeyWrapper.getTable().getWrappedObject()); } @Test public void testContainsColumn() { Column column = new Column("foo"); - assertFalse(primaryKeyWrapper.containsColumn(column)); + ColumnWrapper columnWrapper = ColumnWrapperFactory.createColumnWrapper(column); + assertFalse(primaryKeyWrapper.containsColumn(columnWrapper)); wrappedPrimaryKey.addColumn(column); - assertTrue(primaryKeyWrapper.containsColumn(column)); + assertTrue(primaryKeyWrapper.containsColumn(columnWrapper)); } @Test @@ -99,9 +102,9 @@ public void testColumnIterator() throws Exception { assertFalse(primaryKeyWrapper.columnIterator().hasNext()); Column column = new Column(); wrappedPrimaryKey.addColumn(column); - Iterator columnIterator = primaryKeyWrapper.columnIterator(); + Iterator columnIterator = primaryKeyWrapper.columnIterator(); assertTrue(columnIterator.hasNext()); - assertSame(column, columnIterator.next()); + assertSame(column, columnIterator.next().getWrappedObject()); } @Test diff --git a/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/PropertyWrapperTest.java b/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/wrp/PropertyWrapperTest.java similarity index 84% rename from jbt/src/test/java/org/hibernate/tool/orm/jbt/api/PropertyWrapperTest.java rename to jbt/src/test/java/org/hibernate/tool/orm/jbt/api/wrp/PropertyWrapperTest.java index 0158eeed36..3f2554c820 100644 --- a/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/PropertyWrapperTest.java +++ b/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/wrp/PropertyWrapperTest.java @@ -1,4 +1,4 @@ -package org.hibernate.tool.orm.jbt.api; +package org.hibernate.tool.orm.jbt.api.wrp; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertFalse; @@ -8,6 +8,8 @@ import static org.junit.jupiter.api.Assertions.assertSame; import static org.junit.jupiter.api.Assertions.assertTrue; +import java.lang.reflect.Field; + import org.hibernate.mapping.Backref; import org.hibernate.mapping.BasicValue; import org.hibernate.mapping.Column; @@ -17,9 +19,10 @@ import org.hibernate.mapping.RootClass; import org.hibernate.mapping.Table; import org.hibernate.mapping.Value; +import org.hibernate.tool.orm.jbt.internal.factory.PersistentClassWrapperFactory; import org.hibernate.tool.orm.jbt.internal.factory.PropertyWrapperFactory; -import org.hibernate.tool.orm.jbt.util.DummyMetadataBuildingContext; -import org.hibernate.type.Type; +import org.hibernate.tool.orm.jbt.internal.factory.ValueWrapperFactory; +import org.hibernate.tool.orm.jbt.internal.util.DummyMetadataBuildingContext; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; @@ -30,8 +33,8 @@ public class PropertyWrapperTest { @BeforeEach public void beforeEach() { - wrappedProperty = new Property(); - propertyWrapper = (PropertyWrapper)PropertyWrapperFactory.createPropertyWrapper(wrappedProperty); + propertyWrapper = PropertyWrapperFactory.createPropertyWrapper(); + wrappedProperty = (Property)propertyWrapper.getWrappedObject(); } @Test @@ -45,8 +48,8 @@ public void testGetValue() { assertNull(propertyWrapper.getValue()); Value value = new BasicValue(DummyMetadataBuildingContext.INSTANCE); wrappedProperty.setValue(value); - Value v = propertyWrapper.getValue(); - assertSame(value, v); + ValueWrapper v = propertyWrapper.getValue(); + assertSame(value, v.getWrappedObject()); } @Test @@ -59,8 +62,9 @@ public void testSetName() { @Test public void testSetPersistentClass() { PersistentClass persistentClass = new RootClass(DummyMetadataBuildingContext.INSTANCE); + PersistentClassWrapper persistentClassWrapper = PersistentClassWrapperFactory.createPersistentClassWrapper(persistentClass); assertNull(wrappedProperty.getPersistentClass()); - propertyWrapper.setPersistentClass(persistentClass); + propertyWrapper.setPersistentClass(persistentClassWrapper); assertSame(persistentClass, wrappedProperty.getPersistentClass()); } @@ -69,7 +73,7 @@ public void testGetPersistentClass() { PersistentClass persistentClass = new RootClass(DummyMetadataBuildingContext.INSTANCE); assertNull(propertyWrapper.getPersistentClass()); wrappedProperty.setPersistentClass(persistentClass); - assertSame(persistentClass, propertyWrapper.getPersistentClass()); + assertSame(persistentClass, propertyWrapper.getPersistentClass().getWrappedObject()); } @Test @@ -104,16 +108,17 @@ public void testGetType() { v.setTypeName("int"); assertNull(propertyWrapper.getType()); wrappedProperty.setValue(v); - Type t = propertyWrapper.getType(); + TypeWrapper t = propertyWrapper.getType(); assertEquals("integer", t.getName()); - assertSame(v.getType(), t); + assertSame(v.getType(), t.getWrappedObject()); } @Test public void testSetValue() { assertNull(wrappedProperty.getValue()); BasicValue value = new BasicValue(DummyMetadataBuildingContext.INSTANCE); - propertyWrapper.setValue(value); + ValueWrapper valueWrapper = ValueWrapperFactory.createValueWrapper(value); + propertyWrapper.setValue(valueWrapper); assertSame(value, wrappedProperty.getValue()); } @@ -134,7 +139,9 @@ public void testSetCascade() { @Test public void testIsBackRef() throws Exception { assertFalse(propertyWrapper.isBackRef()); - propertyWrapper = (PropertyWrapper)PropertyWrapperFactory.createPropertyWrapper(new Backref()); + Field field = propertyWrapper.getClass().getDeclaredField("property"); + field.setAccessible(true); + field.set(propertyWrapper, new Backref()); assertTrue(propertyWrapper.isBackRef()); } diff --git a/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/QueryExporterWrapperTest.java b/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/wrp/QueryExporterWrapperTest.java similarity index 97% rename from jbt/src/test/java/org/hibernate/tool/orm/jbt/api/QueryExporterWrapperTest.java rename to jbt/src/test/java/org/hibernate/tool/orm/jbt/api/wrp/QueryExporterWrapperTest.java index 44bdfe80e0..9ebd748fde 100644 --- a/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/QueryExporterWrapperTest.java +++ b/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/wrp/QueryExporterWrapperTest.java @@ -1,4 +1,4 @@ -package org.hibernate.tool.orm.jbt.api; +package org.hibernate.tool.orm.jbt.api.wrp; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertNotEquals; diff --git a/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/QueryWrapperTest.java b/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/wrp/QueryWrapperTest.java similarity index 97% rename from jbt/src/test/java/org/hibernate/tool/orm/jbt/api/QueryWrapperTest.java rename to jbt/src/test/java/org/hibernate/tool/orm/jbt/api/wrp/QueryWrapperTest.java index 79990c0956..47bb2dee29 100644 --- a/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/QueryWrapperTest.java +++ b/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/wrp/QueryWrapperTest.java @@ -1,4 +1,4 @@ -package org.hibernate.tool.orm.jbt.api; +package org.hibernate.tool.orm.jbt.api.wrp; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertFalse; @@ -23,7 +23,6 @@ import org.hibernate.query.spi.QueryParameterBinding; import org.hibernate.query.sqm.internal.QuerySqmImpl; import org.hibernate.tool.orm.jbt.internal.factory.QueryWrapperFactory; -import org.hibernate.type.Type; import org.junit.jupiter.api.AfterEach; import org.junit.jupiter.api.BeforeAll; import org.junit.jupiter.api.BeforeEach; @@ -40,7 +39,7 @@ public class QueryWrapperTest { ""; private static final String TEST_HBM_XML_STRING = - "" + + "" + " " + " " + " " + @@ -181,7 +180,7 @@ public void testGetReturnAliases() { @Test public void testGetReturnTypes() { - Type[] returnTypes = simpleQueryWrapper.getReturnTypes(); + TypeWrapper[] returnTypes = simpleQueryWrapper.getReturnTypes(); assertNotNull(returnTypes); assertEquals(0, returnTypes.length); } diff --git a/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/RevengSettingsWrapperTest.java b/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/wrp/RevengSettingsWrapperTest.java similarity index 73% rename from jbt/src/test/java/org/hibernate/tool/orm/jbt/api/RevengSettingsWrapperTest.java rename to jbt/src/test/java/org/hibernate/tool/orm/jbt/api/wrp/RevengSettingsWrapperTest.java index 56155401e4..4e7e51a095 100644 --- a/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/RevengSettingsWrapperTest.java +++ b/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/wrp/RevengSettingsWrapperTest.java @@ -1,8 +1,9 @@ -package org.hibernate.tool.orm.jbt.api; +package org.hibernate.tool.orm.jbt.api.wrp; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertFalse; import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertSame; import static org.junit.jupiter.api.Assertions.assertTrue; import org.hibernate.tool.api.reveng.RevengSettings; @@ -17,8 +18,8 @@ public class RevengSettingsWrapperTest { @BeforeEach public void beforeEach() { - wrappedRevengSettings = new RevengSettings(null); - revengSettingsWrapper = RevengSettingsWrapperFactory.createRevengSettingsWrapper(wrappedRevengSettings); + revengSettingsWrapper = RevengSettingsWrapperFactory.createRevengSettingsWrapper(null); + wrappedRevengSettings = (RevengSettings)revengSettingsWrapper.getWrappedObject(); } @Test @@ -31,28 +32,28 @@ public void testConstruction() { @Test public void testSetDefaultPackageName() { assertEquals("", wrappedRevengSettings.getDefaultPackageName()); - revengSettingsWrapper.setDefaultPackageName("foo"); + assertSame(revengSettingsWrapper, revengSettingsWrapper.setDefaultPackageName("foo")); assertEquals("foo", wrappedRevengSettings.getDefaultPackageName()); } @Test public void testSetDetectManyToMany() { assertTrue(wrappedRevengSettings.getDetectManyToMany()); - revengSettingsWrapper.setDetectManyToMany(false); + assertSame(revengSettingsWrapper, revengSettingsWrapper.setDetectManyToMany(false)); assertFalse(wrappedRevengSettings.getDetectManyToMany()); } @Test public void testSetDetectOneToOne() { assertTrue(wrappedRevengSettings.getDetectOneToOne()); - revengSettingsWrapper.setDetectOneToOne(false); + assertSame(revengSettingsWrapper, revengSettingsWrapper.setDetectOneToOne(false)); assertFalse(wrappedRevengSettings.getDetectOneToOne()); } @Test public void testSetDetectOptimisticLock() { assertTrue(wrappedRevengSettings.getDetectOptimsticLock()); - revengSettingsWrapper.setDetectOptimisticLock(false); + assertSame(revengSettingsWrapper, revengSettingsWrapper.setDetectOptimisticLock(false)); assertFalse(wrappedRevengSettings.getDetectOptimsticLock()); } diff --git a/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/RevengStrategyWrapperTest.java b/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/wrp/RevengStrategyWrapperTest.java similarity index 71% rename from jbt/src/test/java/org/hibernate/tool/orm/jbt/api/RevengStrategyWrapperTest.java rename to jbt/src/test/java/org/hibernate/tool/orm/jbt/api/wrp/RevengStrategyWrapperTest.java index f1f4c70974..7c58ad7305 100644 --- a/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/RevengStrategyWrapperTest.java +++ b/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/wrp/RevengStrategyWrapperTest.java @@ -1,4 +1,4 @@ -package org.hibernate.tool.orm.jbt.api; +package org.hibernate.tool.orm.jbt.api.wrp; import static org.junit.jupiter.api.Assertions.assertNotNull; import static org.junit.jupiter.api.Assertions.assertNotSame; @@ -9,7 +9,7 @@ import org.hibernate.tool.api.reveng.RevengSettings; import org.hibernate.tool.api.reveng.RevengStrategy; import org.hibernate.tool.internal.reveng.strategy.AbstractStrategy; -import org.hibernate.tool.internal.reveng.strategy.DefaultStrategy; +import org.hibernate.tool.orm.jbt.internal.factory.RevengSettingsWrapperFactory; import org.hibernate.tool.orm.jbt.internal.factory.RevengStrategyWrapperFactory; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; @@ -21,8 +21,8 @@ public class RevengStrategyWrapperTest { @BeforeEach public void beforeEach() { - wrappedRevengStrategy = new DefaultStrategy(); - revengStrategyWrapper = RevengStrategyWrapperFactory.createRevengStrategyWrapper(wrappedRevengStrategy); + revengStrategyWrapper = RevengStrategyWrapperFactory.createRevengStrategyWrapper(); + wrappedRevengStrategy = (RevengStrategy)revengStrategyWrapper.getWrappedObject(); } @Test @@ -34,11 +34,12 @@ public void testConstruction() { @Test public void testSetSettings() throws Exception { - RevengSettings revengSettings = new RevengSettings(null); + RevengSettingsWrapper revengSettingsWrapper = RevengSettingsWrapperFactory.createRevengSettingsWrapper(null); + RevengSettings revengSettings = (RevengSettings)revengSettingsWrapper.getWrappedObject(); Field field = AbstractStrategy.class.getDeclaredField("settings"); field.setAccessible(true); assertNotSame(field.get(wrappedRevengStrategy), revengSettings); - revengStrategyWrapper.setSettings(revengSettings); + revengStrategyWrapper.setSettings(revengSettingsWrapper); assertSame(field.get(wrappedRevengStrategy), revengSettings); } diff --git a/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/SchemaExportWrapperTest.java b/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/wrp/SchemaExportWrapperTest.java similarity index 70% rename from jbt/src/test/java/org/hibernate/tool/orm/jbt/api/SchemaExportWrapperTest.java rename to jbt/src/test/java/org/hibernate/tool/orm/jbt/api/wrp/SchemaExportWrapperTest.java index 12c7f207b8..048bdea2c1 100644 --- a/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/SchemaExportWrapperTest.java +++ b/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/wrp/SchemaExportWrapperTest.java @@ -1,4 +1,4 @@ -package org.hibernate.tool.orm.jbt.api; +package org.hibernate.tool.orm.jbt.api.wrp; import static org.junit.jupiter.api.Assertions.assertFalse; import static org.junit.jupiter.api.Assertions.assertNotNull; @@ -10,12 +10,12 @@ import java.util.List; import org.hibernate.boot.Metadata; -import org.hibernate.cfg.Configuration; import org.hibernate.cfg.Environment; import org.hibernate.tool.hbm2ddl.SchemaExport; +import org.hibernate.tool.orm.jbt.internal.factory.ConfigurationWrapperFactory; import org.hibernate.tool.orm.jbt.internal.factory.SchemaExportWrapperFactory; -import org.hibernate.tool.orm.jbt.util.MockConnectionProvider; -import org.hibernate.tool.orm.jbt.util.MockDialect; +import org.hibernate.tool.orm.jbt.internal.util.MockConnectionProvider; +import org.hibernate.tool.orm.jbt.internal.util.MockDialect; import org.hibernate.tool.schema.TargetType; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; @@ -24,24 +24,25 @@ public class SchemaExportWrapperTest { private SchemaExport wrappedSchemaExport = null; private SchemaExportWrapper schemaExportWrapper = null; - private Configuration configuration = null; + private ConfigurationWrapper configurationWrapper = null; @BeforeEach - public void beforeEach() { - configuration = new Configuration(); - configuration.setProperty(Environment.DIALECT, MockDialect.class.getName()); - configuration.setProperty(Environment.CONNECTION_PROVIDER, MockConnectionProvider.class.getName()); + public void beforeEach() throws Exception { + configurationWrapper = ConfigurationWrapperFactory.createNativeConfigurationWrapper(); + configurationWrapper.setProperty(Environment.DIALECT, MockDialect.class.getName()); + configurationWrapper.setProperty(Environment.CONNECTION_PROVIDER, MockConnectionProvider.class.getName()); wrappedSchemaExport = new TestSchemaExport(); - schemaExportWrapper = SchemaExportWrapperFactory.createSchemaExportWrapper( - wrappedSchemaExport, configuration); + schemaExportWrapper = SchemaExportWrapperFactory.createSchemaExportWrapper(configurationWrapper); + Field field = schemaExportWrapper.getClass().getDeclaredField("schemaExport"); + field.setAccessible(true); + field.set(schemaExportWrapper, wrappedSchemaExport); } @Test public void testConstruction() { - assertNotNull(configuration); + assertNotNull(configurationWrapper); assertNotNull(wrappedSchemaExport); assertNotNull(schemaExportWrapper); - assertSame(configuration, schemaExportWrapper.getConfiguration()); } @Test diff --git a/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/SessionFactoryWrapperTest.java b/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/wrp/SessionFactoryWrapperTest.java similarity index 84% rename from jbt/src/test/java/org/hibernate/tool/orm/jbt/api/SessionFactoryWrapperTest.java rename to jbt/src/test/java/org/hibernate/tool/orm/jbt/api/wrp/SessionFactoryWrapperTest.java index be3804647a..83965ee5f0 100644 --- a/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/SessionFactoryWrapperTest.java +++ b/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/wrp/SessionFactoryWrapperTest.java @@ -1,4 +1,4 @@ -package org.hibernate.tool.orm.jbt.api; +package org.hibernate.tool.orm.jbt.api.wrp; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertFalse; @@ -18,11 +18,9 @@ import org.hibernate.SessionFactory; import org.hibernate.cfg.AvailableSettings; import org.hibernate.cfg.Configuration; -import org.hibernate.persister.collection.CollectionPersister; -import org.hibernate.persister.entity.EntityPersister; import org.hibernate.tool.orm.jbt.internal.factory.SessionFactoryWrapperFactory; -import org.hibernate.tool.orm.jbt.util.MockConnectionProvider; -import org.hibernate.tool.orm.jbt.util.MockDialect; +import org.hibernate.tool.orm.jbt.internal.util.MockConnectionProvider; +import org.hibernate.tool.orm.jbt.internal.util.MockDialect; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.io.TempDir; @@ -38,7 +36,7 @@ public class SessionFactoryWrapperTest { ""; private static final String TEST_HBM_XML_STRING = - "" + + "" + " " + " " + " " + @@ -92,7 +90,7 @@ public void testClose() { @Test public void testGetAllClassMetadata() throws Exception { - Map allClassMetadata = sessionFactoryWrapper.getAllClassMetadata(); + Map allClassMetadata = sessionFactoryWrapper.getAllClassMetadata(); assertNotNull(allClassMetadata); assertEquals(1, allClassMetadata.size()); assertNotNull(allClassMetadata.get(Foo.class.getName())); @@ -100,18 +98,18 @@ public void testGetAllClassMetadata() throws Exception { @Test public void testGetAllCollectionMetadata() throws Exception { - Map allCollectionMetadata = sessionFactoryWrapper.getAllCollectionMetadata(); + Map allCollectionMetadata = sessionFactoryWrapper.getAllCollectionMetadata(); assertNotNull(allCollectionMetadata); assertEquals(1, allCollectionMetadata.size()); - CollectionPersister barsPersister = allCollectionMetadata.get(Foo.class.getName() + ".bars"); + CollectionMetadataWrapper barsPersister = allCollectionMetadata.get(Foo.class.getName() + ".bars"); assertNotNull(barsPersister); } @Test public void testOpenSession() { - Session session = sessionFactoryWrapper.openSession(); + SessionWrapper session = sessionFactoryWrapper.openSession(); assertNotNull(session); - assertSame(session.getSessionFactory(), wrappedSessionFactory); + assertSame(((Session)session.getWrappedObject()).getSessionFactory(), wrappedSessionFactory); } @Test diff --git a/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/SessionWrapperTest.java b/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/wrp/SessionWrapperTest.java similarity index 86% rename from jbt/src/test/java/org/hibernate/tool/orm/jbt/api/SessionWrapperTest.java rename to jbt/src/test/java/org/hibernate/tool/orm/jbt/api/wrp/SessionWrapperTest.java index 7750f860b7..3c1e80c8bf 100644 --- a/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/SessionWrapperTest.java +++ b/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/wrp/SessionWrapperTest.java @@ -1,4 +1,4 @@ -package org.hibernate.tool.orm.jbt.api; +package org.hibernate.tool.orm.jbt.api.wrp; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertFalse; @@ -16,9 +16,10 @@ import org.hibernate.SessionFactory; import org.hibernate.cfg.AvailableSettings; import org.hibernate.cfg.Configuration; +import org.hibernate.query.Query; import org.hibernate.tool.orm.jbt.internal.factory.SessionWrapperFactory; -import org.hibernate.tool.orm.jbt.util.MockConnectionProvider; -import org.hibernate.tool.orm.jbt.util.MockDialect; +import org.hibernate.tool.orm.jbt.internal.util.MockConnectionProvider; +import org.hibernate.tool.orm.jbt.internal.util.MockDialect; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.io.TempDir; @@ -34,7 +35,7 @@ public class SessionWrapperTest { ""; private static final String TEST_HBM_XML_STRING = - "" + + "" + " " + " " + " " + @@ -91,7 +92,7 @@ public void testGetEntityName() { @Test public void testGetSessionFactory() { SessionFactory sessionFactory = wrappedSession.getSessionFactory(); - assertSame(sessionFactory, sessionWrapper.getSessionFactory()); + assertSame(sessionFactory, sessionWrapper.getSessionFactory().getWrappedObject()); } @Test @@ -126,8 +127,10 @@ public void testContains() { @Test public void testCreateCriteria() { - jakarta.persistence.Query query = sessionWrapper.createCriteria(Foo.class); - assertNotNull(query); + QueryWrapper queryWrapper = sessionWrapper.createCriteria(Foo.class); + assertNotNull(queryWrapper); + Query q = (Query)queryWrapper.getWrappedObject(); + assertSame(q.getSession(), sessionWrapper.getWrappedObject()); } } diff --git a/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/TableFilterWrapperTest.java b/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/wrp/TableFilterWrapperTest.java similarity index 95% rename from jbt/src/test/java/org/hibernate/tool/orm/jbt/api/TableFilterWrapperTest.java rename to jbt/src/test/java/org/hibernate/tool/orm/jbt/api/wrp/TableFilterWrapperTest.java index aaf1a00e71..82ca33cab4 100644 --- a/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/TableFilterWrapperTest.java +++ b/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/wrp/TableFilterWrapperTest.java @@ -1,4 +1,4 @@ -package org.hibernate.tool.orm.jbt.api; +package org.hibernate.tool.orm.jbt.api.wrp; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertNotEquals; @@ -18,8 +18,8 @@ public class TableFilterWrapperTest { @BeforeEach public void beforeEach() { - wrappedTableFilter = new TableFilter(); - tableFilterWrapper = TableFilterWrapperFactory.createTableFilterWrapper(wrappedTableFilter); + tableFilterWrapper = TableFilterWrapperFactory.createTableFilterWrapper(); + wrappedTableFilter = (TableFilter)tableFilterWrapper.getWrappedObject(); } @Test diff --git a/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/TableWrapperTest.java b/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/wrp/TableWrapperTest.java similarity index 70% rename from jbt/src/test/java/org/hibernate/tool/orm/jbt/api/TableWrapperTest.java rename to jbt/src/test/java/org/hibernate/tool/orm/jbt/api/wrp/TableWrapperTest.java index dcc19243d3..5e529bdc4c 100644 --- a/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/TableWrapperTest.java +++ b/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/wrp/TableWrapperTest.java @@ -1,22 +1,23 @@ -package org.hibernate.tool.orm.jbt.api; +package org.hibernate.tool.orm.jbt.api.wrp; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertFalse; import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertNotSame; import static org.junit.jupiter.api.Assertions.assertNull; import static org.junit.jupiter.api.Assertions.assertSame; import static org.junit.jupiter.api.Assertions.assertTrue; import java.lang.reflect.Method; import java.util.Iterator; +import java.util.List; -import org.hibernate.mapping.BasicValue; import org.hibernate.mapping.Column; -import org.hibernate.mapping.KeyValue; +import org.hibernate.mapping.ForeignKey; import org.hibernate.mapping.PrimaryKey; import org.hibernate.mapping.Table; +import org.hibernate.tool.orm.jbt.internal.factory.ColumnWrapperFactory; import org.hibernate.tool.orm.jbt.internal.factory.TableWrapperFactory; -import org.hibernate.tool.orm.jbt.util.DummyMetadataBuildingContext; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; @@ -27,8 +28,8 @@ public class TableWrapperTest { @BeforeEach public void beforeEach() { - wrappedTable = new Table("Hibernate Tools", "foo"); - tableWrapper = TableWrapperFactory.createTableWrapper(wrappedTable); + tableWrapper = TableWrapperFactory.createTableWrapper("foo"); + wrappedTable = (Table)tableWrapper.getWrappedObject(); } @Test @@ -47,8 +48,9 @@ public void testGetName() { @Test public void testAddColumn() { Column column = new Column("foo"); + ColumnWrapper columnWrapper = ColumnWrapperFactory.createColumnWrapper(column); assertNull(wrappedTable.getColumn(column)); - tableWrapper.addColumn(column); + tableWrapper.addColumn(columnWrapper); assertSame(column, wrappedTable.getColumn(column)); } @@ -69,20 +71,32 @@ public void testGetSchema() { @Test public void testGetPrimaryKey() { PrimaryKey primaryKey = new PrimaryKey(wrappedTable); - assertNull(tableWrapper.getPrimaryKey()); + assertNotSame(primaryKey, tableWrapper.getPrimaryKey().getWrappedObject()); wrappedTable.setPrimaryKey(primaryKey); - assertSame(primaryKey, tableWrapper.getPrimaryKey()); + assertSame(primaryKey, tableWrapper.getPrimaryKey().getWrappedObject()); } @Test public void testGetColumnIterator() { Column column = new Column("Hibernate Tools"); - Iterator columnIterator = tableWrapper.getColumnIterator(); + Iterator columnIterator = tableWrapper.getColumnIterator(); assertFalse(columnIterator.hasNext()); wrappedTable.addColumn(column); columnIterator = tableWrapper.getColumnIterator(); assertTrue(columnIterator.hasNext()); - assertSame(column, columnIterator.next()); + assertSame(column, columnIterator.next().getWrappedObject()); + } + + @Test + public void testGetForeignKeyIterator() { + Column column = new Column("Hibernate Tools"); + Iterator foreignKeyIterator = tableWrapper.getForeignKeyIterator(); + assertFalse(foreignKeyIterator.hasNext()); + wrappedTable.createForeignKey("foo", List.of(column), "bar", ""); + foreignKeyIterator = tableWrapper.getForeignKeyIterator(); + assertTrue(foreignKeyIterator.hasNext()); + ForeignKeyWrapper foreignKeyWrapper = foreignKeyIterator.next(); + assertTrue(((ForeignKey)foreignKeyWrapper.getWrappedObject()).containsColumn(column)); } @Test @@ -147,12 +161,13 @@ public void testIsPhysicalTable() { assertTrue(tableWrapper.isPhysicalTable()); } + // Methods 'Table#getIdentifierValue()' and 'Table.setIdentifierValue(KeyValue)' were removed since Hibernate 6.6.0.CR1 @Test public void testGetIdentifierValue() { - KeyValue value = new BasicValue(DummyMetadataBuildingContext.INSTANCE); +// KeyValue value = new BasicValue(DummyMetadataBuildingContext.INSTANCE); assertNull(tableWrapper.getIdentifierValue()); - wrappedTable.setIdentifierValue(value); - assertSame(value, tableWrapper.getIdentifierValue()); +// wrappedTable.setIdentifierValue(value); +// assertSame(value, tableWrapper.getIdentifierValue().getWrappedObject()); } } diff --git a/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/TypeFactoryWrapperTest.java b/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/wrp/TypeFactoryWrapperTest.java similarity index 98% rename from jbt/src/test/java/org/hibernate/tool/orm/jbt/api/TypeFactoryWrapperTest.java rename to jbt/src/test/java/org/hibernate/tool/orm/jbt/api/wrp/TypeFactoryWrapperTest.java index d20740daa7..0cba288282 100644 --- a/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/TypeFactoryWrapperTest.java +++ b/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/wrp/TypeFactoryWrapperTest.java @@ -1,4 +1,4 @@ -package org.hibernate.tool.orm.jbt.api; +package org.hibernate.tool.orm.jbt.api.wrp; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertNotNull; @@ -172,7 +172,7 @@ public void testGetTrueFalseType() { @Test public void testGetYesNoType() { TypeWrapper typeWrapper = typeFactoryWrapper.getYesNoType(); - assertEquals("true_false", typeWrapper.getName()); + assertEquals("yes_no", typeWrapper.getName()); } @Test diff --git a/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/TypeWrapperTest.java b/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/wrp/TypeWrapperTest.java similarity index 98% rename from jbt/src/test/java/org/hibernate/tool/orm/jbt/api/TypeWrapperTest.java rename to jbt/src/test/java/org/hibernate/tool/orm/jbt/api/wrp/TypeWrapperTest.java index 42b59ffae7..b0581fca3c 100644 --- a/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/TypeWrapperTest.java +++ b/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/wrp/TypeWrapperTest.java @@ -1,4 +1,4 @@ -package org.hibernate.tool.orm.jbt.api; +package org.hibernate.tool.orm.jbt.api.wrp; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertFalse; @@ -12,7 +12,7 @@ import org.hibernate.mapping.PersistentClass; import org.hibernate.mapping.RootClass; import org.hibernate.tool.orm.jbt.internal.factory.TypeWrapperFactory; -import org.hibernate.tool.orm.jbt.util.DummyMetadataBuildingContext; +import org.hibernate.tool.orm.jbt.internal.util.DummyMetadataBuildingContext; import org.hibernate.type.AnyType; import org.hibernate.type.ArrayType; import org.hibernate.type.BagType; diff --git a/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/wrp/ValueWrapperTest.java b/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/wrp/ValueWrapperTest.java new file mode 100644 index 0000000000..4c6186fdd6 --- /dev/null +++ b/jbt/src/test/java/org/hibernate/tool/orm/jbt/api/wrp/ValueWrapperTest.java @@ -0,0 +1,2534 @@ +package org.hibernate.tool.orm.jbt.api.wrp; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNotEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertSame; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.junit.jupiter.api.Assertions.fail; + +import java.util.Iterator; +import java.util.Properties; + +import org.hibernate.FetchMode; +import org.hibernate.mapping.Any; +import org.hibernate.mapping.Array; +import org.hibernate.mapping.Bag; +import org.hibernate.mapping.BasicValue; +import org.hibernate.mapping.Collection; +import org.hibernate.mapping.Column; +import org.hibernate.mapping.Component; +import org.hibernate.mapping.DependantValue; +import org.hibernate.mapping.Fetchable; +import org.hibernate.mapping.IdentifierBag; +import org.hibernate.mapping.IndexedCollection; +import org.hibernate.mapping.KeyValue; +import org.hibernate.mapping.List; +import org.hibernate.mapping.ManyToOne; +import org.hibernate.mapping.Map; +import org.hibernate.mapping.OneToMany; +import org.hibernate.mapping.OneToOne; +import org.hibernate.mapping.PersistentClass; +import org.hibernate.mapping.PrimitiveArray; +import org.hibernate.mapping.Property; +import org.hibernate.mapping.RootClass; +import org.hibernate.mapping.Set; +import org.hibernate.mapping.SimpleValue; +import org.hibernate.mapping.Table; +import org.hibernate.mapping.Value; +import org.hibernate.tool.orm.jbt.internal.factory.ColumnWrapperFactory; +import org.hibernate.tool.orm.jbt.internal.factory.PersistentClassWrapperFactory; +import org.hibernate.tool.orm.jbt.internal.factory.TableWrapperFactory; +import org.hibernate.tool.orm.jbt.internal.factory.ValueWrapperFactory; +import org.hibernate.tool.orm.jbt.internal.util.DummyMetadataBuildingContext; +import org.hibernate.type.AnyType; +import org.hibernate.type.ArrayType; +import org.hibernate.type.BagType; +import org.hibernate.type.BasicType; +import org.hibernate.type.ComponentType; +import org.hibernate.type.IdentifierBagType; +import org.hibernate.type.ListType; +import org.hibernate.type.ManyToOneType; +import org.hibernate.type.MapType; +import org.hibernate.type.OneToOneType; +import org.hibernate.type.SetType; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +public class ValueWrapperTest { + + private ValueWrapper arrayValueWrapper = null; + private Value wrappedArrayValue = null; + private ValueWrapper bagValueWrapper = null; + private Value wrappedBagValue = null; + private ValueWrapper listValueWrapper = null; + private Value wrappedListValue = null; + private ValueWrapper manyToOneValueWrapper = null; + private Value wrappedManyToOneValue = null; + private ValueWrapper mapValueWrapper = null; + private Value wrappedMapValue = null; + private ValueWrapper oneToManyValueWrapper = null; + private Value wrappedOneToManyValue = null; + private ValueWrapper oneToOneValueWrapper = null; + private Value wrappedOneToOneValue = null; + private ValueWrapper primitiveArrayValueWrapper = null; + private Value wrappedPrimitiveArrayValue = null; + private ValueWrapper setValueWrapper = null; + private Value wrappedSetValue = null; + private ValueWrapper simpleValueWrapper = null; + private Value wrappedSimpleValue = null; + private ValueWrapper componentValueWrapper = null; + private Value wrappedComponentValue = null; + private ValueWrapper dependantValueWrapper = null; + private Value wrappedDependantValue = null; + private ValueWrapper anyValueWrapper = null; + private Value wrappedAnyValue = null; + private ValueWrapper identifierBagValueWrapper = null; + private Value wrappedIdentifierBagValue = null; + + private PersistentClassWrapper persistentClassWrapper = null; + private PersistentClass wrappedPersistentClass = null; + + private Table wrappedTable = null; + private TableWrapper tableWrapper = null; + + @BeforeEach + public void beforeEach() { + wrappedPersistentClass = new RootClass(DummyMetadataBuildingContext.INSTANCE); + persistentClassWrapper = PersistentClassWrapperFactory.createPersistentClassWrapper(wrappedPersistentClass); + + tableWrapper = TableWrapperFactory.createTableWrapper("HT"); + wrappedTable = (Table)tableWrapper.getWrappedObject(); + + wrappedArrayValue = new Array(DummyMetadataBuildingContext.INSTANCE, wrappedPersistentClass); + arrayValueWrapper = ValueWrapperFactory.createValueWrapper(wrappedArrayValue); + + wrappedBagValue = new Bag(DummyMetadataBuildingContext.INSTANCE, wrappedPersistentClass); + bagValueWrapper = ValueWrapperFactory.createValueWrapper(wrappedBagValue); + + wrappedListValue = new List(DummyMetadataBuildingContext.INSTANCE, wrappedPersistentClass); + listValueWrapper = ValueWrapperFactory.createValueWrapper(wrappedListValue); + + wrappedManyToOneValue = new ManyToOne(DummyMetadataBuildingContext.INSTANCE, wrappedTable); + manyToOneValueWrapper = ValueWrapperFactory.createValueWrapper(wrappedManyToOneValue); + + wrappedMapValue = new Map(DummyMetadataBuildingContext.INSTANCE, wrappedPersistentClass); + mapValueWrapper = ValueWrapperFactory.createValueWrapper(wrappedMapValue); + + wrappedOneToManyValue = new OneToMany(DummyMetadataBuildingContext.INSTANCE, wrappedPersistentClass); + oneToManyValueWrapper = ValueWrapperFactory.createValueWrapper(wrappedOneToManyValue); + + wrappedOneToOneValue = new OneToOne(DummyMetadataBuildingContext.INSTANCE, wrappedTable, wrappedPersistentClass); + oneToOneValueWrapper = ValueWrapperFactory.createValueWrapper(wrappedOneToOneValue); + + wrappedPrimitiveArrayValue = new PrimitiveArray(DummyMetadataBuildingContext.INSTANCE, wrappedPersistentClass); + primitiveArrayValueWrapper = ValueWrapperFactory.createValueWrapper(wrappedPrimitiveArrayValue); + + wrappedSetValue = new Set(DummyMetadataBuildingContext.INSTANCE, wrappedPersistentClass); + setValueWrapper = ValueWrapperFactory.createValueWrapper(wrappedSetValue); + + wrappedSimpleValue = new BasicValue(DummyMetadataBuildingContext.INSTANCE); + simpleValueWrapper = ValueWrapperFactory.createValueWrapper(wrappedSimpleValue); + + wrappedComponentValue = new Component(DummyMetadataBuildingContext.INSTANCE, wrappedPersistentClass); + componentValueWrapper = ValueWrapperFactory.createValueWrapper(wrappedComponentValue); + + wrappedDependantValue = new DependantValue(DummyMetadataBuildingContext.INSTANCE, wrappedTable, + (KeyValue) wrappedSimpleValue); + dependantValueWrapper = ValueWrapperFactory.createValueWrapper(wrappedDependantValue); + + wrappedAnyValue = new Any(DummyMetadataBuildingContext.INSTANCE, wrappedTable); + anyValueWrapper = ValueWrapperFactory.createValueWrapper(wrappedAnyValue); + + wrappedIdentifierBagValue = new IdentifierBag(DummyMetadataBuildingContext.INSTANCE, wrappedPersistentClass); + identifierBagValueWrapper = ValueWrapperFactory.createValueWrapper(wrappedIdentifierBagValue); + + } + + @Test + public void testConstruction() { + assertNotNull(arrayValueWrapper); + assertNotNull(wrappedArrayValue); + assertNotNull(bagValueWrapper); + assertNotNull(wrappedBagValue); + assertNotNull(listValueWrapper); + assertNotNull(wrappedListValue); + assertNotNull(manyToOneValueWrapper); + assertNotNull(wrappedManyToOneValue); + assertNotNull(mapValueWrapper); + assertNotNull(wrappedMapValue); + assertNotNull(oneToManyValueWrapper); + assertNotNull(wrappedOneToManyValue); + assertNotNull(oneToOneValueWrapper); + assertNotNull(wrappedOneToOneValue); + assertNotNull(primitiveArrayValueWrapper); + assertNotNull(wrappedPrimitiveArrayValue); + assertNotNull(setValueWrapper); + assertNotNull(wrappedSetValue); + assertNotNull(simpleValueWrapper); + assertNotNull(wrappedSimpleValue); + assertNotNull(componentValueWrapper); + assertNotNull(wrappedComponentValue); + assertNotNull(dependantValueWrapper); + assertNotNull(wrappedDependantValue); + assertNotNull(anyValueWrapper); + assertNotNull(wrappedAnyValue); + assertNotNull(identifierBagValueWrapper); + assertNotNull(wrappedIdentifierBagValue); + } + + @Test + public void testIsSimpleValue() { + assertFalse(arrayValueWrapper.isSimpleValue()); + assertFalse(bagValueWrapper.isSimpleValue()); + assertFalse(listValueWrapper.isSimpleValue()); + assertTrue(manyToOneValueWrapper.isSimpleValue()); + assertFalse(mapValueWrapper.isSimpleValue()); + assertFalse(oneToManyValueWrapper.isSimpleValue()); + assertTrue(oneToOneValueWrapper.isSimpleValue()); + assertFalse(primitiveArrayValueWrapper.isSimpleValue()); + assertFalse(setValueWrapper.isSimpleValue()); + assertTrue(simpleValueWrapper.isSimpleValue()); + assertTrue(componentValueWrapper.isSimpleValue()); + assertTrue(dependantValueWrapper.isSimpleValue()); + assertTrue(anyValueWrapper.isSimpleValue()); + assertFalse(identifierBagValueWrapper.isSimpleValue()); + } + + @Test + public void testIsCollection() { + assertTrue(arrayValueWrapper.isCollection()); + assertTrue(bagValueWrapper.isCollection()); + assertTrue(listValueWrapper.isCollection()); + assertFalse(manyToOneValueWrapper.isCollection()); + assertTrue(mapValueWrapper.isCollection()); + assertFalse(oneToManyValueWrapper.isCollection()); + assertFalse(oneToOneValueWrapper.isCollection()); + assertTrue(primitiveArrayValueWrapper.isCollection()); + assertTrue(setValueWrapper.isCollection()); + assertFalse(simpleValueWrapper.isCollection()); + assertFalse(componentValueWrapper.isCollection()); + assertFalse(dependantValueWrapper.isCollection()); + assertFalse(anyValueWrapper.isCollection()); + assertTrue(identifierBagValueWrapper.isCollection()); + } + + @Test + public void testGetCollectionElement() { + assertNull(arrayValueWrapper.getCollectionElement()); + ((Collection)wrappedArrayValue).setElement(wrappedSimpleValue); + assertSame(wrappedSimpleValue, arrayValueWrapper.getCollectionElement().getWrappedObject()); + assertNull(bagValueWrapper.getCollectionElement()); + ((Collection)wrappedBagValue).setElement(wrappedSimpleValue); + assertSame(wrappedSimpleValue,bagValueWrapper.getCollectionElement().getWrappedObject()); + assertNull(listValueWrapper.getCollectionElement()); + ((Collection)wrappedListValue).setElement(wrappedSimpleValue); + assertSame(wrappedSimpleValue, listValueWrapper.getCollectionElement().getWrappedObject()); + assertNull(manyToOneValueWrapper.getCollectionElement()); + assertNull(mapValueWrapper.getCollectionElement()); + ((Collection)wrappedMapValue).setElement(wrappedSimpleValue); + assertSame(wrappedSimpleValue, mapValueWrapper.getCollectionElement().getWrappedObject()); + assertNull(oneToManyValueWrapper.getCollectionElement()); + assertNull(oneToOneValueWrapper.getCollectionElement()); + assertNull(primitiveArrayValueWrapper.getCollectionElement()); + ((Collection)wrappedPrimitiveArrayValue).setElement(wrappedSimpleValue); + assertSame(wrappedSimpleValue, primitiveArrayValueWrapper.getCollectionElement().getWrappedObject()); + assertNull(setValueWrapper.getCollectionElement()); + ((Collection)wrappedSetValue).setElement(wrappedSimpleValue); + assertSame(wrappedSimpleValue, setValueWrapper.getCollectionElement().getWrappedObject()); + assertNull(simpleValueWrapper.getCollectionElement()); + assertNull(componentValueWrapper.getCollectionElement()); + assertNull(dependantValueWrapper.getCollectionElement()); + assertNull(anyValueWrapper.getCollectionElement()); + assertNull(identifierBagValueWrapper.getCollectionElement()); + ((Collection)wrappedIdentifierBagValue).setElement(wrappedSimpleValue); + assertSame(wrappedSimpleValue, identifierBagValueWrapper.getCollectionElement().getWrappedObject()); + } + + @Test + public void testIsOneToMany() { + assertFalse(arrayValueWrapper.isOneToMany()); + assertFalse(bagValueWrapper.isOneToMany()); + assertFalse(listValueWrapper.isOneToMany()); + assertFalse(manyToOneValueWrapper.isOneToMany()); + assertFalse(mapValueWrapper.isOneToMany()); + assertTrue(oneToManyValueWrapper.isOneToMany()); + assertFalse(oneToOneValueWrapper.isOneToMany()); + assertFalse(primitiveArrayValueWrapper.isOneToMany()); + assertFalse(setValueWrapper.isOneToMany()); + assertFalse(simpleValueWrapper.isOneToMany()); + assertFalse(componentValueWrapper.isOneToMany()); + assertFalse(dependantValueWrapper.isOneToMany()); + assertFalse(anyValueWrapper.isOneToMany()); + assertFalse(identifierBagValueWrapper.isOneToMany()); + } + + @Test + public void testIsManyToOne() { + assertFalse(arrayValueWrapper.isManyToOne()); + assertFalse(bagValueWrapper.isManyToOne()); + assertFalse(listValueWrapper.isManyToOne()); + assertTrue(manyToOneValueWrapper.isManyToOne()); + assertFalse(mapValueWrapper.isManyToOne()); + assertFalse(oneToManyValueWrapper.isManyToOne()); + assertFalse(oneToOneValueWrapper.isManyToOne()); + assertFalse(primitiveArrayValueWrapper.isManyToOne()); + assertFalse(setValueWrapper.isManyToOne()); + assertFalse(simpleValueWrapper.isManyToOne()); + assertFalse(componentValueWrapper.isManyToOne()); + assertFalse(dependantValueWrapper.isManyToOne()); + assertFalse(anyValueWrapper.isManyToOne()); + assertFalse(identifierBagValueWrapper.isManyToOne()); + } + + @Test + public void testIsOneToOne() { + assertFalse(arrayValueWrapper.isOneToOne()); + assertFalse(bagValueWrapper.isOneToOne()); + assertFalse(listValueWrapper.isOneToOne()); + assertFalse(manyToOneValueWrapper.isOneToOne()); + assertFalse(mapValueWrapper.isOneToOne()); + assertFalse(oneToManyValueWrapper.isOneToOne()); + assertTrue(oneToOneValueWrapper.isOneToOne()); + assertFalse(primitiveArrayValueWrapper.isOneToOne()); + assertFalse(setValueWrapper.isOneToOne()); + assertFalse(simpleValueWrapper.isOneToOne()); + assertFalse(componentValueWrapper.isOneToOne()); + assertFalse(dependantValueWrapper.isOneToOne()); + assertFalse(anyValueWrapper.isOneToOne()); + assertFalse(identifierBagValueWrapper.isOneToOne()); + } + + @Test + public void testIsMap() { + assertFalse(arrayValueWrapper.isMap()); + assertFalse(bagValueWrapper.isMap()); + assertFalse(listValueWrapper.isMap()); + assertFalse(manyToOneValueWrapper.isMap()); + assertTrue(mapValueWrapper.isMap()); + assertFalse(oneToManyValueWrapper.isMap()); + assertFalse(oneToOneValueWrapper.isMap()); + assertFalse(primitiveArrayValueWrapper.isMap()); + assertFalse(setValueWrapper.isMap()); + assertFalse(simpleValueWrapper.isMap()); + assertFalse(componentValueWrapper.isMap()); + assertFalse(dependantValueWrapper.isMap()); + assertFalse(anyValueWrapper.isMap()); + assertFalse(identifierBagValueWrapper.isMap()); + } + + @Test + public void testIsComponent() { + assertFalse(arrayValueWrapper.isComponent()); + assertFalse(bagValueWrapper.isComponent()); + assertFalse(listValueWrapper.isComponent()); + assertFalse(manyToOneValueWrapper.isComponent()); + assertFalse(mapValueWrapper.isComponent()); + assertFalse(oneToManyValueWrapper.isComponent()); + assertFalse(oneToOneValueWrapper.isComponent()); + assertFalse(primitiveArrayValueWrapper.isComponent()); + assertFalse(setValueWrapper.isComponent()); + assertFalse(simpleValueWrapper.isComponent()); + assertTrue(componentValueWrapper.isComponent()); + assertFalse(dependantValueWrapper.isComponent()); + assertFalse(anyValueWrapper.isComponent()); + assertFalse(identifierBagValueWrapper.isComponent()); + } + + @Test + public void testIsEmbedded() { + assertFalse(arrayValueWrapper.isEmbedded()); + assertFalse(bagValueWrapper.isEmbedded()); + assertFalse(listValueWrapper.isEmbedded()); + assertFalse(manyToOneValueWrapper.isEmbedded()); + assertFalse(mapValueWrapper.isEmbedded()); + assertFalse(oneToManyValueWrapper.isEmbedded()); + assertFalse(oneToOneValueWrapper.isEmbedded()); + assertFalse(primitiveArrayValueWrapper.isEmbedded()); + assertFalse(setValueWrapper.isEmbedded()); + assertFalse(simpleValueWrapper.isEmbedded()); + assertFalse(componentValueWrapper.isEmbedded()); + ((Component)wrappedComponentValue).setEmbedded(true); + assertTrue(componentValueWrapper.isEmbedded()); + assertFalse(dependantValueWrapper.isEmbedded()); + assertFalse(anyValueWrapper.isEmbedded()); + assertFalse(identifierBagValueWrapper.isEmbedded()); + } + + @Test + public void testIsToOne() { + assertFalse(arrayValueWrapper.isToOne()); + assertFalse(bagValueWrapper.isToOne()); + assertFalse(listValueWrapper.isToOne()); + assertTrue(manyToOneValueWrapper.isToOne()); + assertFalse(mapValueWrapper.isToOne()); + assertFalse(oneToManyValueWrapper.isToOne()); + assertTrue(oneToOneValueWrapper.isToOne()); + assertFalse(primitiveArrayValueWrapper.isToOne()); + assertFalse(setValueWrapper.isToOne()); + assertFalse(simpleValueWrapper.isToOne()); + assertFalse(componentValueWrapper.isToOne()); + assertFalse(dependantValueWrapper.isToOne()); + assertFalse(anyValueWrapper.isToOne()); + assertFalse(identifierBagValueWrapper.isToOne()); + } + + @Test + public void testGetTable() { + ((RootClass)wrappedPersistentClass).setTable(null); + assertNull(arrayValueWrapper.getTable()); + ((RootClass)wrappedPersistentClass).setTable(wrappedTable); + assertSame(wrappedTable, arrayValueWrapper.getTable().getWrappedObject()); + ((RootClass)wrappedPersistentClass).setTable(null); + assertNull(bagValueWrapper.getTable()); + ((RootClass)wrappedPersistentClass).setTable(wrappedTable); + assertSame(wrappedTable, bagValueWrapper.getTable().getWrappedObject()); + ((RootClass)wrappedPersistentClass).setTable(null); + assertNull(listValueWrapper.getTable()); + ((RootClass)wrappedPersistentClass).setTable(wrappedTable); + assertSame(wrappedTable, listValueWrapper.getTable().getWrappedObject()); + ((ManyToOne)wrappedManyToOneValue).setTable(null); + assertNull(manyToOneValueWrapper.getTable()); + ((ManyToOne)wrappedManyToOneValue).setTable(wrappedTable); + assertSame(wrappedTable, manyToOneValueWrapper.getTable().getWrappedObject()); + ((RootClass)wrappedPersistentClass).setTable(null); + assertNull(mapValueWrapper.getTable()); + ((RootClass)wrappedPersistentClass).setTable(wrappedTable); + assertSame(wrappedTable, mapValueWrapper.getTable().getWrappedObject()); + assertNull(oneToManyValueWrapper.getTable()); + ((RootClass)wrappedPersistentClass).setTable(wrappedTable); + wrappedOneToManyValue = new OneToMany(DummyMetadataBuildingContext.INSTANCE, wrappedPersistentClass); + oneToManyValueWrapper = ValueWrapperFactory.createValueWrapper(wrappedOneToManyValue); + assertSame(wrappedTable, oneToManyValueWrapper.getTable().getWrappedObject()); + assertSame(wrappedTable, oneToOneValueWrapper.getTable().getWrappedObject()); + ((OneToOne)wrappedOneToOneValue).setTable(null); + assertNull(oneToOneValueWrapper.getTable()); + ((RootClass)wrappedPersistentClass).setTable(null); + assertNull(primitiveArrayValueWrapper.getTable()); + ((RootClass)wrappedPersistentClass).setTable(wrappedTable); + assertSame(wrappedTable, primitiveArrayValueWrapper.getTable().getWrappedObject()); + ((RootClass)wrappedPersistentClass).setTable(null); + assertNull(setValueWrapper.getTable()); + ((RootClass)wrappedPersistentClass).setTable(wrappedTable); + assertSame(wrappedTable, setValueWrapper.getTable().getWrappedObject()); + ((SimpleValue)wrappedSimpleValue).setTable(null); + assertNull(simpleValueWrapper.getTable()); + ((SimpleValue)wrappedSimpleValue).setTable(wrappedTable); + assertSame(wrappedTable, simpleValueWrapper.getTable().getWrappedObject()); + ((Component)wrappedComponentValue).setTable(null); + assertNull(componentValueWrapper.getTable()); + ((Component)wrappedComponentValue).setTable(wrappedTable); + assertSame(wrappedTable, componentValueWrapper.getTable().getWrappedObject()); + ((SimpleValue)wrappedDependantValue).setTable(null); + assertNull(dependantValueWrapper.getTable()); + ((SimpleValue)wrappedDependantValue).setTable(wrappedTable); + assertSame(wrappedTable, dependantValueWrapper.getTable().getWrappedObject()); + assertSame(wrappedTable, anyValueWrapper.getTable().getWrappedObject()); + ((Any)wrappedAnyValue).setTable(null); + assertNull(anyValueWrapper.getTable()); + ((RootClass)wrappedPersistentClass).setTable(null); + assertNull(identifierBagValueWrapper.getTable()); + ((RootClass)wrappedPersistentClass).setTable(wrappedTable); + assertSame(wrappedTable, identifierBagValueWrapper.getTable().getWrappedObject()); + } + + @Test + public void testGetType() { + ((SimpleValue)wrappedSimpleValue).setTypeName("java.lang.Integer"); + TypeWrapper type = simpleValueWrapper.getType(); + assertEquals("integer", type.getName()); + ((Collection)wrappedArrayValue).setElement(wrappedSimpleValue); + type = arrayValueWrapper.getType(); + assertEquals("[Ljava.lang.Integer;(null)", type.getName()); + assertTrue(type.getWrappedObject() instanceof ArrayType); + ((Collection)wrappedBagValue).setElement(wrappedSimpleValue); + type = bagValueWrapper.getType(); + assertEquals("java.util.Collection(null)", type.getName()); + assertTrue(type.getWrappedObject() instanceof BagType); + ((Collection)wrappedListValue).setElement(wrappedSimpleValue); + type = listValueWrapper.getType(); + assertEquals("java.util.List(null)", type.getName()); + assertTrue(type.getWrappedObject() instanceof ListType); + type = manyToOneValueWrapper.getType(); + assertEquals(null, type.getName()); + assertTrue(type.getWrappedObject() instanceof ManyToOneType); + ((Collection)wrappedMapValue).setElement(wrappedSimpleValue); + type = mapValueWrapper.getType(); + assertEquals("java.util.Map(null)", type.getName()); + assertTrue(type.getWrappedObject() instanceof MapType); + type = oneToManyValueWrapper.getType(); + assertEquals(null, type.getName()); + assertTrue(type.getWrappedObject() instanceof ManyToOneType); + type = oneToOneValueWrapper.getType(); + assertEquals(null, type.getName()); + assertTrue(type.getWrappedObject() instanceof OneToOneType); + ((Collection)wrappedPrimitiveArrayValue).setElement(wrappedSimpleValue); + type = primitiveArrayValueWrapper.getType(); + assertEquals("[I(null)", type.getName()); + assertTrue(type.getWrappedObject() instanceof ArrayType); + ((Collection)wrappedSetValue).setElement(wrappedSimpleValue); + type = setValueWrapper.getType(); + assertEquals("java.util.Set(null)", type.getName()); + assertTrue(type.getWrappedObject() instanceof SetType); + ((Component)wrappedComponentValue).setComponentClassName("java.lang.String"); + type = componentValueWrapper.getType(); + assertEquals("component[]", type.getName()); + assertTrue(type.getWrappedObject() instanceof ComponentType); + type = dependantValueWrapper.getType(); + assertEquals("integer", type.getName()); + assertTrue(type.getWrappedObject() instanceof BasicType); + ((Any)wrappedAnyValue).setIdentifierType("java.lang.Integer"); + type = anyValueWrapper.getType(); + assertEquals("object", type.getName()); + assertTrue(type.getWrappedObject() instanceof AnyType); + ((Collection)wrappedIdentifierBagValue).setElement(wrappedSimpleValue); + type = identifierBagValueWrapper.getType(); + assertEquals("java.util.Collection(null)", type.getName()); + assertTrue(type.getWrappedObject() instanceof IdentifierBagType); + } + + @Test + public void testSetElement() { + assertNull(((Collection)wrappedArrayValue).getElement()); + arrayValueWrapper.setElement(simpleValueWrapper); + assertSame(wrappedSimpleValue, ((Collection)wrappedArrayValue).getElement()); + assertNull(((Collection)wrappedBagValue).getElement()); + bagValueWrapper.setElement(simpleValueWrapper); + assertSame(wrappedSimpleValue, ((Collection)wrappedBagValue).getElement()); + assertNull(((Collection)wrappedListValue).getElement()); + listValueWrapper.setElement(simpleValueWrapper); + assertSame(wrappedSimpleValue, ((Collection)wrappedListValue).getElement()); + // next call has no effect + manyToOneValueWrapper.setElement(simpleValueWrapper); + assertNull(((Collection)wrappedMapValue).getElement()); + mapValueWrapper.setElement(simpleValueWrapper); + assertSame(wrappedSimpleValue, ((Collection)wrappedMapValue).getElement()); + // next call has no effect + oneToManyValueWrapper.setElement(simpleValueWrapper); + // next call has no effect + oneToOneValueWrapper.setElement(simpleValueWrapper); + assertNull(((Collection)wrappedPrimitiveArrayValue).getElement()); + primitiveArrayValueWrapper.setElement(simpleValueWrapper); + assertSame(wrappedSimpleValue, ((Collection)wrappedPrimitiveArrayValue).getElement()); + assertNull(((Collection)wrappedSetValue).getElement()); + setValueWrapper.setElement(simpleValueWrapper); + assertSame(wrappedSimpleValue, ((Collection)wrappedSetValue).getElement()); + // next call has no effect + simpleValueWrapper.setElement(arrayValueWrapper); + // next call has no effect + componentValueWrapper.setElement(arrayValueWrapper); + // next call has no effect + dependantValueWrapper.setElement(arrayValueWrapper); + // next call has no effect + anyValueWrapper.setElement(arrayValueWrapper); + assertNull(((Collection)wrappedIdentifierBagValue).getElement()); + identifierBagValueWrapper.setElement(simpleValueWrapper); + assertSame(wrappedSimpleValue, ((Collection)wrappedIdentifierBagValue).getElement()); + } + + @Test + public void testSetCollectionTable() { + assertNull(((Collection)wrappedArrayValue).getCollectionTable()); + arrayValueWrapper.setCollectionTable(tableWrapper); + assertSame(wrappedTable, ((Collection)wrappedArrayValue).getCollectionTable()); + assertNull(((Collection)wrappedBagValue).getCollectionTable()); + bagValueWrapper.setCollectionTable(tableWrapper); + assertSame(wrappedTable, ((Collection)wrappedBagValue).getCollectionTable()); + assertNull(((Collection)wrappedListValue).getCollectionTable()); + listValueWrapper.setCollectionTable(tableWrapper); + assertSame(wrappedTable, ((Collection)wrappedListValue).getCollectionTable()); + // next call has no effect + manyToOneValueWrapper.setCollectionTable(tableWrapper); + assertNull(((Collection)wrappedMapValue).getCollectionTable()); + mapValueWrapper.setCollectionTable(tableWrapper); + assertSame(wrappedTable, ((Collection)wrappedMapValue).getCollectionTable()); + // next call has no effect + oneToManyValueWrapper.setCollectionTable(tableWrapper); + // next call has no effect + oneToOneValueWrapper.setCollectionTable(tableWrapper); + assertNull(((Collection)wrappedPrimitiveArrayValue).getCollectionTable()); + primitiveArrayValueWrapper.setCollectionTable(tableWrapper); + assertSame(wrappedTable, ((Collection)wrappedPrimitiveArrayValue).getCollectionTable()); + assertNull(((Collection)wrappedSetValue).getCollectionTable()); + setValueWrapper.setCollectionTable(tableWrapper); + assertSame(wrappedTable, ((Collection)wrappedSetValue).getCollectionTable()); + // next call has no effect + simpleValueWrapper.setCollectionTable(tableWrapper); + // next call has no effect + componentValueWrapper.setCollectionTable(tableWrapper); + // next call has no effect + dependantValueWrapper.setCollectionTable(tableWrapper); + // next call has no effect + anyValueWrapper.setCollectionTable(tableWrapper); + assertNull(((Collection)wrappedIdentifierBagValue).getCollectionTable()); + identifierBagValueWrapper.setCollectionTable(tableWrapper); + assertSame(wrappedTable, ((Collection)wrappedIdentifierBagValue).getCollectionTable()); + } + + @Test + public void testSetTable() { + assertNull(wrappedArrayValue.getTable()); + arrayValueWrapper.setTable(tableWrapper); + assertNull(wrappedArrayValue.getTable()); + assertNull(wrappedBagValue.getTable()); + bagValueWrapper.setTable(tableWrapper); + assertNull(wrappedBagValue.getTable()); + assertNull(wrappedListValue.getTable()); + listValueWrapper.setTable(tableWrapper); + assertNull(wrappedListValue.getTable()); + assertSame(wrappedTable, wrappedManyToOneValue.getTable()); + manyToOneValueWrapper.setTable(null); + assertNull(wrappedManyToOneValue.getTable()); + assertNull(wrappedMapValue.getTable()); + mapValueWrapper.setTable(tableWrapper); + assertNull(wrappedMapValue.getTable()); + assertNull(wrappedOneToManyValue.getTable()); + oneToManyValueWrapper.setTable(tableWrapper); + assertNull(wrappedOneToManyValue.getTable()); + assertSame(wrappedTable, wrappedOneToOneValue.getTable()); + oneToOneValueWrapper.setTable(null); + assertNull(wrappedOneToOneValue.getTable()); + assertNull(wrappedPrimitiveArrayValue.getTable()); + primitiveArrayValueWrapper.setTable(tableWrapper); + assertNull(wrappedPrimitiveArrayValue.getTable()); + assertNull(wrappedSetValue.getTable()); + setValueWrapper.setTable(tableWrapper); + assertNull(wrappedSetValue.getTable()); + assertNull(wrappedSimpleValue.getTable()); + simpleValueWrapper.setTable(tableWrapper); + assertSame(wrappedTable, wrappedSimpleValue.getTable()); + assertNull(wrappedComponentValue.getTable()); + componentValueWrapper.setTable(tableWrapper); + assertSame(wrappedTable, wrappedComponentValue.getTable()); + assertSame(wrappedTable, wrappedDependantValue.getTable()); + dependantValueWrapper.setTable(null); + assertNull(wrappedDependantValue.getTable()); + assertSame(wrappedTable, wrappedAnyValue.getTable()); + anyValueWrapper.setTable(null); + assertNull(wrappedAnyValue.getTable()); + assertNull(wrappedIdentifierBagValue.getTable()); + identifierBagValueWrapper.setTable(tableWrapper); + assertNull(wrappedIdentifierBagValue.getTable()); + } + + @Test + public void testIsList() { + assertTrue(arrayValueWrapper.isList()); + assertFalse(bagValueWrapper.isList()); + assertTrue(listValueWrapper.isList()); + assertFalse(manyToOneValueWrapper.isList()); + assertFalse(mapValueWrapper.isList()); + assertFalse(oneToManyValueWrapper.isList()); + assertFalse(oneToOneValueWrapper.isList()); + assertTrue(primitiveArrayValueWrapper.isList()); + assertFalse(setValueWrapper.isList()); + assertFalse(simpleValueWrapper.isList()); + assertFalse(componentValueWrapper.isList()); + assertFalse(dependantValueWrapper.isList()); + assertFalse(anyValueWrapper.isList()); + assertFalse(identifierBagValueWrapper.isList()); + } + + @Test + public void testSetIndex() { + assertNull(((IndexedCollection)wrappedArrayValue).getIndex()); + arrayValueWrapper.setIndex(simpleValueWrapper); + assertSame(wrappedSimpleValue,((IndexedCollection)wrappedArrayValue).getIndex()); + // next call has no effect + bagValueWrapper.setIndex(simpleValueWrapper); + assertNull(((IndexedCollection)wrappedListValue).getIndex()); + listValueWrapper.setIndex(simpleValueWrapper); + assertSame(wrappedSimpleValue, ((IndexedCollection)wrappedListValue).getIndex()); + // next call has no effect + manyToOneValueWrapper.setIndex(simpleValueWrapper); + assertNull(((IndexedCollection)wrappedMapValue).getIndex()); + mapValueWrapper.setIndex(simpleValueWrapper); + assertSame(wrappedSimpleValue, ((IndexedCollection)wrappedMapValue).getIndex()); + // next call has no effect + oneToManyValueWrapper.setIndex(simpleValueWrapper); + // next call has no effect + oneToOneValueWrapper.setIndex(simpleValueWrapper); + assertNull(((IndexedCollection)wrappedPrimitiveArrayValue).getIndex()); + primitiveArrayValueWrapper.setIndex(simpleValueWrapper); + assertSame(wrappedSimpleValue, ((IndexedCollection)wrappedPrimitiveArrayValue).getIndex()); + // next call has no effect + setValueWrapper.setIndex(simpleValueWrapper); + // next call has no effect + simpleValueWrapper.setIndex(simpleValueWrapper); + // next call has no effect + componentValueWrapper.setIndex(simpleValueWrapper); + // next call has no effect + dependantValueWrapper.setIndex(simpleValueWrapper); + // next call has no effect + anyValueWrapper.setIndex(simpleValueWrapper); + // next call has no effect + identifierBagValueWrapper.setIndex(simpleValueWrapper); + } + + @Test + public void testSetTypeName() { + assertNull(((Collection)wrappedArrayValue).getTypeName()); + arrayValueWrapper.setTypeName("foobar"); + assertEquals("foobar", ((Collection)wrappedArrayValue).getTypeName()); + assertNull(((Collection)wrappedBagValue).getTypeName()); + bagValueWrapper.setTypeName("foobar"); + assertEquals("foobar", ((Collection)wrappedBagValue).getTypeName()); + assertNull(((Collection)wrappedListValue).getTypeName()); + listValueWrapper.setTypeName("foobar"); + assertEquals("foobar", ((Collection)wrappedListValue).getTypeName()); + assertNull(((SimpleValue)wrappedManyToOneValue).getTypeName()); + manyToOneValueWrapper.setTypeName("foobar"); + assertEquals("foobar", ((SimpleValue)wrappedManyToOneValue).getTypeName()); + assertNull(((Collection)wrappedMapValue).getTypeName()); + mapValueWrapper.setTypeName("foobar"); + assertEquals("foobar", ((Collection)wrappedMapValue).getTypeName()); + // next call has no effect + oneToManyValueWrapper.setTypeName("foobar"); + assertNull(((SimpleValue)wrappedOneToOneValue).getTypeName()); + oneToOneValueWrapper.setTypeName("foobar"); + assertEquals("foobar", ((SimpleValue)wrappedOneToOneValue).getTypeName()); + assertNull(((Collection)wrappedPrimitiveArrayValue).getTypeName()); + primitiveArrayValueWrapper.setTypeName("foobar"); + assertEquals("foobar", ((Collection)wrappedPrimitiveArrayValue).getTypeName()); + assertNull(((Collection)wrappedSetValue).getTypeName()); + setValueWrapper.setTypeName("foobar"); + assertEquals("foobar", ((Collection)wrappedSetValue).getTypeName()); + assertNull(((SimpleValue)wrappedSimpleValue).getTypeName()); + simpleValueWrapper.setTypeName("foobar"); + assertEquals("foobar", ((SimpleValue)wrappedSimpleValue).getTypeName()); + assertNull(((SimpleValue)wrappedComponentValue).getTypeName()); + componentValueWrapper.setTypeName("foobar"); + assertEquals("foobar", ((SimpleValue)wrappedComponentValue).getTypeName()); + assertNull(((SimpleValue)wrappedDependantValue).getTypeName()); + dependantValueWrapper.setTypeName("foobar"); + assertEquals("foobar", ((SimpleValue)wrappedDependantValue).getTypeName()); + assertNull(((SimpleValue)wrappedAnyValue).getTypeName()); + anyValueWrapper.setTypeName("foobar"); + assertEquals("foobar", ((SimpleValue)wrappedAnyValue).getTypeName()); + assertNull(((Collection)wrappedIdentifierBagValue).getTypeName()); + identifierBagValueWrapper.setTypeName("foobar"); + assertEquals("foobar", ((Collection)wrappedIdentifierBagValue).getTypeName()); + } + + @Test + public void testGetComponentClassName() { + assertNull(arrayValueWrapper.getComponentClassName()); + assertNull(bagValueWrapper.getComponentClassName()); + assertNull(listValueWrapper.getComponentClassName()); + assertNull(manyToOneValueWrapper.getComponentClassName()); + assertNull(mapValueWrapper.getComponentClassName()); + assertNull(oneToManyValueWrapper.getComponentClassName()); + assertNull(oneToOneValueWrapper.getComponentClassName()); + assertNull(primitiveArrayValueWrapper.getComponentClassName()); + assertNull(setValueWrapper.getComponentClassName()); + assertNull(simpleValueWrapper.getComponentClassName()); + assertNull(componentValueWrapper.getComponentClassName()); + ((Component)wrappedComponentValue).setComponentClassName("foobar"); + assertEquals("foobar", componentValueWrapper.getComponentClassName()); + assertNull(dependantValueWrapper.getComponentClassName()); + assertNull(anyValueWrapper.getComponentClassName()); + assertNull(identifierBagValueWrapper.getComponentClassName()); + } + + @Test + public void testGetColumnIterator() { + Iterator columnIterator = null; + Column column = new Column("foo"); + // collection values have no columns + assertFalse(arrayValueWrapper.getColumnIterator().hasNext()); + assertFalse(bagValueWrapper.getColumnIterator().hasNext()); + assertFalse(listValueWrapper.getColumnIterator().hasNext()); + assertFalse(mapValueWrapper.getColumnIterator().hasNext()); + assertFalse(primitiveArrayValueWrapper.getColumnIterator().hasNext()); + assertFalse(setValueWrapper.getColumnIterator().hasNext()); + assertFalse(identifierBagValueWrapper.getColumnIterator().hasNext()); + // one to many value columns are the ones of the associated class + RootClass pc = new RootClass(DummyMetadataBuildingContext.INSTANCE); + BasicValue kv = new BasicValue(DummyMetadataBuildingContext.INSTANCE); + kv.setTable(new Table("")); + pc.setIdentifier(kv); + ((OneToMany)wrappedOneToManyValue).setAssociatedClass(pc); + assertFalse(oneToManyValueWrapper.getColumnIterator().hasNext()); + kv.addColumn(column); + columnIterator = oneToManyValueWrapper.getColumnIterator(); + ColumnWrapper cw = columnIterator.next(); + assertFalse(columnIterator.hasNext()); + assertSame(cw.getWrappedObject(), column); + // simple value case + ((SimpleValue)wrappedSimpleValue).setTable(new Table("")); + assertFalse(simpleValueWrapper.getColumnIterator().hasNext()); + ((SimpleValue)wrappedSimpleValue).addColumn(column); + columnIterator = simpleValueWrapper.getColumnIterator(); + cw = columnIterator.next(); + assertFalse(columnIterator.hasNext()); + assertSame(cw.getWrappedObject(), column); + // component value case + assertFalse(componentValueWrapper.getColumnIterator().hasNext()); + Property p = new Property(); + p.setValue(kv); + ((Component)wrappedComponentValue).addProperty(p); + columnIterator = componentValueWrapper.getColumnIterator(); + cw = columnIterator.next(); + assertFalse(columnIterator.hasNext()); + assertSame(cw.getWrappedObject(), column); + // many to one value + assertFalse(manyToOneValueWrapper.getColumnIterator().hasNext()); + ((ManyToOne)wrappedManyToOneValue).addColumn(column); + columnIterator = manyToOneValueWrapper.getColumnIterator(); + cw = columnIterator.next(); + assertFalse(columnIterator.hasNext()); + assertSame(cw.getWrappedObject(), column); + // one to one value + assertFalse(oneToOneValueWrapper.getColumnIterator().hasNext()); + ((OneToOne)wrappedOneToOneValue).addColumn(column); + columnIterator = oneToOneValueWrapper.getColumnIterator(); + cw = columnIterator.next(); + assertFalse(columnIterator.hasNext()); + assertSame(cw.getWrappedObject(), column); + // dependant value case + ((DependantValue)wrappedDependantValue).setTable(new Table("")); + assertFalse(dependantValueWrapper.getColumnIterator().hasNext()); + ((DependantValue)wrappedDependantValue).addColumn(column); + columnIterator = dependantValueWrapper.getColumnIterator(); + cw = columnIterator.next(); + assertFalse(columnIterator.hasNext()); + assertSame(cw.getWrappedObject(), column); + // any value case + ((Any)wrappedAnyValue).setTable(new Table("")); + assertFalse(anyValueWrapper.getColumnIterator().hasNext()); + ((Any)wrappedAnyValue).addColumn(column); + columnIterator = anyValueWrapper.getColumnIterator(); + cw = columnIterator.next(); + assertFalse(columnIterator.hasNext()); + assertSame(cw.getWrappedObject(), column); + } + + @Test + public void testIsTypeSpecified() { + try { + arrayValueWrapper.isTypeSpecified(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'isTypeSpecified()'")); + } + try { + bagValueWrapper.isTypeSpecified(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'isTypeSpecified()'")); + } + try { + listValueWrapper.isTypeSpecified(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'isTypeSpecified()'")); + } + try { + mapValueWrapper.isTypeSpecified(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'isTypeSpecified()'")); + } + try { + oneToManyValueWrapper.isTypeSpecified(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'isTypeSpecified()'")); + } + try { + primitiveArrayValueWrapper.isTypeSpecified(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'isTypeSpecified()'")); + } + try { + setValueWrapper.isTypeSpecified(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'isTypeSpecified()'")); + } + try { + identifierBagValueWrapper.isTypeSpecified(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'isTypeSpecified()'")); + } + assertFalse(manyToOneValueWrapper.isTypeSpecified()); + ((ManyToOne)wrappedManyToOneValue).setTypeName("foo"); + assertFalse(manyToOneValueWrapper.isTypeSpecified()); + ((ManyToOne)wrappedManyToOneValue).setReferencedEntityName("foo"); + assertTrue(manyToOneValueWrapper.isTypeSpecified()); + assertFalse(oneToOneValueWrapper.isTypeSpecified()); + ((OneToOne)wrappedOneToOneValue).setTypeName("foo"); + assertFalse(oneToOneValueWrapper.isTypeSpecified()); + ((OneToOne)wrappedOneToOneValue).setReferencedEntityName("foo"); + assertTrue(manyToOneValueWrapper.isTypeSpecified()); + assertFalse(simpleValueWrapper.isTypeSpecified()); + ((SimpleValue)wrappedSimpleValue).setTypeName("foo"); + assertTrue(simpleValueWrapper.isTypeSpecified()); + assertFalse(componentValueWrapper.isTypeSpecified()); + ((Component)wrappedComponentValue).setTypeName("foo"); + assertTrue(componentValueWrapper.isTypeSpecified()); + assertFalse(dependantValueWrapper.isTypeSpecified()); + ((DependantValue)wrappedDependantValue).setTypeName("foo"); + assertTrue(dependantValueWrapper.isTypeSpecified()); + assertFalse(anyValueWrapper.isTypeSpecified()); + ((Any)wrappedAnyValue).setTypeName("foo"); + assertTrue(anyValueWrapper.isTypeSpecified()); + } + + @Test + public void testGetCollectionTable() { + assertNull(arrayValueWrapper.getCollectionTable()); + ((Collection)wrappedArrayValue).setCollectionTable(wrappedTable); + assertSame(wrappedTable, arrayValueWrapper.getCollectionTable().getWrappedObject()); + assertNull(bagValueWrapper.getCollectionTable()); + ((Collection)wrappedBagValue).setCollectionTable(wrappedTable); + assertSame(wrappedTable, bagValueWrapper.getCollectionTable().getWrappedObject()); + assertNull(listValueWrapper.getCollectionTable()); + ((Collection)wrappedListValue).setCollectionTable(wrappedTable); + assertSame(wrappedTable, listValueWrapper.getCollectionTable().getWrappedObject()); + assertNull(manyToOneValueWrapper.getCollectionTable()); + assertNull(mapValueWrapper.getCollectionTable()); + ((Collection)wrappedMapValue).setCollectionTable(wrappedTable); + assertSame(wrappedTable, mapValueWrapper.getCollectionTable().getWrappedObject()); + assertNull(oneToManyValueWrapper.getCollectionTable()); + assertNull(oneToOneValueWrapper.getCollectionTable()); + assertNull(primitiveArrayValueWrapper.getCollectionTable()); + ((Collection)wrappedPrimitiveArrayValue).setCollectionTable(wrappedTable); + assertSame(wrappedTable, primitiveArrayValueWrapper.getCollectionTable().getWrappedObject()); + assertNull(setValueWrapper.getCollectionTable()); + ((Collection)wrappedSetValue).setCollectionTable(wrappedTable); + assertSame(wrappedTable, setValueWrapper.getCollectionTable().getWrappedObject()); + assertNull(simpleValueWrapper.getCollectionTable()); + assertNull(componentValueWrapper.getCollectionTable()); + assertNull(dependantValueWrapper.getCollectionTable()); + assertNull(anyValueWrapper.getCollectionTable()); + assertNull(identifierBagValueWrapper.getCollectionTable()); + ((Collection)wrappedIdentifierBagValue).setCollectionTable(wrappedTable); + assertSame(wrappedTable, identifierBagValueWrapper.getCollectionTable().getWrappedObject()); + } + + @Test + public void testGetKey() { + assertNull(arrayValueWrapper.getKey()); + ((Collection)wrappedArrayValue).setKey((KeyValue)wrappedSimpleValue); + assertSame(wrappedSimpleValue, arrayValueWrapper.getKey().getWrappedObject()); + assertNull(bagValueWrapper.getKey()); + ((Collection)wrappedBagValue).setKey((KeyValue)wrappedSimpleValue); + assertSame(wrappedSimpleValue, bagValueWrapper.getKey().getWrappedObject()); + assertNull(listValueWrapper.getKey()); + ((Collection)wrappedListValue).setKey((KeyValue)wrappedSimpleValue); + assertSame(wrappedSimpleValue, listValueWrapper.getKey().getWrappedObject()); + assertNull(mapValueWrapper.getKey()); + ((Collection)wrappedMapValue).setKey((KeyValue)wrappedSimpleValue); + assertSame(wrappedSimpleValue, mapValueWrapper.getKey().getWrappedObject()); + assertNull(primitiveArrayValueWrapper.getKey()); + ((Collection)wrappedPrimitiveArrayValue).setKey((KeyValue)wrappedSimpleValue); + assertSame(wrappedSimpleValue, primitiveArrayValueWrapper.getKey().getWrappedObject()); + assertNull(setValueWrapper.getKey()); + ((Collection)wrappedSetValue).setKey((KeyValue)wrappedSimpleValue); + assertSame(wrappedSimpleValue, setValueWrapper.getKey().getWrappedObject()); + assertNull(identifierBagValueWrapper.getKey()); + ((Collection)wrappedIdentifierBagValue).setKey((KeyValue)wrappedSimpleValue); + assertSame(wrappedSimpleValue, identifierBagValueWrapper.getKey().getWrappedObject()); + try { + simpleValueWrapper.getKey(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'getKey()'")); + } + try { + manyToOneValueWrapper.getKey(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'getKey()'")); + } + try { + oneToOneValueWrapper.getKey(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'getKey()'")); + } + try { + componentValueWrapper.getKey(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'getKey()'")); + } + try { + dependantValueWrapper.getKey(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'getKey()'")); + } + try { + anyValueWrapper.getKey(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'getKey()'")); + } + } + + @Test + public void testGetIndex() { + assertNull(arrayValueWrapper.getIndex()); + ((IndexedCollection)wrappedArrayValue).setIndex(wrappedSimpleValue); + assertSame(wrappedSimpleValue, arrayValueWrapper.getIndex().getWrappedObject()); + assertNull(bagValueWrapper.getIndex()); + assertNull(listValueWrapper.getIndex()); + ((IndexedCollection)wrappedListValue).setIndex(wrappedSimpleValue); + assertSame(wrappedSimpleValue, listValueWrapper.getIndex().getWrappedObject()); + assertNull(manyToOneValueWrapper.getIndex()); + assertNull(mapValueWrapper.getIndex()); + ((IndexedCollection)wrappedMapValue).setIndex(wrappedSimpleValue); + assertSame(wrappedSimpleValue, mapValueWrapper.getIndex().getWrappedObject()); + assertNull(oneToManyValueWrapper.getIndex()); + assertNull(oneToOneValueWrapper.getIndex()); + assertNull(primitiveArrayValueWrapper.getIndex()); + ((IndexedCollection)wrappedPrimitiveArrayValue).setIndex(wrappedSimpleValue); + assertSame(wrappedSimpleValue, primitiveArrayValueWrapper.getIndex().getWrappedObject()); + assertNull(setValueWrapper.getIndex()); + assertNull(simpleValueWrapper.getIndex()); + assertNull(componentValueWrapper.getIndex()); + assertNull(dependantValueWrapper.getIndex()); + assertNull(anyValueWrapper.getIndex()); + assertNull(identifierBagValueWrapper.getIndex()); + } + + @Test + public void testGetElementClassName() { + // only supported by array values + assertNull(arrayValueWrapper.getElementClassName()); + ((Array)wrappedArrayValue).setElementClassName("foo"); + assertEquals("foo", arrayValueWrapper.getElementClassName()); + assertNull(primitiveArrayValueWrapper.getElementClassName()); + ((PrimitiveArray)wrappedPrimitiveArrayValue).setElementClassName("foo"); + assertEquals("foo", primitiveArrayValueWrapper.getElementClassName()); + try { + bagValueWrapper.getElementClassName(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'getElementClassName()'")); + } + try { + listValueWrapper.getElementClassName(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'getElementClassName()'")); + } + try { + setValueWrapper.getElementClassName(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'getElementClassName()'")); + } + try { + mapValueWrapper.getElementClassName(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'getElementClassName()'")); + } + try { + simpleValueWrapper.getElementClassName(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'getElementClassName()'")); + } + try { + manyToOneValueWrapper.getElementClassName(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'getElementClassName()'")); + } + try { + oneToOneValueWrapper.getElementClassName(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'getElementClassName()'")); + } + try { + oneToManyValueWrapper.getElementClassName(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'getElementClassName()'")); + } + try { + componentValueWrapper.getElementClassName(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'getElementClassName()'")); + } + try { + dependantValueWrapper.getElementClassName(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'getElementClassName()'")); + } + try { + anyValueWrapper.getElementClassName(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'getElementClassName()'")); + } + try { + identifierBagValueWrapper.getElementClassName(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'getElementClassName()'")); + } + } + + @Test + public void testGetTypeName() { + assertNull(arrayValueWrapper.getTypeName()); + ((Collection)wrappedArrayValue).setTypeName("foobar"); + assertEquals("foobar", arrayValueWrapper.getTypeName()); + assertNull(bagValueWrapper.getTypeName()); + ((Collection)wrappedBagValue).setTypeName("foobar"); + assertEquals("foobar", bagValueWrapper.getTypeName()); + assertNull(listValueWrapper.getTypeName()); + ((Collection)wrappedListValue).setTypeName("foobar"); + assertEquals("foobar", listValueWrapper.getTypeName()); + assertNull(manyToOneValueWrapper.getTypeName()); + ((SimpleValue)wrappedManyToOneValue).setTypeName("foobar"); + assertEquals("foobar", manyToOneValueWrapper.getTypeName()); + assertNull(mapValueWrapper.getTypeName()); + ((Collection)wrappedMapValue).setTypeName("foobar"); + assertEquals("foobar", mapValueWrapper.getTypeName()); + assertNull(oneToManyValueWrapper.getTypeName()); + assertNull(oneToOneValueWrapper.getTypeName()); + ((SimpleValue)wrappedOneToOneValue).setTypeName("foobar"); + assertEquals("foobar", oneToOneValueWrapper.getTypeName()); + assertNull(primitiveArrayValueWrapper.getTypeName()); + ((Collection)wrappedPrimitiveArrayValue).setTypeName("foobar"); + assertEquals("foobar", primitiveArrayValueWrapper.getTypeName()); + assertNull(setValueWrapper.getTypeName()); + ((Collection)wrappedSetValue).setTypeName("foobar"); + assertEquals("foobar", setValueWrapper.getTypeName()); + assertNull(simpleValueWrapper.getTypeName()); + ((SimpleValue)wrappedSimpleValue).setTypeName("foobar"); + assertEquals("foobar", simpleValueWrapper.getTypeName()); + assertNull(componentValueWrapper.getTypeName()); + ((SimpleValue)wrappedComponentValue).setTypeName("foobar"); + assertEquals("foobar", componentValueWrapper.getTypeName()); + assertNull(dependantValueWrapper.getTypeName()); + ((SimpleValue)wrappedDependantValue).setTypeName("foobar"); + assertEquals("foobar", dependantValueWrapper.getTypeName()); + assertNull(anyValueWrapper.getTypeName()); + ((SimpleValue)wrappedAnyValue).setTypeName("foobar"); + assertEquals("foobar", dependantValueWrapper.getTypeName()); + assertNull(identifierBagValueWrapper.getTypeName()); + ((Collection)wrappedIdentifierBagValue).setTypeName("foobar"); + assertEquals("foobar", identifierBagValueWrapper.getTypeName()); + } + + @Test + public void testIsDependantValue() { + assertFalse(arrayValueWrapper.isDependantValue()); + assertFalse(bagValueWrapper.isDependantValue()); + assertFalse(listValueWrapper.isDependantValue()); + assertFalse(manyToOneValueWrapper.isDependantValue()); + assertFalse(mapValueWrapper.isDependantValue()); + assertFalse(oneToManyValueWrapper.isDependantValue()); + assertFalse(oneToOneValueWrapper.isDependantValue()); + assertFalse(primitiveArrayValueWrapper.isDependantValue()); + assertFalse(setValueWrapper.isDependantValue()); + assertFalse(simpleValueWrapper.isDependantValue()); + assertFalse(componentValueWrapper.isDependantValue()); + assertTrue(dependantValueWrapper.isDependantValue()); + assertFalse(anyValueWrapper.isDependantValue()); + assertFalse(identifierBagValueWrapper.isDependantValue()); + } + + @Test + public void testIsAny() { + assertFalse(arrayValueWrapper.isAny()); + assertFalse(bagValueWrapper.isAny()); + assertFalse(listValueWrapper.isAny()); + assertFalse(manyToOneValueWrapper.isAny()); + assertFalse(mapValueWrapper.isAny()); + assertFalse(oneToManyValueWrapper.isAny()); + assertFalse(oneToOneValueWrapper.isAny()); + assertFalse(primitiveArrayValueWrapper.isAny()); + assertFalse(setValueWrapper.isAny()); + assertFalse(simpleValueWrapper.isAny()); + assertFalse(componentValueWrapper.isAny()); + assertFalse(dependantValueWrapper.isAny()); + assertTrue(anyValueWrapper.isAny()); + assertFalse(identifierBagValueWrapper.isAny()); + } + + @Test + public void testIsSet() { + assertFalse(arrayValueWrapper.isSet()); + assertFalse(bagValueWrapper.isSet()); + assertFalse(listValueWrapper.isSet()); + assertFalse(manyToOneValueWrapper.isSet()); + assertFalse(mapValueWrapper.isSet()); + assertFalse(oneToManyValueWrapper.isSet()); + assertFalse(oneToOneValueWrapper.isSet()); + assertFalse(primitiveArrayValueWrapper.isSet()); + assertTrue(setValueWrapper.isSet()); + assertFalse(simpleValueWrapper.isSet()); + assertFalse(componentValueWrapper.isSet()); + assertFalse(dependantValueWrapper.isSet()); + assertFalse(anyValueWrapper.isSet()); + assertFalse(identifierBagValueWrapper.isSet()); + } + + @Test + public void testIsPrimitiveArray() { + assertFalse(arrayValueWrapper.isPrimitiveArray()); + assertFalse(bagValueWrapper.isPrimitiveArray()); + assertFalse(listValueWrapper.isPrimitiveArray()); + assertFalse(manyToOneValueWrapper.isPrimitiveArray()); + assertFalse(mapValueWrapper.isPrimitiveArray()); + assertFalse(oneToManyValueWrapper.isPrimitiveArray()); + assertFalse(oneToOneValueWrapper.isPrimitiveArray()); + assertTrue(primitiveArrayValueWrapper.isPrimitiveArray()); + assertFalse(setValueWrapper.isPrimitiveArray()); + assertFalse(simpleValueWrapper.isPrimitiveArray()); + assertFalse(componentValueWrapper.isPrimitiveArray()); + assertFalse(dependantValueWrapper.isPrimitiveArray()); + assertFalse(anyValueWrapper.isPrimitiveArray()); + assertFalse(identifierBagValueWrapper.isPrimitiveArray()); + } + + @Test + public void testIsArray() { + assertTrue(arrayValueWrapper.isArray()); + assertFalse(bagValueWrapper.isArray()); + assertFalse(listValueWrapper.isArray()); + assertFalse(manyToOneValueWrapper.isArray()); + assertFalse(mapValueWrapper.isArray()); + assertFalse(oneToManyValueWrapper.isArray()); + assertFalse(oneToOneValueWrapper.isArray()); + assertTrue(primitiveArrayValueWrapper.isArray()); + assertFalse(setValueWrapper.isArray()); + assertFalse(simpleValueWrapper.isArray()); + assertFalse(componentValueWrapper.isArray()); + assertFalse(dependantValueWrapper.isArray()); + assertFalse(anyValueWrapper.isArray()); + assertFalse(identifierBagValueWrapper.isArray()); + } + + @Test + public void testIsIdentifierBag() { + assertFalse(arrayValueWrapper.isIdentifierBag()); + assertFalse(bagValueWrapper.isIdentifierBag()); + assertFalse(listValueWrapper.isIdentifierBag()); + assertFalse(manyToOneValueWrapper.isIdentifierBag()); + assertFalse(mapValueWrapper.isIdentifierBag()); + assertFalse(oneToManyValueWrapper.isIdentifierBag()); + assertFalse(oneToOneValueWrapper.isIdentifierBag()); + assertFalse(primitiveArrayValueWrapper.isIdentifierBag()); + assertFalse(setValueWrapper.isIdentifierBag()); + assertFalse(simpleValueWrapper.isIdentifierBag()); + assertFalse(componentValueWrapper.isIdentifierBag()); + assertFalse(dependantValueWrapper.isIdentifierBag()); + assertFalse(anyValueWrapper.isIdentifierBag()); + assertTrue(identifierBagValueWrapper.isIdentifierBag()); + } + + @Test + public void testIsBag() { + assertFalse(arrayValueWrapper.isBag()); + assertTrue(bagValueWrapper.isBag()); + assertFalse(listValueWrapper.isBag()); + assertFalse(manyToOneValueWrapper.isBag()); + assertFalse(mapValueWrapper.isBag()); + assertFalse(oneToManyValueWrapper.isBag()); + assertFalse(oneToOneValueWrapper.isBag()); + assertFalse(primitiveArrayValueWrapper.isBag()); + assertFalse(setValueWrapper.isBag()); + assertFalse(simpleValueWrapper.isBag()); + assertFalse(componentValueWrapper.isBag()); + assertFalse(dependantValueWrapper.isBag()); + assertFalse(anyValueWrapper.isBag()); + assertFalse(identifierBagValueWrapper.isBag()); + } + + @Test + public void testGetReferencedEntityName() { + assertNull(manyToOneValueWrapper.getReferencedEntityName()); + ((ManyToOne)wrappedManyToOneValue).setReferencedEntityName("foobar"); + assertEquals("foobar", manyToOneValueWrapper.getReferencedEntityName()); + assertNull(oneToManyValueWrapper.getReferencedEntityName()); + ((OneToMany)wrappedOneToManyValue).setReferencedEntityName("foobar"); + assertEquals("foobar", oneToManyValueWrapper.getReferencedEntityName()); + assertNull(oneToOneValueWrapper.getReferencedEntityName()); + ((OneToOne)wrappedOneToOneValue).setReferencedEntityName("foobar"); + assertEquals("foobar", oneToOneValueWrapper.getReferencedEntityName()); + try { + arrayValueWrapper.getReferencedEntityName(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'getReferencedEntityName()'")); + } + try { + bagValueWrapper.getReferencedEntityName(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'getReferencedEntityName()'")); + } + try { + listValueWrapper.getReferencedEntityName(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'getReferencedEntityName()'")); + } + try { + mapValueWrapper.getReferencedEntityName(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'getReferencedEntityName()'")); + } + try { + primitiveArrayValueWrapper.getReferencedEntityName(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'getReferencedEntityName()'")); + } + try { + setValueWrapper.getReferencedEntityName(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'getReferencedEntityName()'")); + } + try { + simpleValueWrapper.getReferencedEntityName(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'getReferencedEntityName()'")); + } + try { + componentValueWrapper.getReferencedEntityName(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'getReferencedEntityName()'")); + } + try { + dependantValueWrapper.getReferencedEntityName(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'getReferencedEntityName()'")); + } + try { + anyValueWrapper.getReferencedEntityName(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'getReferencedEntityName()'")); + } + try { + identifierBagValueWrapper.getReferencedEntityName(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'getReferencedEntityName()'")); + } + } + + @Test + public void testGetEntityName() { + try { + arrayValueWrapper.getEntityName(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'getEntityName()'")); + } + try { + bagValueWrapper.getEntityName(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'getEntityName()'")); + } + try { + listValueWrapper.getEntityName(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'getEntityName()'")); + } + try { + manyToOneValueWrapper.getEntityName(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'getEntityName()'")); + } + try { + mapValueWrapper.getEntityName(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'getEntityName()'")); + } + try { + oneToManyValueWrapper.getEntityName(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'getEntityName()'")); + } + assertNull(oneToOneValueWrapper.getEntityName()); + wrappedPersistentClass.setEntityName("foobar"); + wrappedOneToOneValue = new OneToOne(DummyMetadataBuildingContext.INSTANCE, wrappedTable, wrappedPersistentClass); + oneToOneValueWrapper = ValueWrapperFactory.createValueWrapper(wrappedOneToOneValue); + assertEquals("foobar", oneToOneValueWrapper.getEntityName()); + try { + primitiveArrayValueWrapper.getEntityName(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'getEntityName()'")); + } + try { + setValueWrapper.getEntityName(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'getEntityName()'")); + } + try { + simpleValueWrapper.getEntityName(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'getEntityName()'")); + } + try { + componentValueWrapper.getEntityName(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'getEntityName()'")); + } + try { + dependantValueWrapper.getEntityName(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'getEntityName()'")); + } + try { + anyValueWrapper.getEntityName(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'getEntityName()'")); + } + try { + identifierBagValueWrapper.getEntityName(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'getEntityName()'")); + } + } + + @Test + public void testGetPropertyIterator() { + // only the component values have properties + Iterator propertyIterator = componentValueWrapper.getPropertyIterator(); + assertFalse(propertyIterator.hasNext()); + Property p = new Property(); + ((Component)wrappedComponentValue).addProperty(p); + propertyIterator = componentValueWrapper.getPropertyIterator(); + PropertyWrapper propertyWrapper = propertyIterator.next(); + assertFalse(propertyIterator.hasNext()); + assertSame(p, propertyWrapper.getWrappedObject()); + // other values do not support 'getPropertyIterator()' + try { + arrayValueWrapper.getPropertyIterator(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'getPropertyIterator()'")); + } + try { + bagValueWrapper.getPropertyIterator(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'getPropertyIterator()'")); + } + try { + listValueWrapper.getPropertyIterator(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'getPropertyIterator()'")); + } + try { + manyToOneValueWrapper.getPropertyIterator(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'getPropertyIterator()'")); + } + try { + mapValueWrapper.getPropertyIterator(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'getPropertyIterator()'")); + } + try { + oneToManyValueWrapper.getPropertyIterator(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'getPropertyIterator()'")); + } + try { + oneToOneValueWrapper.getPropertyIterator(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'getPropertyIterator()'")); + } + try { + primitiveArrayValueWrapper.getPropertyIterator(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'getPropertyIterator()'")); + } + try { + setValueWrapper.getPropertyIterator(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'getPropertyIterator()'")); + } + try { + simpleValueWrapper.getPropertyIterator(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'getPropertyIterator()'")); + } + try { + dependantValueWrapper.getPropertyIterator(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'getPropertyIterator()'")); + } + try { + anyValueWrapper.getPropertyIterator(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'getPropertyIterator()'")); + } + try { + identifierBagValueWrapper.getPropertyIterator(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'getPropertyIterator()'")); + } + } + + @Test + public void testAddColumn() { + Column column = new Column("foo"); + ColumnWrapper columnWrapper = ColumnWrapperFactory.createColumnWrapper(column); + assertFalse(wrappedManyToOneValue.getColumns().contains(column)); + manyToOneValueWrapper.addColumn(columnWrapper); + assertTrue(wrappedManyToOneValue.getColumns().contains(column)); + assertFalse(wrappedOneToOneValue.getColumns().contains(column)); + oneToOneValueWrapper.addColumn(columnWrapper); + assertTrue(wrappedOneToOneValue.getColumns().contains(column)); + ((BasicValue)wrappedSimpleValue).setTable(wrappedTable); + assertFalse(wrappedSimpleValue.getColumns().contains(column)); + simpleValueWrapper.addColumn(columnWrapper); + assertTrue(wrappedSimpleValue.getColumns().contains(column)); + assertFalse(wrappedDependantValue.getColumns().contains(column)); + dependantValueWrapper.addColumn(columnWrapper); + assertTrue(wrappedDependantValue.getColumns().contains(column)); + assertFalse(wrappedAnyValue.getColumns().contains(column)); + anyValueWrapper.addColumn(columnWrapper); + assertTrue(wrappedAnyValue.getColumns().contains(column)); + try { + arrayValueWrapper.addColumn(columnWrapper); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'addColumn(Column)'")); + } + try { + bagValueWrapper.addColumn(columnWrapper); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'addColumn(Column)'")); + } + try { + listValueWrapper.addColumn(columnWrapper); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'addColumn(Column)'")); + } + try { + mapValueWrapper.addColumn(columnWrapper); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'addColumn(Column)'")); + } + try { + oneToManyValueWrapper.addColumn(columnWrapper); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'addColumn(Column)'")); + } + try { + primitiveArrayValueWrapper.addColumn(columnWrapper); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'addColumn(Column)'")); + } + try { + setValueWrapper.addColumn(columnWrapper); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'addColumn(Column)'")); + } + try { + componentValueWrapper.addColumn(columnWrapper); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("Cant add a column to a component")); + } + try { + identifierBagValueWrapper.addColumn(columnWrapper); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'addColumn(Column)'")); + } + } + + @Test + public void testSetTypeParameters() { + Properties properties = new Properties(); + assertNull(((Collection)wrappedArrayValue).getTypeParameters()); + arrayValueWrapper.setTypeParameters(properties); + assertSame(((Collection)wrappedArrayValue).getTypeParameters(), properties); + assertNull(((Collection)wrappedBagValue).getTypeParameters()); + bagValueWrapper.setTypeParameters(properties); + assertSame(((Collection)wrappedBagValue).getTypeParameters(), properties); + assertNull(((Collection)wrappedListValue).getTypeParameters()); + listValueWrapper.setTypeParameters(properties); + assertSame(((Collection)wrappedListValue).getTypeParameters(), properties); + assertNull(((SimpleValue)wrappedManyToOneValue).getTypeParameters()); + manyToOneValueWrapper.setTypeParameters(properties); + assertSame(((SimpleValue)wrappedManyToOneValue).getTypeParameters(), properties); + assertNull(((Collection)wrappedMapValue).getTypeParameters()); + mapValueWrapper.setTypeParameters(properties); + assertSame(((Collection)wrappedMapValue).getTypeParameters(), properties); + assertNull(((SimpleValue)wrappedOneToOneValue).getTypeParameters()); + oneToOneValueWrapper.setTypeParameters(properties); + assertSame(((SimpleValue)wrappedOneToOneValue).getTypeParameters(), properties); + assertNull(((Collection)wrappedPrimitiveArrayValue).getTypeParameters()); + primitiveArrayValueWrapper.setTypeParameters(properties); + assertSame(((Collection)wrappedPrimitiveArrayValue).getTypeParameters(), properties); + assertNull(((Collection)wrappedSetValue).getTypeParameters()); + setValueWrapper.setTypeParameters(properties); + assertSame(((Collection)wrappedSetValue).getTypeParameters(), properties); + assertNull(((SimpleValue)wrappedSimpleValue).getTypeParameters()); + simpleValueWrapper.setTypeParameters(properties); + assertSame(((SimpleValue)wrappedSimpleValue).getTypeParameters(), properties); + assertNull(((SimpleValue)wrappedComponentValue).getTypeParameters()); + componentValueWrapper.setTypeParameters(properties); + assertSame(((SimpleValue)wrappedComponentValue).getTypeParameters(), properties); + assertNull(((SimpleValue)wrappedDependantValue).getTypeParameters()); + dependantValueWrapper.setTypeParameters(properties); + assertSame(((SimpleValue)wrappedDependantValue).getTypeParameters(), properties); + assertNull(((SimpleValue)wrappedAnyValue).getTypeParameters()); + anyValueWrapper.setTypeParameters(properties); + assertSame(((SimpleValue)wrappedAnyValue).getTypeParameters(), properties); + assertNull(((Collection)wrappedIdentifierBagValue).getTypeParameters()); + identifierBagValueWrapper.setTypeParameters(properties); + assertSame(((Collection)wrappedIdentifierBagValue).getTypeParameters(), properties); + try { + oneToManyValueWrapper.setTypeParameters(properties); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'setTypeParameters(Properties)'")); + } + } + + @Test + public void testGetForeignKeyName() { + assertNull(manyToOneValueWrapper.getForeignKeyName()); + ((SimpleValue)wrappedManyToOneValue).setForeignKeyName("foo"); + assertEquals("foo", manyToOneValueWrapper.getForeignKeyName()); + assertNull(oneToOneValueWrapper.getForeignKeyName()); + ((SimpleValue)wrappedOneToOneValue).setForeignKeyName("foo"); + assertEquals("foo", oneToOneValueWrapper.getForeignKeyName()); + assertNull(simpleValueWrapper.getForeignKeyName()); + ((SimpleValue)wrappedSimpleValue).setForeignKeyName("foo"); + assertEquals("foo", simpleValueWrapper.getForeignKeyName()); + assertNull(componentValueWrapper.getForeignKeyName()); + ((SimpleValue)wrappedComponentValue).setForeignKeyName("foo"); + assertEquals("foo", componentValueWrapper.getForeignKeyName()); + assertNull(dependantValueWrapper.getForeignKeyName()); + ((SimpleValue)wrappedDependantValue).setForeignKeyName("foo"); + assertEquals("foo", dependantValueWrapper.getForeignKeyName()); + assertNull(anyValueWrapper.getForeignKeyName()); + ((SimpleValue)wrappedAnyValue).setForeignKeyName("foo"); + assertEquals("foo", anyValueWrapper.getForeignKeyName()); + try { + arrayValueWrapper.getForeignKeyName(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'getForeignKeyName()'")); + } + try { + bagValueWrapper.getForeignKeyName(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'getForeignKeyName()'")); + } + try { + listValueWrapper.getForeignKeyName(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'getForeignKeyName()'")); + } + try { + mapValueWrapper.getForeignKeyName(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'getForeignKeyName()'")); + } + try { + oneToManyValueWrapper.getForeignKeyName(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'getForeignKeyName()'")); + } + try { + primitiveArrayValueWrapper.getForeignKeyName(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'getForeignKeyName()'")); + } + try { + setValueWrapper.getForeignKeyName(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'getForeignKeyName()'")); + } + try { + identifierBagValueWrapper.getForeignKeyName(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'getForeignKeyName()'")); + } + } + + @Test + public void testGetOwner() { + assertSame(wrappedPersistentClass, arrayValueWrapper.getOwner().getWrappedObject()); + assertSame(wrappedPersistentClass, bagValueWrapper.getOwner().getWrappedObject()); + assertSame(wrappedPersistentClass, listValueWrapper.getOwner().getWrappedObject()); + assertSame(wrappedPersistentClass, mapValueWrapper.getOwner().getWrappedObject()); + assertSame(wrappedPersistentClass, primitiveArrayValueWrapper.getOwner().getWrappedObject()); + assertSame(wrappedPersistentClass, setValueWrapper.getOwner().getWrappedObject()); + assertSame(wrappedPersistentClass, identifierBagValueWrapper.getOwner().getWrappedObject()); + assertSame(wrappedPersistentClass, componentValueWrapper.getOwner().getWrappedObject()); + try { + manyToOneValueWrapper.getOwner(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'getOwner()'")); + } + try { + oneToManyValueWrapper.getOwner(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'getOwner()'")); + } + try { + oneToOneValueWrapper.getOwner(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'getOwner()'")); + } + try { + simpleValueWrapper.getOwner(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'getOwner()'")); + } + try { + dependantValueWrapper.getOwner(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'getOwner()'")); + } + try { + anyValueWrapper.getOwner(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'getOwner()'")); + } + } + + @Test + public void testGetElement() { + assertNull(arrayValueWrapper.getElement()); + ((Collection)wrappedArrayValue).setElement(wrappedSimpleValue); + assertSame(wrappedSimpleValue, arrayValueWrapper.getElement().getWrappedObject()); + assertNull(bagValueWrapper.getElement()); + ((Collection)wrappedBagValue).setElement(wrappedSimpleValue); + assertSame(wrappedSimpleValue, bagValueWrapper.getElement().getWrappedObject()); + assertNull(listValueWrapper.getElement()); + ((Collection)wrappedListValue).setElement(wrappedSimpleValue); + assertSame(wrappedSimpleValue, listValueWrapper.getElement().getWrappedObject()); + assertNull(manyToOneValueWrapper.getElement()); + assertNull(mapValueWrapper.getElement()); + ((Collection)wrappedMapValue).setElement(wrappedSimpleValue); + assertSame(wrappedSimpleValue, mapValueWrapper.getElement().getWrappedObject()); + assertNull(oneToManyValueWrapper.getElement()); + assertNull(oneToOneValueWrapper.getElement()); + assertNull(primitiveArrayValueWrapper.getElement()); + ((Collection)wrappedPrimitiveArrayValue).setElement(wrappedSimpleValue); + assertSame(wrappedSimpleValue, primitiveArrayValueWrapper.getElement().getWrappedObject()); + assertNull(setValueWrapper.getElement()); + ((Collection)wrappedSetValue).setElement(wrappedSimpleValue); + assertSame(wrappedSimpleValue, setValueWrapper.getElement().getWrappedObject()); + assertNull(simpleValueWrapper.getElement()); + assertNull(componentValueWrapper.getElement()); + assertNull(dependantValueWrapper.getElement()); + assertNull(anyValueWrapper.getElement()); + assertNull(identifierBagValueWrapper.getElement()); + ((Collection)wrappedIdentifierBagValue).setElement(wrappedSimpleValue); + assertSame(wrappedSimpleValue, identifierBagValueWrapper.getElement().getWrappedObject()); + } + + @Test + public void testGetParentProperty() { + assertNull(componentValueWrapper.getParentProperty()); + ((Component)wrappedComponentValue).setParentProperty("foo"); + assertEquals("foo", componentValueWrapper.getParentProperty()); + try { + arrayValueWrapper.getParentProperty(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'getParentProperty()'")); + } + try { + bagValueWrapper.getParentProperty(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'getParentProperty()'")); + } + try { + listValueWrapper.getParentProperty(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'getParentProperty()'")); + } + try { + manyToOneValueWrapper.getParentProperty(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'getParentProperty()'")); + } + try { + oneToOneValueWrapper.getParentProperty(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'getParentProperty()'")); + } + try { + mapValueWrapper.getParentProperty(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'getParentProperty()'")); + } + try { + oneToManyValueWrapper.getParentProperty(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'getParentProperty()'")); + } + try { + primitiveArrayValueWrapper.getParentProperty(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'getParentProperty()'")); + } + try { + setValueWrapper.getParentProperty(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'getParentProperty()'")); + } + try { + simpleValueWrapper.getParentProperty(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'getParentProperty()'")); + } + try { + dependantValueWrapper.getParentProperty(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'getParentProperty()'")); + } + try { + anyValueWrapper.getParentProperty(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'getParentProperty()'")); + } + try { + identifierBagValueWrapper.getParentProperty(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'getParentProperty()'")); + } + } + + @Test + public void testSetElementClassName() { + assertNull(((Array)wrappedArrayValue).getElementClassName()); + arrayValueWrapper.setElementClassName("foo"); + assertEquals("foo", ((Array)wrappedArrayValue).getElementClassName()); + assertNull(((Array)wrappedPrimitiveArrayValue).getElementClassName()); + primitiveArrayValueWrapper.setElementClassName("foo"); + assertEquals("foo", ((Array)wrappedPrimitiveArrayValue).getElementClassName()); + try { + bagValueWrapper.setElementClassName("foo"); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'setElementClassName(String)'")); + } + try { + listValueWrapper.setElementClassName("foo"); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'setElementClassName(String)'")); + } + try { + manyToOneValueWrapper.setElementClassName("foo"); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'setElementClassName(String)'")); + } + try { + mapValueWrapper.setElementClassName("foo"); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'setElementClassName(String)'")); + } + try { + oneToManyValueWrapper.setElementClassName("foo"); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'setElementClassName(String)'")); + } + try { + oneToOneValueWrapper.setElementClassName("foo"); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'setElementClassName(String)'")); + } + try { + setValueWrapper.setElementClassName("foo"); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'setElementClassName(String)'")); + } + try { + simpleValueWrapper.setElementClassName("foo"); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'setElementClassName(String)'")); + } + try { + componentValueWrapper.setElementClassName("foo"); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'setElementClassName(String)'")); + } + try { + dependantValueWrapper.setElementClassName("foo"); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'setElementClassName(String)'")); + } + try { + anyValueWrapper.setElementClassName("foo"); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'setElementClassName(String)'")); + } + try { + identifierBagValueWrapper.setElementClassName("foo"); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'setElementClassName(String)'")); + } + } + + @Test + public void testSetKey() { + assertNull(((Collection)wrappedArrayValue).getKey()); + arrayValueWrapper.setKey(simpleValueWrapper); + assertSame(wrappedSimpleValue,((Collection)wrappedArrayValue).getKey()); + assertNull(((Collection)wrappedBagValue).getKey()); + bagValueWrapper.setKey(simpleValueWrapper); + assertSame(wrappedSimpleValue, ((Collection)wrappedBagValue).getKey()); + assertNull(((Collection)wrappedListValue).getKey()); + listValueWrapper.setKey(simpleValueWrapper); + assertSame(wrappedSimpleValue,((Collection)wrappedListValue).getKey()); + assertNull(((Collection)wrappedMapValue).getKey()); + mapValueWrapper.setKey(simpleValueWrapper); + assertSame(wrappedSimpleValue, ((Collection)wrappedMapValue).getKey()); + assertNull(((Collection)wrappedPrimitiveArrayValue).getKey()); + primitiveArrayValueWrapper.setKey(simpleValueWrapper); + assertSame(wrappedSimpleValue, ((Collection)wrappedPrimitiveArrayValue).getKey()); + assertNull(((Collection)wrappedSetValue).getKey()); + setValueWrapper.setKey(simpleValueWrapper); + assertSame(wrappedSimpleValue, ((Collection)wrappedSetValue).getKey()); + assertNull(((Collection)wrappedIdentifierBagValue).getKey()); + identifierBagValueWrapper.setKey(simpleValueWrapper); + assertSame(wrappedSimpleValue, ((Collection)wrappedIdentifierBagValue).getKey()); + try { + manyToOneValueWrapper.setKey(simpleValueWrapper); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'setKey(KeyValue)'")); + } + try { + oneToManyValueWrapper.setKey(simpleValueWrapper); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'setKey(KeyValue)'")); + } + try { + oneToOneValueWrapper.setKey(simpleValueWrapper); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'setKey(KeyValue)'")); + } + try { + simpleValueWrapper.setKey(simpleValueWrapper); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'setKey(KeyValue)'")); + } + try { + componentValueWrapper.setKey(simpleValueWrapper); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'setKey(KeyValue)'")); + } + try { + dependantValueWrapper.setKey(simpleValueWrapper); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'setKey(KeyValue)'")); + } + try { + anyValueWrapper.setKey(simpleValueWrapper); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'setKey(KeyValue)'")); + } + } + + @Test + public void testSetFetchModeJoin() { + assertNotEquals(FetchMode.JOIN, wrappedArrayValue.getFetchMode()); + arrayValueWrapper.setFetchModeJoin(); + assertEquals(FetchMode.JOIN, wrappedArrayValue.getFetchMode()); + assertNotEquals(FetchMode.JOIN, wrappedBagValue.getFetchMode()); + bagValueWrapper.setFetchModeJoin(); + assertEquals(FetchMode.JOIN, wrappedBagValue.getFetchMode()); + assertNotEquals(FetchMode.JOIN, wrappedListValue.getFetchMode()); + listValueWrapper.setFetchModeJoin(); + assertEquals(FetchMode.JOIN, wrappedListValue.getFetchMode()); + assertNotEquals(FetchMode.JOIN, wrappedManyToOneValue.getFetchMode()); + manyToOneValueWrapper.setFetchModeJoin(); + assertEquals(FetchMode.JOIN, wrappedManyToOneValue.getFetchMode()); + assertNotEquals(FetchMode.JOIN, wrappedOneToOneValue.getFetchMode()); + oneToOneValueWrapper.setFetchModeJoin(); + assertEquals(FetchMode.JOIN, wrappedOneToOneValue.getFetchMode()); + assertNotEquals(FetchMode.JOIN, wrappedMapValue.getFetchMode()); + mapValueWrapper.setFetchModeJoin(); + assertEquals(FetchMode.JOIN, wrappedMapValue.getFetchMode()); + assertNotEquals(FetchMode.JOIN, wrappedPrimitiveArrayValue.getFetchMode()); + primitiveArrayValueWrapper.setFetchModeJoin(); + assertEquals(FetchMode.JOIN, wrappedPrimitiveArrayValue.getFetchMode()); + assertNotEquals(FetchMode.JOIN, wrappedSetValue.getFetchMode()); + setValueWrapper.setFetchModeJoin(); + assertEquals(FetchMode.JOIN, wrappedSetValue.getFetchMode()); + assertNotEquals(FetchMode.JOIN, wrappedIdentifierBagValue.getFetchMode()); + identifierBagValueWrapper.setFetchModeJoin(); + assertEquals(FetchMode.JOIN, wrappedIdentifierBagValue.getFetchMode()); + try { + oneToManyValueWrapper.setFetchModeJoin(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'setFetchModeJoin()'")); + } + try { + simpleValueWrapper.setFetchModeJoin(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'setFetchModeJoin()'")); + } + try { + componentValueWrapper.setFetchModeJoin(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'setFetchModeJoin()'")); + } + try { + dependantValueWrapper.setFetchModeJoin(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'setFetchModeJoin()'")); + } + try { + anyValueWrapper.setFetchModeJoin(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'setFetchModeJoin()'")); + } + } + + @Test + public void testIsInverse() { + assertFalse(arrayValueWrapper.isInverse()); + ((Collection)wrappedArrayValue).setInverse(true); + assertTrue(arrayValueWrapper.isInverse()); + assertFalse(bagValueWrapper.isInverse()); + ((Collection)wrappedBagValue).setInverse(true); + assertTrue(bagValueWrapper.isInverse()); + assertFalse(listValueWrapper.isInverse()); + ((Collection)wrappedListValue).setInverse(true); + assertTrue(listValueWrapper.isInverse()); + assertFalse(mapValueWrapper.isInverse()); + ((Collection)wrappedMapValue).setInverse(true); + assertTrue(mapValueWrapper.isInverse()); + assertFalse(setValueWrapper.isInverse()); + ((Collection)wrappedSetValue).setInverse(true); + assertTrue(setValueWrapper.isInverse()); + assertFalse(identifierBagValueWrapper.isInverse()); + ((Collection)wrappedIdentifierBagValue).setInverse(true); + assertTrue(identifierBagValueWrapper.isInverse()); + assertFalse(primitiveArrayValueWrapper.isInverse()); + ((Collection)wrappedPrimitiveArrayValue).setInverse(true); + assertTrue(primitiveArrayValueWrapper.isInverse()); + try { + manyToOneValueWrapper.isInverse(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'isInverse()'")); + } + try { + oneToManyValueWrapper.isInverse(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'isInverse()'")); + } + try { + oneToOneValueWrapper.isInverse(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'isInverse()'")); + } + try { + simpleValueWrapper.isInverse(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'isInverse()'")); + } + try { + componentValueWrapper.isInverse(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'isInverse()'")); + } + try { + anyValueWrapper.isInverse(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'isInverse()'")); + } + try { + dependantValueWrapper.isInverse(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'isInverse()'")); + } + } + + @Test + public void testGetAssociatedClass() { + try { + arrayValueWrapper.getAssociatedClass(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'getAssociatedClass()'")); + } + try { + bagValueWrapper.getAssociatedClass(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'getAssociatedClass()'")); + } + try { + listValueWrapper.getAssociatedClass(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'getAssociatedClass()'")); + } + try { + setValueWrapper.getAssociatedClass(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'getAssociatedClass()'")); + } + try { + primitiveArrayValueWrapper.getAssociatedClass(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'getAssociatedClass()'")); + } + try { + mapValueWrapper.getAssociatedClass(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'getAssociatedClass()'")); + } + try { + identifierBagValueWrapper.getAssociatedClass(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'getAssociatedClass()'")); + } + try { + manyToOneValueWrapper.getAssociatedClass(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'getAssociatedClass()'")); + } + try { + oneToOneValueWrapper.getAssociatedClass(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'getAssociatedClass()'")); + } + try { + simpleValueWrapper.getAssociatedClass(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'getAssociatedClass()'")); + } + try { + componentValueWrapper.getAssociatedClass(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'getAssociatedClass()'")); + } + try { + anyValueWrapper.getAssociatedClass(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'getAssociatedClass()'")); + } + try { + dependantValueWrapper.getAssociatedClass(); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'getAssociatedClass()'")); + } + assertNull(oneToManyValueWrapper.getAssociatedClass()); + ((OneToMany)wrappedOneToManyValue).setAssociatedClass(wrappedPersistentClass); + assertSame(wrappedPersistentClass, oneToManyValueWrapper.getAssociatedClass().getWrappedObject()); + } + + @Test + public void testSetLazy() { + arrayValueWrapper.setLazy(true); + assertTrue(((Fetchable)wrappedArrayValue).isLazy()); + arrayValueWrapper.setLazy(false); + assertFalse(((Fetchable)wrappedArrayValue).isLazy()); + bagValueWrapper.setLazy(true); + assertTrue(((Fetchable)wrappedBagValue).isLazy()); + bagValueWrapper.setLazy(false); + assertFalse(((Fetchable)wrappedBagValue).isLazy()); + listValueWrapper.setLazy(true); + assertTrue(((Fetchable)wrappedListValue).isLazy()); + listValueWrapper.setLazy(false); + assertFalse(((Fetchable)wrappedListValue).isLazy()); + primitiveArrayValueWrapper.setLazy(true); + assertTrue(((Fetchable)wrappedPrimitiveArrayValue).isLazy()); + primitiveArrayValueWrapper.setLazy(false); + assertFalse(((Fetchable)wrappedPrimitiveArrayValue).isLazy()); + setValueWrapper.setLazy(true); + assertTrue(((Fetchable)wrappedSetValue).isLazy()); + setValueWrapper.setLazy(false); + assertFalse(((Fetchable)wrappedSetValue).isLazy()); + mapValueWrapper.setLazy(true); + assertTrue(((Fetchable)wrappedMapValue).isLazy()); + mapValueWrapper.setLazy(false); + assertFalse(((Fetchable)wrappedMapValue).isLazy()); + identifierBagValueWrapper.setLazy(true); + assertTrue(((Fetchable)wrappedIdentifierBagValue).isLazy()); + identifierBagValueWrapper.setLazy(false); + assertFalse(((Fetchable)wrappedIdentifierBagValue).isLazy()); + anyValueWrapper.setLazy(true); + assertTrue(((Any)wrappedAnyValue).isLazy()); + anyValueWrapper.setLazy(false); + assertFalse(((Any)wrappedAnyValue).isLazy()); + manyToOneValueWrapper.setLazy(true); + assertTrue(((Fetchable)wrappedManyToOneValue).isLazy()); + manyToOneValueWrapper.setLazy(false); + assertFalse(((Fetchable)wrappedManyToOneValue).isLazy()); + oneToOneValueWrapper.setLazy(true); + assertTrue(((Fetchable)wrappedOneToOneValue).isLazy()); + oneToOneValueWrapper.setLazy(false); + assertFalse(((Fetchable)wrappedOneToOneValue).isLazy()); + try { + simpleValueWrapper.setLazy(true); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'setLazy(boolean)'")); + } + try { + componentValueWrapper.setLazy(true); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'setLazy(boolean)'")); + } + try { + dependantValueWrapper.setLazy(true); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'setLazy(boolean)'")); + } + try { + oneToManyValueWrapper.setLazy(true); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'setLazy(boolean)'")); + } + } + + @Test + public void testSetRole() { + assertNull(((Collection)wrappedArrayValue).getRole()); + arrayValueWrapper.setRole("foo"); + assertEquals("foo", ((Collection)wrappedArrayValue).getRole()); + assertNull(((Collection)wrappedBagValue).getRole()); + bagValueWrapper.setRole("foo"); + assertEquals("foo", ((Collection)wrappedBagValue).getRole()); + assertNull(((Collection)wrappedListValue).getRole()); + listValueWrapper.setRole("foo"); + assertEquals("foo", ((Collection)wrappedListValue).getRole()); + assertNull(((Collection)wrappedMapValue).getRole()); + mapValueWrapper.setRole("foo"); + assertEquals("foo", ((Collection)wrappedMapValue).getRole()); + assertNull(((Collection)wrappedPrimitiveArrayValue).getRole()); + primitiveArrayValueWrapper.setRole("foo"); + assertEquals("foo", ((Collection)wrappedPrimitiveArrayValue).getRole()); + assertNull(((Collection)wrappedSetValue).getRole()); + setValueWrapper.setRole("foo"); + assertEquals("foo", ((Collection)wrappedSetValue).getRole()); + assertNull(((Collection)wrappedIdentifierBagValue).getRole()); + identifierBagValueWrapper.setRole("foo"); + assertEquals("foo", ((Collection)wrappedIdentifierBagValue).getRole()); + try { + manyToOneValueWrapper.setRole("foo"); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'setRole(String)'")); + } + try { + oneToManyValueWrapper.setRole("foo"); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'setRole(String)'")); + } + try { + oneToOneValueWrapper.setRole("foo"); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'setRole(String)'")); + } + try { + simpleValueWrapper.setRole("foo"); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'setRole(String)'")); + } + try { + componentValueWrapper.setRole("foo"); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'setRole(String)'")); + } + try { + dependantValueWrapper.setRole("foo"); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'setRole(String)'")); + } + try { + anyValueWrapper.setRole("foo"); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'setRole(String)'")); + } + } + + @Test + public void testSetReferencedEntityName() { + assertNull(((ManyToOne)wrappedManyToOneValue).getReferencedEntityName()); + manyToOneValueWrapper.setReferencedEntityName("foobar"); + assertEquals("foobar", ((ManyToOne)wrappedManyToOneValue).getReferencedEntityName()); + assertNull(((OneToMany)wrappedOneToManyValue).getReferencedEntityName()); + oneToManyValueWrapper.setReferencedEntityName("foobar"); + assertEquals("foobar", ((OneToMany)wrappedOneToManyValue).getReferencedEntityName()); + assertNull(((OneToOne)wrappedOneToOneValue).getReferencedEntityName()); + oneToOneValueWrapper.setReferencedEntityName("foobar"); + assertEquals("foobar", ((OneToOne)wrappedOneToOneValue).getReferencedEntityName()); + try { + arrayValueWrapper.setReferencedEntityName("foobar"); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'setReferencedEntityName(String)'")); + } + try { + bagValueWrapper.setReferencedEntityName("foobar"); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'setReferencedEntityName(String)'")); + } + try { + listValueWrapper.setReferencedEntityName("foobar"); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'setReferencedEntityName(String)'")); + } + try { + mapValueWrapper.setReferencedEntityName("foobar"); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'setReferencedEntityName(String)'")); + } + try { + primitiveArrayValueWrapper.setReferencedEntityName("foobar"); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'setReferencedEntityName(String)'")); + } + try { + setValueWrapper.setReferencedEntityName("foobar"); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'setReferencedEntityName(String)'")); + } + try { + simpleValueWrapper.setReferencedEntityName("foobar"); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'setReferencedEntityName(String)'")); + } + try { + componentValueWrapper.setReferencedEntityName("foobar"); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'setReferencedEntityName(String)'")); + } + try { + dependantValueWrapper.setReferencedEntityName("foobar"); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'setReferencedEntityName(String)'")); + } + try { + anyValueWrapper.setReferencedEntityName("foobar"); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'setReferencedEntityName(String)'")); + } + try { + identifierBagValueWrapper.setReferencedEntityName("foobar"); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'setReferencedEntityName(String)'")); + } + } + + @Test + public void testSetAssociatedClass() { + try { + arrayValueWrapper.setAssociatedClass(persistentClassWrapper); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'setAssociatedClass(PersistentClass)'")); + } + try { + bagValueWrapper.setAssociatedClass(persistentClassWrapper); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'setAssociatedClass(PersistentClass)'")); + } + try { + listValueWrapper.setAssociatedClass(persistentClassWrapper); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'setAssociatedClass(PersistentClass)'")); + } + try { + setValueWrapper.setAssociatedClass(persistentClassWrapper); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'setAssociatedClass(PersistentClass)'")); + } + try { + primitiveArrayValueWrapper.setAssociatedClass(persistentClassWrapper); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'setAssociatedClass(PersistentClass)'")); + } + try { + mapValueWrapper.setAssociatedClass(persistentClassWrapper); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'setAssociatedClass(PersistentClass)'")); + } + try { + identifierBagValueWrapper.setAssociatedClass(persistentClassWrapper); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'setAssociatedClass(PersistentClass)'")); + } + try { + manyToOneValueWrapper.setAssociatedClass(persistentClassWrapper); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'setAssociatedClass(PersistentClass)'")); + } + try { + oneToOneValueWrapper.setAssociatedClass(persistentClassWrapper); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'setAssociatedClass(PersistentClass)'")); + } + try { + simpleValueWrapper.setAssociatedClass(persistentClassWrapper); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'setAssociatedClass(PersistentClass)'")); + } + try { + componentValueWrapper.setAssociatedClass(persistentClassWrapper); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'setAssociatedClass(PersistentClass)'")); + } + try { + anyValueWrapper.setAssociatedClass(persistentClassWrapper); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'setAssociatedClass(PersistentClass)'")); + } + try { + dependantValueWrapper.setAssociatedClass(persistentClassWrapper); + fail(); + } catch (UnsupportedOperationException e) { + assertTrue(e.getMessage().contains("does not support 'setAssociatedClass(PersistentClass)'")); + } + assertNull(((OneToMany)wrappedOneToManyValue).getAssociatedClass()); + oneToManyValueWrapper.setAssociatedClass(persistentClassWrapper); + assertSame(wrappedPersistentClass, ((OneToMany)wrappedOneToManyValue).getAssociatedClass()); + } + +} diff --git a/jbt/src/test/java/org/hibernate/tool/orm/jbt/util/ConfigurationMetadataDescriptorTest.java b/jbt/src/test/java/org/hibernate/tool/orm/jbt/internal/util/ConfigurationMetadataDescriptorTest.java similarity index 93% rename from jbt/src/test/java/org/hibernate/tool/orm/jbt/util/ConfigurationMetadataDescriptorTest.java rename to jbt/src/test/java/org/hibernate/tool/orm/jbt/internal/util/ConfigurationMetadataDescriptorTest.java index 61edb9e125..1370436326 100644 --- a/jbt/src/test/java/org/hibernate/tool/orm/jbt/util/ConfigurationMetadataDescriptorTest.java +++ b/jbt/src/test/java/org/hibernate/tool/orm/jbt/internal/util/ConfigurationMetadataDescriptorTest.java @@ -1,4 +1,4 @@ -package org.hibernate.tool.orm.jbt.util; +package org.hibernate.tool.orm.jbt.internal.util; import static org.junit.jupiter.api.Assertions.assertNotNull; import static org.junit.jupiter.api.Assertions.assertSame; @@ -16,7 +16,7 @@ public class ConfigurationMetadataDescriptorTest { private static final String TEST_HBM_XML_STRING = - "" + + "" + " " + " " + " " + diff --git a/jbt/src/test/java/org/hibernate/tool/orm/jbt/util/DummyMetadataBuildingContextTest.java b/jbt/src/test/java/org/hibernate/tool/orm/jbt/internal/util/DummyMetadataBuildingContextTest.java similarity index 85% rename from jbt/src/test/java/org/hibernate/tool/orm/jbt/util/DummyMetadataBuildingContextTest.java rename to jbt/src/test/java/org/hibernate/tool/orm/jbt/internal/util/DummyMetadataBuildingContextTest.java index e0c3030dbc..643a437134 100644 --- a/jbt/src/test/java/org/hibernate/tool/orm/jbt/util/DummyMetadataBuildingContextTest.java +++ b/jbt/src/test/java/org/hibernate/tool/orm/jbt/internal/util/DummyMetadataBuildingContextTest.java @@ -1,4 +1,4 @@ -package org.hibernate.tool.orm.jbt.util; +package org.hibernate.tool.orm.jbt.internal.util; import static org.junit.jupiter.api.Assertions.assertNotNull; import static org.junit.jupiter.api.Assertions.assertTrue; @@ -6,6 +6,7 @@ import org.hibernate.boot.registry.StandardServiceRegistry; import org.hibernate.dialect.Dialect; import org.hibernate.engine.jdbc.spi.JdbcServices; +import org.hibernate.tool.orm.jbt.internal.util.DummyMetadataBuildingContext; import org.junit.jupiter.api.Test; public class DummyMetadataBuildingContextTest { diff --git a/jbt/src/test/java/org/hibernate/tool/orm/jbt/util/DummyMetadataDescriptorTest.java b/jbt/src/test/java/org/hibernate/tool/orm/jbt/internal/util/DummyMetadataDescriptorTest.java similarity index 88% rename from jbt/src/test/java/org/hibernate/tool/orm/jbt/util/DummyMetadataDescriptorTest.java rename to jbt/src/test/java/org/hibernate/tool/orm/jbt/internal/util/DummyMetadataDescriptorTest.java index 4abb34b4f1..46be017e0f 100644 --- a/jbt/src/test/java/org/hibernate/tool/orm/jbt/util/DummyMetadataDescriptorTest.java +++ b/jbt/src/test/java/org/hibernate/tool/orm/jbt/internal/util/DummyMetadataDescriptorTest.java @@ -1,4 +1,4 @@ -package org.hibernate.tool.orm.jbt.util; +package org.hibernate.tool.orm.jbt.internal.util; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertNotNull; @@ -9,6 +9,7 @@ import org.hibernate.boot.Metadata; import org.hibernate.tool.api.metadata.MetadataDescriptor; +import org.hibernate.tool.orm.jbt.internal.util.DummyMetadataDescriptor; import org.junit.jupiter.api.Test; public class DummyMetadataDescriptorTest { diff --git a/jbt/src/test/java/org/hibernate/tool/orm/jbt/util/HibernateToolsPersistenceProviderTest.java b/jbt/src/test/java/org/hibernate/tool/orm/jbt/internal/util/HibernateToolsPersistenceProviderTest.java similarity index 94% rename from jbt/src/test/java/org/hibernate/tool/orm/jbt/util/HibernateToolsPersistenceProviderTest.java rename to jbt/src/test/java/org/hibernate/tool/orm/jbt/internal/util/HibernateToolsPersistenceProviderTest.java index 285d6a6c5d..84c52c777e 100644 --- a/jbt/src/test/java/org/hibernate/tool/orm/jbt/util/HibernateToolsPersistenceProviderTest.java +++ b/jbt/src/test/java/org/hibernate/tool/orm/jbt/internal/util/HibernateToolsPersistenceProviderTest.java @@ -1,4 +1,4 @@ -package org.hibernate.tool.orm.jbt.util; +package org.hibernate.tool.orm.jbt.internal.util; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertNotNull; @@ -12,6 +12,7 @@ import java.util.Properties; import org.hibernate.jpa.boot.internal.EntityManagerFactoryBuilderImpl; +import org.hibernate.tool.orm.jbt.internal.util.HibernateToolsPersistenceProvider; import org.junit.jupiter.api.AfterEach; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; diff --git a/jbt/src/test/java/org/hibernate/tool/orm/jbt/util/JpaConfigurationTest.java b/jbt/src/test/java/org/hibernate/tool/orm/jbt/internal/util/JpaConfigurationTest.java similarity index 94% rename from jbt/src/test/java/org/hibernate/tool/orm/jbt/util/JpaConfigurationTest.java rename to jbt/src/test/java/org/hibernate/tool/orm/jbt/internal/util/JpaConfigurationTest.java index cc1e2d81f2..53c22ebf4a 100644 --- a/jbt/src/test/java/org/hibernate/tool/orm/jbt/util/JpaConfigurationTest.java +++ b/jbt/src/test/java/org/hibernate/tool/orm/jbt/internal/util/JpaConfigurationTest.java @@ -1,4 +1,4 @@ -package org.hibernate.tool.orm.jbt.util; +package org.hibernate.tool.orm.jbt.internal.util; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertFalse; @@ -29,8 +29,7 @@ import org.hibernate.mapping.PersistentClass; import org.hibernate.mapping.Table; import org.hibernate.tool.internal.reveng.strategy.DefaultStrategy; -import org.hibernate.tool.orm.jbt.api.PersistentClassWrapper; -import org.hibernate.tool.orm.jbt.wrp.SessionFactoryWrapper; +import org.hibernate.tool.orm.jbt.internal.util.JpaConfiguration; import org.junit.jupiter.api.AfterEach; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; @@ -116,8 +115,7 @@ public void testBuildSessionFactory() { public void testSetProperties() { JpaConfiguration jpaConfiguration = new JpaConfiguration("foobar", null); jpaConfiguration.metadata = (Metadata)createDummy(Metadata.class); - jpaConfiguration.sessionFactory = new SessionFactoryWrapper( - (SessionFactory)createDummy(SessionFactoryImplementor.class)); + jpaConfiguration.sessionFactory = (SessionFactory)createDummy(SessionFactoryImplementor.class); assertNull(jpaConfiguration.getProperty("foo")); Properties properties = new Properties(); properties.put("foo", "bar"); @@ -134,8 +132,7 @@ public void testAddProperties() { properties.put("foo", "bar"); JpaConfiguration jpaConfiguration = new JpaConfiguration("foobar", properties); jpaConfiguration.metadata = (Metadata)createDummy(Metadata.class); - jpaConfiguration.sessionFactory = new SessionFactoryWrapper( - (SessionFactory)createDummy(SessionFactoryImplementor.class)); + jpaConfiguration.sessionFactory = (SessionFactory)createDummy(SessionFactoryImplementor.class); assertEquals("bar", jpaConfiguration.getProperty("foo")); assertNull(jpaConfiguration.getProperty("bar")); properties = new Properties(); @@ -165,7 +162,7 @@ public void testInitialize() { assertNotNull(jpaConfiguration.metadata); assertNotNull(jpaConfiguration.metadata.getEntityBinding(FooBar.class.getName())); assertNotNull(jpaConfiguration.sessionFactory); - assertEquals("bar", jpaConfiguration.sessionFactory.getProperties().get("foo")); + assertEquals("bar", ((SessionFactoryImplementor)jpaConfiguration.sessionFactory).getProperties().get("foo")); assertEquals("bar", jpaConfiguration.getProperties().get("foo")); } @@ -175,8 +172,8 @@ public void testGetClassMappings() { Iterator classMappings = jpaConfiguration.getClassMappings(); assertNotNull(classMappings); assertTrue(classMappings.hasNext()); - PersistentClassWrapper pc = (PersistentClassWrapper)classMappings.next(); - assertSame(pc.getWrappedObject().getMappedClass(), FooBar.class); + PersistentClass pc = classMappings.next(); + assertSame(pc.getMappedClass(), FooBar.class); } @Test diff --git a/jbt/src/test/java/org/hibernate/tool/orm/jbt/util/JpaMappingFileHelperTest.java b/jbt/src/test/java/org/hibernate/tool/orm/jbt/internal/util/JpaMappingFileHelperTest.java similarity index 94% rename from jbt/src/test/java/org/hibernate/tool/orm/jbt/util/JpaMappingFileHelperTest.java rename to jbt/src/test/java/org/hibernate/tool/orm/jbt/internal/util/JpaMappingFileHelperTest.java index 9618f0f767..0f9741a707 100644 --- a/jbt/src/test/java/org/hibernate/tool/orm/jbt/util/JpaMappingFileHelperTest.java +++ b/jbt/src/test/java/org/hibernate/tool/orm/jbt/internal/util/JpaMappingFileHelperTest.java @@ -1,4 +1,4 @@ -package org.hibernate.tool.orm.jbt.util; +package org.hibernate.tool.orm.jbt.internal.util; import static org.junit.jupiter.api.Assertions.assertTrue; @@ -9,6 +9,7 @@ import java.net.URLClassLoader; import java.nio.file.Files; +import org.hibernate.tool.orm.jbt.internal.util.JpaMappingFileHelper; import org.junit.jupiter.api.AfterEach; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; diff --git a/jbt/src/test/java/org/hibernate/tool/orm/jbt/util/MetadataHelperTest.java b/jbt/src/test/java/org/hibernate/tool/orm/jbt/internal/util/MetadataHelperTest.java similarity index 92% rename from jbt/src/test/java/org/hibernate/tool/orm/jbt/util/MetadataHelperTest.java rename to jbt/src/test/java/org/hibernate/tool/orm/jbt/internal/util/MetadataHelperTest.java index b5c8c30f74..79aeb798ae 100644 --- a/jbt/src/test/java/org/hibernate/tool/orm/jbt/util/MetadataHelperTest.java +++ b/jbt/src/test/java/org/hibernate/tool/orm/jbt/internal/util/MetadataHelperTest.java @@ -1,4 +1,4 @@ -package org.hibernate.tool.orm.jbt.util; +package org.hibernate.tool.orm.jbt.internal.util; import static org.junit.jupiter.api.Assertions.assertNotNull; import static org.junit.jupiter.api.Assertions.assertNotSame; @@ -46,7 +46,7 @@ public void testGetMetadata() { configuration.setProperty(AvailableSettings.DIALECT, MockDialect.class.getName()); configuration.setProperty(AvailableSettings.CONNECTION_PROVIDER, MockConnectionProvider.class.getName()); Metadata metadata = MetadataHelper.getMetadata(configuration); - assertNotNull(metadata.getEntityBinding("org.hibernate.tool.orm.jbt.util.MetadataHelperTest$Foo")); + assertNotNull(metadata.getEntityBinding("org.hibernate.tool.orm.jbt.internal.util.MetadataHelperTest$Foo")); } private static class MetadataMethodConfiguration extends Configuration { @@ -88,8 +88,8 @@ private static class Foo { private static final String TEST_HBM_XML_STRING = "" + - "" + + " 'https://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd'>" + + "" + " " + " " + " " + diff --git a/jbt/src/test/java/org/hibernate/tool/orm/jbt/util/MockConnectionProviderTest.java b/jbt/src/test/java/org/hibernate/tool/orm/jbt/internal/util/MockConnectionProviderTest.java similarity index 86% rename from jbt/src/test/java/org/hibernate/tool/orm/jbt/util/MockConnectionProviderTest.java rename to jbt/src/test/java/org/hibernate/tool/orm/jbt/internal/util/MockConnectionProviderTest.java index 9e96bb7dd2..aeaf50d0eb 100644 --- a/jbt/src/test/java/org/hibernate/tool/orm/jbt/util/MockConnectionProviderTest.java +++ b/jbt/src/test/java/org/hibernate/tool/orm/jbt/internal/util/MockConnectionProviderTest.java @@ -1,4 +1,4 @@ -package org.hibernate.tool.orm.jbt.util; +package org.hibernate.tool.orm.jbt.internal.util; import static org.junit.jupiter.api.Assertions.assertNotNull; import static org.junit.jupiter.api.Assertions.assertSame; @@ -6,6 +6,7 @@ import java.sql.Connection; import org.hibernate.engine.jdbc.connections.spi.ConnectionProvider; +import org.hibernate.tool.orm.jbt.internal.util.MockConnectionProvider; import org.junit.jupiter.api.Test; public class MockConnectionProviderTest { diff --git a/jbt/src/test/java/org/hibernate/tool/orm/jbt/util/MockDialectTest.java b/jbt/src/test/java/org/hibernate/tool/orm/jbt/internal/util/MockDialectTest.java similarity index 79% rename from jbt/src/test/java/org/hibernate/tool/orm/jbt/util/MockDialectTest.java rename to jbt/src/test/java/org/hibernate/tool/orm/jbt/internal/util/MockDialectTest.java index aa54ae49b9..c6fe83d175 100644 --- a/jbt/src/test/java/org/hibernate/tool/orm/jbt/util/MockDialectTest.java +++ b/jbt/src/test/java/org/hibernate/tool/orm/jbt/internal/util/MockDialectTest.java @@ -1,8 +1,9 @@ -package org.hibernate.tool.orm.jbt.util; +package org.hibernate.tool.orm.jbt.internal.util; import static org.junit.jupiter.api.Assertions.assertEquals; import org.hibernate.dialect.DatabaseVersion; +import org.hibernate.tool.orm.jbt.internal.util.MockDialect; import org.junit.jupiter.api.Test; public class MockDialectTest { diff --git a/jbt/src/test/java/org/hibernate/tool/orm/jbt/util/NativeConfigurationTest.java b/jbt/src/test/java/org/hibernate/tool/orm/jbt/internal/util/NativeConfigurationTest.java similarity index 93% rename from jbt/src/test/java/org/hibernate/tool/orm/jbt/util/NativeConfigurationTest.java rename to jbt/src/test/java/org/hibernate/tool/orm/jbt/internal/util/NativeConfigurationTest.java index 4bca1a105e..12510de074 100644 --- a/jbt/src/test/java/org/hibernate/tool/orm/jbt/util/NativeConfigurationTest.java +++ b/jbt/src/test/java/org/hibernate/tool/orm/jbt/internal/util/NativeConfigurationTest.java @@ -1,4 +1,4 @@ -package org.hibernate.tool.orm.jbt.util; +package org.hibernate.tool.orm.jbt.internal.util; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertFalse; @@ -24,7 +24,6 @@ import org.hibernate.mapping.PersistentClass; import org.hibernate.mapping.Table; import org.hibernate.tool.internal.reveng.strategy.DefaultStrategy; -import org.hibernate.tool.orm.jbt.wrp.SessionFactoryWrapper; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.w3c.dom.Document; @@ -35,7 +34,7 @@ public class NativeConfigurationTest { private static final String TEST_HBM_XML_STRING = - "" + + "" + " " + " " + " " + @@ -99,7 +98,7 @@ public void testConfigureDocument() throws Exception { fileWriter.close(); String fooClassName = - "org.hibernate.tool.orm.jbt.util.NativeConfigurationTest$Foo"; + "org.hibernate.tool.orm.jbt.internal.util.NativeConfigurationTest$Foo"; Metadata metadata = MetadataHelper.getMetadata(nativeConfiguration); assertNull(metadata.getEntityBinding(fooClassName)); nativeConfiguration.configure(document); @@ -118,10 +117,10 @@ public void testBuildMappings() throws Exception { @Test public void testGetClassMappings() throws Exception { - String fooHbmXmlFilePath = "org/hibernate/tool/orm/jbt/util"; + String fooHbmXmlFilePath = "org/hibernate/tool/orm/jbt/internal/util"; String fooHbmXmlFileName = "NativeConfigurationTest$Foo.hbm.xml"; String fooClassName = - "org.hibernate.tool.orm.jbt.util.NativeConfigurationTest$Foo"; + "org.hibernate.tool.orm.jbt.internal.util.NativeConfigurationTest$Foo"; URL url = getClass().getProtectionDomain().getCodeSource().getLocation(); File hbmXmlFileDir = new File(new File(url.toURI()),fooHbmXmlFilePath); hbmXmlFileDir.deleteOnExit(); @@ -203,10 +202,10 @@ public void testGetEntityResolver() throws Exception { @Test public void testGetClassMapping() throws Exception { - String fooHbmXmlFilePath = "org/hibernate/tool/orm/jbt/util"; + String fooHbmXmlFilePath = "org/hibernate/tool/orm/jbt/internal/util"; String fooHbmXmlFileName = "NativeConfigurationTest$Foo.hbm.xml"; String fooClassName = - "org.hibernate.tool.orm.jbt.util.NativeConfigurationTest$Foo"; + "org.hibernate.tool.orm.jbt.internal.util.NativeConfigurationTest$Foo"; URL url = getClass().getProtectionDomain().getCodeSource().getLocation(); File hbmXmlFileDir = new File(new File(url.toURI()),fooHbmXmlFilePath); hbmXmlFileDir.deleteOnExit(); @@ -226,7 +225,7 @@ public void testGetClassMapping() throws Exception { @Test public void testGetTableMappings() throws Exception { - String fooHbmXmlFilePath = "org/hibernate/tool/orm/jbt/util"; + String fooHbmXmlFilePath = "org/hibernate/tool/orm/jbt/internal/util"; String fooHbmXmlFileName = "NativeConfigurationTest$Foo.hbm.xml"; URL url = getClass().getProtectionDomain().getCodeSource().getLocation(); File hbmXmlFileDir = new File(new File(url.toURI()),fooHbmXmlFilePath); @@ -253,7 +252,7 @@ public void testGetTableMappings() throws Exception { public void testBuildSessionFactory() throws Exception { SessionFactory sessionFactory = nativeConfiguration.buildSessionFactory(); assertNotNull(sessionFactory); - assertTrue(sessionFactory instanceof SessionFactoryWrapper); + assertTrue(sessionFactory instanceof SessionFactory); } } diff --git a/jbt/src/test/java/org/hibernate/tool/orm/jbt/util/RevengConfigurationTest.java b/jbt/src/test/java/org/hibernate/tool/orm/jbt/internal/util/RevengConfigurationTest.java similarity index 99% rename from jbt/src/test/java/org/hibernate/tool/orm/jbt/util/RevengConfigurationTest.java rename to jbt/src/test/java/org/hibernate/tool/orm/jbt/internal/util/RevengConfigurationTest.java index 788e7cfb55..31445ca116 100644 --- a/jbt/src/test/java/org/hibernate/tool/orm/jbt/util/RevengConfigurationTest.java +++ b/jbt/src/test/java/org/hibernate/tool/orm/jbt/internal/util/RevengConfigurationTest.java @@ -1,4 +1,4 @@ -package org.hibernate.tool.orm.jbt.util; +package org.hibernate.tool.orm.jbt.internal.util; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertFalse; @@ -29,6 +29,7 @@ import org.hibernate.tool.api.metadata.MetadataConstants; import org.hibernate.tool.api.reveng.RevengStrategy; import org.hibernate.tool.internal.reveng.strategy.DefaultStrategy; +import org.hibernate.tool.orm.jbt.internal.util.RevengConfiguration; import org.junit.jupiter.api.BeforeAll; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; diff --git a/jbt/src/test/java/org/hibernate/tool/orm/jbt/util/SpecialRootClassTest.java b/jbt/src/test/java/org/hibernate/tool/orm/jbt/internal/util/SpecialRootClassTest.java similarity index 95% rename from jbt/src/test/java/org/hibernate/tool/orm/jbt/util/SpecialRootClassTest.java rename to jbt/src/test/java/org/hibernate/tool/orm/jbt/internal/util/SpecialRootClassTest.java index 1f71a7a068..61d6782069 100644 --- a/jbt/src/test/java/org/hibernate/tool/orm/jbt/util/SpecialRootClassTest.java +++ b/jbt/src/test/java/org/hibernate/tool/orm/jbt/internal/util/SpecialRootClassTest.java @@ -1,4 +1,4 @@ -package org.hibernate.tool.orm.jbt.util; +package org.hibernate.tool.orm.jbt.internal.util; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertFalse; @@ -15,6 +15,8 @@ import org.hibernate.mapping.Property; import org.hibernate.mapping.RootClass; import org.hibernate.mapping.Set; +import org.hibernate.tool.orm.jbt.internal.util.DummyMetadataBuildingContext; +import org.hibernate.tool.orm.jbt.internal.util.SpecialRootClass; import org.junit.jupiter.api.Test; public class SpecialRootClassTest { diff --git a/jbt/src/test/java/org/hibernate/tool/orm/jbt/internal/util/TypeRegistryTest.java b/jbt/src/test/java/org/hibernate/tool/orm/jbt/internal/util/TypeRegistryTest.java index b24928cfcf..9bf88088bc 100644 --- a/jbt/src/test/java/org/hibernate/tool/orm/jbt/internal/util/TypeRegistryTest.java +++ b/jbt/src/test/java/org/hibernate/tool/orm/jbt/internal/util/TypeRegistryTest.java @@ -15,7 +15,7 @@ import java.util.Map; import java.util.TimeZone; -import org.hibernate.tool.orm.jbt.api.TypeWrapper; +import org.hibernate.tool.orm.jbt.api.wrp.TypeWrapper; import org.junit.jupiter.api.BeforeAll; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; diff --git a/jbt/src/test/java/org/hibernate/tool/orm/jbt/wrp/CollectionPersisterWrapperFactoryTest.java b/jbt/src/test/java/org/hibernate/tool/orm/jbt/wrp/CollectionPersisterWrapperFactoryTest.java deleted file mode 100644 index 07534d5b5e..0000000000 --- a/jbt/src/test/java/org/hibernate/tool/orm/jbt/wrp/CollectionPersisterWrapperFactoryTest.java +++ /dev/null @@ -1,88 +0,0 @@ -package org.hibernate.tool.orm.jbt.wrp; - -import static org.junit.jupiter.api.Assertions.assertNotNull; -import static org.junit.jupiter.api.Assertions.assertTrue; - -import java.io.File; -import java.io.FileWriter; -import java.nio.file.Files; -import java.util.HashSet; -import java.util.Set; - -import org.hibernate.cfg.AvailableSettings; -import org.hibernate.cfg.Configuration; -import org.hibernate.persister.collection.CollectionPersister; -import org.hibernate.tool.orm.jbt.util.MockConnectionProvider; -import org.hibernate.tool.orm.jbt.util.MockDialect; -import org.hibernate.tool.orm.jbt.wrp.TypeWrapperFactory.TypeWrapper; -import org.hibernate.type.Type; -import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.io.TempDir; - -public class CollectionPersisterWrapperFactoryTest { - - private static final String TEST_CFG_XML_STRING = - "" + - " " + - " " + MockDialect.class.getName() + "" + - " " + MockConnectionProvider.class.getName() + "" + - " " + - ""; - - private static final String TEST_HBM_XML_STRING = - "" + - " " + - " " + - " " + - " " + - " " + - " " + - " " + - ""; - - public static class Foo { - public String id; - public Set bars = new HashSet(); - } - - @TempDir - public File tempDir; - - private CollectionPersister collectionPersisterWrapper = null; - private CollectionPersister wrappedCollectionPersister = null; - - private SessionFactoryWrapper sessionFactory = null; - - @BeforeEach - public void beforeEach() throws Exception { - tempDir = Files.createTempDirectory("temp").toFile(); - File cfgXmlFile = new File(tempDir, "hibernate.cfg.xml"); - FileWriter fileWriter = new FileWriter(cfgXmlFile); - fileWriter.write(TEST_CFG_XML_STRING); - fileWriter.close(); - File hbmXmlFile = new File(tempDir, "Foo.hbm.xml"); - fileWriter = new FileWriter(hbmXmlFile); - fileWriter.write(TEST_HBM_XML_STRING); - fileWriter.close(); - Configuration configuration = (Configuration)WrapperFactory.createNativeConfigurationWrapper(); - configuration.addFile(hbmXmlFile); - configuration.configure(cfgXmlFile); - sessionFactory = (SessionFactoryWrapper)configuration.buildSessionFactory(); - collectionPersisterWrapper = sessionFactory.getCollectionMetadata(Foo.class.getName() + ".bars"); - wrappedCollectionPersister = (CollectionPersister)((Wrapper)collectionPersisterWrapper).getWrappedObject(); - } - - @Test - public void testConstruction() { - assertNotNull(collectionPersisterWrapper); - assertNotNull(wrappedCollectionPersister); - } - - @Test - public void testGetElementType() { - Type elementType = collectionPersisterWrapper.getElementType(); - assertTrue(elementType instanceof TypeWrapper); - } - -} diff --git a/jbt/src/test/java/org/hibernate/tool/orm/jbt/wrp/ConfigurationWrapperFactoryTest.java b/jbt/src/test/java/org/hibernate/tool/orm/jbt/wrp/ConfigurationWrapperFactoryTest.java deleted file mode 100644 index ed085f6064..0000000000 --- a/jbt/src/test/java/org/hibernate/tool/orm/jbt/wrp/ConfigurationWrapperFactoryTest.java +++ /dev/null @@ -1,885 +0,0 @@ -package org.hibernate.tool.orm.jbt.wrp; - -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertFalse; -import static org.junit.jupiter.api.Assertions.assertNotNull; -import static org.junit.jupiter.api.Assertions.assertNotSame; -import static org.junit.jupiter.api.Assertions.assertNull; -import static org.junit.jupiter.api.Assertions.assertSame; -import static org.junit.jupiter.api.Assertions.assertTrue; -import static org.junit.jupiter.api.Assertions.fail; - -import java.io.File; -import java.io.FileWriter; -import java.io.PrintWriter; -import java.lang.reflect.Field; -import java.net.URL; -import java.net.URLClassLoader; -import java.nio.file.Files; -import java.sql.Connection; -import java.sql.DriverManager; -import java.sql.Statement; -import java.util.Iterator; -import java.util.Properties; - -import javax.xml.parsers.DocumentBuilderFactory; - -import org.h2.Driver; -import org.hibernate.SessionFactory; -import org.hibernate.boot.Metadata; -import org.hibernate.boot.MetadataSources; -import org.hibernate.boot.jaxb.spi.Binding; -import org.hibernate.cfg.AvailableSettings; -import org.hibernate.cfg.Configuration; -import org.hibernate.cfg.DefaultNamingStrategy; -import org.hibernate.cfg.NamingStrategy; -import org.hibernate.mapping.PersistentClass; -import org.hibernate.mapping.Table; -import org.hibernate.tool.api.reveng.RevengStrategy; -import org.hibernate.tool.internal.reveng.strategy.DefaultStrategy; -import org.hibernate.tool.orm.jbt.util.JpaConfiguration; -import org.hibernate.tool.orm.jbt.util.MetadataHelper; -import org.hibernate.tool.orm.jbt.util.MockConnectionProvider; -import org.hibernate.tool.orm.jbt.util.MockDialect; -import org.hibernate.tool.orm.jbt.util.NativeConfiguration; -import org.hibernate.tool.orm.jbt.util.RevengConfiguration; -import org.hibernate.tool.orm.jbt.wrp.ConfigurationWrapperFactory.ConfigurationWrapper; -import org.hibernate.tool.orm.jbt.wrp.ConfigurationWrapperFactory.JpaConfigurationWrapperImpl; -import org.hibernate.tool.orm.jbt.wrp.ConfigurationWrapperFactory.NativeConfigurationWrapperImpl; -import org.hibernate.tool.orm.jbt.wrp.ConfigurationWrapperFactory.RevengConfigurationWrapperImpl; -import org.junit.jupiter.api.AfterEach; -import org.junit.jupiter.api.BeforeAll; -import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.io.TempDir; -import org.w3c.dom.Document; -import org.w3c.dom.Element; -import org.xml.sax.EntityResolver; -import org.xml.sax.helpers.DefaultHandler; - -import jakarta.persistence.Entity; -import jakarta.persistence.Id; - -public class ConfigurationWrapperFactoryTest { - - private static final String TEST_HBM_XML_STRING = - "" + - " " + - " " + - " " + - ""; - - private static final String TEST_CFG_XML_STRING = - "" + - " " + - " " + - " " + - ""; - - private static final String PERSISTENCE_XML = - "" + - " " + - " "+ FooBar.class.getName() +"" + - " " + - " " + - " " + - " " + - " " + - " " + - ""; - - static class Foo { - public String id; - } - - @Entity public class FooBar { - @Id public int id; - } - - @BeforeAll - public static void beforeAll() throws Exception { - DriverManager.registerDriver(new Driver()); - } - - private ClassLoader original = null; - - @TempDir - public File tempRoot; - - private ConfigurationWrapper nativeConfigurationWrapper = null; - private Configuration wrappedNativeConfiguration = null; - private ConfigurationWrapper revengConfigurationWrapper = null; - private Configuration wrappedRevengConfiguration = null; - private ConfigurationWrapper jpaConfigurationWrapper = null; - private Configuration wrappedJpaConfiguration = null; - - @BeforeEach - public void beforeEach() throws Exception { - tempRoot = Files.createTempDirectory("temp").toFile(); - createPersistenceXml(); - swapClassLoader(); - initializeFacadesAndTargets(); - } - - @AfterEach - public void afterEach() { - Thread.currentThread().setContextClassLoader(original); - } - - @Test - public void testConstruction() { - assertNotNull(nativeConfigurationWrapper); - assertNotNull(wrappedNativeConfiguration); - assertNotNull(revengConfigurationWrapper); - assertNotNull(wrappedRevengConfiguration); - assertNotNull(jpaConfigurationWrapper); - assertNotNull(wrappedJpaConfiguration); - } - - @Test - public void testGetProperty() { - assertNull(nativeConfigurationWrapper.getProperty("foo")); - wrappedNativeConfiguration.setProperty("foo", "bar"); - assertEquals("bar", nativeConfigurationWrapper.getProperty("foo")); - assertNull(revengConfigurationWrapper.getProperty("foo")); - wrappedRevengConfiguration.setProperty("foo", "bar"); - assertEquals("bar", revengConfigurationWrapper.getProperty("foo")); - assertNull(jpaConfigurationWrapper.getProperty("foo")); - wrappedJpaConfiguration.setProperty("foo", "bar"); - assertEquals("bar", jpaConfigurationWrapper.getProperty("foo")); - } - - @Test - public void testAddFile() throws Exception { - File testFile = File.createTempFile("test", "hbm.xml"); - PrintWriter printWriter = new PrintWriter(testFile); - printWriter.write(TEST_HBM_XML_STRING); - printWriter.close(); - testFile.deleteOnExit(); - // For native configuration - MetadataSources metadataSources = MetadataHelper.getMetadataSources(wrappedNativeConfiguration); - assertTrue(metadataSources.getXmlBindings().isEmpty()); - assertSame( - wrappedNativeConfiguration, - nativeConfigurationWrapper.addFile(testFile)); - assertFalse(metadataSources.getXmlBindings().isEmpty()); - Binding binding = metadataSources.getXmlBindings().iterator().next(); - assertEquals(testFile.getAbsolutePath(), binding.getOrigin().getName()); - // For reveng configuration - try { - revengConfigurationWrapper.addFile(testFile); - fail(); - } catch (RuntimeException e) { - assertEquals( - e.getMessage(), - "Method 'addFile' should not be called on instances of " + RevengConfigurationWrapperImpl.class.getName()); - } - // For jpa configuration - try { - jpaConfigurationWrapper.addFile(testFile); - fail(); - } catch (RuntimeException e) { - assertEquals( - e.getMessage(), - "Method 'addFile' should not be called on instances of " + JpaConfigurationWrapperImpl.class.getName()); - } - } - - @Test - public void testSetProperty() { - // For native configuration - assertNull(wrappedNativeConfiguration.getProperty("foo")); - nativeConfigurationWrapper.setProperty("foo", "bar"); - assertEquals("bar", wrappedNativeConfiguration.getProperty("foo")); - // For reveng configuration - assertNull(wrappedRevengConfiguration.getProperty("foo")); - revengConfigurationWrapper.setProperty("foo", "bar"); - assertEquals("bar", wrappedRevengConfiguration.getProperty("foo")); - // For jpa configuration - assertNull(wrappedJpaConfiguration.getProperty("foo")); - jpaConfigurationWrapper.setProperty("foo", "bar"); - assertEquals("bar", wrappedJpaConfiguration.getProperty("foo")); - } - - @Test - public void testSetProperties() { - Properties testProperties = new Properties(); - // For native configuration - assertNotSame(testProperties, wrappedNativeConfiguration.getProperties()); - assertSame( - wrappedNativeConfiguration, - nativeConfigurationWrapper.setProperties(testProperties)); - assertSame(testProperties, wrappedNativeConfiguration.getProperties()); - // For reveng configuration - assertNotSame(testProperties, wrappedRevengConfiguration.getProperties()); - assertSame( - wrappedRevengConfiguration, - revengConfigurationWrapper.setProperties(testProperties)); - assertSame(testProperties, wrappedRevengConfiguration.getProperties()); - // For jpa configuration - assertNotSame(testProperties, wrappedJpaConfiguration.getProperties()); - assertSame( - wrappedJpaConfiguration, - jpaConfigurationWrapper.setProperties(testProperties)); - assertSame(testProperties, wrappedJpaConfiguration.getProperties()); - } - - @Test - public void testSetEntityResolver() throws Exception { - EntityResolver testResolver = new DefaultHandler(); - // For native configuration - Field entityResolverField = NativeConfiguration.class.getDeclaredField("entityResolver"); - entityResolverField.setAccessible(true); - assertNull(entityResolverField.get(wrappedNativeConfiguration)); - nativeConfigurationWrapper.setEntityResolver(testResolver); - assertNotNull(entityResolverField.get(wrappedNativeConfiguration)); - assertSame(testResolver, entityResolverField.get(wrappedNativeConfiguration)); - // For reveng configuration - try { - revengConfigurationWrapper.setEntityResolver(testResolver); - fail(); - } catch (RuntimeException e) { - assertEquals( - e.getMessage(), - "Method 'setEntityResolver' should not be called on instances of " + RevengConfigurationWrapperImpl.class.getName()); - } - // For jpa configuration - try { - jpaConfigurationWrapper.setEntityResolver(testResolver); - fail(); - } catch (RuntimeException e) { - assertEquals( - e.getMessage(), - "Method 'setEntityResolver' should not be called on instances of " + JpaConfigurationWrapperImpl.class.getName()); - } - } - - @Test - public void testSetNamingStrategy() throws Exception { - NamingStrategy namingStrategy = new DefaultNamingStrategy(); - // For native configuration - Field namingStrategyField = NativeConfiguration.class.getDeclaredField("namingStrategy"); - namingStrategyField.setAccessible(true); - assertNull(namingStrategyField.get(wrappedNativeConfiguration)); - nativeConfigurationWrapper.setNamingStrategy(namingStrategy); - assertNotNull(namingStrategyField.get(wrappedNativeConfiguration)); - assertSame(namingStrategyField.get(wrappedNativeConfiguration), namingStrategy); - // For reveng configuration - try { - revengConfigurationWrapper.setNamingStrategy(namingStrategy); - fail(); - } catch (RuntimeException e) { - assertEquals( - e.getMessage(), - "Method 'setNamingStrategy' should not be called on instances of " + RevengConfigurationWrapperImpl.class.getName()); - } - // For jpa configuration - try { - jpaConfigurationWrapper.setNamingStrategy(namingStrategy); - fail(); - } catch (RuntimeException e) { - assertEquals( - e.getMessage(), - "Method 'setNamingStrategy' should not be called on instances of " + JpaConfigurationWrapperImpl.class.getName()); - } - } - - @Test - public void testGetProperties() { - Properties testProperties = new Properties(); - // For native configuration - assertNotSame(testProperties, nativeConfigurationWrapper.getProperties()); - wrappedNativeConfiguration.setProperties(testProperties); - assertSame(testProperties, nativeConfigurationWrapper.getProperties()); - // For reveng configuration - assertNotSame(testProperties, revengConfigurationWrapper.getProperties()); - wrappedRevengConfiguration.setProperties(testProperties); - assertSame(testProperties, revengConfigurationWrapper.getProperties()); - // For jpa configuration - assertNotSame(testProperties, jpaConfigurationWrapper.getProperties()); - wrappedJpaConfiguration.setProperties(testProperties); - assertSame(testProperties, jpaConfigurationWrapper.getProperties()); - } - - @Test - public void testAddProperties() { - Properties testProperties = new Properties(); - testProperties.put("foo", "bar"); - // For native configuration - assertNull(wrappedNativeConfiguration.getProperty("foo")); - nativeConfigurationWrapper.addProperties(testProperties); - assertEquals("bar", wrappedNativeConfiguration.getProperty("foo")); - // For reveng configuration - assertNull(wrappedRevengConfiguration.getProperty("foo")); - revengConfigurationWrapper.addProperties(testProperties); - assertEquals("bar", wrappedRevengConfiguration.getProperty("foo")); - // For jpa configuration - assertNull(wrappedJpaConfiguration.getProperty("foo")); - jpaConfigurationWrapper.addProperties(testProperties); - assertEquals("bar", wrappedJpaConfiguration.getProperty("foo")); - } - - @Test - public void testConfigureDocument() throws Exception { - Document document = DocumentBuilderFactory - .newInstance() - .newDocumentBuilder() - .newDocument(); - Element hibernateConfiguration = document.createElement("hibernate-configuration"); - document.appendChild(hibernateConfiguration); - Element sessionFactory = document.createElement("session-factory"); - sessionFactory.setAttribute("name", "bar"); - hibernateConfiguration.appendChild(sessionFactory); - Element mapping = document.createElement("mapping"); - mapping.setAttribute("resource", "Foo.hbm.xml"); - sessionFactory.appendChild(mapping); - - URL url = getClass().getProtectionDomain().getCodeSource().getLocation(); - File hbmXmlFile = new File(new File(url.toURI()), "Foo.hbm.xml"); - hbmXmlFile.deleteOnExit(); - FileWriter fileWriter = new FileWriter(hbmXmlFile); - fileWriter.write(TEST_HBM_XML_STRING); - fileWriter.close(); - - // For native configuration - String fooClassName = - "org.hibernate.tool.orm.jbt.wrp.ConfigurationWrapperFactoryTest$Foo"; - Metadata metadata = MetadataHelper.getMetadata(wrappedNativeConfiguration); - assertNull(metadata.getEntityBinding(fooClassName)); - nativeConfigurationWrapper.configure(document); - metadata = MetadataHelper.getMetadata(wrappedNativeConfiguration); - assertNotNull(metadata.getEntityBinding(fooClassName)); - // For reveng configuration - try { - revengConfigurationWrapper.configure(document); - fail(); - } catch (RuntimeException e) { - assertEquals( - e.getMessage(), - "Method 'configure' should not be called on instances of " + RevengConfigurationWrapperImpl.class.getName()); - } - // For jpa configuration - try { - jpaConfigurationWrapper.configure(document); - fail(); - } catch (RuntimeException e) { - assertEquals( - e.getMessage(), - "Method 'configure' should not be called on instances of " + JpaConfigurationWrapperImpl.class.getName()); - } - } - - @Test - public void testConfigureFile() throws Exception { - // For native configuration - URL url = getClass().getProtectionDomain().getCodeSource().getLocation(); - File cfgXmlFile = new File(new File(url.toURI()), "foobarfile.cfg.xml"); - FileWriter fileWriter = new FileWriter(cfgXmlFile); - fileWriter.write(TEST_CFG_XML_STRING); - fileWriter.close(); - File hbmXmlFile = new File(new File(url.toURI()), "Foo.hbm.xml"); - fileWriter = new FileWriter(hbmXmlFile); - fileWriter.write(TEST_HBM_XML_STRING); - fileWriter.close(); - - String fooClassName = - "org.hibernate.tool.orm.jbt.wrp.ConfigurationWrapperFactoryTest$Foo"; - Metadata metadata = MetadataHelper.getMetadata(wrappedNativeConfiguration); - assertNull(metadata.getEntityBinding(fooClassName)); - Field metadataField = NativeConfiguration.class.getDeclaredField("metadata"); - metadataField.setAccessible(true); - metadataField.set(wrappedNativeConfiguration, null); - nativeConfigurationWrapper.configure(cfgXmlFile); - metadata = MetadataHelper.getMetadata(wrappedNativeConfiguration); - assertNotNull(metadata.getEntityBinding(fooClassName)); - assertTrue(cfgXmlFile.delete()); - assertTrue(hbmXmlFile.delete()); - - // For reveng configuration - try { - revengConfigurationWrapper.configure(cfgXmlFile); - fail(); - } catch (RuntimeException e) { - assertEquals( - e.getMessage(), - "Method 'configure' should not be called on instances of " + RevengConfigurationWrapperImpl.class.getName()); - } - // For jpa configuration - try { - jpaConfigurationWrapper.configure(cfgXmlFile); - fail(); - } catch (RuntimeException e) { - assertEquals( - e.getMessage(), - "Method 'configure' should not be called on instances of " + JpaConfigurationWrapperImpl.class.getName()); - } - } - - @Test - public void testConfigureDefault() throws Exception { - URL url = getClass().getProtectionDomain().getCodeSource().getLocation(); - File cfgXmlFile = new File(new File(url.toURI()), "hibernate.cfg.xml"); - cfgXmlFile.deleteOnExit(); - FileWriter fileWriter = new FileWriter(cfgXmlFile); - fileWriter.write(TEST_CFG_XML_STRING); - fileWriter.close(); - File hbmXmlFile = new File(new File(url.toURI()), "Foo.hbm.xml"); - hbmXmlFile.deleteOnExit(); - fileWriter = new FileWriter(hbmXmlFile); - fileWriter.write(TEST_HBM_XML_STRING); - fileWriter.close(); - - // For native configuration - String fooClassName = - "org.hibernate.tool.orm.jbt.wrp.ConfigurationWrapperFactoryTest$Foo"; - Metadata metadata = MetadataHelper.getMetadata(wrappedNativeConfiguration); - assertNull(metadata.getEntityBinding(fooClassName)); - Field metadataField = NativeConfiguration.class.getDeclaredField("metadata"); - metadataField.setAccessible(true); - metadataField.set(wrappedNativeConfiguration, null); - nativeConfigurationWrapper.configure(); - metadata = MetadataHelper.getMetadata(wrappedNativeConfiguration); - assertNotNull(metadata.getEntityBinding(fooClassName)); - // For reveng configuration - try { - revengConfigurationWrapper.configure(); - fail(); - } catch (RuntimeException e) { - e.printStackTrace(); - assertEquals( - e.getMessage(), - "Method 'configure' should not be called on instances of " + RevengConfigurationWrapperImpl.class.getName()); - } - // For jpa configuration - try { - jpaConfigurationWrapper.configure(); - fail(); - } catch (RuntimeException e) { - assertEquals( - e.getMessage(), - "Method 'configure' should not be called on instances of " + JpaConfigurationWrapperImpl.class.getName()); - } - } - - @Test - public void testAddClass() throws Exception { - String fooHbmXmlFilePath = "org/hibernate/tool/orm/jbt/wrp"; - String fooHbmXmlFileName = "ConfigurationWrapperFactoryTest$Foo.hbm.xml"; - String fooClassName = - "org.hibernate.tool.orm.jbt.wrp.ConfigurationWrapperFactoryTest$Foo"; - URL url = getClass().getProtectionDomain().getCodeSource().getLocation(); - File hbmXmlFileDir = new File(new File(url.toURI()),fooHbmXmlFilePath); - hbmXmlFileDir.deleteOnExit(); - hbmXmlFileDir.mkdirs(); - File hbmXmlFile = new File(hbmXmlFileDir, fooHbmXmlFileName); - hbmXmlFile.deleteOnExit(); - FileWriter fileWriter = new FileWriter(hbmXmlFile); - fileWriter.write(TEST_HBM_XML_STRING); - fileWriter.close(); - - // For native configuration - Metadata metadata = MetadataHelper.getMetadata(wrappedNativeConfiguration); - assertNull(metadata.getEntityBinding(fooClassName)); - Field metadataField = NativeConfiguration.class.getDeclaredField("metadata"); - metadataField.setAccessible(true); - metadataField.set(wrappedNativeConfiguration, null); - nativeConfigurationWrapper.addClass(Foo.class); - metadata = MetadataHelper.getMetadata(wrappedNativeConfiguration); - assertNotNull(metadata.getEntityBinding(fooClassName)); - // For reveng configuration - try { - revengConfigurationWrapper.addClass(Foo.class); - fail(); - } catch (RuntimeException e) { - assertEquals( - e.getMessage(), - "Method 'addClass' should not be called on instances of " + RevengConfigurationWrapperImpl.class.getName()); - } - // For jpa configuration - try { - jpaConfigurationWrapper.addClass(Foo.class); - fail(); - } catch (RuntimeException e) { - assertEquals( - e.getMessage(), - "Method 'addClass' should not be called on instances of " + JpaConfigurationWrapperImpl.class.getName()); - } - } - - @Test - public void testBuildMappings() throws Exception { - // For native configuration - Field metadataField = NativeConfiguration.class.getDeclaredField("metadata"); - metadataField.setAccessible(true); - assertNull(metadataField.get(wrappedNativeConfiguration)); - nativeConfigurationWrapper.buildMappings(); - assertNotNull(metadataField.get(wrappedNativeConfiguration)); - // For reveng configuration - metadataField = RevengConfiguration.class.getDeclaredField("metadata"); - metadataField.setAccessible(true); - wrappedRevengConfiguration.setProperty("hibernate.connection.url", "jdbc:h2:mem:test"); - wrappedRevengConfiguration.setProperty("hibernate.default_schema", "PUBLIC"); - assertNull(metadataField.get(wrappedRevengConfiguration)); - revengConfigurationWrapper.buildMappings(); - assertNotNull(metadataField.get(wrappedRevengConfiguration)); - // For jpa configuration - metadataField = JpaConfiguration.class.getDeclaredField("metadata"); - metadataField.setAccessible(true); - assertNull(metadataField.get(wrappedJpaConfiguration)); - jpaConfigurationWrapper.buildMappings(); - assertNotNull(metadataField.get(wrappedJpaConfiguration)); - } - - @Test - public void testBuildSessionFactory() throws Throwable { - // For native configuration - SessionFactory sessionFactory = - nativeConfigurationWrapper.buildSessionFactory(); - assertNotNull(sessionFactory); - assertTrue(sessionFactory instanceof SessionFactoryWrapper); - sessionFactory = null; - assertNull(sessionFactory); - // For reveng configuration - try { - revengConfigurationWrapper.buildSessionFactory(); - fail(); - } catch (RuntimeException e) { - assertEquals( - e.getMessage(), - "Method 'buildSessionFactory' should not be called on instances of " + RevengConfigurationWrapperImpl.class.getName()); - } - // For jpa configuration - sessionFactory = jpaConfigurationWrapper.buildSessionFactory(); - assertNotNull(sessionFactory); - assertTrue(sessionFactory instanceof SessionFactoryWrapper); - } - - @Test - public void testGetClassMappings() throws Exception { - // For native configuration - String fooHbmXmlFilePath = "org/hibernate/tool/orm/jbt/wrp"; - String fooHbmXmlFileName = "ConfigurationWrapperFactoryTest$Foo.hbm.xml"; - String fooClassName = - "org.hibernate.tool.orm.jbt.wrp.ConfigurationWrapperFactoryTest$Foo"; - URL url = getClass().getProtectionDomain().getCodeSource().getLocation(); - File hbmXmlFileDir = new File(new File(url.toURI()),fooHbmXmlFilePath); - hbmXmlFileDir.deleteOnExit(); - hbmXmlFileDir.mkdirs(); - File hbmXmlFile = new File(hbmXmlFileDir, fooHbmXmlFileName); - hbmXmlFile.deleteOnExit(); - FileWriter fileWriter = new FileWriter(hbmXmlFile); - fileWriter.write(TEST_HBM_XML_STRING); - fileWriter.close(); - wrappedNativeConfiguration.addClass(Foo.class); - Iterator classMappings = nativeConfigurationWrapper.getClassMappings(); - assertTrue(classMappings.hasNext()); - PersistentClass fooClassFacade = classMappings.next(); - assertSame(fooClassFacade.getEntityName(), fooClassName); - classMappings = null; - assertNull(classMappings); - // For reveng configuration - Connection connection = DriverManager.getConnection("jdbc:h2:mem:test"); - Statement statement = connection.createStatement(); - statement.execute("CREATE TABLE FOO(id int primary key, bar varchar(255))"); - wrappedRevengConfiguration.setProperty("hibernate.connection.url", "jdbc:h2:mem:test"); - wrappedRevengConfiguration.setProperty("hibernate.default_schema", "PUBLIC"); - classMappings = revengConfigurationWrapper.getClassMappings(); - assertNotNull(classMappings); - assertFalse(classMappings.hasNext()); - ((RevengConfiguration)wrappedRevengConfiguration).readFromJDBC(); - classMappings = revengConfigurationWrapper.getClassMappings(); - assertNotNull(classMappings); - assertTrue(classMappings.hasNext()); - fooClassFacade = classMappings.next(); - assertEquals(fooClassFacade.getEntityName(), "Foo"); - statement.execute("DROP TABLE FOO"); - statement.close(); - connection.close(); - classMappings = null; - assertNull(classMappings); - // For jpa configuration - classMappings = jpaConfigurationWrapper.getClassMappings(); - assertNotNull(classMappings); - assertTrue(classMappings.hasNext()); - fooClassFacade = classMappings.next(); - assertEquals(fooClassFacade.getEntityName(), FooBar.class.getName()); - } - - @Test - public void testSetPreferBasicCompositeIds() { - // For native configuration - try { - nativeConfigurationWrapper.setPreferBasicCompositeIds(false); - fail(); - } catch (RuntimeException e) { - assertEquals( - e.getMessage(), - "Method 'setPreferBasicCompositeIds' should not be called on instances of " + NativeConfigurationWrapperImpl.class.getName()); - } - // For reveng configuration - // the default is true - assertTrue(((RevengConfiguration)wrappedRevengConfiguration).preferBasicCompositeIds()); - revengConfigurationWrapper.setPreferBasicCompositeIds(false); - assertFalse(((RevengConfiguration)wrappedRevengConfiguration).preferBasicCompositeIds()); - // For jpa configuration - try { - jpaConfigurationWrapper.setPreferBasicCompositeIds(false); - fail(); - } catch (RuntimeException e) { - assertEquals( - e.getMessage(), - "Method 'setPreferBasicCompositeIds' should not be called on instances of " + JpaConfigurationWrapperImpl.class.getName()); - } - } - - @Test - public void testSetReverseEngineeringStrategy() { - RevengStrategy reverseEngineeringStrategy = new DefaultStrategy(); - // For native configuration - try { - nativeConfigurationWrapper.setReverseEngineeringStrategy(reverseEngineeringStrategy); - fail(); - } catch (RuntimeException e) { - assertEquals( - e.getMessage(), - "Method 'setReverseEngineeringStrategy' should not be called on instances of " + NativeConfigurationWrapperImpl.class.getName()); - } - // For reveng configuration - assertNotSame( - reverseEngineeringStrategy, - ((RevengConfiguration)wrappedRevengConfiguration).getReverseEngineeringStrategy()); - revengConfigurationWrapper.setReverseEngineeringStrategy(reverseEngineeringStrategy); - assertSame( - reverseEngineeringStrategy, - ((RevengConfiguration)wrappedRevengConfiguration).getReverseEngineeringStrategy()); - // For jpa configuration - try { - jpaConfigurationWrapper.setReverseEngineeringStrategy(reverseEngineeringStrategy); - fail(); - } catch (RuntimeException e) { - assertEquals( - e.getMessage(), - "Method 'setReverseEngineeringStrategy' should not be called on instances of " + JpaConfigurationWrapperImpl.class.getName()); - } - } - - @Test - public void testReadFromJDBC() throws Exception { - // For native configuration - try { - nativeConfigurationWrapper.readFromJDBC(); - fail(); - } catch (RuntimeException e) { - assertEquals( - e.getMessage(), - "Method 'readFromJDBC' should not be called on instances of " + NativeConfigurationWrapperImpl.class.getName()); - } - // For reveng configuration - Connection connection = DriverManager.getConnection("jdbc:h2:mem:test"); - Statement statement = connection.createStatement(); - statement.execute("CREATE TABLE FOO(id int primary key, bar varchar(255))"); - wrappedRevengConfiguration.setProperty("hibernate.connection.url", "jdbc:h2:mem:test"); - wrappedRevengConfiguration.setProperty("hibernate.default_schema", "PUBLIC"); - Metadata metadata = ((RevengConfiguration)wrappedRevengConfiguration).getMetadata(); - assertNull(metadata); - revengConfigurationWrapper.readFromJDBC(); - metadata = ((RevengConfiguration)wrappedRevengConfiguration).getMetadata(); - Iterator iterator = metadata.getEntityBindings().iterator(); - PersistentClass persistentClass = iterator.next(); - assertEquals("Foo", persistentClass.getClassName()); - statement.execute("DROP TABLE FOO"); - statement.close(); - connection.close(); - // For jpa configuration - try { - jpaConfigurationWrapper.readFromJDBC(); - fail(); - } catch (RuntimeException e) { - assertEquals( - e.getMessage(), - "Method 'readFromJDBC' should not be called on instances of " + JpaConfigurationWrapperImpl.class.getName()); - } - } - - @Test - public void testGetClassMapping() throws Exception { - // For native configuration - String fooHbmXmlFilePath = "org/hibernate/tool/orm/jbt/wrp"; - String fooHbmXmlFileName = "ConfigurationWrapperFactoryTest$Foo.hbm.xml"; - String fooClassName = - "org.hibernate.tool.orm.jbt.wrp.ConfigurationWrapperFactoryTest$Foo"; - URL url = getClass().getProtectionDomain().getCodeSource().getLocation(); - File hbmXmlFileDir = new File(new File(url.toURI()),fooHbmXmlFilePath); - hbmXmlFileDir.deleteOnExit(); - hbmXmlFileDir.mkdirs(); - File hbmXmlFile = new File(hbmXmlFileDir, fooHbmXmlFileName); - hbmXmlFile.deleteOnExit(); - FileWriter fileWriter = new FileWriter(hbmXmlFile); - fileWriter.write(TEST_HBM_XML_STRING); - fileWriter.close(); - Field metadataField = NativeConfiguration.class.getDeclaredField("metadata"); - metadataField.setAccessible(true); - assertNull(nativeConfigurationWrapper.getClassMapping("Foo")); - metadataField.set(wrappedNativeConfiguration, null); - wrappedNativeConfiguration.addClass(Foo.class); - assertNotNull(nativeConfigurationWrapper.getClassMapping(fooClassName)); - // For reveng configuration - assertNull(revengConfigurationWrapper.getClassMapping("Foo")); - Connection connection = DriverManager.getConnection("jdbc:h2:mem:test"); - Statement statement = connection.createStatement(); - statement.execute("CREATE TABLE FOO(id int primary key, bar varchar(255))"); - wrappedRevengConfiguration.setProperty("hibernate.connection.url", "jdbc:h2:mem:test"); - wrappedRevengConfiguration.setProperty("hibernate.default_schema", "PUBLIC"); - ((RevengConfiguration)wrappedRevengConfiguration).readFromJDBC(); - assertNotNull(revengConfigurationWrapper.getClassMapping("Foo")); - statement.execute("DROP TABLE FOO"); - statement.close(); - connection.close(); - // For jpa configuration - assertNull(jpaConfigurationWrapper.getClassMapping("Bar")); - assertNotNull(jpaConfigurationWrapper.getClassMapping(FooBar.class.getName())); - } - - @Test - public void testGetNamingStrategy() { - // For native configuration - NamingStrategy namingStrategy = new DefaultNamingStrategy(); - assertNull(nativeConfigurationWrapper.getNamingStrategy()); - ((NativeConfiguration)wrappedNativeConfiguration).setNamingStrategy(namingStrategy); - assertSame(nativeConfigurationWrapper.getNamingStrategy(), namingStrategy); - // For reveng configuration - try { - revengConfigurationWrapper.getNamingStrategy(); - fail(); - } catch (RuntimeException e) { - assertEquals( - e.getMessage(), - "Method 'getNamingStrategy' should not be called on instances of " + RevengConfigurationWrapperImpl.class.getName()); - } - // For jpa configuration - try { - jpaConfigurationWrapper.getNamingStrategy(); - fail(); - } catch (RuntimeException e) { - assertEquals( - e.getMessage(), - "Method 'getNamingStrategy' should not be called on instances of " + JpaConfigurationWrapperImpl.class.getName()); - } - - } - - @Test - public void testGetEntityResolver() throws Exception { - // For native configuration - Field entityResolverField = NativeConfiguration.class.getDeclaredField("entityResolver"); - entityResolverField.setAccessible(true); - EntityResolver testResolver = new DefaultHandler(); - assertNotSame(testResolver, nativeConfigurationWrapper.getEntityResolver()); - entityResolverField.set(wrappedNativeConfiguration, testResolver); - assertSame(testResolver, nativeConfigurationWrapper.getEntityResolver()); - // For reveng configuration - try { - revengConfigurationWrapper.getEntityResolver(); - fail(); - } catch (RuntimeException e) { - assertEquals( - e.getMessage(), - "Method 'getEntityResolver' should not be called on instances of " + RevengConfigurationWrapperImpl.class.getName()); - } - // For jpa configuration - try { - jpaConfigurationWrapper.getEntityResolver(); - fail(); - } catch (RuntimeException e) { - assertEquals( - e.getMessage(), - "Method 'getEntityResolver' should not be called on instances of " + JpaConfigurationWrapperImpl.class.getName()); - } - } - - @Test - public void testGetTableMappings() throws Exception { - // For native configuration - String fooHbmXmlFilePath = "org/hibernate/tool/orm/jbt/wrp"; - String fooHbmXmlFileName = "ConfigurationWrapperFactoryTest$Foo.hbm.xml"; - URL url = getClass().getProtectionDomain().getCodeSource().getLocation(); - File hbmXmlFileDir = new File(new File(url.toURI()),fooHbmXmlFilePath); - hbmXmlFileDir.deleteOnExit(); - hbmXmlFileDir.mkdirs(); - File hbmXmlFile = new File(hbmXmlFileDir, fooHbmXmlFileName); - hbmXmlFile.deleteOnExit(); - FileWriter fileWriter = new FileWriter(hbmXmlFile); - fileWriter.write(TEST_HBM_XML_STRING); - fileWriter.close(); - wrappedNativeConfiguration.addClass(Foo.class); - Iterator
tableMappings = nativeConfigurationWrapper.getTableMappings(); - assertTrue(tableMappings.hasNext()); - Table fooTableFacade = tableMappings.next(); - assertEquals(fooTableFacade.getName(), "ConfigurationWrapperFactoryTest$Foo"); - tableMappings = null; - assertNull(tableMappings); - fooTableFacade = null; - assertNull(fooTableFacade); - // For reveng configuration - Connection connection = DriverManager.getConnection("jdbc:h2:mem:test"); - Statement statement = connection.createStatement(); - statement.execute("CREATE TABLE FOO(id int primary key, bar varchar(255))"); - wrappedRevengConfiguration.setProperty("hibernate.connection.url", "jdbc:h2:mem:test"); - wrappedRevengConfiguration.setProperty("hibernate.default_schema", "PUBLIC"); - tableMappings = revengConfigurationWrapper.getTableMappings(); - assertNotNull(tableMappings); - assertFalse(tableMappings.hasNext()); - ((RevengConfiguration)wrappedRevengConfiguration).readFromJDBC(); - tableMappings = revengConfigurationWrapper.getTableMappings(); - assertNotNull(tableMappings); - assertTrue(tableMappings.hasNext()); - fooTableFacade = tableMappings.next(); - assertEquals(fooTableFacade.getName(), "FOO"); - statement.execute("DROP TABLE FOO"); - statement.close(); - connection.close(); - tableMappings = null; - assertNull(tableMappings); - fooTableFacade = null; - assertNull(fooTableFacade); - // For jpa configuration - tableMappings = jpaConfigurationWrapper.getTableMappings(); - assertNotNull(tableMappings); - assertTrue(tableMappings.hasNext()); - fooTableFacade = tableMappings.next(); - assertEquals(fooTableFacade.getName(), "ConfigurationWrapperFactoryTest$FooBar"); - } - - private void createPersistenceXml() throws Exception { - File metaInf = new File(tempRoot, "META-INF"); - metaInf.mkdirs(); - File persistenceXml = new File(metaInf, "persistence.xml"); - persistenceXml.createNewFile(); - FileWriter fileWriter = new FileWriter(persistenceXml); - fileWriter.write(PERSISTENCE_XML); - fileWriter.close(); - } - - private void swapClassLoader() throws Exception { - original = Thread.currentThread().getContextClassLoader(); - ClassLoader urlCl = URLClassLoader.newInstance( - new URL[] { new URL(tempRoot.toURI().toURL().toString())} , - original); - Thread.currentThread().setContextClassLoader(urlCl); - } - - private void initializeFacadesAndTargets() { - nativeConfigurationWrapper = ConfigurationWrapperFactory.createNativeConfigurationWrapper(); - wrappedNativeConfiguration = nativeConfigurationWrapper.getWrappedObject(); - wrappedNativeConfiguration.setProperty(AvailableSettings.DIALECT, MockDialect.class.getName()); - wrappedNativeConfiguration.setProperty(AvailableSettings.CONNECTION_PROVIDER, MockConnectionProvider.class.getName()); - revengConfigurationWrapper = ConfigurationWrapperFactory.createRevengConfigurationWrapper(); - wrappedRevengConfiguration = revengConfigurationWrapper.getWrappedObject(); - jpaConfigurationWrapper = ConfigurationWrapperFactory.createJpaConfigurationWrapper(null, null); - wrappedJpaConfiguration = jpaConfigurationWrapper.getWrappedObject(); - } - -} diff --git a/jbt/src/test/java/org/hibernate/tool/orm/jbt/wrp/CriteriaWrapperFactoryTest.java b/jbt/src/test/java/org/hibernate/tool/orm/jbt/wrp/CriteriaWrapperFactoryTest.java deleted file mode 100644 index 4ff9522c48..0000000000 --- a/jbt/src/test/java/org/hibernate/tool/orm/jbt/wrp/CriteriaWrapperFactoryTest.java +++ /dev/null @@ -1,72 +0,0 @@ -package org.hibernate.tool.orm.jbt.wrp; - -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertNotEquals; -import static org.junit.jupiter.api.Assertions.assertNotNull; -import static org.junit.jupiter.api.Assertions.assertSame; -import static org.junit.jupiter.api.Assertions.assertTrue; - -import java.lang.reflect.InvocationHandler; -import java.lang.reflect.Method; -import java.lang.reflect.Proxy; -import java.util.Arrays; -import java.util.List; - -import org.hibernate.tool.orm.jbt.wrp.CriteriaWrapperFactory.CriteriaExtension; -import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Test; - -import jakarta.persistence.Query; - -public class CriteriaWrapperFactoryTest { - - private static final List RESULT_LIST = Arrays.asList("foo", "bar"); - - private Query queryTarget, queryWrapper; - - @BeforeEach - public void beforeEach() { - queryTarget = createQueryTarget(); - queryWrapper = createQueryWrapper(queryTarget); - } - - @Test - public void testConstruction() { - assertNotNull(queryTarget); - assertNotNull(queryWrapper); - } - - @Test - public void testSetMaxResults() { - assertNotEquals(queryTarget.getMaxResults(), Integer.MAX_VALUE); - queryWrapper.setMaxResults(Integer.MAX_VALUE); - assertEquals(queryTarget.getMaxResults(), Integer.MAX_VALUE); - } - - @Test - public void testList() { - assertTrue(queryWrapper instanceof CriteriaExtension); - assertSame(((CriteriaExtension)queryWrapper).list(), RESULT_LIST); - } - - private Query createQueryTarget() { - return (Query)Proxy.newProxyInstance( - getClass().getClassLoader(), - new Class[] { Query.class }, - new InvocationHandler () { - private int maxResults = 0; - @Override - public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { - if (method.getName().equals("getMaxResults")) { return maxResults; } - else if (method.getName().equals("setMaxResults")) { maxResults = (int)args[0]; } - else if (method.getName().equals("getResultList")) { return RESULT_LIST; } - return null; - } - }); - } - - private Query createQueryWrapper(Query target) { - return CriteriaWrapperFactory.createCriteriaWrapper(target); - } - -} diff --git a/jbt/src/test/java/org/hibernate/tool/orm/jbt/wrp/DdlExporterWrapperFactoryTest.java b/jbt/src/test/java/org/hibernate/tool/orm/jbt/wrp/DdlExporterWrapperFactoryTest.java deleted file mode 100644 index ccc13c2969..0000000000 --- a/jbt/src/test/java/org/hibernate/tool/orm/jbt/wrp/DdlExporterWrapperFactoryTest.java +++ /dev/null @@ -1,56 +0,0 @@ -package org.hibernate.tool.orm.jbt.wrp; - -import static org.junit.jupiter.api.Assertions.assertFalse; -import static org.junit.jupiter.api.Assertions.assertNotNull; -import static org.junit.jupiter.api.Assertions.assertNotSame; -import static org.junit.jupiter.api.Assertions.assertNull; -import static org.junit.jupiter.api.Assertions.assertSame; -import static org.junit.jupiter.api.Assertions.assertTrue; - -import java.lang.reflect.Field; -import java.util.Properties; - -import org.hibernate.tool.api.export.ExporterConstants; -import org.hibernate.tool.internal.export.common.AbstractExporter; -import org.hibernate.tool.internal.export.ddl.DdlExporter; -import org.hibernate.tool.orm.jbt.wrp.DdlExporterWrapperFactory.DdlExporterWrapper; -import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Test; - -public class DdlExporterWrapperFactoryTest { - - private DdlExporter wrappedDdlExporter = null; - private DdlExporterWrapper ddlExporterWrapper = null; - - @BeforeEach - public void beforeEach() { - wrappedDdlExporter = new DdlExporter(); - ddlExporterWrapper = DdlExporterWrapperFactory.create(wrappedDdlExporter); - } - - @Test - public void testCreate() { - assertNotNull(ddlExporterWrapper); - assertSame(wrappedDdlExporter, ddlExporterWrapper.getWrappedObject()); - } - - @Test - public void testSetExport() { - assertNull(wrappedDdlExporter.getProperties().get(ExporterConstants.EXPORT_TO_DATABASE)); - ddlExporterWrapper.setExport(false); - assertFalse((Boolean)wrappedDdlExporter.getProperties().get(ExporterConstants.EXPORT_TO_DATABASE)); - ddlExporterWrapper.setExport(true); - assertTrue((Boolean)wrappedDdlExporter.getProperties().get(ExporterConstants.EXPORT_TO_DATABASE)); - } - - @Test - public void testGetProperties() throws Exception { - Field propertiesField = AbstractExporter.class.getDeclaredField("properties"); - propertiesField.setAccessible(true); - Properties properties = new Properties(); - assertNotSame(properties, ddlExporterWrapper.getProperties()); - propertiesField.set(wrappedDdlExporter, properties); - assertSame(properties, ddlExporterWrapper.getProperties()); - } - -} diff --git a/jbt/src/test/java/org/hibernate/tool/orm/jbt/wrp/DelegatingColumnWrapperImplTest.java b/jbt/src/test/java/org/hibernate/tool/orm/jbt/wrp/DelegatingColumnWrapperImplTest.java deleted file mode 100644 index b03c0b5a61..0000000000 --- a/jbt/src/test/java/org/hibernate/tool/orm/jbt/wrp/DelegatingColumnWrapperImplTest.java +++ /dev/null @@ -1,116 +0,0 @@ -package org.hibernate.tool.orm.jbt.wrp; - -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertNotNull; -import static org.junit.jupiter.api.Assertions.assertNull; -import static org.junit.jupiter.api.Assertions.assertSame; -import static org.junit.jupiter.api.Assertions.assertTrue; - -import java.lang.reflect.Field; -import java.lang.reflect.InvocationHandler; -import java.lang.reflect.Method; -import java.lang.reflect.Proxy; - -import org.hibernate.cfg.AvailableSettings; -import org.hibernate.cfg.Configuration; -import org.hibernate.mapping.Column; -import org.hibernate.mapping.Value; -import org.hibernate.tool.orm.jbt.util.MockConnectionProvider; -import org.hibernate.tool.orm.jbt.util.MockDialect; -import org.hibernate.tool.orm.jbt.wrp.ValueWrapperFactory.ValueWrapper; -import org.hibernate.type.spi.TypeConfiguration; -import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Test; - -public class DelegatingColumnWrapperImplTest { - - private DelegatingColumnWrapperImpl columnWrapper = null; - - @BeforeEach - public void beforeEach() { - columnWrapper = new DelegatingColumnWrapperImpl(new Column()); - } - - @Test - public void testGetSqlType() { - assertNull(columnWrapper.getSqlType()); - columnWrapper.setSqlType("foobar"); - assertEquals("foobar", columnWrapper.getSqlType()); - columnWrapper = new DelegatingColumnWrapperImpl(new Column()); - Configuration cfg = new Configuration(); - cfg.setProperty(AvailableSettings.DIALECT, MockDialect.class.getName()); - cfg.setProperty(AvailableSettings.CONNECTION_PROVIDER, MockConnectionProvider.class.getName()); - columnWrapper.getWrappedObject().setValue(createValue()); - assertEquals("integer", columnWrapper.getSqlType(cfg)); - } - - @Test - public void testGetLength() { - assertEquals(Integer.MIN_VALUE, columnWrapper.getLength()); - columnWrapper.getWrappedObject().setLength(Integer.MAX_VALUE); - assertEquals(Integer.MAX_VALUE, columnWrapper.getLength()); - } - - @Test - public void testGetDefaultLength() throws Exception { - Field defaultLengthField = DelegatingColumnWrapperImpl.class.getDeclaredField("DEFAULT_LENGTH"); - defaultLengthField.setAccessible(true); - assertEquals(defaultLengthField.get(null), columnWrapper.getDefaultLength()); - } - - @Test - public void testGetPrecision() { - assertEquals(Integer.MIN_VALUE, columnWrapper.getPrecision()); - columnWrapper.getWrappedObject().setPrecision(Integer.MAX_VALUE); - assertEquals(Integer.MAX_VALUE, columnWrapper.getPrecision()); - } - - @Test - public void testGetDefaultPrecision() throws Exception { - Field defaultPrecisionField = DelegatingColumnWrapperImpl.class.getDeclaredField("DEFAULT_PRECISION"); - defaultPrecisionField.setAccessible(true); - assertEquals(defaultPrecisionField.get(null), columnWrapper.getDefaultPrecision()); - } - - @Test - public void testGetScale() { - assertEquals(Integer.MIN_VALUE, columnWrapper.getScale()); - columnWrapper.getWrappedObject().setScale(Integer.MAX_VALUE); - assertEquals(Integer.MAX_VALUE, columnWrapper.getScale()); - } - - @Test - public void testGetDefaultScale() throws Exception { - Field defaultScaleField = DelegatingColumnWrapperImpl.class.getDeclaredField("DEFAULT_SCALE"); - defaultScaleField.setAccessible(true); - assertEquals(defaultScaleField.get(null), columnWrapper.getDefaultScale()); - } - - @Test - public void testGetValue() { - Value v = createValue(); - assertNull(columnWrapper.getValue()); - columnWrapper.getWrappedObject().setValue(v); - Value valueWrapper = columnWrapper.getValue(); - assertNotNull(valueWrapper); - assertTrue(valueWrapper instanceof ValueWrapper); - assertSame(v, ((ValueWrapper)valueWrapper).getWrappedObject()); - } - - private Value createValue() { - return (Value)Proxy.newProxyInstance( - getClass().getClassLoader(), - new Class[] { Value.class }, - new InvocationHandler() { - @Override - public Object invoke(Object proxy, Method method, Object[] args) - throws Throwable { - if (method.getName().equals("getType")) { - return new TypeConfiguration().getBasicTypeForJavaType(Integer.class); - } - return null; - } - }); - } - -} diff --git a/jbt/src/test/java/org/hibernate/tool/orm/jbt/wrp/DelegatingTableWrapperImplTest.java b/jbt/src/test/java/org/hibernate/tool/orm/jbt/wrp/DelegatingTableWrapperImplTest.java deleted file mode 100644 index a229724097..0000000000 --- a/jbt/src/test/java/org/hibernate/tool/orm/jbt/wrp/DelegatingTableWrapperImplTest.java +++ /dev/null @@ -1,38 +0,0 @@ -package org.hibernate.tool.orm.jbt.wrp; - -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertNotNull; -import static org.junit.jupiter.api.Assertions.assertSame; - -import org.hibernate.mapping.BasicValue; -import org.hibernate.mapping.KeyValue; -import org.hibernate.mapping.Table; -import org.hibernate.tool.orm.jbt.util.DummyMetadataBuildingContext; -import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Test; - -public class DelegatingTableWrapperImplTest { - - private DelegatingTableWrapperImpl tableWrapper = null; - - @BeforeEach - public void beforeEach() { - tableWrapper = new DelegatingTableWrapperImpl(new Table("Hibernate Tools", "foo")); - KeyValue v = new BasicValue(DummyMetadataBuildingContext.INSTANCE); - tableWrapper.setIdentifierValue(v); - } - - @Test - public void testConstruction() { - assertNotNull(tableWrapper); - assertEquals("foo", tableWrapper.getName()); - } - - @Test - public void testGetIdentifierValue() { - KeyValue v = new BasicValue(DummyMetadataBuildingContext.INSTANCE); - tableWrapper.getWrappedObject().setIdentifierValue(v); - assertSame(v, ((Wrapper)tableWrapper.getIdentifierValue()).getWrappedObject()); - } - -} diff --git a/jbt/src/test/java/org/hibernate/tool/orm/jbt/wrp/EntityPersisterWrapperFactoryTest.java b/jbt/src/test/java/org/hibernate/tool/orm/jbt/wrp/EntityPersisterWrapperFactoryTest.java deleted file mode 100644 index 061e427610..0000000000 --- a/jbt/src/test/java/org/hibernate/tool/orm/jbt/wrp/EntityPersisterWrapperFactoryTest.java +++ /dev/null @@ -1,234 +0,0 @@ -package org.hibernate.tool.orm.jbt.wrp; - -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertNotNull; -import static org.junit.jupiter.api.Assertions.assertNull; -import static org.junit.jupiter.api.Assertions.assertSame; -import static org.junit.jupiter.api.Assertions.assertTrue; - -import java.io.File; -import java.io.FileWriter; -import java.lang.reflect.InvocationHandler; -import java.lang.reflect.Method; -import java.lang.reflect.Proxy; -import java.nio.file.Files; -import java.util.Arrays; -import java.util.HashSet; -import java.util.Set; - -import org.hibernate.cfg.AvailableSettings; -import org.hibernate.cfg.Configuration; -import org.hibernate.engine.spi.SessionFactoryImplementor; -import org.hibernate.engine.spi.SharedSessionContractImplementor; -import org.hibernate.persister.entity.EntityPersister; -import org.hibernate.tool.orm.jbt.util.MockConnectionProvider; -import org.hibernate.tool.orm.jbt.util.MockDialect; -import org.hibernate.tool.orm.jbt.wrp.EntityPersisterWrapperFactory.EntityPersisterExtension; -import org.hibernate.tool.orm.jbt.wrp.TypeWrapperFactory.TypeExtension; -import org.hibernate.tuple.entity.EntityMetamodel; -import org.hibernate.type.CollectionType; -import org.hibernate.type.Type; -import org.hibernate.type.internal.NamedBasicTypeImpl; -import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.io.TempDir; - -public class EntityPersisterWrapperFactoryTest { - - private static final String TEST_CFG_XML_STRING = - "" + - " " + - " " + MockDialect.class.getName() + "" + - " " + MockConnectionProvider.class.getName() + "" + - " " + - ""; - - private static final String TEST_HBM_XML_STRING = - "" + - " " + - " " + - " " + - " " + - " " + - " " + - " " + - ""; - - public static class Foo { - public String id; - public Set bars = new HashSet(); - } - - @TempDir - public File tempDir; - - private EntityPersister entityPersisterWrapper = null; - private EntityPersister wrappedEntityPersister = null; - - private SessionFactoryWrapper sessionFactory = null; - - @BeforeEach - public void beforeEach() throws Exception { - tempDir = Files.createTempDirectory("temp").toFile(); - File cfgXmlFile = new File(tempDir, "hibernate.cfg.xml"); - FileWriter fileWriter = new FileWriter(cfgXmlFile); - fileWriter.write(TEST_CFG_XML_STRING); - fileWriter.close(); - File hbmXmlFile = new File(tempDir, "Foo.hbm.xml"); - fileWriter = new FileWriter(hbmXmlFile); - fileWriter.write(TEST_HBM_XML_STRING); - fileWriter.close(); - Configuration configuration = (Configuration)WrapperFactory.createNativeConfigurationWrapper(); - configuration.addFile(hbmXmlFile); - configuration.configure(cfgXmlFile); - sessionFactory = (SessionFactoryWrapper)configuration.buildSessionFactory(); - entityPersisterWrapper = sessionFactory.getClassMetadata(Foo.class.getName()); - wrappedEntityPersister = (EntityPersister)((Wrapper)entityPersisterWrapper).getWrappedObject(); - } - - @Test - public void testConstruction() { - assertNotNull(entityPersisterWrapper); - assertNotNull(wrappedEntityPersister); - } - - @Test - public void testGetEntityName() { - assertEquals(Foo.class.getName(), entityPersisterWrapper.getEntityName()); - } - - @Test - public void testGetIdentifierPropertyName() { - assertEquals("id", entityPersisterWrapper.getIdentifierPropertyName()); - } - - @Test - public void testGetPropertyNames() { - String[] propertyNames = entityPersisterWrapper.getPropertyNames(); - assertEquals(1, propertyNames.length); - assertEquals("bars", propertyNames[0]); - } - - @Test - public void testGetPropertyTypes() { - Type[] propertyTypeWrappers = entityPersisterWrapper.getPropertyTypes(); - assertEquals(1, propertyTypeWrappers.length); - Type propertyTypeWrapper = propertyTypeWrappers[0]; - assertTrue(propertyTypeWrapper instanceof Wrapper); - assertTrue(propertyTypeWrapper instanceof TypeExtension); - Object wrappedPropertyType = ((Wrapper)propertyTypeWrapper).getWrappedObject(); - assertTrue(wrappedPropertyType instanceof CollectionType); - assertTrue(propertyTypeWrapper.isCollectionType()); - assertEquals( - "org.hibernate.tool.orm.jbt.wrp.EntityPersisterWrapperFactoryTest$Foo.bars", - ((TypeExtension)propertyTypeWrapper).getRole()); - } - - @Test - public void testGetMappedClass() { - assertSame(Foo.class, entityPersisterWrapper.getMappedClass()); - } - - @Test - public void testGetIdentifierType() { - Type typeWrapper = entityPersisterWrapper.getIdentifierType(); - assertNotNull(typeWrapper); - assertTrue(typeWrapper instanceof Wrapper); - Object wrappedType = ((Wrapper)typeWrapper).getWrappedObject(); - assertNotNull(wrappedType); - assertTrue(wrappedType instanceof NamedBasicTypeImpl); - assertSame("string", ((NamedBasicTypeImpl)wrappedType).getName()); - } - - @Test - public void testGetPropertyValue() { - Foo foo = new Foo(); - Set foobarSet = new HashSet(Arrays.asList("foo", "bar")); - foo.bars = foobarSet; - assertSame(foobarSet, entityPersisterWrapper.getPropertyValue(foo, "bars")); - } - - @Test - public void testHasIdentifierProperty() { - assertTrue(entityPersisterWrapper.hasIdentifierProperty()); - } - - @Test - public void testGetIdentifier() { - SharedSessionContractImplementor sessionFacade = sessionFactory.openSession(); - Foo foo = new Foo(); - foo.id = "bar"; - Object identifier = entityPersisterWrapper.getIdentifier(foo, sessionFacade); - assertSame("bar", identifier); - } - - @Test - public void testIsInstanceOfAbstractEntityPersister() throws Exception { - Object dummyEntityPersister = EntityPersisterWrapperFactory.create(createTestEntityPersister()); - Method isInstanceOfAbstractEntityPersisterMethod = - EntityPersisterExtension.class - .getDeclaredMethod("isInstanceOfAbstractEntityPersister"); - assertTrue((Boolean)isInstanceOfAbstractEntityPersisterMethod.invoke(dummyEntityPersister, (Object[])null)); - } - - @Test - public void testGetTuplizerPropertyValue() throws Exception { - Object dummyEntityPersister = EntityPersisterWrapperFactory.create(createTestEntityPersister()); - Method getTuplizerPropertyValueMethod = - EntityPersisterExtension.class - .getDeclaredMethod("getTuplizerPropertyValue", new Class[] { Object.class, int.class }); - assertSame(PROPERTY_VALUE, getTuplizerPropertyValueMethod.invoke(dummyEntityPersister, new Object(), 0)); - } - - @Test - public void testGetPropertyIndexOrNull() throws Exception { - Object dummyEntityPersister = EntityPersisterWrapperFactory.create(createTestEntityPersister()); - Method getPropertyIndexOrNullMethod = - EntityPersisterExtension.class - .getDeclaredMethod("getPropertyIndexOrNull", new Class[] { String.class }); - assertEquals(0, getPropertyIndexOrNullMethod.invoke(dummyEntityPersister, "bars")); - assertNull(getPropertyIndexOrNullMethod.invoke(dummyEntityPersister, "foo")); - } - - private EntityPersister createTestEntityPersister() { - return (EntityPersister)Proxy.newProxyInstance( - EntityPersisterWrapperFactoryTest.class.getClassLoader(), - new Class[] { EntityPersister.class }, - new TestInvocationHandler()); - } - - private EntityMetamodel createTestEntityMetamodel() throws Exception { - tempDir = Files.createTempDirectory("temp").toFile(); - File cfgXmlFile = new File(tempDir, "hibernate.cfg.xml"); - FileWriter fileWriter = new FileWriter(cfgXmlFile); - fileWriter.write(TEST_CFG_XML_STRING); - fileWriter.close(); - File hbmXmlFile = new File(tempDir, "Foo.hbm.xml"); - fileWriter = new FileWriter(hbmXmlFile); - fileWriter.write(TEST_HBM_XML_STRING); - fileWriter.close(); - Configuration configuration = new Configuration(); - configuration.addFile(hbmXmlFile); - configuration.configure(cfgXmlFile); - SessionFactoryImplementor sfi = (SessionFactoryImplementor)configuration.buildSessionFactory(); - return sfi - .getMetamodel() - .entityPersister(Foo.class) - .getEntityMetamodel(); - } - - private class TestInvocationHandler implements InvocationHandler { - @Override - public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { - if ("getValue".equals(method.getName())) { - return PROPERTY_VALUE; - } if ("getEntityMetamodel".equals(method.getName())) { - return createTestEntityMetamodel(); - } - return null; - } - } - - private static final Object PROPERTY_VALUE = new Object(); - -} diff --git a/jbt/src/test/java/org/hibernate/tool/orm/jbt/wrp/ExporterWrapperFactoryTest.java b/jbt/src/test/java/org/hibernate/tool/orm/jbt/wrp/ExporterWrapperFactoryTest.java deleted file mode 100644 index cdad6d1137..0000000000 --- a/jbt/src/test/java/org/hibernate/tool/orm/jbt/wrp/ExporterWrapperFactoryTest.java +++ /dev/null @@ -1,218 +0,0 @@ -package org.hibernate.tool.orm.jbt.wrp; - -import static org.junit.jupiter.api.Assertions.assertFalse; -import static org.junit.jupiter.api.Assertions.assertNotNull; -import static org.junit.jupiter.api.Assertions.assertNotSame; -import static org.junit.jupiter.api.Assertions.assertNull; -import static org.junit.jupiter.api.Assertions.assertSame; -import static org.junit.jupiter.api.Assertions.assertTrue; - -import java.io.File; -import java.io.StringWriter; -import java.lang.reflect.Field; -import java.util.Properties; - -import org.hibernate.cfg.Configuration; -import org.hibernate.tool.api.export.Exporter; -import org.hibernate.tool.api.export.ExporterConstants; -import org.hibernate.tool.internal.export.cfg.CfgExporter; -import org.hibernate.tool.internal.export.common.AbstractExporter; -import org.hibernate.tool.internal.export.common.GenericExporter; -import org.hibernate.tool.internal.export.ddl.DdlExporter; -import org.hibernate.tool.internal.export.query.QueryExporter; -import org.hibernate.tool.orm.jbt.api.ArtifactCollectorWrapper; -import org.hibernate.tool.orm.jbt.internal.factory.ArtifactCollectorWrapperFactory; -import org.hibernate.tool.orm.jbt.util.ConfigurationMetadataDescriptor; -import org.hibernate.tool.orm.jbt.util.DummyMetadataDescriptor; -import org.hibernate.tool.orm.jbt.wrp.DdlExporterWrapperFactory.DdlExporterWrapper; -import org.hibernate.tool.orm.jbt.wrp.ExporterWrapperFactory.ExporterWrapper; -import org.hibernate.tool.orm.jbt.wrp.GenericExporterWrapperFactory.GenericExporterWrapper; -import org.hibernate.tool.orm.jbt.wrp.QueryExporterWrapperFactory.QueryExporterWrapper; -import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Test; - -public class ExporterWrapperFactoryTest { - - private ExporterWrapper exporterWrapper = null; - - @BeforeEach - public void beforeEach() { - exporterWrapper = ExporterWrapperFactory.create(TestExporter.class.getName()); - } - - @Test - public void testCreate() { - Exporter wrappedExporter = null; - Object metadataDescriptor = null; - // first try the default TestExporter - assertNotNull(exporterWrapper); - wrappedExporter = exporterWrapper.getWrappedObject(); - assertTrue(wrappedExporter instanceof TestExporter); - metadataDescriptor = wrappedExporter.getProperties().get(ExporterConstants.METADATA_DESCRIPTOR); - assertTrue(metadataDescriptor instanceof ConfigurationMetadataDescriptor); - // next try the CfgExporter - exporterWrapper = ExporterWrapperFactory.create(CfgExporter.class.getName()); - assertNotNull(exporterWrapper); - wrappedExporter = exporterWrapper.getWrappedObject(); - assertTrue(wrappedExporter instanceof CfgExporter); - metadataDescriptor = wrappedExporter.getProperties().get(ExporterConstants.METADATA_DESCRIPTOR); - assertTrue(metadataDescriptor instanceof DummyMetadataDescriptor); - } - - @Test - public void testSetConfiguration() throws Exception { - Object metadataDescriptor = null; - Properties properties = new Properties(); - Configuration configuration = new Configuration(); - configuration.setProperties(properties); - Field field = ConfigurationMetadataDescriptor.class.getDeclaredField("configuration"); - field.setAccessible(true); - // First use the TestExporter - metadataDescriptor = exporterWrapper.getWrappedObject().getProperties().get(ExporterConstants.METADATA_DESCRIPTOR); - assertNotNull(metadataDescriptor); - assertTrue(metadataDescriptor instanceof ConfigurationMetadataDescriptor); - assertNotSame(configuration, field.get(metadataDescriptor)); - exporterWrapper.setConfiguration(configuration); - metadataDescriptor = exporterWrapper.getWrappedObject().getProperties().get(ExporterConstants.METADATA_DESCRIPTOR); - assertNotNull(metadataDescriptor); - assertTrue(metadataDescriptor instanceof ConfigurationMetadataDescriptor); - assertSame(configuration, field.get(metadataDescriptor)); - // Now test with a CfgExporter - exporterWrapper = ExporterWrapperFactory.create(CfgExporter.class.getName()); - assertNotSame(properties, ((CfgExporter)exporterWrapper.getWrappedObject()).getCustomProperties()); - metadataDescriptor = exporterWrapper.getWrappedObject().getProperties().get(ExporterConstants.METADATA_DESCRIPTOR); - assertNotNull(metadataDescriptor); - assertTrue(metadataDescriptor instanceof DummyMetadataDescriptor); - exporterWrapper.setConfiguration(configuration); - assertSame(properties, ((CfgExporter)exporterWrapper.getWrappedObject()).getCustomProperties()); - metadataDescriptor = exporterWrapper.getWrappedObject().getProperties().get(ExporterConstants.METADATA_DESCRIPTOR); - assertNotNull(metadataDescriptor); - assertTrue(metadataDescriptor instanceof ConfigurationMetadataDescriptor); - assertSame(configuration, field.get(metadataDescriptor)); - } - - @Test - public void testSetArtifactCollector() { - ArtifactCollectorWrapper artifactCollectorWrapper = ArtifactCollectorWrapperFactory.createArtifactCollectorWrapper(); - Object wrappedArtifactCollector = artifactCollectorWrapper.getWrappedObject(); - assertNotSame(wrappedArtifactCollector, exporterWrapper.getWrappedObject().getProperties().get(ExporterConstants.ARTIFACT_COLLECTOR)); - exporterWrapper.setArtifactCollector(artifactCollectorWrapper); - assertSame(wrappedArtifactCollector, exporterWrapper.getWrappedObject().getProperties().get(ExporterConstants.ARTIFACT_COLLECTOR)); - } - - @Test - public void testSetOutputDirectory() { - File file = new File(""); - assertNotSame(file, exporterWrapper.getWrappedObject().getProperties().get(ExporterConstants.DESTINATION_FOLDER)); - exporterWrapper.setOutputDirectory(file); - assertSame(file, exporterWrapper.getWrappedObject().getProperties().get(ExporterConstants.DESTINATION_FOLDER)); - } - - @Test - public void testSetTemplatePath() { - String[] templatePath = new String[] {}; - assertNotSame(templatePath, exporterWrapper.getWrappedObject().getProperties().get(ExporterConstants.TEMPLATE_PATH)); - exporterWrapper.setTemplatePath(templatePath); - assertSame(templatePath, exporterWrapper.getWrappedObject().getProperties().get(ExporterConstants.TEMPLATE_PATH)); - } - - @Test - public void testStart() throws Exception { - assertFalse(((TestExporter)exporterWrapper.getWrappedObject()).started); - exporterWrapper.start(); - assertTrue(((TestExporter)exporterWrapper.getWrappedObject()).started); - } - - @Test - public void testGetProperties() throws Exception { - Field propertiesField = AbstractExporter.class.getDeclaredField("properties"); - propertiesField.setAccessible(true); - Properties properties = new Properties(); - assertNotNull(exporterWrapper.getProperties()); - assertNotSame(properties, exporterWrapper.getProperties()); - propertiesField.set(exporterWrapper.getWrappedObject(), properties); - assertSame(properties, exporterWrapper.getProperties()); - } - - @Test - public void testGetGenericExporter() { - // TestExporter should not return a GenericExporterFacade instance - assertNull(exporterWrapper.getGenericExporter()); - // try now with a GenericExporter - exporterWrapper = ExporterWrapperFactory.create(GenericExporter.class.getName()); - GenericExporterWrapper genericExporterWrapper = exporterWrapper.getGenericExporter(); - assertNotNull(genericExporterWrapper); - Object exporterTarget = ((Wrapper)exporterWrapper).getWrappedObject(); - Object genericExporterTarget = ((Wrapper)genericExporterWrapper).getWrappedObject(); - assertSame(exporterTarget, genericExporterTarget); - } - - @Test - public void testGetHbm2DDlExporter() { - // TestExporter should not return a GenericExporterFacade instance - assertNull(exporterWrapper.getHbm2DDLExporter()); - // try now with a DdlExporter - exporterWrapper = ExporterWrapperFactory.create(DdlExporter.class.getName()); - DdlExporterWrapper ddlExporterWrapper = exporterWrapper.getHbm2DDLExporter(); - assertNotNull(ddlExporterWrapper); - Object exporterTarget = ((Wrapper)exporterWrapper).getWrappedObject(); - Object ddlExporterTarget = ((Wrapper)ddlExporterWrapper).getWrappedObject(); - assertSame(exporterTarget, ddlExporterTarget); - } - - @Test - public void testGetQueryExporter() { - // TestExporter should not return a GenericExporterFacade instance - assertNull(exporterWrapper.getQueryExporter()); - // try now with a QueryExporter - exporterWrapper = ExporterWrapperFactory.create(QueryExporter.class.getName()); - QueryExporterWrapper queryExporterWrapper = exporterWrapper.getQueryExporter(); - assertNotNull(queryExporterWrapper); - Object exporterTarget = ((Wrapper)exporterWrapper).getWrappedObject(); - Object queryExporterTarget = ((Wrapper)queryExporterWrapper).getWrappedObject(); - assertSame(exporterTarget, queryExporterTarget); - } - - @Test - public void testSetCustomProperties() { - Properties properties = new Properties(); - // 'setCustomProperties()' should not be called on other exporters than CfgExporter - TestExporter wrappedTestExporter = (TestExporter)exporterWrapper.getWrappedObject(); - assertNull(wrappedTestExporter.props); - exporterWrapper.setCustomProperties(properties); - assertNull(wrappedTestExporter.props); - // try now with CfgExporter - exporterWrapper = ExporterWrapperFactory.create(CfgExporter.class.getName()); - CfgExporter wrappedCfgExporter = (CfgExporter)exporterWrapper.getWrappedObject(); - assertNotSame(properties, wrappedCfgExporter.getCustomProperties()); - exporterWrapper.setCustomProperties(properties); - assertSame(properties, wrappedCfgExporter.getCustomProperties()); - } - - @Test - public void testSetOutput() { - StringWriter stringWriter = new StringWriter(); - // 'setOutput()' should not be called on other exporters than CfgExporter - TestExporter wrappedTestExporter = (TestExporter)exporterWrapper.getWrappedObject(); - assertNull(wrappedTestExporter.output); - exporterWrapper.setOutput(stringWriter); - assertNull(wrappedTestExporter.output); - // try now with CfgExporter - exporterWrapper = ExporterWrapperFactory.create(CfgExporter.class.getName()); - CfgExporter wrappedCfgExporter = (CfgExporter)exporterWrapper.getWrappedObject(); - assertNotSame(stringWriter, wrappedCfgExporter.getOutput()); - exporterWrapper.setOutput(stringWriter); - assertSame(stringWriter, wrappedCfgExporter.getOutput()); - } - - public static class TestExporter extends AbstractExporter { - private boolean started = false; - private Properties props = null; - private StringWriter output = null; - @Override protected void doStart() {} - @Override public void start() { started = true; } - void setCustomProperties(Properties p) { props = p; } - void setOutput(StringWriter sw) { output = sw; } - } - -} diff --git a/jbt/src/test/java/org/hibernate/tool/orm/jbt/wrp/GenericExporterWrapperFactoryTest.java b/jbt/src/test/java/org/hibernate/tool/orm/jbt/wrp/GenericExporterWrapperFactoryTest.java deleted file mode 100644 index a074c09884..0000000000 --- a/jbt/src/test/java/org/hibernate/tool/orm/jbt/wrp/GenericExporterWrapperFactoryTest.java +++ /dev/null @@ -1,66 +0,0 @@ -package org.hibernate.tool.orm.jbt.wrp; - -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertNotNull; -import static org.junit.jupiter.api.Assertions.assertNull; -import static org.junit.jupiter.api.Assertions.assertSame; - -import org.hibernate.tool.api.export.ExporterConstants; -import org.hibernate.tool.internal.export.common.GenericExporter; -import org.hibernate.tool.orm.jbt.wrp.GenericExporterWrapperFactory.GenericExporterWrapper; -import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Test; - -public class GenericExporterWrapperFactoryTest { - - private GenericExporter wrappedGenericExporter = null; - private GenericExporterWrapper genericExporterWrapper = null; - - @BeforeEach - public void beforeEach() { - wrappedGenericExporter = new GenericExporter(); - genericExporterWrapper = GenericExporterWrapperFactory.create(wrappedGenericExporter); - } - - @Test - public void testCreate() { - assertNotNull(genericExporterWrapper); - assertSame(wrappedGenericExporter, genericExporterWrapper.getWrappedObject()); - } - - @Test - public void testSetFilePattern() { - assertNull(wrappedGenericExporter.getProperties().get(ExporterConstants.FILE_PATTERN)); - genericExporterWrapper.setFilePattern("foobar"); - assertEquals("foobar", wrappedGenericExporter.getProperties().get(ExporterConstants.FILE_PATTERN)); - } - - @Test - public void testSetTemplate() { - assertNull(wrappedGenericExporter.getProperties().get(ExporterConstants.TEMPLATE_NAME)); - genericExporterWrapper.setTemplateName("barfoo"); - assertEquals("barfoo", wrappedGenericExporter.getProperties().get(ExporterConstants.TEMPLATE_NAME)); - } - - @Test - public void testSetForEach() { - assertNull(wrappedGenericExporter.getProperties().get(ExporterConstants.FOR_EACH)); - genericExporterWrapper.setForEach("foobar"); - assertEquals("foobar", wrappedGenericExporter.getProperties().get(ExporterConstants.FOR_EACH)); - } - - @Test - public void testGetFilePattern() { - assertNull(genericExporterWrapper.getFilePattern()); - wrappedGenericExporter.getProperties().put(ExporterConstants.FILE_PATTERN, "foobar"); - assertEquals("foobar", genericExporterWrapper.getFilePattern()); - } - - @Test - public void testGetTemplateName() { - assertNull(genericExporterWrapper.getTemplateName()); - wrappedGenericExporter.getProperties().put(ExporterConstants.TEMPLATE_NAME, "foobar"); - assertEquals("foobar", genericExporterWrapper.getTemplateName()); - } - -} diff --git a/jbt/src/test/java/org/hibernate/tool/orm/jbt/wrp/HbmExporterWrapperTest.java b/jbt/src/test/java/org/hibernate/tool/orm/jbt/wrp/HbmExporterWrapperTest.java deleted file mode 100644 index 1c78c5cb9d..0000000000 --- a/jbt/src/test/java/org/hibernate/tool/orm/jbt/wrp/HbmExporterWrapperTest.java +++ /dev/null @@ -1,184 +0,0 @@ -package org.hibernate.tool.orm.jbt.wrp; - -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertFalse; -import static org.junit.jupiter.api.Assertions.assertNotNull; -import static org.junit.jupiter.api.Assertions.assertNull; -import static org.junit.jupiter.api.Assertions.assertSame; -import static org.junit.jupiter.api.Assertions.assertTrue; - -import java.io.File; -import java.io.Writer; -import java.lang.reflect.Field; -import java.util.HashMap; -import java.util.Map; - -import org.hibernate.cfg.Configuration; -import org.hibernate.mapping.PersistentClass; -import org.hibernate.mapping.RootClass; -import org.hibernate.tool.api.export.ExporterConstants; -import org.hibernate.tool.internal.export.common.AbstractExporter; -import org.hibernate.tool.internal.export.common.TemplateHelper; -import org.hibernate.tool.internal.export.java.Cfg2JavaTool; -import org.hibernate.tool.internal.export.java.EntityPOJOClass; -import org.hibernate.tool.internal.export.java.POJOClass; -import org.hibernate.tool.orm.jbt.util.ConfigurationMetadataDescriptor; -import org.hibernate.tool.orm.jbt.util.DummyMetadataBuildingContext; -import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.io.TempDir; - -public class HbmExporterWrapperTest { - - private HbmExporterWrapper hbmExporterWrapper = null; - private Configuration cfg = null; - private File f = null; - private boolean templateProcessed = false; - private boolean delegateHasExported = false; - - - @TempDir private File tempFolder; - - @BeforeEach - public void beforeEach() { - cfg = new Configuration(); - f = new File(tempFolder, "foo"); - hbmExporterWrapper = new HbmExporterWrapper(cfg, f); - } - - @Test - public void testConstruction() throws Exception { - assertTrue(tempFolder.exists()); - assertFalse(f.exists()); - assertNotNull(hbmExporterWrapper); - assertSame(f, hbmExporterWrapper.getProperties().get(ExporterConstants.OUTPUT_FILE_NAME)); - ConfigurationMetadataDescriptor descriptor = (ConfigurationMetadataDescriptor)hbmExporterWrapper - .getProperties().get(ExporterConstants.METADATA_DESCRIPTOR); - assertNotNull(descriptor); - Field configurationField = ConfigurationMetadataDescriptor.class.getDeclaredField("configuration"); - configurationField.setAccessible(true); - assertSame(cfg, configurationField.get(descriptor)); - } - - @Test - public void testSetDelegate() throws Exception { - Object delegate = new Object(); - Field delegateField = HbmExporterWrapper.class.getDeclaredField("delegateExporter"); - delegateField.setAccessible(true); - assertNull(delegateField.get(hbmExporterWrapper)); - hbmExporterWrapper.setDelegate(delegate); - assertSame(delegate, delegateField.get(hbmExporterWrapper)); - } - - @Test - public void testExportPOJO() throws Exception { - // first without a delegate exporter - Map context = new HashMap<>(); - PersistentClass pc = new RootClass(DummyMetadataBuildingContext.INSTANCE); - pc.setEntityName("foo"); - pc.setClassName("foo"); - POJOClass pojoClass = new EntityPOJOClass(pc, new Cfg2JavaTool()); - TemplateHelper templateHelper = new TemplateHelper() { - public void processTemplate(String templateName, Writer output, String rootContext) { - templateProcessed = true; - } - }; - templateHelper.init(null, new String[] {}); - Field templateHelperField = AbstractExporter.class.getDeclaredField("vh"); - templateHelperField.setAccessible(true); - templateHelperField.set(hbmExporterWrapper, templateHelper); - assertFalse(templateProcessed); - assertFalse(delegateHasExported); - hbmExporterWrapper.exportPOJO(context, pojoClass); - assertTrue(templateProcessed); - assertFalse(delegateHasExported); - // now with a delegate exporter - templateProcessed = false; - Object delegateExporter = new Object() { - @SuppressWarnings("unused") - private void exportPojo(Map map, Object object, String string) { - assertSame(map, context); - assertSame(object, pojoClass); - assertEquals(string, pojoClass.getQualifiedDeclarationName()); - delegateHasExported = true; - } - }; - hbmExporterWrapper.setDelegate(delegateExporter); - assertFalse(templateProcessed); - assertFalse(delegateHasExported); - hbmExporterWrapper.exportPOJO(context, pojoClass); - assertFalse(templateProcessed); - assertTrue(delegateHasExported); - } - - @Test - public void testSuperExportPOJO() throws Exception { - // first without a delegate exporter - Map context = new HashMap<>(); - PersistentClass pc = new RootClass(DummyMetadataBuildingContext.INSTANCE); - pc.setEntityName("foo"); - pc.setClassName("foo"); - POJOClass pojoClass = new EntityPOJOClass(pc, new Cfg2JavaTool()); - TemplateHelper templateHelper = new TemplateHelper() { - public void processTemplate(String templateName, Writer output, String rootContext) { - templateProcessed = true; - } - }; - templateHelper.init(null, new String[] {}); - Field templateHelperField = AbstractExporter.class.getDeclaredField("vh"); - templateHelperField.setAccessible(true); - templateHelperField.set(hbmExporterWrapper, templateHelper); - assertFalse(templateProcessed); - assertFalse(delegateHasExported); - hbmExporterWrapper.superExportPOJO(context, pojoClass); - assertTrue(templateProcessed); - assertFalse(delegateHasExported); - // now with a delegate exporter - templateProcessed = false; - Object delegateExporter = new Object() { - @SuppressWarnings("unused") - public void exportPojo(Map map, Object object, String string) { - assertSame(map, context); - assertSame(object, pojoClass); - assertEquals(string, pojoClass.getQualifiedDeclarationName()); - delegateHasExported = true; - } - }; - hbmExporterWrapper.setDelegate(delegateExporter); - assertFalse(templateProcessed); - assertFalse(delegateHasExported); - hbmExporterWrapper.superExportPOJO(context, pojoClass); - assertTrue(templateProcessed); - assertFalse(delegateHasExported); - } - - @Test - public void testGetOutputDirectory() { - assertNull(hbmExporterWrapper.getOutputDirectory()); - File file = new File("testGetOutputDirectory"); - hbmExporterWrapper.getProperties().put(ExporterConstants.DESTINATION_FOLDER, file); - assertSame(file, hbmExporterWrapper.getOutputDirectory()); - } - - @Test - public void testSetOutputDirectory() { - assertNull(hbmExporterWrapper.getProperties().get(ExporterConstants.DESTINATION_FOLDER)); - File file = new File("testSetOutputDirectory"); - hbmExporterWrapper.setOutputDirectory(file); - assertSame(file, hbmExporterWrapper.getProperties().get(ExporterConstants.DESTINATION_FOLDER)); - } - - @Test - public void testSetExportPOJODelegate() throws Exception { - Object delegate = new Object() { - @SuppressWarnings("unused") - public void exportPojo(Map map, Object pojoClass, String qualifiedDeclarationName) { } - }; - Field delegateField = HbmExporterWrapper.class.getDeclaredField("delegateExporter"); - delegateField.setAccessible(true); - assertNull(delegateField.get(hbmExporterWrapper)); - hbmExporterWrapper.setExportPOJODelegate(delegate); - assertSame(delegate, delegateField.get(hbmExporterWrapper)); - } - -} diff --git a/jbt/src/test/java/org/hibernate/tool/orm/jbt/wrp/HqlCodeAssistWrapperTest.java b/jbt/src/test/java/org/hibernate/tool/orm/jbt/wrp/HqlCodeAssistWrapperTest.java deleted file mode 100644 index a927618622..0000000000 --- a/jbt/src/test/java/org/hibernate/tool/orm/jbt/wrp/HqlCodeAssistWrapperTest.java +++ /dev/null @@ -1,53 +0,0 @@ -package org.hibernate.tool.orm.jbt.wrp; - -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertNotEquals; -import static org.junit.jupiter.api.Assertions.assertNotNull; -import static org.junit.jupiter.api.Assertions.assertNull; - -import org.hibernate.boot.Metadata; -import org.hibernate.cfg.Configuration; -import org.hibernate.tool.orm.jbt.util.MetadataHelper; -import org.hibernate.tool.orm.jbt.util.NativeConfiguration; -import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Test; - -public class HqlCodeAssistWrapperTest { - - private HqlCodeAssistWrapper hqlCodeAssistWrapper = null; - - @BeforeEach - public void beforeEach() { - Configuration configuration = new NativeConfiguration(); - configuration.setProperty("hibernate.connection.url", "jdbc:h2:mem:test"); - Metadata metadata = MetadataHelper.getMetadata(configuration); - hqlCodeAssistWrapper = new HqlCodeAssistWrapper(metadata); - } - - @Test - public void testCodeComplete() { - // First test the handler's 'accept' method - TestCodeCompletionHandler completionHandler = new TestCodeCompletionHandler(); - assertEquals(0, completionHandler.acceptCount); - hqlCodeAssistWrapper.codeComplete("", 0, completionHandler); - assertNotEquals(0, completionHandler.acceptCount); - // Now try to invoke the handler's 'completionFailure' method - hqlCodeAssistWrapper = new HqlCodeAssistWrapper(null); - assertNull(completionHandler.errorMessage); - hqlCodeAssistWrapper.codeComplete("FROM ", 5, completionHandler); - assertNotNull(completionHandler.errorMessage); - } - - static class TestCodeCompletionHandler { - int acceptCount = 0; - String errorMessage = null; - public boolean accept(Object o) { - acceptCount++; - return false; - } - public void completionFailure(String errorMessage) { - this.errorMessage = errorMessage; - } - } - -} diff --git a/jbt/src/test/java/org/hibernate/tool/orm/jbt/wrp/HqlCompletionProposalWrapperFactoryTest.java b/jbt/src/test/java/org/hibernate/tool/orm/jbt/wrp/HqlCompletionProposalWrapperFactoryTest.java deleted file mode 100644 index b9239f5f20..0000000000 --- a/jbt/src/test/java/org/hibernate/tool/orm/jbt/wrp/HqlCompletionProposalWrapperFactoryTest.java +++ /dev/null @@ -1,118 +0,0 @@ -package org.hibernate.tool.orm.jbt.wrp; - -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertNotEquals; -import static org.junit.jupiter.api.Assertions.assertNotNull; -import static org.junit.jupiter.api.Assertions.assertNull; -import static org.junit.jupiter.api.Assertions.assertSame; - -import org.hibernate.mapping.Property; -import org.hibernate.tool.ide.completion.HQLCompletionProposal; -import org.hibernate.tool.orm.jbt.wrp.HqlCompletionProposalWrapperFactory.HqlCompletionProposalWrapper; -import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Test; - -public class HqlCompletionProposalWrapperFactoryTest { - - private HqlCompletionProposalWrapper hqlCompletionProposalWrapper = null; - private HQLCompletionProposal hqlCompletionProposalTarget = null; - - @BeforeEach - public void beforeEach() { - hqlCompletionProposalTarget = - new HQLCompletionProposal( - HQLCompletionProposal.PROPERTY, - Integer.MAX_VALUE); - hqlCompletionProposalWrapper = HqlCompletionProposalWrapperFactory - .createHqlCompletionProposalWrapper(hqlCompletionProposalTarget); - } - - @Test - public void testConstruction() { - assertNotNull(hqlCompletionProposalTarget); - assertNotNull(hqlCompletionProposalWrapper); - } - - @Test - public void testGetCompletion() { - assertNotEquals("foo", hqlCompletionProposalWrapper.getCompletion()); - hqlCompletionProposalTarget.setCompletion("foo"); - assertEquals("foo", hqlCompletionProposalWrapper.getCompletion()); - } - - @Test - public void testGetReplaceStart() { - assertNotEquals(Integer.MAX_VALUE, hqlCompletionProposalWrapper.getReplaceStart()); - hqlCompletionProposalTarget.setReplaceStart(Integer.MAX_VALUE); - assertEquals(Integer.MAX_VALUE, hqlCompletionProposalWrapper.getReplaceStart()); - } - - @Test - public void testGetReplaceEnd() { - assertNotEquals(Integer.MIN_VALUE, hqlCompletionProposalWrapper.getReplaceEnd()); - hqlCompletionProposalTarget.setReplaceEnd(Integer.MIN_VALUE); - assertEquals(Integer.MIN_VALUE, hqlCompletionProposalWrapper.getReplaceEnd()); - } - - @Test - public void testGetSimpleName() { - assertNotEquals("foo", hqlCompletionProposalWrapper.getSimpleName()); - hqlCompletionProposalTarget.setSimpleName("foo"); - assertEquals("foo", hqlCompletionProposalWrapper.getSimpleName()); - } - - @Test - public void testGetCompletionKind() { - assertEquals(HQLCompletionProposal.PROPERTY, hqlCompletionProposalWrapper.getCompletionKind()); - hqlCompletionProposalTarget.setCompletionKind(HQLCompletionProposal.KEYWORD); - assertEquals(HQLCompletionProposal.KEYWORD, hqlCompletionProposalWrapper.getCompletionKind()); - } - - @Test - public void testGetEntityName() { - assertNotEquals("foo", hqlCompletionProposalWrapper.getEntityName()); - hqlCompletionProposalTarget.setEntityName("foo"); - assertEquals("foo", hqlCompletionProposalWrapper.getEntityName()); - } - - @Test - public void testGetShortEntityName() { - assertNotEquals("foo", hqlCompletionProposalWrapper.getShortEntityName()); - hqlCompletionProposalTarget.setShortEntityName("foo"); - assertEquals("foo", hqlCompletionProposalWrapper.getShortEntityName()); - } - - @Test - public void testGetProperty() { - Property propertyTarget = new Property(); - assertNull(hqlCompletionProposalWrapper.getProperty()); - hqlCompletionProposalTarget.setProperty(propertyTarget); - assertSame(propertyTarget, hqlCompletionProposalWrapper.getProperty()); - } - - @Test - public void testAliasRefKind() { - assertSame(HQLCompletionProposal.ALIAS_REF, hqlCompletionProposalWrapper.aliasRefKind()); - } - - @Test - public void testEntityNameKind() { - assertSame(HQLCompletionProposal.ENTITY_NAME, hqlCompletionProposalWrapper.entityNameKind()); - } - - @Test - public void testPropertyKind() { - assertSame(HQLCompletionProposal.PROPERTY, hqlCompletionProposalWrapper.propertyKind()); - } - - @Test - public void testKeywordKind() { - assertSame(HQLCompletionProposal.KEYWORD, hqlCompletionProposalWrapper.keywordKind()); - } - - @Test - public void testFunctionKind() { - assertSame(HQLCompletionProposal.FUNCTION, hqlCompletionProposalWrapper.functionKind()); - } - -} diff --git a/jbt/src/test/java/org/hibernate/tool/orm/jbt/wrp/NamingStrategyWrapperFactoryTest.java b/jbt/src/test/java/org/hibernate/tool/orm/jbt/wrp/NamingStrategyWrapperFactoryTest.java deleted file mode 100644 index 65b7118639..0000000000 --- a/jbt/src/test/java/org/hibernate/tool/orm/jbt/wrp/NamingStrategyWrapperFactoryTest.java +++ /dev/null @@ -1,30 +0,0 @@ -package org.hibernate.tool.orm.jbt.wrp; - -import static org.junit.jupiter.api.Assertions.assertEquals; - -import java.lang.reflect.Method; - -import org.hibernate.cfg.DefaultNamingStrategy; -import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Test; - -public class NamingStrategyWrapperFactoryTest { - - private Object namingStrategyWrapperFactory = null; - - @BeforeEach - public void beforeEach() { - namingStrategyWrapperFactory = NamingStrategyWrapperFactory.create(DefaultNamingStrategy.class.getName()); - } - - @Test - public void testGetClassName() throws Exception { - Method getClassNameMethod = namingStrategyWrapperFactory - .getClass() - .getDeclaredMethod("getStrategyClassName", new Class[] {}); - assertEquals( - DefaultNamingStrategy.class.getName(), - getClassNameMethod.invoke(namingStrategyWrapperFactory, new Object[] {})); - } - -} diff --git a/jbt/src/test/java/org/hibernate/tool/orm/jbt/wrp/PropertyWrapperFactoryTest.java b/jbt/src/test/java/org/hibernate/tool/orm/jbt/wrp/PropertyWrapperFactoryTest.java deleted file mode 100644 index 38ebff64eb..0000000000 --- a/jbt/src/test/java/org/hibernate/tool/orm/jbt/wrp/PropertyWrapperFactoryTest.java +++ /dev/null @@ -1,219 +0,0 @@ -package org.hibernate.tool.orm.jbt.wrp; - -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertFalse; -import static org.junit.jupiter.api.Assertions.assertNotEquals; -import static org.junit.jupiter.api.Assertions.assertNotNull; -import static org.junit.jupiter.api.Assertions.assertNull; -import static org.junit.jupiter.api.Assertions.assertSame; -import static org.junit.jupiter.api.Assertions.assertTrue; - -import org.hibernate.mapping.Backref; -import org.hibernate.mapping.BasicValue; -import org.hibernate.mapping.Column; -import org.hibernate.mapping.Component; -import org.hibernate.mapping.Property; -import org.hibernate.mapping.RootClass; -import org.hibernate.mapping.Table; -import org.hibernate.mapping.Value; -import org.hibernate.tool.orm.jbt.api.PersistentClassWrapper; -import org.hibernate.tool.orm.jbt.internal.factory.PersistentClassWrapperFactory; -import org.hibernate.tool.orm.jbt.util.DummyMetadataBuildingContext; -import org.hibernate.tool.orm.jbt.wrp.PropertyWrapperFactory.PropertyWrapper; -import org.hibernate.tool.orm.jbt.wrp.TypeWrapperFactory.TypeWrapper; -import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Test; - -public class PropertyWrapperFactoryTest { - - private Property wrappedProperty = null; - private PropertyWrapper propertyWrapper = null; - - @BeforeEach - public void beforeEach() { - wrappedProperty = new Property(); - propertyWrapper = (PropertyWrapper)PropertyWrapperFactory.createPropertyWrapper(wrappedProperty); - } - - @Test - public void testCreatePropertyWrapper() { - assertNotNull(wrappedProperty); - assertNotNull(propertyWrapper); - assertSame(wrappedProperty, propertyWrapper.getWrappedObject()); - } - - @Test - public void testGetValue() { - assertNull(propertyWrapper.getValue()); - Value valueTarget = new BasicValue(DummyMetadataBuildingContext.INSTANCE); - wrappedProperty.setValue(valueTarget); - Value valueWrapper = propertyWrapper.getValue(); - assertNotNull(valueWrapper); - assertSame(valueTarget, ((Wrapper)valueWrapper).getWrappedObject()); - } - - @Test - public void testSetName() { - assertNotEquals("foo", wrappedProperty.getName()); - propertyWrapper.setName("foo"); - assertEquals("foo", wrappedProperty.getName()); - } - - @Test - public void testSetPersistentClass() { - PersistentClassWrapper persistentClass = PersistentClassWrapperFactory.createRootClassWrapper(); - assertNull(wrappedProperty.getPersistentClass()); - propertyWrapper.setPersistentClass(persistentClass.getWrappedObject()); - assertSame(persistentClass.getWrappedObject(), wrappedProperty.getPersistentClass()); - } - - @Test - public void testGetPersistentClass() { - PersistentClassWrapper persistentClass = PersistentClassWrapperFactory.createRootClassWrapper(); - assertNull(propertyWrapper.getPersistentClass()); - wrappedProperty.setPersistentClass(persistentClass.getWrappedObject()); - PersistentClassWrapper persistentClassWrapper = (PersistentClassWrapper)propertyWrapper.getPersistentClass(); - assertSame(persistentClass.getWrappedObject(), persistentClassWrapper.getWrappedObject()); - } - - @Test - public void testIsComposite() { - wrappedProperty.setValue(new BasicValue(DummyMetadataBuildingContext.INSTANCE)); - assertFalse(propertyWrapper.isComposite()); - Component component = new Component( - DummyMetadataBuildingContext.INSTANCE, - new Table(""), - new RootClass(DummyMetadataBuildingContext.INSTANCE)); - wrappedProperty.setValue(component); - assertTrue(propertyWrapper.isComposite()); - } - - @Test - public void testGetPropetyAccessorName() { - assertNotEquals("foo", propertyWrapper.getPropertyAccessorName()); - wrappedProperty.setPropertyAccessorName("foo"); - assertEquals("foo", propertyWrapper.getPropertyAccessorName()); - } - - @Test - public void testGetName() { - assertNotEquals("foo", propertyWrapper.getName()); - wrappedProperty.setName("foo"); - assertEquals("foo", propertyWrapper.getName()); - } - - @Test - public void testGetType() { - BasicValue v = new BasicValue(DummyMetadataBuildingContext.INSTANCE); - v.setTypeName("int"); - assertNull(propertyWrapper.getType()); - wrappedProperty.setValue(v); - TypeWrapper typeWrapper = (TypeWrapper)propertyWrapper.getType(); - assertEquals("integer", typeWrapper.getName()); - assertSame(v.getType(), typeWrapper.getWrappedObject()); - } - - @Test - public void testSetValue() { - assertNull(wrappedProperty.getValue()); - BasicValue value = new BasicValue(DummyMetadataBuildingContext.INSTANCE); - propertyWrapper.setValue(value); - assertSame(value, wrappedProperty.getValue()); - } - - @Test - public void testSetPropertyAccessorName() { - assertNotEquals("foo", wrappedProperty.getPropertyAccessorName()); - propertyWrapper.setPropertyAccessorName("foo"); - assertEquals("foo", wrappedProperty.getPropertyAccessorName()); - } - - @Test - public void testSetCascade() { - assertNotEquals("foo", wrappedProperty.getCascade()); - propertyWrapper.setCascade("foo"); - assertEquals("foo", wrappedProperty.getCascade()); - } - - @Test - public void testIsBackRef() throws Exception { - assertFalse(propertyWrapper.isBackRef()); - propertyWrapper = (PropertyWrapper)PropertyWrapperFactory.createPropertyWrapper(new Backref()); - assertTrue(propertyWrapper.isBackRef()); - } - - @Test - public void testIsSelectable() { - wrappedProperty.setSelectable(true); - assertTrue(propertyWrapper.isSelectable()); - wrappedProperty.setSelectable(false); - assertFalse(propertyWrapper.isSelectable()); - } - - @Test - public void testIsInsertable() { - BasicValue v = new BasicValue(DummyMetadataBuildingContext.INSTANCE); - v.setTable(new Table("")); - Column c = new Column(); - v.addColumn(c); - wrappedProperty.setValue(v); - wrappedProperty.setInsertable(true); - assertTrue(propertyWrapper.isInsertable()); - wrappedProperty.setInsertable(false); - assertFalse(propertyWrapper.isInsertable()); - } - - @Test - public void testIsUpdateable() { - BasicValue v = new BasicValue(DummyMetadataBuildingContext.INSTANCE); - v.setTable(new Table("")); - Column c = new Column(); - v.addColumn(c); - wrappedProperty.setValue(v); - wrappedProperty.setUpdateable(false); - assertFalse(propertyWrapper.isUpdateable()); - wrappedProperty.setUpdateable(true); - assertTrue(propertyWrapper.isUpdateable()); - } - - @Test - public void testGetCascade() { - assertNotEquals("foo", propertyWrapper.getCascade()); - wrappedProperty.setCascade("foo"); - assertEquals("foo", propertyWrapper.getCascade()); - } - - @Test - public void testIsLazy() { - wrappedProperty.setLazy(true); - assertTrue(propertyWrapper.isLazy()); - wrappedProperty.setLazy(false); - assertFalse(propertyWrapper.isLazy()); - } - - @Test - public void testIsOptional() { - wrappedProperty.setValue(new BasicValue(DummyMetadataBuildingContext.INSTANCE)); - wrappedProperty.setOptional(true); - assertTrue(propertyWrapper.isOptional()); - wrappedProperty.setOptional(false); - assertFalse(propertyWrapper.isOptional()); - } - - @Test - public void testIsNaturalIdentifier() { - wrappedProperty.setNaturalIdentifier(true); - assertTrue(propertyWrapper.isNaturalIdentifier()); - wrappedProperty.setNaturalIdentifier(false); - assertFalse(propertyWrapper.isNaturalIdentifier()); - } - - @Test - public void testIsOptimisticLocked() { - wrappedProperty.setOptimisticLocked(true); - assertTrue(propertyWrapper.isOptimisticLocked()); - wrappedProperty.setOptimisticLocked(false); - assertFalse(propertyWrapper.isOptimisticLocked()); - } - -} diff --git a/jbt/src/test/java/org/hibernate/tool/orm/jbt/wrp/QueryExporterWrapperFactoryTest.java b/jbt/src/test/java/org/hibernate/tool/orm/jbt/wrp/QueryExporterWrapperFactoryTest.java deleted file mode 100644 index f63f64a493..0000000000 --- a/jbt/src/test/java/org/hibernate/tool/orm/jbt/wrp/QueryExporterWrapperFactoryTest.java +++ /dev/null @@ -1,50 +0,0 @@ -package org.hibernate.tool.orm.jbt.wrp; - -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertNotEquals; -import static org.junit.jupiter.api.Assertions.assertNotNull; -import static org.junit.jupiter.api.Assertions.assertNotSame; -import static org.junit.jupiter.api.Assertions.assertSame; - -import java.util.Collections; -import java.util.List; - -import org.hibernate.tool.api.export.ExporterConstants; -import org.hibernate.tool.internal.export.query.QueryExporter; -import org.hibernate.tool.orm.jbt.wrp.QueryExporterWrapperFactory.QueryExporterWrapper; -import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Test; - -public class QueryExporterWrapperFactoryTest { - - private QueryExporter wrappedQueryExporter = null; - private QueryExporterWrapper queryExporterWrapper = null; - - @BeforeEach - public void beforeEach() { - wrappedQueryExporter = new QueryExporter(); - queryExporterWrapper = QueryExporterWrapperFactory.create(wrappedQueryExporter); - } - - @Test - public void testCreate() { - assertNotNull(queryExporterWrapper); - assertSame(wrappedQueryExporter, queryExporterWrapper.getWrappedObject()); - } - - @Test - public void testSetQueries() { - List queries = Collections.emptyList(); - assertNotSame(queries, wrappedQueryExporter.getProperties().get(ExporterConstants.QUERY_LIST)); - queryExporterWrapper.setQueries(queries); - assertSame(queries, wrappedQueryExporter.getProperties().get(ExporterConstants.QUERY_LIST)); - } - - @Test - public void testSetFileName() { - assertNotEquals("foo", wrappedQueryExporter.getProperties().get(ExporterConstants.OUTPUT_FILE_NAME)); - queryExporterWrapper.setFilename("foo"); - assertEquals("foo", wrappedQueryExporter.getProperties().get(ExporterConstants.OUTPUT_FILE_NAME)); - } - -} diff --git a/jbt/src/test/java/org/hibernate/tool/orm/jbt/wrp/QueryWrapperFactoryTest.java b/jbt/src/test/java/org/hibernate/tool/orm/jbt/wrp/QueryWrapperFactoryTest.java deleted file mode 100644 index fb4efac2b4..0000000000 --- a/jbt/src/test/java/org/hibernate/tool/orm/jbt/wrp/QueryWrapperFactoryTest.java +++ /dev/null @@ -1,207 +0,0 @@ -package org.hibernate.tool.orm.jbt.wrp; - -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertFalse; -import static org.junit.jupiter.api.Assertions.assertNotNull; -import static org.junit.jupiter.api.Assertions.assertTrue; - -import java.io.File; -import java.io.FileWriter; -import java.nio.file.Files; -import java.sql.Connection; -import java.sql.DriverManager; -import java.sql.Statement; -import java.util.Arrays; -import java.util.List; - -import org.h2.Driver; -import org.hibernate.cfg.Configuration; -import org.hibernate.query.Query; -import org.hibernate.query.spi.QueryParameterBinding; -import org.hibernate.query.sqm.internal.QuerySqmImpl; -import org.hibernate.tool.orm.jbt.util.NativeConfiguration; -import org.hibernate.tool.orm.jbt.wrp.QueryWrapperFactory.QueryWrapper; -import org.hibernate.tool.orm.jbt.wrp.SessionWrapperFactory.SessionWrapper; -import org.hibernate.type.Type; -import org.junit.jupiter.api.AfterEach; -import org.junit.jupiter.api.BeforeAll; -import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.io.TempDir; - -public class QueryWrapperFactoryTest { - - private static final String TEST_CFG_XML_STRING = - "" + - " " + - " jdbc:h2:mem:test" + - " " + - ""; - - private static final String TEST_HBM_XML_STRING = - "" + - " " + - " " + - " " + - " " + - ""; - - static class Foo { - public int id; - public String bars; - } - - @BeforeAll - public static void beforeAll() throws Exception { - DriverManager.registerDriver(new Driver()); - } - - @TempDir - public File tempDir; - - private QueryWrapper simpleQueryWrapper = null; - private Query wrappedSimpleQuery = null; - - private QueryWrapper namedParameterizedQueryWrapper = null; - private Query wrappedNamedParameterizedQuery = null; - - private QueryWrapper positionalParameterizedQueryWrapper = null; - private Query wrappedPositionalParameterizedQuery = null; - - private QueryWrapper collectionParameterizedQueryWrapper = null; - private Query wrappedCollectionParameterizedQuery = null; - - private SessionFactoryWrapper sessionFactory = null; - private Connection connection = null; - private Statement statement = null; - - - @SuppressWarnings("deprecation") - @BeforeEach - public void before() throws Exception { - tempDir = Files.createTempDirectory("temp").toFile(); - createDatabase(); - createSessionFactory(); - SessionWrapper session = (SessionWrapper)sessionFactory.openSession(); - simpleQueryWrapper = (QueryWrapper)session - .createQuery("from " + Foo.class.getName()); - wrappedSimpleQuery = simpleQueryWrapper.getWrappedObject(); - namedParameterizedQueryWrapper = (QueryWrapper)session - .createQuery("from " + Foo.class.getName() + " where id = :foo"); - wrappedNamedParameterizedQuery = namedParameterizedQueryWrapper.getWrappedObject(); - positionalParameterizedQueryWrapper = (QueryWrapper)session - .createQuery("from " + Foo.class.getName() + " where id = ?1"); - wrappedPositionalParameterizedQuery = positionalParameterizedQueryWrapper.getWrappedObject(); - collectionParameterizedQueryWrapper = (QueryWrapper)session - .createQuery("from " + Foo.class.getName() + " where id in :foo"); - wrappedCollectionParameterizedQuery = collectionParameterizedQueryWrapper.getWrappedObject(); - } - - @AfterEach - public void afterEach() throws Exception { - dropDatabase(); - } - - @Test - public void testCreateQueryWrapper() { - assertNotNull(simpleQueryWrapper); - assertTrue(simpleQueryWrapper instanceof QueryWrapperFactory.QueryWrapper); - assertNotNull(namedParameterizedQueryWrapper); - assertTrue(namedParameterizedQueryWrapper instanceof QueryWrapperFactory.QueryWrapper); - assertNotNull(positionalParameterizedQueryWrapper); - assertTrue(positionalParameterizedQueryWrapper instanceof QueryWrapperFactory.QueryWrapper); - } - - @Test - public void testList() throws Exception { - List result = simpleQueryWrapper.list(); - assertTrue(result.isEmpty()); - statement.execute("INSERT INTO FOO VALUES(1, 'bars')"); - result = simpleQueryWrapper.list(); - assertEquals(1, result.size()); - Object obj = result.get(0); - assertTrue(obj instanceof Foo); - Foo foo = (Foo)obj; - assertEquals(1, foo.id); - assertEquals("bars", foo.bars); - } - - @Test - public void testSetMaxResults() { - simpleQueryWrapper.setMaxResults(1); - assertEquals(1, wrappedSimpleQuery.getMaxResults()); - simpleQueryWrapper.setMaxResults(Integer.MAX_VALUE); - assertEquals(Integer.MAX_VALUE, wrappedSimpleQuery.getMaxResults()); - } - - @Test - public void testSetParameterList() { - QueryParameterBinding binding = - ((QuerySqmImpl)wrappedCollectionParameterizedQuery).getParameterBindings().getBinding("foo"); - assertFalse(binding.isBound()); - collectionParameterizedQueryWrapper.setParameterList("foo", Arrays.asList(1), new Object()); - assertTrue(binding.isBound()); - } - - @Test - public void testSetNamedParameter() { - QueryParameterBinding binding = - ((QuerySqmImpl)wrappedNamedParameterizedQuery).getParameterBindings().getBinding("foo"); - assertFalse(binding.isBound()); - namedParameterizedQueryWrapper.setParameter("foo", 1, new Object()); - assertTrue(binding.isBound()); - assertEquals(1, binding.getBindValue()); - } - - @Test - public void testSetPositionalParameter() { - QueryParameterBinding binding = - ((QuerySqmImpl)wrappedPositionalParameterizedQuery).getParameterBindings().getBinding(1); - assertFalse(binding.isBound()); - positionalParameterizedQueryWrapper.setParameter(1, 1, new Object()); - assertTrue(binding.isBound()); - assertEquals(1, binding.getBindValue()); - } - - @Test - public void testGetReturnAliases() { - String[] aliases = simpleQueryWrapper.getReturnAliases(); - assertNotNull(aliases); - assertEquals(0, aliases.length); - } - - @Test - public void testGetReturnTypes() { - Type[] returnTypes = simpleQueryWrapper.getReturnTypes(); - assertNotNull(returnTypes); - assertEquals(0, returnTypes.length); - } - - private void createDatabase() throws Exception { - connection = DriverManager.getConnection("jdbc:h2:mem:test"); - statement = connection.createStatement(); - statement.execute("CREATE TABLE FOO(id int primary key, bars varchar(255))"); - } - - private void createSessionFactory() throws Exception { - File cfgXmlFile = new File(tempDir, "hibernate.cfg.xml"); - FileWriter fileWriter = new FileWriter(cfgXmlFile); - fileWriter.write(TEST_CFG_XML_STRING); - fileWriter.close(); - File hbmXmlFile = new File(tempDir, "Foo.hbm.xml"); - fileWriter = new FileWriter(hbmXmlFile); - fileWriter.write(TEST_HBM_XML_STRING); - fileWriter.close(); - Configuration configuration = new NativeConfiguration(); - configuration.addFile(hbmXmlFile); - configuration.configure(cfgXmlFile); - sessionFactory = new SessionFactoryWrapper(configuration.buildSessionFactory()); - } - - private void dropDatabase() throws Exception { - statement.execute("DROP TABLE FOO"); - statement.close(); - connection.close(); - } - -} diff --git a/jbt/src/test/java/org/hibernate/tool/orm/jbt/wrp/SchemaExportWrapperTest.java b/jbt/src/test/java/org/hibernate/tool/orm/jbt/wrp/SchemaExportWrapperTest.java deleted file mode 100644 index adb51f8cd2..0000000000 --- a/jbt/src/test/java/org/hibernate/tool/orm/jbt/wrp/SchemaExportWrapperTest.java +++ /dev/null @@ -1,64 +0,0 @@ -package org.hibernate.tool.orm.jbt.wrp; - -import static org.junit.jupiter.api.Assertions.assertFalse; -import static org.junit.jupiter.api.Assertions.assertNotNull; -import static org.junit.jupiter.api.Assertions.assertSame; -import static org.junit.jupiter.api.Assertions.assertTrue; - -import java.lang.reflect.Field; -import java.util.EnumSet; - -import org.hibernate.boot.Metadata; -import org.hibernate.cfg.Configuration; -import org.hibernate.cfg.Environment; -import org.hibernate.tool.orm.jbt.util.MockConnectionProvider; -import org.hibernate.tool.orm.jbt.util.MockDialect; -import org.hibernate.tool.schema.TargetType; -import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Test; - -public class SchemaExportWrapperTest { - - private SchemaExportWrapper schemaExportWrapper = null; - private Configuration configuration = null; - - @BeforeEach - public void beforeEach() { - configuration = new Configuration(); - configuration.setProperty(Environment.DIALECT, MockDialect.class.getName()); - configuration.setProperty(Environment.CONNECTION_PROVIDER, MockConnectionProvider.class.getName()); - schemaExportWrapper = new TestSchemaExportWrapper(configuration); - } - - @Test - public void testConstruction() throws Exception { - assertNotNull(schemaExportWrapper); - Field configurationField = SchemaExportWrapper.class.getDeclaredField("configuration"); - configurationField.setAccessible(true); - assertSame(configuration, configurationField.get(schemaExportWrapper)); - } - - @Test - public void testCreate() { - assertFalse(((TestSchemaExportWrapper)schemaExportWrapper).created); - schemaExportWrapper.create(); - assertTrue(((TestSchemaExportWrapper)schemaExportWrapper).created); - } - - private class TestSchemaExportWrapper extends SchemaExportWrapper { - - private boolean created = false; - - public TestSchemaExportWrapper(Configuration configuration) { - super(configuration); - } - - @Override - public void create(EnumSet targetTypes, Metadata metadata) { - created = true; - } - - - } - -} diff --git a/jbt/src/test/java/org/hibernate/tool/orm/jbt/wrp/SessionFactoryWrapperTest.java b/jbt/src/test/java/org/hibernate/tool/orm/jbt/wrp/SessionFactoryWrapperTest.java deleted file mode 100644 index c7c888371f..0000000000 --- a/jbt/src/test/java/org/hibernate/tool/orm/jbt/wrp/SessionFactoryWrapperTest.java +++ /dev/null @@ -1,132 +0,0 @@ -package org.hibernate.tool.orm.jbt.wrp; - -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertNotNull; -import static org.junit.jupiter.api.Assertions.assertNull; -import static org.junit.jupiter.api.Assertions.assertTrue; - -import java.io.File; -import java.io.FileWriter; -import java.lang.reflect.InvocationHandler; -import java.lang.reflect.Proxy; -import java.nio.file.Files; -import java.util.HashSet; -import java.util.Map; -import java.util.Set; - -import org.hibernate.Session; -import org.hibernate.cfg.AvailableSettings; -import org.hibernate.cfg.Configuration; -import org.hibernate.engine.spi.SessionFactoryImplementor; -import org.hibernate.persister.collection.CollectionPersister; -import org.hibernate.persister.entity.EntityPersister; -import org.hibernate.tool.orm.jbt.util.MockConnectionProvider; -import org.hibernate.tool.orm.jbt.util.MockDialect; -import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.io.TempDir; - -public class SessionFactoryWrapperTest { - - - private static final String TEST_CFG_XML_STRING = - "" + - " " + - " " + MockDialect.class.getName() + "" + - " " + MockConnectionProvider.class.getName() + "" + - " " + - ""; - - private static final String TEST_HBM_XML_STRING = - "" + - " " + - " " + - " " + - " " + - " " + - " " + - " " + - ""; - - static class Foo { - public String id; - public Set bars = new HashSet(); - } - - @TempDir - public File tempDir; - - private SessionFactoryWrapper sessionFactoryWrapper = null; - - @BeforeEach - public void beforeEach() throws Exception { - tempDir = Files.createTempDirectory("temp").toFile(); - File cfgXmlFile = new File(tempDir, "hibernate.cfg.xml"); - FileWriter fileWriter = new FileWriter(cfgXmlFile); - fileWriter.write(TEST_CFG_XML_STRING); - fileWriter.close(); - File hbmXmlFile = new File(tempDir, "Foo.hbm.xml"); - fileWriter = new FileWriter(hbmXmlFile); - fileWriter.write(TEST_HBM_XML_STRING); - fileWriter.close(); - Configuration configuration = new Configuration(); - configuration.addFile(hbmXmlFile); - configuration.configure(cfgXmlFile); - sessionFactoryWrapper = new SessionFactoryWrapper( - (SessionFactoryImplementor)configuration.buildSessionFactory()); - } - - @Test - public void testOpenSession() { - Session session = sessionFactoryWrapper.openSession(); - assertTrue(session instanceof Proxy); - InvocationHandler invocationHandler = Proxy.getInvocationHandler(session); - assertEquals("org.hibernate.tool.orm.jbt.wrp.SessionWrapperFactory$SessionWrapperInvocationHandler", invocationHandler.getClass().getName()); - } - - @Test - public void testConstruction() { - assertNotNull(sessionFactoryWrapper); - } - - @Test - public void testGetAllClassMetadata() throws Exception { - Map allClassMetadata = sessionFactoryWrapper.getAllClassMetadata(); - assertNotNull(allClassMetadata); - assertEquals(1, allClassMetadata.size()); - EntityPersister fooPersister = allClassMetadata.get(Foo.class.getName()); - assertNotNull(fooPersister); - assertTrue(fooPersister instanceof EntityPersisterWrapperFactory.EntityPersisterExtension); - } - - @Test - public void testGetAllCollectionMetadata() throws Exception { - Map allCollectionMetadata = sessionFactoryWrapper.getAllCollectionMetadata(); - assertEquals(1, allCollectionMetadata.size()); - CollectionPersister barsPersister = allCollectionMetadata.get(Foo.class.getName() + ".bars"); - assertNotNull(barsPersister); - assertTrue(barsPersister instanceof Wrapper); - } - - - @Test - public void testGetClassMetadata() throws Exception { - assertNull(sessionFactoryWrapper.getClassMetadata("foo")); - EntityPersister fooPersister = sessionFactoryWrapper.getClassMetadata(Foo.class.getName()); - assertNotNull(fooPersister); - assertTrue(fooPersister instanceof EntityPersisterWrapperFactory.EntityPersisterExtension); - assertNull(sessionFactoryWrapper.getClassMetadata(Object.class)); - fooPersister = sessionFactoryWrapper.getClassMetadata(Foo.class); - assertNotNull(fooPersister); - assertTrue(fooPersister instanceof EntityPersisterWrapperFactory.EntityPersisterExtension); - } - - @Test - public void testGetCollectionMetadata() throws Exception { - assertNull(sessionFactoryWrapper.getCollectionMetadata("bars")); - CollectionPersister barsPersister = sessionFactoryWrapper.getCollectionMetadata(Foo.class.getName() + ".bars"); - assertNotNull(barsPersister); - assertTrue(barsPersister instanceof Wrapper); - } - -} diff --git a/jbt/src/test/java/org/hibernate/tool/orm/jbt/wrp/SessionWrapperFactoryTest.java b/jbt/src/test/java/org/hibernate/tool/orm/jbt/wrp/SessionWrapperFactoryTest.java deleted file mode 100644 index 838523c643..0000000000 --- a/jbt/src/test/java/org/hibernate/tool/orm/jbt/wrp/SessionWrapperFactoryTest.java +++ /dev/null @@ -1,134 +0,0 @@ -package org.hibernate.tool.orm.jbt.wrp; - -import static org.junit.jupiter.api.Assertions.assertFalse; -import static org.junit.jupiter.api.Assertions.assertNotNull; -import static org.junit.jupiter.api.Assertions.assertSame; -import static org.junit.jupiter.api.Assertions.assertTrue; - -import java.io.File; -import java.io.FileWriter; -import java.lang.reflect.InvocationHandler; -import java.lang.reflect.Proxy; -import java.nio.file.Files; -import java.util.HashSet; -import java.util.Set; - -import org.hibernate.cfg.AvailableSettings; -import org.hibernate.cfg.Configuration; -import org.hibernate.engine.spi.SessionFactoryImplementor; -import org.hibernate.engine.spi.SessionImplementor; -import org.hibernate.query.Query; -import org.hibernate.tool.orm.jbt.util.MockConnectionProvider; -import org.hibernate.tool.orm.jbt.util.MockDialect; -import org.hibernate.tool.orm.jbt.wrp.SessionWrapperFactory.SessionWrapper; -import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.io.TempDir; - - -public class SessionWrapperFactoryTest { - - private static final String TEST_CFG_XML_STRING = - "" + - " " + - " " + MockDialect.class.getName() + "" + - " " + MockConnectionProvider.class.getName() + "" + - " " + - ""; - - private static final String TEST_HBM_XML_STRING = - "" + - " " + - " " + - " " + - " " + - " " + - " " + - " " + - ""; - - static class Foo { - public String id; - public Set bars = new HashSet(); - } - - @TempDir - public File tempDir; - - private SessionFactoryImplementor sessionFactory = null; - private SessionImplementor session = null; - private SessionWrapper sessionWrapper = null; - - @BeforeEach - public void before() throws Exception { - tempDir = Files.createTempDirectory("temp").toFile(); - File cfgXmlFile = new File(tempDir, "hibernate.cfg.xml"); - FileWriter fileWriter = new FileWriter(cfgXmlFile); - fileWriter.write(TEST_CFG_XML_STRING); - fileWriter.close(); - File hbmXmlFile = new File(tempDir, "Foo.hbm.xml"); - fileWriter = new FileWriter(hbmXmlFile); - fileWriter.write(TEST_HBM_XML_STRING); - fileWriter.close(); - Configuration configuration = new Configuration(); - configuration.addFile(hbmXmlFile); - configuration.configure(cfgXmlFile); - sessionFactory = (SessionFactoryImplementor)configuration.buildSessionFactory(); - session = sessionFactory.openSession(); - sessionWrapper = SessionWrapperFactory.createSessionWrapper(sessionFactory, session); - } - - @Test - public void testConstruction() { - assertNotNull(session); - assertNotNull(sessionWrapper); - } - - @Test - public void testGetSessionFactory() { - assertSame(sessionFactory, session.getSessionFactory()); - assertSame(sessionFactory, sessionWrapper.getSessionFactory()); - } - - @Test - public void testCreateQuery() { - Query query = sessionWrapper.createQuery("from " + Foo.class.getName()); - assertNotNull(query); - assertTrue(query instanceof QueryWrapperFactory.QueryWrapper); - } - - @Test - public void testIsOpen() { - assertTrue(sessionWrapper.isOpen()); - session.close(); - assertFalse(sessionWrapper.isOpen()); - } - - @Test - public void testClose() { - assertTrue(session.isOpen()); - sessionWrapper.close(); - assertFalse(session.isOpen()); - } - - @Test - public void testContains() { - Foo first = new Foo(); - first.id = "1"; - session.persist(first); - Foo second = new Foo(); - assertTrue(sessionWrapper.contains(first)); - assertFalse(sessionWrapper.contains(second)); - assertFalse(sessionWrapper.contains("blah")); - } - - @Test - public void testCreateCriteria() { - jakarta.persistence.Query query = ((SessionWrapperFactory.SessionWrapper)sessionWrapper) - .createCriteria(Foo.class); - assertTrue(Proxy.isProxyClass(query.getClass())); - InvocationHandler invocationHandler = Proxy.getInvocationHandler(query); - assertSame(CriteriaWrapperFactory.CriteriaInvocationHandler.class, invocationHandler.getClass()); - } - -} diff --git a/jbt/src/test/java/org/hibernate/tool/orm/jbt/wrp/TypeFactoryWrapperTest.java b/jbt/src/test/java/org/hibernate/tool/orm/jbt/wrp/TypeFactoryWrapperTest.java deleted file mode 100644 index 774962526a..0000000000 --- a/jbt/src/test/java/org/hibernate/tool/orm/jbt/wrp/TypeFactoryWrapperTest.java +++ /dev/null @@ -1,237 +0,0 @@ -package org.hibernate.tool.orm.jbt.wrp; - -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertNotNull; - -import java.text.SimpleDateFormat; -import java.time.ZoneId; -import java.time.ZoneOffset; -import java.util.Currency; -import java.util.Date; -import java.util.Locale; -import java.util.Map; -import java.util.TimeZone; - -import org.hibernate.tool.orm.jbt.wrp.TypeWrapperFactory.TypeWrapper; -import org.hibernate.type.Type; -import org.junit.jupiter.api.AfterAll; -import org.junit.jupiter.api.BeforeAll; -import org.junit.jupiter.api.Test; - -public class TypeFactoryWrapperTest { - - private static Locale SAVED_LOCALE = null; - - @BeforeAll - public static void beforeAll() { - SAVED_LOCALE = Locale.getDefault(); - Locale.setDefault(new Locale("nl", "BE")); - } - - @AfterAll - public static void afterAll() { - Locale.setDefault(SAVED_LOCALE); - } - - @Test - public void testConstruction() { - assertNotNull(TypeFactoryWrapper.INSTANCE); - } - - @Test - public void testGetBooleanType() { - TypeWrapper booleanTypeWrapper = TypeFactoryWrapper.INSTANCE.getBooleanType(); - assertEquals("boolean", ((Type)booleanTypeWrapper.getWrappedObject()).getName()); - } - - @Test - public void testGetByteType() { - TypeWrapper byteTypeWrapper = TypeFactoryWrapper.INSTANCE.getByteType(); - assertEquals("byte", ((Type)byteTypeWrapper.getWrappedObject()).getName()); - } - - @Test - public void testGetBigIntegerType() { - TypeWrapper bigIntegerTypeWrapper = TypeFactoryWrapper.INSTANCE.getBigIntegerType(); - assertEquals("big_integer", ((Type)bigIntegerTypeWrapper.getWrappedObject()).getName()); - } - - @Test - public void testGetShortType() { - TypeWrapper shortTypeWrapper = TypeFactoryWrapper.INSTANCE.getShortType(); - assertEquals("short", ((Type)shortTypeWrapper.getWrappedObject()).getName()); - } - - @Test - public void testGetCalendarType() { - TypeWrapper calendarTypeWrapper = TypeFactoryWrapper.INSTANCE.getCalendarType(); - assertEquals("calendar", ((Type)calendarTypeWrapper.getWrappedObject()).getName()); - } - - @Test - public void testGetCalendarDateType() { - TypeWrapper calendarDateTypeWrapper = TypeFactoryWrapper.INSTANCE.getCalendarDateType(); - assertEquals("calendar_date", ((Type)calendarDateTypeWrapper.getWrappedObject()).getName()); - } - - @Test - public void testGetIntegerType() { - TypeWrapper integerTypeWrapper = TypeFactoryWrapper.INSTANCE.getIntegerType(); - assertEquals("integer", ((Type)integerTypeWrapper.getWrappedObject()).getName()); - } - - @Test - public void testGetBigDecimalType() { - TypeWrapper bigDecimalTypeWrapper = TypeFactoryWrapper.INSTANCE.getBigDecimalType(); - assertEquals("big_decimal", ((Type)bigDecimalTypeWrapper.getWrappedObject()).getName()); - } - - @Test - public void testGetCharacterType() { - TypeWrapper characterTypeWrapper = TypeFactoryWrapper.INSTANCE.getCharacterType(); - assertEquals("character", ((Type)characterTypeWrapper.getWrappedObject()).getName()); - } - - @Test - public void testGetClassType() { - TypeWrapper classTypeWrapper = TypeFactoryWrapper.INSTANCE.getClassType(); - assertEquals("class", ((Type)classTypeWrapper.getWrappedObject()).getName()); - } - - @Test - public void testGetCurrencyType() { - TypeWrapper currencyTypeWrapper = TypeFactoryWrapper.INSTANCE.getCurrencyType(); - assertEquals("currency", ((Type)currencyTypeWrapper.getWrappedObject()).getName()); - } - - @Test - public void testGetDateType() { - TypeWrapper dateTypeWrapper = TypeFactoryWrapper.INSTANCE.getDateType(); - assertEquals("date", ((Type)dateTypeWrapper.getWrappedObject()).getName()); - } - - @Test - public void testGetDoubleType() { - TypeWrapper doubleTypeWrapper = TypeFactoryWrapper.INSTANCE.getDoubleType(); - assertEquals("double", ((Type)doubleTypeWrapper.getWrappedObject()).getName()); - } - - @Test - public void testGetFloatType() { - TypeWrapper floatTypeWrapper = TypeFactoryWrapper.INSTANCE.getFloatType(); - assertEquals("float", ((Type)floatTypeWrapper.getWrappedObject()).getName()); - } - - @Test - public void testGetLocaleType() { - TypeWrapper localeTypeWrapper = TypeFactoryWrapper.INSTANCE.getLocaleType(); - assertEquals("locale", ((Type)localeTypeWrapper.getWrappedObject()).getName()); - } - - @Test - public void testGetLongType() { - TypeWrapper longTypeWrapper = TypeFactoryWrapper.INSTANCE.getLongType(); - assertEquals("long", ((Type)longTypeWrapper.getWrappedObject()).getName()); - } - - @Test - public void testGetStringType() { - TypeWrapper stringTypeWrapper = TypeFactoryWrapper.INSTANCE.getStringType(); - assertEquals("string", ((Type)stringTypeWrapper.getWrappedObject()).getName()); - } - - @Test - public void testGetTextType() { - TypeWrapper textTypeWrapper = TypeFactoryWrapper.INSTANCE.getTextType(); - assertEquals("text", ((Type)textTypeWrapper.getWrappedObject()).getName()); - } - - @Test - public void testGetTimeType() { - TypeWrapper timeTypeWrapper = TypeFactoryWrapper.INSTANCE.getTimeType(); - assertEquals("time", ((Type)timeTypeWrapper.getWrappedObject()).getName()); - } - - @Test - public void testGetTimestampType() { - TypeWrapper timestampTypeWrapper = TypeFactoryWrapper.INSTANCE.getTimestampType(); - assertEquals("timestamp", ((Type)timestampTypeWrapper.getWrappedObject()).getName()); - } - - @Test - public void testGetTimezoneType() { - TypeWrapper timezoneTypeWrapper = TypeFactoryWrapper.INSTANCE.getTimezoneType(); - assertEquals("timezone", ((Type)timezoneTypeWrapper.getWrappedObject()).getName()); - } - - @Test - public void testGetTrueFalseType() { - TypeWrapper trueFalselTypeWrapper = TypeFactoryWrapper.INSTANCE.getTrueFalseType(); - assertEquals("true_false", ((Type)trueFalselTypeWrapper.getWrappedObject()).getName()); - } - - @Test - public void testGetYesNoType() { - TypeWrapper yesNoTypeWrapper = TypeFactoryWrapper.INSTANCE.getYesNoType(); - assertEquals("yes_no", ((Type)yesNoTypeWrapper.getWrappedObject()).getName()); - } - - @Test - public void testGetNamedType() { - TypeWrapper typeWrapper = TypeFactoryWrapper.INSTANCE.getNamedType(String.class.getName()); - assertEquals("string", ((Type)typeWrapper.getWrappedObject()).getName()); - } - - @Test - public void testGetBasicType() { - TypeWrapper typeWrapper = TypeFactoryWrapper.INSTANCE.getBasicType(String.class.getName()); - assertEquals("string", ((Type)typeWrapper.getWrappedObject()).getName()); - } - - @Test - public void testGetTypeFormats() { - Map typeFormats = TypeFactoryWrapper.INSTANCE.getTypeFormats(); - assertEquals(23, typeFormats.size()); - assertEquals("true", typeFormats.get(TypeFactoryWrapper.INSTANCE.getBooleanType())); - assertEquals("42", typeFormats.get(TypeFactoryWrapper.INSTANCE.getByteType())); - assertEquals("42", typeFormats.get(TypeFactoryWrapper.INSTANCE.getBigIntegerType())); - assertEquals("42", typeFormats.get(TypeFactoryWrapper.INSTANCE.getShortType())); - assertEquals( - new SimpleDateFormat("yyyy-MM-dd").format(new Date()), - typeFormats.get(TypeFactoryWrapper.INSTANCE.getCalendarType())); - assertEquals( - new SimpleDateFormat("yyyy-MM-dd").format(new Date()), - typeFormats.get(TypeFactoryWrapper.INSTANCE.getCalendarDateType())); - assertEquals("42", typeFormats.get(TypeFactoryWrapper.INSTANCE.getIntegerType())); - assertEquals("42", typeFormats.get(TypeFactoryWrapper.INSTANCE.getBigDecimalType())); - assertEquals("h", typeFormats.get(TypeFactoryWrapper.INSTANCE.getCharacterType())); - assertEquals( - Class.class.getName(), - typeFormats.get(TypeFactoryWrapper.INSTANCE.getClassType())); - assertEquals( - Currency.getInstance(Locale.getDefault()).toString(), - typeFormats.get(TypeFactoryWrapper.INSTANCE.getCurrencyType())); - assertEquals( - new SimpleDateFormat("yyyy-MM-dd").format(new Date()), - typeFormats.get(TypeFactoryWrapper.INSTANCE.getDateType())); - assertEquals("42.42", typeFormats.get(TypeFactoryWrapper.INSTANCE.getDoubleType())); - assertEquals("42.42", typeFormats.get(TypeFactoryWrapper.INSTANCE.getFloatType())); - assertEquals( - Locale.getDefault().toString(), - typeFormats.get(TypeFactoryWrapper.INSTANCE.getLocaleType())); - assertEquals("42", typeFormats.get(TypeFactoryWrapper.INSTANCE.getLongType())); - assertEquals("a string", typeFormats.get(TypeFactoryWrapper.INSTANCE.getStringType())); - assertEquals("a text", typeFormats.get(TypeFactoryWrapper.INSTANCE.getTextType())); - assertEquals(':', typeFormats.get(TypeFactoryWrapper.INSTANCE.getTimeType()).charAt(2)); - //JdbcTimestampJavaType uses timezone UTC+0 for the string format vs the system default tz for JdbcDateJavaType. - SimpleDateFormat utcDateFormat = new SimpleDateFormat("yyyy-MM-dd"); - utcDateFormat.setTimeZone(TimeZone.getTimeZone(ZoneId.from( ZoneOffset.UTC ))); - assertEquals(utcDateFormat.format(new Date()).substring(0, 10), - typeFormats.get(TypeFactoryWrapper.INSTANCE.getTimestampType()).substring(0, 10)); - assertEquals( - TimeZone.getDefault().getID(), - typeFormats.get(TypeFactoryWrapper.INSTANCE.getTimezoneType())); - assertEquals("true", typeFormats.get(TypeFactoryWrapper.INSTANCE.getTrueFalseType())); - assertEquals("true", typeFormats.get(TypeFactoryWrapper.INSTANCE.getYesNoType())); - } -} diff --git a/jbt/src/test/java/org/hibernate/tool/orm/jbt/wrp/TypeWrapperFactoryTest.java b/jbt/src/test/java/org/hibernate/tool/orm/jbt/wrp/TypeWrapperFactoryTest.java deleted file mode 100644 index dcb65357a3..0000000000 --- a/jbt/src/test/java/org/hibernate/tool/orm/jbt/wrp/TypeWrapperFactoryTest.java +++ /dev/null @@ -1,19 +0,0 @@ -package org.hibernate.tool.orm.jbt.wrp; - -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertNotNull; - -import org.hibernate.tool.orm.jbt.wrp.TypeWrapperFactory.TypeWrapper; -import org.hibernate.type.Type; -import org.junit.jupiter.api.Test; - -public class TypeWrapperFactoryTest { - - @Test - public void testCreateTypeWrapper() { - TypeWrapper typeWrapper = TypeWrapperFactory.createTypeWrapper(TypeFactoryWrapper.INSTANCE.getStringType()); - assertNotNull(typeWrapper); - assertEquals("string", ((Type)((Wrapper)typeWrapper).getWrappedObject()).getName()); - } - -} diff --git a/jbt/src/test/java/org/hibernate/tool/orm/jbt/wrp/TypeWrapperTest.java b/jbt/src/test/java/org/hibernate/tool/orm/jbt/wrp/TypeWrapperTest.java deleted file mode 100644 index 7c80b108c6..0000000000 --- a/jbt/src/test/java/org/hibernate/tool/orm/jbt/wrp/TypeWrapperTest.java +++ /dev/null @@ -1,273 +0,0 @@ -package org.hibernate.tool.orm.jbt.wrp; - -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertFalse; -import static org.junit.jupiter.api.Assertions.assertNull; -import static org.junit.jupiter.api.Assertions.assertTrue; -import static org.junit.jupiter.api.Assertions.fail; - -import org.hibernate.boot.spi.MetadataBuildingContext; -import org.hibernate.mapping.Component; -import org.hibernate.mapping.PersistentClass; -import org.hibernate.mapping.RootClass; -import org.hibernate.tool.orm.jbt.util.DummyMetadataBuildingContext; -import org.hibernate.tool.orm.jbt.wrp.TypeWrapperFactory.TypeWrapper; -import org.hibernate.type.AnyType; -import org.hibernate.type.ArrayType; -import org.hibernate.type.BagType; -import org.hibernate.type.ComponentType; -import org.hibernate.type.ManyToOneType; -import org.hibernate.type.OneToOneType; -import org.hibernate.type.spi.TypeConfiguration; -import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Test; - -public class TypeWrapperTest { - - private TypeConfiguration typeConfiguration = null; - - @BeforeEach - public void beforeEach() { - typeConfiguration = new TypeConfiguration(); - } - - @Test - public void testToString() { - // first try type that is string representable - TypeWrapper classTypeWrapper = TypeWrapperFactory.createTypeWrapper( - typeConfiguration.getBasicTypeForJavaType(Class.class)); - assertEquals( - TypeWrapperTest.class.getName(), - classTypeWrapper.toString(TypeWrapperTest.class)); - // next try a type that cannot be represented by a string - try { - TypeWrapper arrayTypeWrapper = - TypeWrapperFactory.createTypeWrapper(new ArrayType("foo", "bar", String.class)); - arrayTypeWrapper.toString(new String[] { "foo", "bar" }); - fail(); - } catch (UnsupportedOperationException e) { - assertTrue(e.getMessage().contains("does not support 'toString(Object)'")); - } - } - - @Test - public void testGetName() { - // first try a class type - TypeWrapper classTypeWrapper = TypeWrapperFactory.createTypeWrapper( - typeConfiguration.getBasicTypeForJavaType(Class.class)); - assertEquals("class", classTypeWrapper.getName()); - // next try a array type - TypeWrapper arrayTypeWrapper = - TypeWrapperFactory.createTypeWrapper(new ArrayType("foo", "bar", String.class)); - assertEquals("[Ljava.lang.String;(foo)", arrayTypeWrapper.getName()); - } - - @Test - public void testFromStringValue() { - TypeWrapper classTypeWrapper = TypeWrapperFactory.createTypeWrapper( - typeConfiguration.getBasicTypeForJavaType(Class.class)); - assertEquals( - TypeWrapperTest.class, - classTypeWrapper.fromStringValue(TypeWrapperTest.class.getName())); - // next try type that is not string representable - try { - TypeWrapper arrayTypeWrapper = - TypeWrapperFactory.createTypeWrapper(new ArrayType("foo", "bar", String.class)); - arrayTypeWrapper.fromStringValue("just a random string"); - fail(); - } catch (UnsupportedOperationException e) { - assertTrue(e.getMessage().contains("does not support 'fromStringValue(Object)'")); - } - } - - @Test - public void testIsEntityType() { - // first try type that is not an entity type - TypeWrapper classTypeWrapper = TypeWrapperFactory.createTypeWrapper( - typeConfiguration.getBasicTypeForJavaType(Class.class)); - assertFalse(classTypeWrapper.isEntityType()); - // next try type that is an entity type - TypeWrapper entityTypeWrapper = TypeWrapperFactory.createTypeWrapper( - new ManyToOneType((TypeConfiguration)null, null)); - assertTrue(entityTypeWrapper.isEntityType()); - } - - @Test - public void testIsOneToOne() { - // first try type that is not a one to one type - try { - TypeWrapper classTypeWrapper = TypeWrapperFactory.createTypeWrapper( - typeConfiguration.getBasicTypeForJavaType(Class.class)); - classTypeWrapper.isOneToOne(); - fail(); - } catch (UnsupportedOperationException e) { - assertTrue(e.getMessage().contains("does not support 'isOneToOne()'")); - } - // next try another type that is not a one to one type - TypeWrapper entityTypeWrapper = TypeWrapperFactory.createTypeWrapper( - new ManyToOneType((TypeConfiguration)null, null)); - assertFalse(entityTypeWrapper.isOneToOne()); - // finally try a type that is a one to one type - TypeWrapper oneToOneTypeWrapper = TypeWrapperFactory.createTypeWrapper( - new OneToOneType( - null, null, null, false, null, false, false, null, null, false)); - assertTrue(oneToOneTypeWrapper.isOneToOne()); - } - - @Test - public void testIsAnyType() { - // first try type that is not a any type - TypeWrapper classTypeWrapper = TypeWrapperFactory.createTypeWrapper( - typeConfiguration.getBasicTypeForJavaType(Class.class)); - assertFalse(classTypeWrapper.isAnyType()); - // next try a any type - TypeWrapper anyTypeWrapper = - TypeWrapperFactory.createTypeWrapper(new AnyType(null, null, null, true)); - assertTrue(anyTypeWrapper.isAnyType()); - } - - @Test - public void testIsComponentType() { - // first try type that is not a component type - TypeWrapper classTypeWrapper = TypeWrapperFactory.createTypeWrapper( - typeConfiguration.getBasicTypeForJavaType(Class.class)); - assertFalse(classTypeWrapper.isComponentType()); - // next try a component type - Component component = new Component( - DummyMetadataBuildingContext.INSTANCE, - new RootClass(DummyMetadataBuildingContext.INSTANCE)); - component.setComponentClassName("java.lang.Object"); - TypeWrapper anyTypeWrapper = - TypeWrapperFactory.createTypeWrapper( - new ComponentType(component, null, DummyMetadataBuildingContext.INSTANCE)); - assertTrue(anyTypeWrapper.isComponentType()); - } - - @Test - public void testIsCollectionType() { - // first try type that is not a collection type - TypeWrapper classTypeWrapper = - TypeWrapperFactory.createTypeWrapper( - typeConfiguration.getBasicTypeForJavaType(Class.class)); - assertFalse(classTypeWrapper.isCollectionType()); - // next try a collection type - TypeWrapper arrayTypeWrapper = - TypeWrapperFactory.createTypeWrapper(new ArrayType(null, null, String.class)); - assertTrue(arrayTypeWrapper.isCollectionType()); - } - - @Test - public void testGetReturnedClassName() { - // first try a class type - TypeWrapper classTypeWrapper = TypeWrapperFactory.createTypeWrapper( - typeConfiguration.getBasicTypeForJavaType(Class.class)); - assertEquals(Class.class.getName(), classTypeWrapper.getReturnedClassName()); - // next try an array type of string values - TypeWrapper arrayTypeWrapper = TypeWrapperFactory.createTypeWrapper( - new ArrayType("foo", "bar", String.class)); - assertEquals(String[].class.getName(), arrayTypeWrapper.getReturnedClassName()); - // next try a many to one type - TypeConfiguration typeConfiguration = new TypeConfiguration(); - MetadataBuildingContext metadataBuildingContext = DummyMetadataBuildingContext.INSTANCE; - PersistentClass orgFooBarClass = new RootClass(DummyMetadataBuildingContext.INSTANCE); - orgFooBarClass.setEntityName("org.foo.bar"); - orgFooBarClass.setClassName(OrgFooBar.class.getName()); - metadataBuildingContext.getMetadataCollector().getEntityBindingMap().put( - "org.foo.bar", - orgFooBarClass); - typeConfiguration.scope(DummyMetadataBuildingContext.INSTANCE); - TypeWrapper manyToOneTypeWrapper = TypeWrapperFactory.createTypeWrapper( - new ManyToOneType(typeConfiguration, "org.foo.bar")); - assertEquals(OrgFooBar.class.getName(), manyToOneTypeWrapper.getReturnedClassName()); - } - - @Test - public void testGetAssociatedEntityName() { - // first try a class type - TypeWrapper classTypeWrapper = TypeWrapperFactory.createTypeWrapper( - typeConfiguration.getBasicTypeForJavaType(Class.class)); - assertNull(classTypeWrapper.getAssociatedEntityName()); - // next try a many to one type - TypeWrapper manyToOneTypeWrapper = TypeWrapperFactory.createTypeWrapper( - new ManyToOneType((TypeConfiguration)null, "foo")); - assertEquals("foo", manyToOneTypeWrapper.getAssociatedEntityName()); - } - - @Test - public void testIsIntegerType() { - // first try a class type - TypeWrapper classTypeWrapper = TypeWrapperFactory.createTypeWrapper( - typeConfiguration.getBasicTypeForJavaType(Class.class)); - assertFalse(classTypeWrapper.isIntegerType()); - // next try a integer type - TypeWrapper integerTypeWrapper = TypeWrapperFactory.createTypeWrapper( - typeConfiguration.getBasicTypeForJavaType(Integer.class)); - assertTrue(integerTypeWrapper.isIntegerType()); - } - - @Test - public void testIsArrayType() { - // first try a class type - TypeWrapper classTypeWrapper = TypeWrapperFactory.createTypeWrapper( - typeConfiguration.getBasicTypeForJavaType(Class.class)); - assertFalse(classTypeWrapper.isArrayType()); - // next try a bag type - TypeWrapper bagTypeWrapper = TypeWrapperFactory.createTypeWrapper(new BagType(null, null)); - assertFalse(bagTypeWrapper.isArrayType()); - // finally try a array type - TypeWrapper arrayTypeWrapper = - TypeWrapperFactory.createTypeWrapper(new ArrayType("foo", "bar", String.class)); - assertTrue(arrayTypeWrapper.isArrayType()); - } - - @Test - public void testIsInstanceOfPrimitiveType() { - // first try a class type - TypeWrapper classTypeWrapper = TypeWrapperFactory.createTypeWrapper( - typeConfiguration.getBasicTypeForJavaType(Class.class)); - assertFalse(classTypeWrapper.isInstanceOfPrimitiveType()); - // next try a string type - TypeWrapper stringTypeWrapper = TypeWrapperFactory.createTypeWrapper( - typeConfiguration.getBasicTypeForJavaType(String.class)); - assertFalse(stringTypeWrapper.isInstanceOfPrimitiveType()); - // finally try a integer type - TypeWrapper integerTypeWrapper = TypeWrapperFactory.createTypeWrapper( - typeConfiguration.getBasicTypeForJavaType(Integer.class)); - assertTrue(integerTypeWrapper.isInstanceOfPrimitiveType()); - } - - @Test - public void testGetPrimitiveClass() { - // first try a class type - try { - TypeWrapper classTypeWrapper = TypeWrapperFactory.createTypeWrapper( - typeConfiguration.getBasicTypeForJavaType(Class.class)); - classTypeWrapper.getPrimitiveClass(); - } catch (UnsupportedOperationException e) { - assertTrue(e.getMessage().contains("does not support 'getPrimitiveClass()'")); - } - // next try a integer type - TypeWrapper integerTypeWrapper = TypeWrapperFactory.createTypeWrapper( - typeConfiguration.getBasicTypeForJavaType(Integer.class)); - assertEquals(int.class, integerTypeWrapper.getPrimitiveClass()); - } - - @Test - public void testGetRole() { - // first try a class type - try { - TypeWrapper classTypeWrapper = TypeWrapperFactory.createTypeWrapper( - typeConfiguration.getBasicTypeForJavaType(Class.class)); - classTypeWrapper.getRole(); - } catch (UnsupportedOperationException e) { - assertTrue(e.getMessage().contains("does not support 'getRole()'")); - } - // finally try a array type - TypeWrapper arrayTypeWrapper = - TypeWrapperFactory.createTypeWrapper(new ArrayType("foo", "bar", String.class)); - assertEquals("foo", arrayTypeWrapper.getRole()); - } - - public static class OrgFooBar {} - -} diff --git a/jbt/src/test/java/org/hibernate/tool/orm/jbt/wrp/ValueWrapperFactoryTest.java b/jbt/src/test/java/org/hibernate/tool/orm/jbt/wrp/ValueWrapperFactoryTest.java deleted file mode 100644 index 393b410334..0000000000 --- a/jbt/src/test/java/org/hibernate/tool/orm/jbt/wrp/ValueWrapperFactoryTest.java +++ /dev/null @@ -1,58 +0,0 @@ -package org.hibernate.tool.orm.jbt.wrp; - -import static org.junit.jupiter.api.Assertions.assertNotNull; -import static org.junit.jupiter.api.Assertions.assertNull; -import static org.junit.jupiter.api.Assertions.assertSame; - -import org.hibernate.mapping.BasicValue; -import org.hibernate.mapping.KeyValue; -import org.hibernate.mapping.List; -import org.hibernate.mapping.Value; -import org.hibernate.tool.orm.jbt.util.DummyMetadataBuildingContext; -import org.hibernate.tool.orm.jbt.wrp.ValueWrapperFactory.ValueWrapper; -import org.junit.jupiter.api.Test; - -public class ValueWrapperFactoryTest { - - @Test - public void testCreateValueWrapper() { - Value valueTarget = new BasicValue(DummyMetadataBuildingContext.INSTANCE); - Value valueWrapper = ValueWrapperFactory.createValueWrapper(valueTarget); - assertNotNull(valueWrapper); - assertSame(valueTarget, ((Wrapper)valueWrapper).getWrappedObject()); - } - - @Test - public void testGetElement() { - List valueTarget = new List(DummyMetadataBuildingContext.INSTANCE, null); - Value basicValue = new BasicValue(DummyMetadataBuildingContext.INSTANCE); - ValueWrapper valueWrapper = ValueWrapperFactory.createValueWrapper(valueTarget); - valueTarget.setElement(basicValue); - assertSame(basicValue, ((Wrapper)valueWrapper.getElement()).getWrappedObject()); - valueTarget.setElement(null); - assertNull(valueWrapper.getElement()); - } - - @Test - public void testGetCollectionElement() { - List valueTarget = new List(DummyMetadataBuildingContext.INSTANCE, null); - Value basicValue = new BasicValue(DummyMetadataBuildingContext.INSTANCE); - ValueWrapper valueWrapper = ValueWrapperFactory.createValueWrapper(valueTarget); - valueTarget.setElement(basicValue); - assertSame(basicValue, ((Wrapper)valueWrapper.getCollectionElement()).getWrappedObject()); - valueTarget.setElement(null); - assertNull(valueWrapper.getCollectionElement()); - } - - @Test - public void testGetKey() { - List valueTarget = new List(DummyMetadataBuildingContext.INSTANCE, null); - KeyValue keyValue = new BasicValue(DummyMetadataBuildingContext.INSTANCE); - ValueWrapper valueWrapper = ValueWrapperFactory.createValueWrapper(valueTarget); - valueTarget.setKey(keyValue); - assertSame(keyValue, ((Wrapper)valueWrapper.getKey()).getWrappedObject()); - valueTarget.setKey(null); - assertNull(valueWrapper.getKey()); - } - -} diff --git a/maven/docs/5-minute-tutorial.md b/maven/docs/5-minute-tutorial.md index 118ad98e68..885bf77573 100644 --- a/maven/docs/5-minute-tutorial.md +++ b/maven/docs/5-minute-tutorial.md @@ -120,7 +120,7 @@ To properly generate our entity, we need to do two more things. The first is of ... - 6.0.0-SNAPSHOT + 6.2.22.Final diff --git a/maven/pom.xml b/maven/pom.xml index b03073f3f3..4f1b567f48 100644 --- a/maven/pom.xml +++ b/maven/pom.xml @@ -21,7 +21,7 @@ org.hibernate.tool hibernate-tools-parent - 6.5.0.Final + 6.6.27-SNAPSHOT hibernate-tools-maven @@ -68,11 +68,13 @@ - false + + false false 3.5 3.5.2 + 3.9.9 2.9 @@ -86,12 +88,27 @@ org.hibernate.tool hibernate-tools-orm + + org.junit.jupiter + junit-jupiter-engine + test + + + com.h2database + h2 + test + org.apache.maven maven-plugin-api ${maven-plugin-api.version} + + org.apache.maven + maven-core + ${maven-core.version} + org.apache.maven.plugin-tools maven-plugin-annotations @@ -124,12 +141,18 @@ default-descriptor process-classes + + hibernate-tools + help-goal helpmojo + + hibernate-tools + @@ -150,10 +173,38 @@ + + maven-invoker-plugin + ${maven-invoker-plugin.version} + + + com.h2database + h2 + ${h2.version} + + + + true + ${project.build.directory}/it + ${project.build.directory}/local-repo + setup + verify + **/pom.xml + + + + integration-test + + install + run + + + + - + maven-project-info-reports-plugin diff --git a/maven/src/it/hbm2java/invoker.properties b/maven/src/it/hbm2java/invoker.properties new file mode 100644 index 0000000000..27e586ee24 --- /dev/null +++ b/maven/src/it/hbm2java/invoker.properties @@ -0,0 +1,18 @@ +############################################################################ +# Hibernate Tools, Tooling for your Hibernate Projects # +# # +# Copyright 2018-2025 Red Hat, Inc. # +# # +# Licensed under the Apache License, Version 2.0 (the "License"); # +# you may not use this file except in compliance with the License. # +# You may obtain a copy of the License at # +# # +# http://www.apache.org/licenses/LICENSE-2.0 # +# # +# Unless required by applicable law or agreed to in writing, software # +# distributed under the License is distributed on an "AS IS" basis, # +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # +# See the License for the specific language governing permissions and # +# limitations under the License. # +############################################################################ +invoker.goals = generate-resources \ No newline at end of file diff --git a/maven/src/it/hbm2java/jpa-default/pom.xml b/maven/src/it/hbm2java/jpa-default/pom.xml new file mode 100644 index 0000000000..940e1a8d6c --- /dev/null +++ b/maven/src/it/hbm2java/jpa-default/pom.xml @@ -0,0 +1,53 @@ + + + + 4.0.0 + + org.hibernate.tool.maven.test + hbm2java-jpa-default + 0.0.1-SNAPSHOT + + + + com.h2database + h2 + @h2.version@ + + + + + + + org.hibernate.tool + hibernate-tools-maven + @project.version@ + + + Entity generation + generate-sources + + hbm2java + + + + + + + + \ No newline at end of file diff --git a/maven/src/it/hbm2java/jpa-default/setup.bsh b/maven/src/it/hbm2java/jpa-default/setup.bsh new file mode 100644 index 0000000000..70f35cb226 --- /dev/null +++ b/maven/src/it/hbm2java/jpa-default/setup.bsh @@ -0,0 +1,26 @@ +/* + * Hibernate Tools, Tooling for your Hibernate Projects + * + * Copyright 2018-2025 Red Hat, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +import java.sql.DriverManager; +import java.sql.Connection; + +String JDBC_CONNECTION = "jdbc:h2:" + basedir + "/test"; +String CREATE_PERSON_TABLE = "create table PERSON (ID int not null, NAME varchar(20), primary key (ID))"; + +Connection connection = DriverManager.getConnection(JDBC_CONNECTION); +connection.createStatement().execute(CREATE_PERSON_TABLE); +connection.close(); diff --git a/maven/src/it/hbm2java/jpa-default/src/main/resources/hibernate.properties b/maven/src/it/hbm2java/jpa-default/src/main/resources/hibernate.properties new file mode 100644 index 0000000000..32da3e5d10 --- /dev/null +++ b/maven/src/it/hbm2java/jpa-default/src/main/resources/hibernate.properties @@ -0,0 +1,21 @@ +############################################################################ +# Hibernate Tools, Tooling for your Hibernate Projects # +# # +# Copyright 2018-2025 Red Hat, Inc. # +# # +# Licensed under the Apache License, Version 2.0 (the "License"); # +# you may not use this file except in compliance with the License. # +# You may obtain a copy of the License at # +# # +# http://www.apache.org/licenses/LICENSE-2.0 # +# # +# Unless required by applicable law or agreed to in writing, software # +# distributed under the License is distributed on an "AS IS" basis, # +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # +# See the License for the specific language governing permissions and # +# limitations under the License. # +############################################################################ +hibernate.connection.driver_class=org.h2.Driver +hibernate.connection.url=jdbc:h2:./test +hibernate.default_catalog=TEST +hibernate.default_schema=PUBLIC \ No newline at end of file diff --git a/maven/src/it/hbm2java/jpa-default/verify.bsh b/maven/src/it/hbm2java/jpa-default/verify.bsh new file mode 100644 index 0000000000..31928d4d9b --- /dev/null +++ b/maven/src/it/hbm2java/jpa-default/verify.bsh @@ -0,0 +1,29 @@ +/* + * Hibernate Tools, Tooling for your Hibernate Projects + * + * Copyright 2018-2025 Red Hat, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +import java.nio.file.Files; + +File personEntity = new File(basedir, "target/generated-sources/Person.java"); +if (!personEntity.isFile()) { + throw new FileNotFoundException("Could not find generated JPA Entity: " + personEntity); +} +byte[] raw = Files.readAllBytes(personEntity.toPath()); +if (!new String(raw).contains("import jakarta.persistence.Entity;")) { + throw new RuntimeException("The generated java file is not a JPA Entity"); +} + + diff --git a/maven/src/it/hbm2java/no-annotations/pom.xml b/maven/src/it/hbm2java/no-annotations/pom.xml new file mode 100644 index 0000000000..f1d6f32fa4 --- /dev/null +++ b/maven/src/it/hbm2java/no-annotations/pom.xml @@ -0,0 +1,56 @@ + + + + 4.0.0 + + org.hibernate.tool.maven.test + hbm2java-no-annotations + 0.0.1-SNAPSHOT + + + + com.h2database + h2 + @h2.version@ + + + + + + + org.hibernate.tool + hibernate-tools-maven + @project.version@ + + + Entity generation + generate-sources + + hbm2java + + + + + false + + + + + + \ No newline at end of file diff --git a/maven/src/it/hbm2java/no-annotations/setup.bsh b/maven/src/it/hbm2java/no-annotations/setup.bsh new file mode 100644 index 0000000000..70f35cb226 --- /dev/null +++ b/maven/src/it/hbm2java/no-annotations/setup.bsh @@ -0,0 +1,26 @@ +/* + * Hibernate Tools, Tooling for your Hibernate Projects + * + * Copyright 2018-2025 Red Hat, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +import java.sql.DriverManager; +import java.sql.Connection; + +String JDBC_CONNECTION = "jdbc:h2:" + basedir + "/test"; +String CREATE_PERSON_TABLE = "create table PERSON (ID int not null, NAME varchar(20), primary key (ID))"; + +Connection connection = DriverManager.getConnection(JDBC_CONNECTION); +connection.createStatement().execute(CREATE_PERSON_TABLE); +connection.close(); diff --git a/maven/src/it/hbm2java/no-annotations/src/main/resources/hibernate.properties b/maven/src/it/hbm2java/no-annotations/src/main/resources/hibernate.properties new file mode 100644 index 0000000000..32da3e5d10 --- /dev/null +++ b/maven/src/it/hbm2java/no-annotations/src/main/resources/hibernate.properties @@ -0,0 +1,21 @@ +############################################################################ +# Hibernate Tools, Tooling for your Hibernate Projects # +# # +# Copyright 2018-2025 Red Hat, Inc. # +# # +# Licensed under the Apache License, Version 2.0 (the "License"); # +# you may not use this file except in compliance with the License. # +# You may obtain a copy of the License at # +# # +# http://www.apache.org/licenses/LICENSE-2.0 # +# # +# Unless required by applicable law or agreed to in writing, software # +# distributed under the License is distributed on an "AS IS" basis, # +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # +# See the License for the specific language governing permissions and # +# limitations under the License. # +############################################################################ +hibernate.connection.driver_class=org.h2.Driver +hibernate.connection.url=jdbc:h2:./test +hibernate.default_catalog=TEST +hibernate.default_schema=PUBLIC \ No newline at end of file diff --git a/maven/src/it/hbm2java/no-annotations/verify.bsh b/maven/src/it/hbm2java/no-annotations/verify.bsh new file mode 100644 index 0000000000..c53e2a18b5 --- /dev/null +++ b/maven/src/it/hbm2java/no-annotations/verify.bsh @@ -0,0 +1,29 @@ +/* + * Hibernate Tools, Tooling for your Hibernate Projects + * + * Copyright 2018-2025 Red Hat, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +import java.nio.file.Files; + +File personEntity = new File(basedir, "target/generated-sources/Person.java"); +if (!personEntity.isFile()) { + throw new FileNotFoundException("Could not find generated Java file: " + personEntity); +} +byte[] raw = Files.readAllBytes(personEntity.toPath()); +if (new String(raw).contains("import jakarta.persistence.Entity;")) { + throw new RuntimeException("The generated Java file should not have an @Entity annotation"); +} + + diff --git a/maven/src/it/hbm2java/no-generics/pom.xml b/maven/src/it/hbm2java/no-generics/pom.xml new file mode 100644 index 0000000000..082b942d96 --- /dev/null +++ b/maven/src/it/hbm2java/no-generics/pom.xml @@ -0,0 +1,56 @@ + + + + 4.0.0 + + org.hibernate.tool.maven.test + hbm2java-no-generics + 0.0.1-SNAPSHOT + + + + com.h2database + h2 + @h2.version@ + + + + + + + org.hibernate.tool + hibernate-tools-maven + @project.version@ + + + Entity generation + generate-sources + + hbm2java + + + + + false + + + + + + \ No newline at end of file diff --git a/maven/src/it/hbm2java/no-generics/setup.bsh b/maven/src/it/hbm2java/no-generics/setup.bsh new file mode 100644 index 0000000000..b4b5a472c6 --- /dev/null +++ b/maven/src/it/hbm2java/no-generics/setup.bsh @@ -0,0 +1,34 @@ +/* + * Hibernate Tools, Tooling for your Hibernate Projects + * + * Copyright 2018-2025 Red Hat, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +import java.sql.DriverManager; +import java.sql.Connection; +import java.sql.Statement; + +String JDBC_CONNECTION = "jdbc:h2:" + basedir + "/test"; +String CREATE_PERSON_TABLE = + "create table PERSON (ID int not null, NAME varchar(20), primary key (ID))"; +String CREATE_ITEM_TABLE = + "create table ITEM (ID int not null, NAME varchar(20), OWNER_ID int not null, " + + " primary key (ID), foreign key (OWNER_ID) references PERSON(ID))"; + +Connection connection = DriverManager.getConnection(JDBC_CONNECTION); +Statement statement = connection.createStatement(); +statement.execute(CREATE_PERSON_TABLE); +statement.execute(CREATE_ITEM_TABLE); +statement.close(); +connection.close(); diff --git a/maven/src/it/hbm2java/no-generics/src/main/resources/hibernate.properties b/maven/src/it/hbm2java/no-generics/src/main/resources/hibernate.properties new file mode 100644 index 0000000000..32da3e5d10 --- /dev/null +++ b/maven/src/it/hbm2java/no-generics/src/main/resources/hibernate.properties @@ -0,0 +1,21 @@ +############################################################################ +# Hibernate Tools, Tooling for your Hibernate Projects # +# # +# Copyright 2018-2025 Red Hat, Inc. # +# # +# Licensed under the Apache License, Version 2.0 (the "License"); # +# you may not use this file except in compliance with the License. # +# You may obtain a copy of the License at # +# # +# http://www.apache.org/licenses/LICENSE-2.0 # +# # +# Unless required by applicable law or agreed to in writing, software # +# distributed under the License is distributed on an "AS IS" basis, # +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # +# See the License for the specific language governing permissions and # +# limitations under the License. # +############################################################################ +hibernate.connection.driver_class=org.h2.Driver +hibernate.connection.url=jdbc:h2:./test +hibernate.default_catalog=TEST +hibernate.default_schema=PUBLIC \ No newline at end of file diff --git a/maven/src/it/hbm2java/no-generics/verify.bsh b/maven/src/it/hbm2java/no-generics/verify.bsh new file mode 100644 index 0000000000..74d90e2a4b --- /dev/null +++ b/maven/src/it/hbm2java/no-generics/verify.bsh @@ -0,0 +1,29 @@ +/* + * Hibernate Tools, Tooling for your Hibernate Projects + * + * Copyright 2018-2025 Red Hat, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +import java.nio.file.Files; + +File personEntity = new File(basedir, "target/generated-sources/Person.java"); +if (!personEntity.isFile()) { + throw new FileNotFoundException("Could not find generated Java file: " + personEntity); +} +byte[] raw = Files.readAllBytes(personEntity.toPath()); +if (new String(raw).contains("Set")) { + throw new RuntimeException("The generated Java file should not have generics"); +} + + diff --git a/maven/src/it/hbm2java/output-directory/pom.xml b/maven/src/it/hbm2java/output-directory/pom.xml new file mode 100644 index 0000000000..23d1cfd9a2 --- /dev/null +++ b/maven/src/it/hbm2java/output-directory/pom.xml @@ -0,0 +1,56 @@ + + + + 4.0.0 + + org.hibernate.tool.maven.test + hbm2java-output-directory + 0.0.1-SNAPSHOT + + + + com.h2database + h2 + @h2.version@ + + + + + + + org.hibernate.tool + hibernate-tools-maven + @project.version@ + + + Entity generation + generate-sources + + hbm2java + + + + + ${build.directory}/someRandomFolder + + + + + + \ No newline at end of file diff --git a/maven/src/it/hbm2java/output-directory/setup.bsh b/maven/src/it/hbm2java/output-directory/setup.bsh new file mode 100644 index 0000000000..70f35cb226 --- /dev/null +++ b/maven/src/it/hbm2java/output-directory/setup.bsh @@ -0,0 +1,26 @@ +/* + * Hibernate Tools, Tooling for your Hibernate Projects + * + * Copyright 2018-2025 Red Hat, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +import java.sql.DriverManager; +import java.sql.Connection; + +String JDBC_CONNECTION = "jdbc:h2:" + basedir + "/test"; +String CREATE_PERSON_TABLE = "create table PERSON (ID int not null, NAME varchar(20), primary key (ID))"; + +Connection connection = DriverManager.getConnection(JDBC_CONNECTION); +connection.createStatement().execute(CREATE_PERSON_TABLE); +connection.close(); diff --git a/maven/src/it/hbm2java/output-directory/src/main/resources/hibernate.properties b/maven/src/it/hbm2java/output-directory/src/main/resources/hibernate.properties new file mode 100644 index 0000000000..32da3e5d10 --- /dev/null +++ b/maven/src/it/hbm2java/output-directory/src/main/resources/hibernate.properties @@ -0,0 +1,21 @@ +############################################################################ +# Hibernate Tools, Tooling for your Hibernate Projects # +# # +# Copyright 2018-2025 Red Hat, Inc. # +# # +# Licensed under the Apache License, Version 2.0 (the "License"); # +# you may not use this file except in compliance with the License. # +# You may obtain a copy of the License at # +# # +# http://www.apache.org/licenses/LICENSE-2.0 # +# # +# Unless required by applicable law or agreed to in writing, software # +# distributed under the License is distributed on an "AS IS" basis, # +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # +# See the License for the specific language governing permissions and # +# limitations under the License. # +############################################################################ +hibernate.connection.driver_class=org.h2.Driver +hibernate.connection.url=jdbc:h2:./test +hibernate.default_catalog=TEST +hibernate.default_schema=PUBLIC \ No newline at end of file diff --git a/maven/src/it/hbm2java/output-directory/verify.bsh b/maven/src/it/hbm2java/output-directory/verify.bsh new file mode 100644 index 0000000000..33fef7e283 --- /dev/null +++ b/maven/src/it/hbm2java/output-directory/verify.bsh @@ -0,0 +1,29 @@ +/* + * Hibernate Tools, Tooling for your Hibernate Projects + * + * Copyright 2018-2025 Red Hat, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +import java.nio.file.Files; + +File personEntity = new File(basedir, "target/someRandomFolder/Person.java"); +if (!personEntity.isFile()) { + throw new FileNotFoundException("Could not find generated JPA Entity: " + personEntity); +} +byte[] raw = Files.readAllBytes(personEntity.toPath()); +if (!new String(raw).contains("import jakarta.persistence.Entity;")) { + throw new RuntimeException("The generated java file is not a JPA Entity"); +} + + diff --git a/maven/src/it/hbm2java/template-path/pom.xml b/maven/src/it/hbm2java/template-path/pom.xml new file mode 100644 index 0000000000..b79b210233 --- /dev/null +++ b/maven/src/it/hbm2java/template-path/pom.xml @@ -0,0 +1,56 @@ + + + + 4.0.0 + + org.hibernate.tool.maven.test + hbm2java-template-path + 0.0.1-SNAPSHOT + + + + com.h2database + h2 + @h2.version@ + + + + + + + org.hibernate.tool + hibernate-tools-maven + @project.version@ + + + Entity generation + generate-sources + + hbm2java + + + + + ${basedir}/templates + + + + + + \ No newline at end of file diff --git a/maven/src/it/hbm2java/template-path/setup.bsh b/maven/src/it/hbm2java/template-path/setup.bsh new file mode 100644 index 0000000000..70f35cb226 --- /dev/null +++ b/maven/src/it/hbm2java/template-path/setup.bsh @@ -0,0 +1,26 @@ +/* + * Hibernate Tools, Tooling for your Hibernate Projects + * + * Copyright 2018-2025 Red Hat, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +import java.sql.DriverManager; +import java.sql.Connection; + +String JDBC_CONNECTION = "jdbc:h2:" + basedir + "/test"; +String CREATE_PERSON_TABLE = "create table PERSON (ID int not null, NAME varchar(20), primary key (ID))"; + +Connection connection = DriverManager.getConnection(JDBC_CONNECTION); +connection.createStatement().execute(CREATE_PERSON_TABLE); +connection.close(); diff --git a/maven/src/it/hbm2java/template-path/src/main/resources/hibernate.properties b/maven/src/it/hbm2java/template-path/src/main/resources/hibernate.properties new file mode 100644 index 0000000000..32da3e5d10 --- /dev/null +++ b/maven/src/it/hbm2java/template-path/src/main/resources/hibernate.properties @@ -0,0 +1,21 @@ +############################################################################ +# Hibernate Tools, Tooling for your Hibernate Projects # +# # +# Copyright 2018-2025 Red Hat, Inc. # +# # +# Licensed under the Apache License, Version 2.0 (the "License"); # +# you may not use this file except in compliance with the License. # +# You may obtain a copy of the License at # +# # +# http://www.apache.org/licenses/LICENSE-2.0 # +# # +# Unless required by applicable law or agreed to in writing, software # +# distributed under the License is distributed on an "AS IS" basis, # +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # +# See the License for the specific language governing permissions and # +# limitations under the License. # +############################################################################ +hibernate.connection.driver_class=org.h2.Driver +hibernate.connection.url=jdbc:h2:./test +hibernate.default_catalog=TEST +hibernate.default_schema=PUBLIC \ No newline at end of file diff --git a/maven/src/it/hbm2java/template-path/templates/pojo/Pojo.ftl b/maven/src/it/hbm2java/template-path/templates/pojo/Pojo.ftl new file mode 100644 index 0000000000..18f3de1a5a --- /dev/null +++ b/maven/src/it/hbm2java/template-path/templates/pojo/Pojo.ftl @@ -0,0 +1,18 @@ + +// This is just an example of a custom template + + diff --git a/maven/src/it/hbm2java/template-path/verify.bsh b/maven/src/it/hbm2java/template-path/verify.bsh new file mode 100644 index 0000000000..b0c2af2d87 --- /dev/null +++ b/maven/src/it/hbm2java/template-path/verify.bsh @@ -0,0 +1,29 @@ +/* + * Hibernate Tools, Tooling for your Hibernate Projects + * + * Copyright 2018-2025 Red Hat, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +import java.nio.file.Files; + +File personEntity = new File(basedir, "target/generated-sources/Person.java"); +if (!personEntity.isFile()) { + throw new FileNotFoundException("Could not find generated JPA Entity: " + personEntity); +} +byte[] raw = Files.readAllBytes(personEntity.toPath()); +if (!new String(raw).contains("// This is just an example of a custom template")) { + throw new RuntimeException("The correct template has not been used"); +} + + diff --git a/maven/src/it/hbm2java/use-generics/pom.xml b/maven/src/it/hbm2java/use-generics/pom.xml new file mode 100644 index 0000000000..8b2931c1ed --- /dev/null +++ b/maven/src/it/hbm2java/use-generics/pom.xml @@ -0,0 +1,53 @@ + + + + 4.0.0 + + org.hibernate.tool.maven.test + hbm2java-use-generics + 0.0.1-SNAPSHOT + + + + com.h2database + h2 + @h2.version@ + + + + + + + org.hibernate.tool + hibernate-tools-maven + @project.version@ + + + Entity generation + generate-sources + + hbm2java + + + + + + + + \ No newline at end of file diff --git a/maven/src/it/hbm2java/use-generics/setup.bsh b/maven/src/it/hbm2java/use-generics/setup.bsh new file mode 100644 index 0000000000..b4b5a472c6 --- /dev/null +++ b/maven/src/it/hbm2java/use-generics/setup.bsh @@ -0,0 +1,34 @@ +/* + * Hibernate Tools, Tooling for your Hibernate Projects + * + * Copyright 2018-2025 Red Hat, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +import java.sql.DriverManager; +import java.sql.Connection; +import java.sql.Statement; + +String JDBC_CONNECTION = "jdbc:h2:" + basedir + "/test"; +String CREATE_PERSON_TABLE = + "create table PERSON (ID int not null, NAME varchar(20), primary key (ID))"; +String CREATE_ITEM_TABLE = + "create table ITEM (ID int not null, NAME varchar(20), OWNER_ID int not null, " + + " primary key (ID), foreign key (OWNER_ID) references PERSON(ID))"; + +Connection connection = DriverManager.getConnection(JDBC_CONNECTION); +Statement statement = connection.createStatement(); +statement.execute(CREATE_PERSON_TABLE); +statement.execute(CREATE_ITEM_TABLE); +statement.close(); +connection.close(); diff --git a/maven/src/it/hbm2java/use-generics/src/main/resources/hibernate.properties b/maven/src/it/hbm2java/use-generics/src/main/resources/hibernate.properties new file mode 100644 index 0000000000..32da3e5d10 --- /dev/null +++ b/maven/src/it/hbm2java/use-generics/src/main/resources/hibernate.properties @@ -0,0 +1,21 @@ +############################################################################ +# Hibernate Tools, Tooling for your Hibernate Projects # +# # +# Copyright 2018-2025 Red Hat, Inc. # +# # +# Licensed under the Apache License, Version 2.0 (the "License"); # +# you may not use this file except in compliance with the License. # +# You may obtain a copy of the License at # +# # +# http://www.apache.org/licenses/LICENSE-2.0 # +# # +# Unless required by applicable law or agreed to in writing, software # +# distributed under the License is distributed on an "AS IS" basis, # +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # +# See the License for the specific language governing permissions and # +# limitations under the License. # +############################################################################ +hibernate.connection.driver_class=org.h2.Driver +hibernate.connection.url=jdbc:h2:./test +hibernate.default_catalog=TEST +hibernate.default_schema=PUBLIC \ No newline at end of file diff --git a/maven/src/it/hbm2java/use-generics/verify.bsh b/maven/src/it/hbm2java/use-generics/verify.bsh new file mode 100644 index 0000000000..ddc33e4437 --- /dev/null +++ b/maven/src/it/hbm2java/use-generics/verify.bsh @@ -0,0 +1,29 @@ +/* + * Hibernate Tools, Tooling for your Hibernate Projects + * + * Copyright 2018-2025 Red Hat, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +import java.nio.file.Files; + +File personEntity = new File(basedir, "target/generated-sources/Person.java"); +if (!personEntity.isFile()) { + throw new FileNotFoundException("Could not find generated Java file: " + personEntity); +} +byte[] raw = Files.readAllBytes(personEntity.toPath()); +if (!new String(raw).contains("Set")) { + throw new RuntimeException("The generated Java file should use generics"); +} + + diff --git a/maven/src/main/java/org/hibernate/tool/maven/AbstractGenerationMojo.java b/maven/src/main/java/org/hibernate/tool/maven/AbstractGenerationMojo.java index 56d8433674..ea76fa0f74 100644 --- a/maven/src/main/java/org/hibernate/tool/maven/AbstractGenerationMojo.java +++ b/maven/src/main/java/org/hibernate/tool/maven/AbstractGenerationMojo.java @@ -23,10 +23,18 @@ import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.IOException; +import java.net.MalformedURLException; +import java.net.URL; +import java.net.URLClassLoader; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.HashSet; import java.util.Properties; +import org.apache.maven.artifact.DependencyResolutionRequiredException; import org.apache.maven.plugin.AbstractMojo; import org.apache.maven.plugins.annotations.Parameter; +import org.apache.maven.project.MavenProject; import org.apache.tools.ant.BuildException; import org.hibernate.tool.api.metadata.MetadataDescriptor; import org.hibernate.tool.api.metadata.MetadataDescriptorFactory; @@ -83,15 +91,24 @@ public abstract class AbstractGenerationMojo extends AbstractMojo { // Not exposed for now private boolean preferBasicCompositeIds = true; + @Parameter(defaultValue = "${project}", readonly = true, required = true) + private MavenProject project; + public void execute() { - getLog().info("Starting " + this.getClass().getSimpleName() + "..."); - RevengStrategy strategy = setupReverseEngineeringStrategy(); - if (propertyFile.exists()) { - executeExporter(createJdbcDescriptor(strategy, loadPropertiesFile())); - } else { - getLog().info("Property file '" + propertyFile + "' cannot be found, aborting..."); - } - getLog().info("Finished " + this.getClass().getSimpleName() + "!"); + ClassLoader original = Thread.currentThread().getContextClassLoader(); + try { + Thread.currentThread().setContextClassLoader(createExporterClassLoader(original)); + getLog().info("Starting " + this.getClass().getSimpleName() + "..."); + RevengStrategy strategy = setupReverseEngineeringStrategy(); + if (propertyFile.exists()) { + executeExporter(createJdbcDescriptor(strategy, loadPropertiesFile())); + } else { + getLog().info("Property file '" + propertyFile + "' cannot be found, aborting..."); + } + getLog().info("Finished " + this.getClass().getSimpleName() + "!"); + } finally { + Thread.currentThread().setContextClassLoader(original); + } } private RevengStrategy setupReverseEngineeringStrategy() { @@ -134,6 +151,18 @@ private MetadataDescriptor createJdbcDescriptor(RevengStrategy strategy, Propert strategy, properties); } + + private ClassLoader createExporterClassLoader(ClassLoader parent) { + ArrayList urls = new ArrayList(); + try { + for (String cpe : project.getRuntimeClasspathElements()) { + urls.add(new File(cpe).toURI().toURL()); + } + } catch (DependencyResolutionRequiredException | MalformedURLException e) { + throw new RuntimeException("Problem while constructing project classloader", e); + } + return new URLClassLoader(urls.toArray(new URL[0]), parent); + } protected abstract void executeExporter(MetadataDescriptor metadataDescriptor); } diff --git a/maven/src/main/java/org/hibernate/tool/maven/GenerateDaoMojo.java b/maven/src/main/java/org/hibernate/tool/maven/GenerateDaoMojo.java index afbe350dec..98554cf7e5 100644 --- a/maven/src/main/java/org/hibernate/tool/maven/GenerateDaoMojo.java +++ b/maven/src/main/java/org/hibernate/tool/maven/GenerateDaoMojo.java @@ -21,6 +21,7 @@ import org.apache.maven.plugins.annotations.Mojo; import org.apache.maven.plugins.annotations.Parameter; +import org.apache.maven.plugins.annotations.ResolutionScope; import org.hibernate.tool.api.export.Exporter; import org.hibernate.tool.api.export.ExporterConstants; import org.hibernate.tool.api.export.ExporterFactory; @@ -36,7 +37,10 @@ *

* See: https://docs.jboss.org/tools/latest/en/hibernatetools/html_single/#d0e4821 */ -@Mojo(name = "hbm2dao", defaultPhase = GENERATE_SOURCES) +@Mojo( + name = "hbm2dao", + defaultPhase = GENERATE_SOURCES, + requiresDependencyResolution = ResolutionScope.RUNTIME) public class GenerateDaoMojo extends AbstractGenerationMojo { /** The directory into which the DAOs will be generated. */ diff --git a/maven/src/main/java/org/hibernate/tool/maven/GenerateDdlMojo.java b/maven/src/main/java/org/hibernate/tool/maven/GenerateDdlMojo.java index a60958f51b..8ade339a4e 100644 --- a/maven/src/main/java/org/hibernate/tool/maven/GenerateDdlMojo.java +++ b/maven/src/main/java/org/hibernate/tool/maven/GenerateDdlMojo.java @@ -21,6 +21,7 @@ import org.apache.maven.plugins.annotations.Mojo; import org.apache.maven.plugins.annotations.Parameter; +import org.apache.maven.plugins.annotations.ResolutionScope; import org.hibernate.boot.Metadata; import org.hibernate.tool.api.metadata.MetadataDescriptor; import org.hibernate.tool.hbm2ddl.SchemaExport; @@ -37,7 +38,10 @@ *

* See https://docs.jboss.org/tools/latest/en/hibernatetools/html_single/#d0e4651 */ -@Mojo(name = "hbm2ddl", defaultPhase = GENERATE_RESOURCES) +@Mojo( + name = "hbm2ddl", + defaultPhase = GENERATE_RESOURCES, + requiresDependencyResolution = ResolutionScope.RUNTIME) public class GenerateDdlMojo extends AbstractGenerationMojo { /** The directory into which the DDLs will be generated. */ diff --git a/maven/src/main/java/org/hibernate/tool/maven/GenerateHbmMojo.java b/maven/src/main/java/org/hibernate/tool/maven/GenerateHbmMojo.java new file mode 100644 index 0000000000..80aa790a4f --- /dev/null +++ b/maven/src/main/java/org/hibernate/tool/maven/GenerateHbmMojo.java @@ -0,0 +1,70 @@ +/* + * Hibernate Tools, Tooling for your Hibernate Projects + * + * Copyright 2016-2020 Red Hat, Inc. + * + * Licensed under the GNU Lesser General Public License (LGPL), + * version 2.1 or later (the "License"). + * You may not use this file except in compliance with the License. + * You may read the licence in the 'lgpl.txt' file in the root folder of + * project or obtain a copy at + * + * http://www.gnu.org/licenses/lgpl-2.1.html + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.hibernate.tool.maven; + +import org.apache.maven.plugins.annotations.Mojo; +import org.apache.maven.plugins.annotations.Parameter; +import org.apache.maven.plugins.annotations.ResolutionScope; +import org.hibernate.tool.api.export.Exporter; +import org.hibernate.tool.api.export.ExporterConstants; +import org.hibernate.tool.api.export.ExporterFactory; +import org.hibernate.tool.api.export.ExporterType; +import org.hibernate.tool.api.metadata.MetadataDescriptor; + +import java.io.File; + +import static org.apache.maven.plugins.annotations.LifecyclePhase.GENERATE_SOURCES; + +/** + * Mojo to generate hbm.xml files from an existing database. + *

+ * See: https://docs.jboss.org/tools/latest/en/hibernatetools/html_single/#d0e4821 + */ +@Mojo( + name = "generateHbm", + defaultPhase = GENERATE_SOURCES, + requiresDependencyResolution = ResolutionScope.RUNTIME) +public class GenerateHbmMojo extends AbstractGenerationMojo { + + /** The directory into which the DAOs will be generated. */ + @Parameter(defaultValue = "${project.basedir}/src/main/resources") + private File outputDirectory; + + @Parameter + private String templatePath; + + protected void executeExporter(MetadataDescriptor metadataDescriptor) { + try { + Exporter hbmExporter = ExporterFactory.createExporter(ExporterType.HBM); + hbmExporter.getProperties().put(ExporterConstants.METADATA_DESCRIPTOR, metadataDescriptor); + hbmExporter.getProperties().put(ExporterConstants.DESTINATION_FOLDER, outputDirectory); + if (templatePath != null) { + getLog().info("Setting template path to: " + templatePath); + hbmExporter.getProperties().put(ExporterConstants.TEMPLATE_PATH, new String[] {templatePath}); + } + getLog().info("Starting HBM export to directory: " + outputDirectory + "..."); + hbmExporter.start(); + } catch (Exception e) { + e.printStackTrace(); + } + } + + +} diff --git a/maven/src/main/java/org/hibernate/tool/maven/GenerateJavaMojo.java b/maven/src/main/java/org/hibernate/tool/maven/GenerateJavaMojo.java index 3ec6709185..848fb9d94a 100644 --- a/maven/src/main/java/org/hibernate/tool/maven/GenerateJavaMojo.java +++ b/maven/src/main/java/org/hibernate/tool/maven/GenerateJavaMojo.java @@ -25,6 +25,7 @@ import org.apache.maven.plugins.annotations.Mojo; import org.apache.maven.plugins.annotations.Parameter; +import org.apache.maven.plugins.annotations.ResolutionScope; import org.hibernate.tool.api.export.Exporter; import org.hibernate.tool.api.export.ExporterConstants; import org.hibernate.tool.api.export.ExporterFactory; @@ -36,7 +37,10 @@ *

* See: https://docs.jboss.org/tools/latest/en/hibernatetools/html_single/#d0e4821 */ -@Mojo(name = "hbm2java", defaultPhase = GENERATE_SOURCES) +@Mojo( + name = "hbm2java", + defaultPhase = GENERATE_SOURCES, + requiresDependencyResolution = ResolutionScope.RUNTIME) public class GenerateJavaMojo extends AbstractGenerationMojo { /** The directory into which the JPA entities will be generated. */ @@ -45,11 +49,11 @@ public class GenerateJavaMojo extends AbstractGenerationMojo { /** Code will contain JPA features, e.g. using annotations from jakarta.persistence * and org.hibernate.annotations. */ - @Parameter(defaultValue = "false") + @Parameter(defaultValue = "true") private boolean ejb3; /** Code will contain JDK 5 constructs such as generics and static imports. */ - @Parameter(defaultValue = "false") + @Parameter(defaultValue = "true") private boolean jdk5; /** A path used for looking up user-edited templates. */ @@ -69,6 +73,8 @@ protected void executeExporter(MetadataDescriptor metadataDescriptor) { getLog().info("Starting POJO export to directory: " + outputDirectory + "..."); pojoExporter.start(); } + + } diff --git a/maven/src/test/java/org/hibernate/tool/maven/GenerateJavaMojoTest.java b/maven/src/test/java/org/hibernate/tool/maven/GenerateJavaMojoTest.java new file mode 100644 index 0000000000..47b1748d8e --- /dev/null +++ b/maven/src/test/java/org/hibernate/tool/maven/GenerateJavaMojoTest.java @@ -0,0 +1,170 @@ +package org.hibernate.tool.maven; + +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import java.io.File; +import java.lang.reflect.Field; +import java.nio.file.Files; +import java.sql.Connection; +import java.sql.DriverManager; +import java.sql.Statement; +import java.util.Properties; + +import org.apache.maven.project.MavenProject; +import org.hibernate.tool.api.metadata.MetadataDescriptor; +import org.hibernate.tool.api.metadata.MetadataDescriptorFactory; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.io.TempDir; + +public class GenerateJavaMojoTest { + + private static final String JDBC_CONNECTION = "jdbc:h2:mem:test"; + private static final String CREATE_PERSON_TABLE = + "create table PERSON (ID int not null, NAME varchar(20), primary key (ID))"; + private static final String CREATE_ITEM_TABLE = + "create table ITEM (ID int not null, NAME varchar(20), OWNER_ID int not null, primary key (ID), foreign key (OWNER_ID) references PERSON(ID))"; + private static final String DROP_ITEM_TABLE = + "drop table ITEM"; + private static final String DROP_PERSON_TABLE = + "drop table PERSON"; + + @TempDir + private File tempDir; + + private File outputDirectory; + private GenerateJavaMojo generateJavaMojo; + + @BeforeEach + public void beforeEach() throws Exception { + createDatabase(); + createOutputDirectory(); + createGenerateJavaMojo(); + } + + @AfterEach + public void afterEach() throws Exception { + dropDatabase(); + } + + @Test + public void testGenerateAnnotatedJava() throws Exception { + File personJavaFile = new File(outputDirectory, "Person.java"); + // Person.java should not exist + assertFalse(personJavaFile.exists()); + // Set value of field 'ejb3' to 'true' and execute mojo + Field ejb3Field = GenerateJavaMojo.class.getDeclaredField("ejb3"); + ejb3Field.setAccessible(true); + ejb3Field.set(generateJavaMojo, true); + // Execute mojo + generateJavaMojo.executeExporter(createMetadataDescriptor()); + // Person.java should exist + assertTrue(personJavaFile.exists()); + // Person.java should be an annotated entity + byte[] raw = Files.readAllBytes(personJavaFile.toPath()); + assertTrue(new String(raw).contains("import jakarta.persistence.Entity;")); + } + + @Test + public void testGenerateNonAnnotatedJava() throws Exception { + File personJavaFile = new File(outputDirectory, "Person.java"); + // Person.java should not exist + assertFalse(personJavaFile.exists()); + // Set value of field 'ejb3' to 'false' and execute mojo + Field ejb3Field = GenerateJavaMojo.class.getDeclaredField("ejb3"); + ejb3Field.setAccessible(true); + ejb3Field.set(generateJavaMojo, false); + // Execute mojo + generateJavaMojo.executeExporter(createMetadataDescriptor()); + // Person.java should exist + assertTrue(personJavaFile.exists()); + // Person.java should be an annotated entity + byte[] raw = Files.readAllBytes(personJavaFile.toPath()); + assertFalse(new String(raw).contains("import jakarta.persistence.Entity;")); + } + + @Test + public void testGenerateJavaWithGenerics() throws Exception { + File personJavaFile = new File(outputDirectory, "Person.java"); + // Person.java should not exist + assertFalse(personJavaFile.exists()); + // Set value of field 'jdk5' to 'true' and execute mojo + Field jdk5Field = GenerateJavaMojo.class.getDeclaredField("jdk5"); + jdk5Field.setAccessible(true); + jdk5Field.set(generateJavaMojo, true); + // Execute mojo + generateJavaMojo.executeExporter(createMetadataDescriptor()); + // Person.java should exist + assertTrue(personJavaFile.exists()); + // Person.java should be an annotated entity + byte[] raw = Files.readAllBytes(personJavaFile.toPath()); + assertTrue(new String(raw).contains("Set")); + } + + @Test + public void testGenerateJavaWithoutGenerics() throws Exception { + File personJavaFile = new File(outputDirectory, "Person.java"); + // Person.java should not exist + assertFalse(personJavaFile.exists()); + // Set value of field 'jdk5' to 'true' and execute mojo + Field jdk5Field = GenerateJavaMojo.class.getDeclaredField("jdk5"); + jdk5Field.setAccessible(true); + jdk5Field.set(generateJavaMojo, false); + // Execute mojo + generateJavaMojo.executeExporter(createMetadataDescriptor()); + // Person.java should exist + assertTrue(personJavaFile.exists()); + // Person.java should be an annotated entity + byte[] raw = Files.readAllBytes(personJavaFile.toPath()); + assertFalse(new String(raw).contains("Set")); + } + + private void createDatabase() throws Exception { + Connection connection = DriverManager.getConnection(JDBC_CONNECTION); + Statement statement = connection.createStatement(); + statement.execute(CREATE_PERSON_TABLE); + statement.execute(CREATE_ITEM_TABLE); + } + + private void dropDatabase() throws Exception { + Connection connection = DriverManager.getConnection(JDBC_CONNECTION); + Statement statement = connection.createStatement(); + statement.execute(DROP_ITEM_TABLE); + statement.execute(DROP_PERSON_TABLE); + } + + private void createGenerateJavaMojo() throws Exception { + generateJavaMojo = new GenerateJavaMojo(); + Field projectField = AbstractGenerationMojo.class.getDeclaredField("project"); + projectField.setAccessible(true); + projectField.set(generateJavaMojo, new MavenProject()); + Field propertyFileField = AbstractGenerationMojo.class.getDeclaredField("propertyFile"); + propertyFileField.setAccessible(true); + propertyFileField.set(generateJavaMojo, new File(tempDir, "hibernate.properties")); + Field outputDirectoryField = GenerateJavaMojo.class.getDeclaredField("outputDirectory"); + outputDirectoryField.setAccessible(true); + outputDirectoryField.set(generateJavaMojo, outputDirectory); + } + + private void createOutputDirectory() { + outputDirectory = new File(tempDir, "generated"); + outputDirectory.mkdir(); + } + + private MetadataDescriptor createMetadataDescriptor() { + return MetadataDescriptorFactory.createReverseEngineeringDescriptor( + null, + createProperties()); + } + + private Properties createProperties() { + Properties result = new Properties(); + result.put("hibernate.connection.url", JDBC_CONNECTION); + result.put("hibernate.default_catalog", "TEST"); + result.put("hibernate.default_schema", "PUBLIC"); + return result; + } + +} diff --git a/mvnw b/mvnw new file mode 100755 index 0000000000..5e9618cac2 --- /dev/null +++ b/mvnw @@ -0,0 +1,332 @@ +#!/bin/sh +# ---------------------------------------------------------------------------- +# Licensed to the Apache Software Foundation (ASF) under one +# or more contributor license agreements. See the NOTICE file +# distributed with this work for additional information +# regarding copyright ownership. The ASF licenses this file +# to you under the Apache License, Version 2.0 (the +# "License"); you may not use this file except in compliance +# with the License. You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, +# software distributed under the License is distributed on an +# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +# KIND, either express or implied. See the License for the +# specific language governing permissions and limitations +# under the License. +# ---------------------------------------------------------------------------- + +# ---------------------------------------------------------------------------- +# Apache Maven Wrapper startup batch script, version 3.3.2 +# +# Required ENV vars: +# ------------------ +# JAVA_HOME - location of a JDK home dir +# +# Optional ENV vars +# ----------------- +# MAVEN_OPTS - parameters passed to the Java VM when running Maven +# e.g. to debug Maven itself, use +# set MAVEN_OPTS=-Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=y,address=8000 +# MAVEN_SKIP_RC - flag to disable loading of mavenrc files +# ---------------------------------------------------------------------------- + +if [ -z "$MAVEN_SKIP_RC" ]; then + + if [ -f /usr/local/etc/mavenrc ]; then + . /usr/local/etc/mavenrc + fi + + if [ -f /etc/mavenrc ]; then + . /etc/mavenrc + fi + + if [ -f "$HOME/.mavenrc" ]; then + . "$HOME/.mavenrc" + fi + +fi + +# OS specific support. $var _must_ be set to either true or false. +cygwin=false +darwin=false +mingw=false +case "$(uname)" in +CYGWIN*) cygwin=true ;; +MINGW*) mingw=true ;; +Darwin*) + darwin=true + # Use /usr/libexec/java_home if available, otherwise fall back to /Library/Java/Home + # See https://developer.apple.com/library/mac/qa/qa1170/_index.html + if [ -z "$JAVA_HOME" ]; then + if [ -x "/usr/libexec/java_home" ]; then + JAVA_HOME="$(/usr/libexec/java_home)" + export JAVA_HOME + else + JAVA_HOME="/Library/Java/Home" + export JAVA_HOME + fi + fi + ;; +esac + +if [ -z "$JAVA_HOME" ]; then + if [ -r /etc/gentoo-release ]; then + JAVA_HOME=$(java-config --jre-home) + fi +fi + +# For Cygwin, ensure paths are in UNIX format before anything is touched +if $cygwin; then + [ -n "$JAVA_HOME" ] \ + && JAVA_HOME=$(cygpath --unix "$JAVA_HOME") + [ -n "$CLASSPATH" ] \ + && CLASSPATH=$(cygpath --path --unix "$CLASSPATH") +fi + +# For Mingw, ensure paths are in UNIX format before anything is touched +if $mingw; then + [ -n "$JAVA_HOME" ] && [ -d "$JAVA_HOME" ] \ + && JAVA_HOME="$( + cd "$JAVA_HOME" || ( + echo "cannot cd into $JAVA_HOME." >&2 + exit 1 + ) + pwd + )" +fi + +if [ -z "$JAVA_HOME" ]; then + javaExecutable="$(which javac)" + if [ -n "$javaExecutable" ] && ! [ "$(expr "$javaExecutable" : '\([^ ]*\)')" = "no" ]; then + # readlink(1) is not available as standard on Solaris 10. + readLink=$(which readlink) + if [ ! "$(expr "$readLink" : '\([^ ]*\)')" = "no" ]; then + if $darwin; then + javaHome="$(dirname "$javaExecutable")" + javaExecutable="$(cd "$javaHome" && pwd -P)/javac" + else + javaExecutable="$(readlink -f "$javaExecutable")" + fi + javaHome="$(dirname "$javaExecutable")" + javaHome=$(expr "$javaHome" : '\(.*\)/bin') + JAVA_HOME="$javaHome" + export JAVA_HOME + fi + fi +fi + +if [ -z "$JAVACMD" ]; then + if [ -n "$JAVA_HOME" ]; then + if [ -x "$JAVA_HOME/jre/sh/java" ]; then + # IBM's JDK on AIX uses strange locations for the executables + JAVACMD="$JAVA_HOME/jre/sh/java" + else + JAVACMD="$JAVA_HOME/bin/java" + fi + else + JAVACMD="$( + \unset -f command 2>/dev/null + \command -v java + )" + fi +fi + +if [ ! -x "$JAVACMD" ]; then + echo "Error: JAVA_HOME is not defined correctly." >&2 + echo " We cannot execute $JAVACMD" >&2 + exit 1 +fi + +if [ -z "$JAVA_HOME" ]; then + echo "Warning: JAVA_HOME environment variable is not set." >&2 +fi + +# traverses directory structure from process work directory to filesystem root +# first directory with .mvn subdirectory is considered project base directory +find_maven_basedir() { + if [ -z "$1" ]; then + echo "Path not specified to find_maven_basedir" >&2 + return 1 + fi + + basedir="$1" + wdir="$1" + while [ "$wdir" != '/' ]; do + if [ -d "$wdir"/.mvn ]; then + basedir=$wdir + break + fi + # workaround for JBEAP-8937 (on Solaris 10/Sparc) + if [ -d "${wdir}" ]; then + wdir=$( + cd "$wdir/.." || exit 1 + pwd + ) + fi + # end of workaround + done + printf '%s' "$( + cd "$basedir" || exit 1 + pwd + )" +} + +# concatenates all lines of a file +concat_lines() { + if [ -f "$1" ]; then + # Remove \r in case we run on Windows within Git Bash + # and check out the repository with auto CRLF management + # enabled. Otherwise, we may read lines that are delimited with + # \r\n and produce $'-Xarg\r' rather than -Xarg due to word + # splitting rules. + tr -s '\r\n' ' ' <"$1" + fi +} + +log() { + if [ "$MVNW_VERBOSE" = true ]; then + printf '%s\n' "$1" + fi +} + +BASE_DIR=$(find_maven_basedir "$(dirname "$0")") +if [ -z "$BASE_DIR" ]; then + exit 1 +fi + +MAVEN_PROJECTBASEDIR=${MAVEN_BASEDIR:-"$BASE_DIR"} +export MAVEN_PROJECTBASEDIR +log "$MAVEN_PROJECTBASEDIR" + +########################################################################################## +# Extension to allow automatically downloading the maven-wrapper.jar from Maven-central +# This allows using the maven wrapper in projects that prohibit checking in binary data. +########################################################################################## +wrapperJarPath="$MAVEN_PROJECTBASEDIR/.mvn/wrapper/maven-wrapper.jar" +if [ -r "$wrapperJarPath" ]; then + log "Found $wrapperJarPath" +else + log "Couldn't find $wrapperJarPath, downloading it ..." + + if [ -n "$MVNW_REPOURL" ]; then + wrapperUrl="$MVNW_REPOURL/org/apache/maven/wrapper/maven-wrapper/3.3.2/maven-wrapper-3.3.2.jar" + else + wrapperUrl="https://repo.maven.apache.org/maven2/org/apache/maven/wrapper/maven-wrapper/3.3.2/maven-wrapper-3.3.2.jar" + fi + while IFS="=" read -r key value; do + # Remove '\r' from value to allow usage on windows as IFS does not consider '\r' as a separator ( considers space, tab, new line ('\n'), and custom '=' ) + safeValue=$(echo "$value" | tr -d '\r') + case "$key" in wrapperUrl) + wrapperUrl="$safeValue" + break + ;; + esac + done <"$MAVEN_PROJECTBASEDIR/.mvn/wrapper/maven-wrapper.properties" + log "Downloading from: $wrapperUrl" + + if $cygwin; then + wrapperJarPath=$(cygpath --path --windows "$wrapperJarPath") + fi + + if command -v wget >/dev/null; then + log "Found wget ... using wget" + [ "$MVNW_VERBOSE" = true ] && QUIET="" || QUIET="--quiet" + if [ -z "$MVNW_USERNAME" ] || [ -z "$MVNW_PASSWORD" ]; then + wget $QUIET "$wrapperUrl" -O "$wrapperJarPath" || rm -f "$wrapperJarPath" + else + wget $QUIET --http-user="$MVNW_USERNAME" --http-password="$MVNW_PASSWORD" "$wrapperUrl" -O "$wrapperJarPath" || rm -f "$wrapperJarPath" + fi + elif command -v curl >/dev/null; then + log "Found curl ... using curl" + [ "$MVNW_VERBOSE" = true ] && QUIET="" || QUIET="--silent" + if [ -z "$MVNW_USERNAME" ] || [ -z "$MVNW_PASSWORD" ]; then + curl $QUIET -o "$wrapperJarPath" "$wrapperUrl" -f -L || rm -f "$wrapperJarPath" + else + curl $QUIET --user "$MVNW_USERNAME:$MVNW_PASSWORD" -o "$wrapperJarPath" "$wrapperUrl" -f -L || rm -f "$wrapperJarPath" + fi + else + log "Falling back to using Java to download" + javaSource="$MAVEN_PROJECTBASEDIR/.mvn/wrapper/MavenWrapperDownloader.java" + javaClass="$MAVEN_PROJECTBASEDIR/.mvn/wrapper/MavenWrapperDownloader.class" + # For Cygwin, switch paths to Windows format before running javac + if $cygwin; then + javaSource=$(cygpath --path --windows "$javaSource") + javaClass=$(cygpath --path --windows "$javaClass") + fi + if [ -e "$javaSource" ]; then + if [ ! -e "$javaClass" ]; then + log " - Compiling MavenWrapperDownloader.java ..." + ("$JAVA_HOME/bin/javac" "$javaSource") + fi + if [ -e "$javaClass" ]; then + log " - Running MavenWrapperDownloader.java ..." + ("$JAVA_HOME/bin/java" -cp .mvn/wrapper MavenWrapperDownloader "$wrapperUrl" "$wrapperJarPath") || rm -f "$wrapperJarPath" + fi + fi + fi +fi +########################################################################################## +# End of extension +########################################################################################## + +# If specified, validate the SHA-256 sum of the Maven wrapper jar file +wrapperSha256Sum="" +while IFS="=" read -r key value; do + case "$key" in wrapperSha256Sum) + wrapperSha256Sum=$value + break + ;; + esac +done <"$MAVEN_PROJECTBASEDIR/.mvn/wrapper/maven-wrapper.properties" +if [ -n "$wrapperSha256Sum" ]; then + wrapperSha256Result=false + if command -v sha256sum >/dev/null; then + if echo "$wrapperSha256Sum $wrapperJarPath" | sha256sum -c >/dev/null 2>&1; then + wrapperSha256Result=true + fi + elif command -v shasum >/dev/null; then + if echo "$wrapperSha256Sum $wrapperJarPath" | shasum -a 256 -c >/dev/null 2>&1; then + wrapperSha256Result=true + fi + else + echo "Checksum validation was requested but neither 'sha256sum' or 'shasum' are available." >&2 + echo "Please install either command, or disable validation by removing 'wrapperSha256Sum' from your maven-wrapper.properties." >&2 + exit 1 + fi + if [ $wrapperSha256Result = false ]; then + echo "Error: Failed to validate Maven wrapper SHA-256, your Maven wrapper might be compromised." >&2 + echo "Investigate or delete $wrapperJarPath to attempt a clean download." >&2 + echo "If you updated your Maven version, you need to update the specified wrapperSha256Sum property." >&2 + exit 1 + fi +fi + +MAVEN_OPTS="$(concat_lines "$MAVEN_PROJECTBASEDIR/.mvn/jvm.config") $MAVEN_OPTS" + +# For Cygwin, switch paths to Windows format before running java +if $cygwin; then + [ -n "$JAVA_HOME" ] \ + && JAVA_HOME=$(cygpath --path --windows "$JAVA_HOME") + [ -n "$CLASSPATH" ] \ + && CLASSPATH=$(cygpath --path --windows "$CLASSPATH") + [ -n "$MAVEN_PROJECTBASEDIR" ] \ + && MAVEN_PROJECTBASEDIR=$(cygpath --path --windows "$MAVEN_PROJECTBASEDIR") +fi + +# Provide a "standardized" way to retrieve the CLI args that will +# work with both Windows and non-Windows executions. +MAVEN_CMD_LINE_ARGS="$MAVEN_CONFIG $*" +export MAVEN_CMD_LINE_ARGS + +WRAPPER_LAUNCHER=org.apache.maven.wrapper.MavenWrapperMain + +# shellcheck disable=SC2086 # safe args +exec "$JAVACMD" \ + $MAVEN_OPTS \ + $MAVEN_DEBUG_OPTS \ + -classpath "$MAVEN_PROJECTBASEDIR/.mvn/wrapper/maven-wrapper.jar" \ + "-Dmaven.multiModuleProjectDirectory=${MAVEN_PROJECTBASEDIR}" \ + ${WRAPPER_LAUNCHER} $MAVEN_CONFIG "$@" diff --git a/mvnw.cmd b/mvnw.cmd new file mode 100644 index 0000000000..1204076a90 --- /dev/null +++ b/mvnw.cmd @@ -0,0 +1,206 @@ +@REM ---------------------------------------------------------------------------- +@REM Licensed to the Apache Software Foundation (ASF) under one +@REM or more contributor license agreements. See the NOTICE file +@REM distributed with this work for additional information +@REM regarding copyright ownership. The ASF licenses this file +@REM to you under the Apache License, Version 2.0 (the +@REM "License"); you may not use this file except in compliance +@REM with the License. You may obtain a copy of the License at +@REM +@REM http://www.apache.org/licenses/LICENSE-2.0 +@REM +@REM Unless required by applicable law or agreed to in writing, +@REM software distributed under the License is distributed on an +@REM "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +@REM KIND, either express or implied. See the License for the +@REM specific language governing permissions and limitations +@REM under the License. +@REM ---------------------------------------------------------------------------- + +@REM ---------------------------------------------------------------------------- +@REM Apache Maven Wrapper startup batch script, version 3.3.2 +@REM +@REM Required ENV vars: +@REM JAVA_HOME - location of a JDK home dir +@REM +@REM Optional ENV vars +@REM MAVEN_BATCH_ECHO - set to 'on' to enable the echoing of the batch commands +@REM MAVEN_BATCH_PAUSE - set to 'on' to wait for a keystroke before ending +@REM MAVEN_OPTS - parameters passed to the Java VM when running Maven +@REM e.g. to debug Maven itself, use +@REM set MAVEN_OPTS=-Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=y,address=8000 +@REM MAVEN_SKIP_RC - flag to disable loading of mavenrc files +@REM ---------------------------------------------------------------------------- + +@REM Begin all REM lines with '@' in case MAVEN_BATCH_ECHO is 'on' +@echo off +@REM set title of command window +title %0 +@REM enable echoing by setting MAVEN_BATCH_ECHO to 'on' +@if "%MAVEN_BATCH_ECHO%" == "on" echo %MAVEN_BATCH_ECHO% + +@REM set %HOME% to equivalent of $HOME +if "%HOME%" == "" (set "HOME=%HOMEDRIVE%%HOMEPATH%") + +@REM Execute a user defined script before this one +if not "%MAVEN_SKIP_RC%" == "" goto skipRcPre +@REM check for pre script, once with legacy .bat ending and once with .cmd ending +if exist "%USERPROFILE%\mavenrc_pre.bat" call "%USERPROFILE%\mavenrc_pre.bat" %* +if exist "%USERPROFILE%\mavenrc_pre.cmd" call "%USERPROFILE%\mavenrc_pre.cmd" %* +:skipRcPre + +@setlocal + +set ERROR_CODE=0 + +@REM To isolate internal variables from possible post scripts, we use another setlocal +@setlocal + +@REM ==== START VALIDATION ==== +if not "%JAVA_HOME%" == "" goto OkJHome + +echo. >&2 +echo Error: JAVA_HOME not found in your environment. >&2 +echo Please set the JAVA_HOME variable in your environment to match the >&2 +echo location of your Java installation. >&2 +echo. >&2 +goto error + +:OkJHome +if exist "%JAVA_HOME%\bin\java.exe" goto init + +echo. >&2 +echo Error: JAVA_HOME is set to an invalid directory. >&2 +echo JAVA_HOME = "%JAVA_HOME%" >&2 +echo Please set the JAVA_HOME variable in your environment to match the >&2 +echo location of your Java installation. >&2 +echo. >&2 +goto error + +@REM ==== END VALIDATION ==== + +:init + +@REM Find the project base dir, i.e. the directory that contains the folder ".mvn". +@REM Fallback to current working directory if not found. + +set MAVEN_PROJECTBASEDIR=%MAVEN_BASEDIR% +IF NOT "%MAVEN_PROJECTBASEDIR%"=="" goto endDetectBaseDir + +set EXEC_DIR=%CD% +set WDIR=%EXEC_DIR% +:findBaseDir +IF EXIST "%WDIR%"\.mvn goto baseDirFound +cd .. +IF "%WDIR%"=="%CD%" goto baseDirNotFound +set WDIR=%CD% +goto findBaseDir + +:baseDirFound +set MAVEN_PROJECTBASEDIR=%WDIR% +cd "%EXEC_DIR%" +goto endDetectBaseDir + +:baseDirNotFound +set MAVEN_PROJECTBASEDIR=%EXEC_DIR% +cd "%EXEC_DIR%" + +:endDetectBaseDir + +IF NOT EXIST "%MAVEN_PROJECTBASEDIR%\.mvn\jvm.config" goto endReadAdditionalConfig + +@setlocal EnableExtensions EnableDelayedExpansion +for /F "usebackq delims=" %%a in ("%MAVEN_PROJECTBASEDIR%\.mvn\jvm.config") do set JVM_CONFIG_MAVEN_PROPS=!JVM_CONFIG_MAVEN_PROPS! %%a +@endlocal & set JVM_CONFIG_MAVEN_PROPS=%JVM_CONFIG_MAVEN_PROPS% + +:endReadAdditionalConfig + +SET MAVEN_JAVA_EXE="%JAVA_HOME%\bin\java.exe" +set WRAPPER_JAR="%MAVEN_PROJECTBASEDIR%\.mvn\wrapper\maven-wrapper.jar" +set WRAPPER_LAUNCHER=org.apache.maven.wrapper.MavenWrapperMain + +set WRAPPER_URL="https://repo.maven.apache.org/maven2/org/apache/maven/wrapper/maven-wrapper/3.3.2/maven-wrapper-3.3.2.jar" + +FOR /F "usebackq tokens=1,2 delims==" %%A IN ("%MAVEN_PROJECTBASEDIR%\.mvn\wrapper\maven-wrapper.properties") DO ( + IF "%%A"=="wrapperUrl" SET WRAPPER_URL=%%B +) + +@REM Extension to allow automatically downloading the maven-wrapper.jar from Maven-central +@REM This allows using the maven wrapper in projects that prohibit checking in binary data. +if exist %WRAPPER_JAR% ( + if "%MVNW_VERBOSE%" == "true" ( + echo Found %WRAPPER_JAR% + ) +) else ( + if not "%MVNW_REPOURL%" == "" ( + SET WRAPPER_URL="%MVNW_REPOURL%/org/apache/maven/wrapper/maven-wrapper/3.3.2/maven-wrapper-3.3.2.jar" + ) + if "%MVNW_VERBOSE%" == "true" ( + echo Couldn't find %WRAPPER_JAR%, downloading it ... + echo Downloading from: %WRAPPER_URL% + ) + + powershell -Command "&{"^ + "$webclient = new-object System.Net.WebClient;"^ + "if (-not ([string]::IsNullOrEmpty('%MVNW_USERNAME%') -and [string]::IsNullOrEmpty('%MVNW_PASSWORD%'))) {"^ + "$webclient.Credentials = new-object System.Net.NetworkCredential('%MVNW_USERNAME%', '%MVNW_PASSWORD%');"^ + "}"^ + "[Net.ServicePointManager]::SecurityProtocol = [Net.SecurityProtocolType]::Tls12; $webclient.DownloadFile('%WRAPPER_URL%', '%WRAPPER_JAR%')"^ + "}" + if "%MVNW_VERBOSE%" == "true" ( + echo Finished downloading %WRAPPER_JAR% + ) +) +@REM End of extension + +@REM If specified, validate the SHA-256 sum of the Maven wrapper jar file +SET WRAPPER_SHA_256_SUM="" +FOR /F "usebackq tokens=1,2 delims==" %%A IN ("%MAVEN_PROJECTBASEDIR%\.mvn\wrapper\maven-wrapper.properties") DO ( + IF "%%A"=="wrapperSha256Sum" SET WRAPPER_SHA_256_SUM=%%B +) +IF NOT %WRAPPER_SHA_256_SUM%=="" ( + powershell -Command "&{"^ + "Import-Module $PSHOME\Modules\Microsoft.PowerShell.Utility -Function Get-FileHash;"^ + "$hash = (Get-FileHash \"%WRAPPER_JAR%\" -Algorithm SHA256).Hash.ToLower();"^ + "If('%WRAPPER_SHA_256_SUM%' -ne $hash){"^ + " Write-Error 'Error: Failed to validate Maven wrapper SHA-256, your Maven wrapper might be compromised.';"^ + " Write-Error 'Investigate or delete %WRAPPER_JAR% to attempt a clean download.';"^ + " Write-Error 'If you updated your Maven version, you need to update the specified wrapperSha256Sum property.';"^ + " exit 1;"^ + "}"^ + "}" + if ERRORLEVEL 1 goto error +) + +@REM Provide a "standardized" way to retrieve the CLI args that will +@REM work with both Windows and non-Windows executions. +set MAVEN_CMD_LINE_ARGS=%* + +%MAVEN_JAVA_EXE% ^ + %JVM_CONFIG_MAVEN_PROPS% ^ + %MAVEN_OPTS% ^ + %MAVEN_DEBUG_OPTS% ^ + -classpath %WRAPPER_JAR% ^ + "-Dmaven.multiModuleProjectDirectory=%MAVEN_PROJECTBASEDIR%" ^ + %WRAPPER_LAUNCHER% %MAVEN_CONFIG% %* +if ERRORLEVEL 1 goto error +goto end + +:error +set ERROR_CODE=1 + +:end +@endlocal & set ERROR_CODE=%ERROR_CODE% + +if not "%MAVEN_SKIP_RC%"=="" goto skipRcPost +@REM check for post script, once with legacy .bat ending and once with .cmd ending +if exist "%USERPROFILE%\mavenrc_post.bat" call "%USERPROFILE%\mavenrc_post.bat" +if exist "%USERPROFILE%\mavenrc_post.cmd" call "%USERPROFILE%\mavenrc_post.cmd" +:skipRcPost + +@REM pause the script if MAVEN_BATCH_PAUSE is set to 'on' +if "%MAVEN_BATCH_PAUSE%"=="on" pause + +if "%MAVEN_TERMINATE_CMD%"=="on" exit %ERROR_CODE% + +cmd /C exit /B %ERROR_CODE% diff --git a/orm/pom.xml b/orm/pom.xml index 77ba3b87e8..9e704fb967 100644 --- a/orm/pom.xml +++ b/orm/pom.xml @@ -25,7 +25,7 @@ org.hibernate.tool hibernate-tools-parent - 6.5.0.Final + 6.6.27-SNAPSHOT hibernate-tools-orm @@ -35,6 +35,11 @@ Hibernate Tools ORM Hibernate Tools ORM + + + false + + com.google.googlejavaformat @@ -82,4 +87,26 @@ + + + + org.jboss.maven.plugins + maven-injection-plugin + + + + ${project.version} + + + org.hibernate.tool.api.version.Version + versionString + + + + + + + + + diff --git a/orm/src/main/java/org/hibernate/tool/api/version/Version.java b/orm/src/main/java/org/hibernate/tool/api/version/Version.java index 743575478b..da4f560172 100644 --- a/orm/src/main/java/org/hibernate/tool/api/version/Version.java +++ b/orm/src/main/java/org/hibernate/tool/api/version/Version.java @@ -1,7 +1,16 @@ package org.hibernate.tool.api.version; public interface Version { - - final static String CURRENT_VERSION = "6.5.0.Final"; + /** + * @deprecated Use {@link #versionString()} instead. + */ + @Deprecated + final static String CURRENT_VERSION = versionString(); + + static String versionString() { + // This implementation is replaced during the build with another one that returns the correct value. + return "UNKNOWN"; + } + } diff --git a/orm/src/main/java/org/hibernate/tool/internal/export/common/TemplateHelper.java b/orm/src/main/java/org/hibernate/tool/internal/export/common/TemplateHelper.java index 3a8152feef..33722b7ce5 100644 --- a/orm/src/main/java/org/hibernate/tool/internal/export/common/TemplateHelper.java +++ b/orm/src/main/java/org/hibernate/tool/internal/export/common/TemplateHelper.java @@ -177,7 +177,7 @@ public void processString(String template, Writer output) { } public void setupContext() { - getContext().put("version", Version.CURRENT_VERSION); + getContext().put("version", Version.versionString()); getContext().put("ctx", getContext() ); //TODO: I would like to remove this, but don't know another way to actually get the list possible "root" keys for debugging. getContext().put("templates", new Templates()); diff --git a/orm/src/main/java/org/hibernate/tool/internal/reveng/binder/PrimaryKeyBinder.java b/orm/src/main/java/org/hibernate/tool/internal/reveng/binder/PrimaryKeyBinder.java index afcaf2d438..62fbfd4140 100644 --- a/orm/src/main/java/org/hibernate/tool/internal/reveng/binder/PrimaryKeyBinder.java +++ b/orm/src/main/java/org/hibernate/tool/internal/reveng/binder/PrimaryKeyBinder.java @@ -24,6 +24,7 @@ import org.hibernate.tool.api.reveng.TableIdentifier; import org.hibernate.tool.internal.reveng.RevengMetadataCollector; import org.hibernate.tool.internal.reveng.binder.ForeignKeyUtils.ForeignKeyForColumns; +import org.hibernate.tool.internal.reveng.util.EnhancedComponent; import org.hibernate.tool.internal.reveng.util.RevengUtils; class PrimaryKeyBinder extends AbstractBinder { @@ -194,7 +195,7 @@ private SimpleValue handleCompositeKey( PersistentClass rc, Set processedColumns, List keyColumns) { - Component result = new Component(getMetadataBuildingContext(), rc); + Component result = new EnhancedComponent(getMetadataBuildingContext(), rc); result.setMetaAttributes(Collections.EMPTY_MAP); result.setEmbedded(false); result.setComponentClassName(getCompositeIdName(rc)); diff --git a/orm/src/main/java/org/hibernate/tool/internal/reveng/reader/ForeignKeyProcessor.java b/orm/src/main/java/org/hibernate/tool/internal/reveng/reader/ForeignKeyProcessor.java index 445e3317c1..55548f45fc 100644 --- a/orm/src/main/java/org/hibernate/tool/internal/reveng/reader/ForeignKeyProcessor.java +++ b/orm/src/main/java/org/hibernate/tool/internal/reveng/reader/ForeignKeyProcessor.java @@ -244,10 +244,9 @@ private void processUserForeignKey( " references unknown or filtered table " + TableIdentifier.create(element.getTable()) ); } else { - dependentTables.put(element.getName(), deptable); - List refColumns = getReferencedColums(referencedTable, element); - referencedColumns.put(element.getName(), refColumns ); - dependentColumns.put(element.getName(), getDependendColumns(refColumns, deptable) ); + dependentTables.put(element.getName(), deptable); + referencedColumns.put(element.getName(), getReferencedColums(referencedTable, element) ); + dependentColumns.put(element.getName(), getDependendColumns(deptable, element) ); } } @@ -264,7 +263,8 @@ private Table determineDependentTable(Map dependentTables, Foreig userfkTable.getName()); } - private List getDependendColumns(List userColumns, Table deptable) { + private List getDependendColumns(Table deptable, ForeignKey element) { + List userColumns = element.getColumns(); List depColumns = new ArrayList(userColumns.size() ); Iterator colIterator = userColumns.iterator(); while(colIterator.hasNext() ) { diff --git a/orm/src/main/java/org/hibernate/tool/internal/reveng/util/EnhancedComponent.java b/orm/src/main/java/org/hibernate/tool/internal/reveng/util/EnhancedComponent.java new file mode 100644 index 0000000000..b09c412e72 --- /dev/null +++ b/orm/src/main/java/org/hibernate/tool/internal/reveng/util/EnhancedComponent.java @@ -0,0 +1,24 @@ +package org.hibernate.tool.internal.reveng.util; + +import java.util.Properties; + +import org.hibernate.MappingException; +import org.hibernate.boot.spi.MetadataBuildingContext; +import org.hibernate.mapping.Component; +import org.hibernate.mapping.PersistentClass; + +@SuppressWarnings("serial") +public class EnhancedComponent extends Component { + + public EnhancedComponent(MetadataBuildingContext metadata, PersistentClass owner) throws MappingException { + super(metadata, owner); + } + + @Override + public Class getComponentClass() throws MappingException { + // we prevent ORM from trying to load a component class by name, + // since at the point when we are building these, a corresponding class is not yet created + // (so can't even think about it being compiled and able to load via any classloader) ... + return Object.class; + } +} diff --git a/orm/src/main/resources/hbm/generalhbm.hbm.ftl b/orm/src/main/resources/hbm/generalhbm.hbm.ftl index bf73afd337..5d9d8e982c 100644 --- a/orm/src/main/resources/hbm/generalhbm.hbm.ftl +++ b/orm/src/main/resources/hbm/generalhbm.hbm.ftl @@ -1,7 +1,7 @@ + "https://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> <#if hmgs?exists && hmgs.hasNonDefaultSettings()> diff --git a/orm/src/main/resources/pojo/PojoPropertyAccessors.ftl b/orm/src/main/resources/pojo/PojoPropertyAccessors.ftl index b166786237..00097a644e 100644 --- a/orm/src/main/resources/pojo/PojoPropertyAccessors.ftl +++ b/orm/src/main/resources/pojo/PojoPropertyAccessors.ftl @@ -3,7 +3,7 @@ <#if pojo.getMetaAttribAsBool(property, "gen-property", true)> <#if pojo.hasFieldJavaDoc(property)> /** - * ${pojo.getFieldJavaDoc(property, 4)} + ${pojo.getFieldJavaDoc(property, 4)} */ <#include "GetPropertyAnnotation.ftl"/> diff --git a/pom.xml b/pom.xml index 57aaf87aaa..63734879c7 100644 --- a/pom.xml +++ b/pom.xml @@ -23,15 +23,15 @@ org.jboss jboss-parent - 40 + 49 - + org.hibernate.tool hibernate-tools-parent - 6.5.0.Final + 6.6.27-SNAPSHOT pom - + Hibernate Tools Parent Project http://hibernate.org/tools/ @@ -78,6 +78,7 @@ orm jbt maven + gradle ant test utils @@ -85,27 +86,54 @@ - 1.10.14 - 4.13.1 - 4.4 - 2.3.32 - 1.19.1 - 2.2.224 - 6.0.6.Final - 6.5.0.Final + 1.10.15 + 4.13.2 + 4.5.0 + 2.3.34 + + 1.24.0 + 2.3.232 + 7.0.3.Final + 6.6.26.Final 2.6.1 8.0.1 - 3.5.3.Final - 5.10.1 + 3.6.1.Final + 5.13.4 8.0.22 19.3.0.0 9.2.1.jre8 + + 3.3.2 + 1.7.2 + 3.9.1 + + + true + + + + + staging-deploy + Local Staging Directory Releases Repository + file:${maven.multiModuleProjectDirectory}/target/staging-deploy/maven + central-releases + Maven Central Releases Repository + https://central.sonatype.com/api/v1/publisher/ + central-snapshots + Maven Central Snapshots Repository + https://central.sonatype.com/repository/maven-snapshots/ + + 11 11 + 3.9.7 - + @@ -223,36 +251,116 @@ - + - - false - - ossrh-releases-repository - Sonatype OSSRH Releases - https://oss.sonatype.org/service/local/staging/deploy/maven2/ - - - - true - - ossrh-snapshots-repository - Sonatype OSSRH Snapshots - https://oss.sonatype.org/content/repositories/snapshots/ + ${central.releases.repo.id} + ${central.releases.repo.name} + ${central.releases.repo.url} - - - - - ossrh-releases-repository - Sonatype OSSRH Releases - https://oss.sonatype.org/service/local/staging/deploy/maven2/ - - - ossrh-snapshots-repository - Sonatype OSSRH Snapshots - https://oss.sonatype.org/content/repositories/snapshots/ - + + ${central.snapshots.repo.id} + ${central.snapshots.repo.name} + ${central.snapshots.repo.url} + + + + + + org.apache.maven.plugins + maven-wrapper-plugin + ${maven-wrapper-plugin.version} + + ${maven.min.version} + bin + + + + org.codehaus.mojo + flatten-maven-plugin + ${flatten-maven-plugin.version} + + ${project.build.directory} + + ossrh + + true + + + + flatten-pom + process-resources + + flatten + + + + + + + + + + org.apache.maven.plugins + maven-deploy-plugin + + ${deploy.skip} + + + + org.codehaus.mojo + flatten-maven-plugin + + + org.apache.maven.plugins + maven-enforcer-plugin + + + enforce-java-version + + enforce + + + + + + To build this project JDK ${jdk.min.version} (or greater) is required. Please install it. + ${jdk.min.version} + + + + + + + + + + + + release + + + performRelease + true + + + + + + + org.apache.maven.plugins + maven-deploy-plugin + + ${local.staging.releases.repo.id}::${local.staging.releases.repo.url} + + + + + + + diff --git a/test/common/pom.xml b/test/common/pom.xml index c43ef4dd92..65d16f80d0 100644 --- a/test/common/pom.xml +++ b/test/common/pom.xml @@ -28,7 +28,7 @@ org.hibernate.tool hibernate-tools-tests-parent - 6.5.0.Final + 6.6.27-SNAPSHOT hibernate-tools-tests-common diff --git a/test/common/src/main/java/org/hibernate/tool/ant/Hbm2JavaConfiguration/TestCase.java b/test/common/src/main/java/org/hibernate/tool/ant/Hbm2JavaConfiguration/TestCase.java index f1875d6276..71be442162 100644 --- a/test/common/src/main/java/org/hibernate/tool/ant/Hbm2JavaConfiguration/TestCase.java +++ b/test/common/src/main/java/org/hibernate/tool/ant/Hbm2JavaConfiguration/TestCase.java @@ -20,7 +20,7 @@ package org.hibernate.tool.ant.Hbm2JavaConfiguration; import static org.junit.jupiter.api.Assertions.assertFalse; -import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertNotNull; import static org.junit.jupiter.api.Assertions.assertTrue; import java.io.File; @@ -77,7 +77,7 @@ public void testHbm2JavaConfiguration() { assertTrue(FileUtil .findFirstString("SomeClass", someClass) .contains("SomeClass generated by hbm2java")); - assertNull(FileUtil.findFirstString("@Entity", someClass)); + assertNotNull(FileUtil.findFirstString("@Entity", someClass)); } diff --git a/test/common/src/main/java/org/hibernate/tool/hbm2x/hbx2840/TestCase.java b/test/common/src/main/java/org/hibernate/tool/hbm2x/hbx2840/TestCase.java new file mode 100644 index 0000000000..4ce16a0420 --- /dev/null +++ b/test/common/src/main/java/org/hibernate/tool/hbm2x/hbx2840/TestCase.java @@ -0,0 +1,71 @@ +/* + * Hibernate Tools, Tooling for your Hibernate Projects + * + * Copyright 2004-2021 Red Hat, Inc. + * + * Licensed under the GNU Lesser General Public License (LGPL), + * version 2.1 or later (the "License"). + * You may not use this file except in compliance with the License. + * You may read the licence in the 'lgpl.txt' file in the root folder of + * project or obtain a copy at + * + * http://www.gnu.org/licenses/lgpl-2.1.html + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.hibernate.tool.hbm2x.hbx2840; + +import java.io.File; + +import org.hibernate.tool.api.export.Exporter; +import org.hibernate.tool.api.export.ExporterConstants; +import org.hibernate.tool.api.export.ExporterFactory; +import org.hibernate.tool.api.export.ExporterType; +import org.hibernate.tool.api.metadata.MetadataDescriptorFactory; +import org.hibernate.tools.test.util.JUnitUtil; +import org.hibernate.tools.test.util.JdbcUtil; + +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.io.TempDir; + +/** + * Test verifies that a foreign key to a table with a composite ID works. + */ +public class TestCase { + + @TempDir + public File outputDir = new File( "output" ); + + @BeforeEach + void setUp() { + JdbcUtil.createDatabase( this ); + Exporter exporter = ExporterFactory.createExporter( ExporterType.JAVA ); + exporter.getProperties().put( + ExporterConstants.METADATA_DESCRIPTOR, + MetadataDescriptorFactory.createReverseEngineeringDescriptor( null, null ) + ); + exporter.getProperties().put( ExporterConstants.DESTINATION_FOLDER, outputDir ); + exporter.getProperties().put( ExporterConstants.TEMPLATE_PATH, new String[0] ); + exporter.getProperties().setProperty( "ejb3", "true" ); + exporter.start(); + } + + @AfterEach + void tearDown() { + JdbcUtil.dropDatabase( this ); + } + + @Test + void testFileExistence() { + JUnitUtil.assertIsNonEmptyFile( new File( outputDir.getAbsolutePath() + "/Parent.java" ) ); + JUnitUtil.assertIsNonEmptyFile( new File( outputDir.getAbsolutePath() + "/Child.java" ) ); + JUnitUtil.assertIsNonEmptyFile( new File( outputDir.getAbsolutePath() + "/ParentId.java" ) ); + JUnitUtil.assertIsNonEmptyFile( new File( outputDir.getAbsolutePath() + "/ChildId.java" ) ); + } +} diff --git a/test/common/src/main/java/org/hibernate/tool/jdbc2cfg/PersistentClasses/TestCase.java b/test/common/src/main/java/org/hibernate/tool/jdbc2cfg/PersistentClasses/TestCase.java index 27ad6b1a93..a42ac7f1cc 100644 --- a/test/common/src/main/java/org/hibernate/tool/jdbc2cfg/PersistentClasses/TestCase.java +++ b/test/common/src/main/java/org/hibernate/tool/jdbc2cfg/PersistentClasses/TestCase.java @@ -47,6 +47,7 @@ import org.hibernate.tools.test.util.JdbcUtil; import org.junit.jupiter.api.AfterEach; import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Disabled; import org.junit.jupiter.api.Test; /** @@ -108,6 +109,8 @@ public void testCreateOneToMany() { assertTrue(itemset.getValue() instanceof Set); } + // TODO HBX-2849 : Investigate and reenable the below test + @Disabled @Test public void testBinding() throws HibernateException, SQLException { diff --git a/test/common/src/main/java/org/hibernate/tool/test/db/DbTestSuite.java b/test/common/src/main/java/org/hibernate/tool/test/db/DbTestSuite.java index c3d24bb19e..d9ef06619b 100644 --- a/test/common/src/main/java/org/hibernate/tool/test/db/DbTestSuite.java +++ b/test/common/src/main/java/org/hibernate/tool/test/db/DbTestSuite.java @@ -53,6 +53,7 @@ public class DbTestSuite { @Nested public class GenerateFromJDBCWithJavaKeyword extends org.hibernate.tool.hbm2x.GenerateFromJDBCWithJavaKeyword.TestCase {} @Nested public class IncrementalSchemaReading extends org.hibernate.tool.hbm2x.IncrementalSchemaReading.TestCase {} @Nested public class JdbcHbm2JavaEjb3 extends org.hibernate.tool.hbm2x.JdbcHbm2JavaEjb3.TestCase {} + @Nested public class HBX2840 extends org.hibernate.tool.hbm2x.hbx2840.TestCase {} @Nested public class QueryExporterTest extends org.hibernate.tool.hbm2x.query.QueryExporterTest.TestCase {} @Nested public class HbmLintTest extends org.hibernate.tool.hbmlint.HbmLintTest.TestCase {} @Nested public class SchemaAnalyzer extends org.hibernate.tool.hbmlint.SchemaAnalyzer.TestCase {} diff --git a/test/common/src/main/resources/org/hibernate/tool/ant/AntHibernateTool/TopDown.hbm.xml b/test/common/src/main/resources/org/hibernate/tool/ant/AntHibernateTool/TopDown.hbm.xml index 7423324ed5..767bd5de29 100644 --- a/test/common/src/main/resources/org/hibernate/tool/ant/AntHibernateTool/TopDown.hbm.xml +++ b/test/common/src/main/resources/org/hibernate/tool/ant/AntHibernateTool/TopDown.hbm.xml @@ -1,7 +1,7 @@ + "https://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> diff --git a/test/common/src/main/resources/org/hibernate/tool/ant/GenericExport/TopDown.hbm.xml b/test/common/src/main/resources/org/hibernate/tool/ant/GenericExport/TopDown.hbm.xml index 7423324ed5..767bd5de29 100644 --- a/test/common/src/main/resources/org/hibernate/tool/ant/GenericExport/TopDown.hbm.xml +++ b/test/common/src/main/resources/org/hibernate/tool/ant/GenericExport/TopDown.hbm.xml @@ -1,7 +1,7 @@ + "https://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> diff --git a/test/common/src/main/resources/org/hibernate/tool/ant/Hbm2JavaConfiguration/SomeClass.hbm.xml b/test/common/src/main/resources/org/hibernate/tool/ant/Hbm2JavaConfiguration/SomeClass.hbm.xml index 6f660da374..a18a73271f 100644 --- a/test/common/src/main/resources/org/hibernate/tool/ant/Hbm2JavaConfiguration/SomeClass.hbm.xml +++ b/test/common/src/main/resources/org/hibernate/tool/ant/Hbm2JavaConfiguration/SomeClass.hbm.xml @@ -1,7 +1,7 @@ + "https://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> diff --git a/test/common/src/main/resources/org/hibernate/tool/ant/Hbm2JavaEJB3Configuration/SomeClass.hbm.xml b/test/common/src/main/resources/org/hibernate/tool/ant/Hbm2JavaEJB3Configuration/SomeClass.hbm.xml index 6f660da374..a18a73271f 100644 --- a/test/common/src/main/resources/org/hibernate/tool/ant/Hbm2JavaEJB3Configuration/SomeClass.hbm.xml +++ b/test/common/src/main/resources/org/hibernate/tool/ant/Hbm2JavaEJB3Configuration/SomeClass.hbm.xml @@ -1,7 +1,7 @@ + "https://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> diff --git a/test/common/src/main/resources/org/hibernate/tool/ant/HbmLint/Column.hbm.xml b/test/common/src/main/resources/org/hibernate/tool/ant/HbmLint/Column.hbm.xml index 658bef462f..54b5df61c2 100644 --- a/test/common/src/main/resources/org/hibernate/tool/ant/HbmLint/Column.hbm.xml +++ b/test/common/src/main/resources/org/hibernate/tool/ant/HbmLint/Column.hbm.xml @@ -1,7 +1,7 @@ + "https://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> + com.h2database + h2 + ${h2.version} + + + + + + + \ No newline at end of file diff --git a/test/maven/src/it/generateHbm/src/main/resources/hibernate.properties b/test/maven/src/it/generateHbm/src/main/resources/hibernate.properties new file mode 100644 index 0000000000..71496b3adc --- /dev/null +++ b/test/maven/src/it/generateHbm/src/main/resources/hibernate.properties @@ -0,0 +1,7 @@ +hibernate.dialect=org.hibernate.dialect.H2Dialect +hibernate.connection.driver_class=org.h2.Driver +hibernate.connection.url=jdbc:h2:./test;DB_CLOSE_ON_EXIT=FALSE +hibernate.connection.username=sa +hibernate.connection.password= +hibernate.connection.pool_size=1 +hibernate.show_sql=true \ No newline at end of file diff --git a/test/maven/src/it/generateHbm/src/main/resources/hibernate.reveng.xml b/test/maven/src/it/generateHbm/src/main/resources/hibernate.reveng.xml new file mode 100644 index 0000000000..7ac52fd2cf --- /dev/null +++ b/test/maven/src/it/generateHbm/src/main/resources/hibernate.reveng.xml @@ -0,0 +1,11 @@ + + + + + + + + + + + \ No newline at end of file diff --git a/test/maven/src/it/generateHbm/src/main/resources/templates/pojo/Pojo.ftl b/test/maven/src/it/generateHbm/src/main/resources/templates/pojo/Pojo.ftl new file mode 100644 index 0000000000..84ff76a5b2 --- /dev/null +++ b/test/maven/src/it/generateHbm/src/main/resources/templates/pojo/Pojo.ftl @@ -0,0 +1,29 @@ +${pojo.getPackageDeclaration()} +// Generated ${date} by Hibernate Tools ${version} + +<#assign classbody> +<#include "PojoTypeDeclaration.ftl"/> { + +<#if !pojo.isInterface()> +<#include "PojoFields.ftl"/> + +<#include "PojoConstructors.ftl"/> + +<#include "PojoPropertyAccessors.ftl"/> + +<#include "PojoToString.ftl"/> + +<#include "PojoEqualsHashcode.ftl"/> + +<#else> +<#include "PojoInterfacePropertyAccessors.ftl"/> + + +<#include "PojoExtraClassCode.ftl"/> + +} + + +${pojo.generateImports()} +${classbody} + diff --git a/test/maven/src/it/generateHbm/src/main/resources/templates/pojo/PojoFields.ftl b/test/maven/src/it/generateHbm/src/main/resources/templates/pojo/PojoFields.ftl new file mode 100644 index 0000000000..18cf396cc6 --- /dev/null +++ b/test/maven/src/it/generateHbm/src/main/resources/templates/pojo/PojoFields.ftl @@ -0,0 +1,7 @@ +<#-- // Fields --> +<#list pojo.getAllPropertiesIterator() as field><#if pojo.getMetaAttribAsBool(field, "gen-property", true)><#if pojo.hasMetaAttribute(field, "field-description")> /** + ${pojo.getFieldJavaDoc(field, 0)} + */ + ${pojo.getFieldModifiers(field)} ${pojo.getJavaTypeName(field, jdk5)} ${c2j.keyWordCheck(field.name)}<#if pojo.hasFieldInitializor(field, jdk5)> = ${pojo.getFieldInitialization(field, jdk5)}; + + diff --git a/test/maven/src/it/generateHbm/test.mv.db b/test/maven/src/it/generateHbm/test.mv.db new file mode 100644 index 0000000000..72d79270f8 Binary files /dev/null and b/test/maven/src/it/generateHbm/test.mv.db differ diff --git a/test/maven/src/it/generateHbm/verify.groovy b/test/maven/src/it/generateHbm/verify.groovy new file mode 100644 index 0000000000..586fe51dc5 --- /dev/null +++ b/test/maven/src/it/generateHbm/verify.groovy @@ -0,0 +1,6 @@ +import java.io.*; + +File file = new File(basedir, "target/generated-sources/Person.hbm.xml"); +if (!file.isFile()) { + throw new FileNotFoundException("Could not find generated HBM file: " + file); +} diff --git a/test/mssql/pom.xml b/test/mssql/pom.xml index 15c32044ed..2b47194833 100644 --- a/test/mssql/pom.xml +++ b/test/mssql/pom.xml @@ -28,7 +28,7 @@ org.hibernate.tool hibernate-tools-tests-parent - 6.5.0.Final + 6.6.27-SNAPSHOT hibernate-tools-tests-mssql diff --git a/test/mysql/pom.xml b/test/mysql/pom.xml index 4617438d3c..c60a46804a 100644 --- a/test/mysql/pom.xml +++ b/test/mysql/pom.xml @@ -28,7 +28,7 @@ org.hibernate.tool hibernate-tools-tests-parent - 6.5.0.Final + 6.6.27-SNAPSHOT hibernate-tools-tests-mysql diff --git a/test/mysql/src/test/resources/org/hibernate/tool/hbmlint/SchemaAnalyzer/SchemaIssues.hbm.xml b/test/mysql/src/test/resources/org/hibernate/tool/hbmlint/SchemaAnalyzer/SchemaIssues.hbm.xml index 67c8779e6e..66c5b1f035 100644 --- a/test/mysql/src/test/resources/org/hibernate/tool/hbmlint/SchemaAnalyzer/SchemaIssues.hbm.xml +++ b/test/mysql/src/test/resources/org/hibernate/tool/hbmlint/SchemaAnalyzer/SchemaIssues.hbm.xml @@ -1,7 +1,7 @@ + "https://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> diff --git a/test/nodb/pom.xml b/test/nodb/pom.xml index 54bc6c5e92..abd30b70a9 100644 --- a/test/nodb/pom.xml +++ b/test/nodb/pom.xml @@ -27,7 +27,7 @@ org.hibernate.tool hibernate-tools-tests-parent - 6.5.0.Final + 6.6.27-SNAPSHOT hibernate-tools-tests-nodb diff --git a/test/nodb/src/test/java/org/hibernate/tool/VersionTest/TestCase.java b/test/nodb/src/test/java/org/hibernate/tool/VersionTest/TestCase.java index 3447393a51..cbd52f1357 100644 --- a/test/nodb/src/test/java/org/hibernate/tool/VersionTest/TestCase.java +++ b/test/nodb/src/test/java/org/hibernate/tool/VersionTest/TestCase.java @@ -45,7 +45,7 @@ public class TestCase { @Test public void testVersion() throws Exception { assertEquals( - org.hibernate.tool.api.version.Version.CURRENT_VERSION, + org.hibernate.tool.api.version.Version.versionString(), extractVersion(getPomXml())); } diff --git a/test/nodb/src/test/java/org/hibernate/tool/hbm2x/GenericExporterTest/TestCase.java b/test/nodb/src/test/java/org/hibernate/tool/hbm2x/GenericExporterTest/TestCase.java index 3d51e38372..54fc9e3ceb 100644 --- a/test/nodb/src/test/java/org/hibernate/tool/hbm2x/GenericExporterTest/TestCase.java +++ b/test/nodb/src/test/java/org/hibernate/tool/hbm2x/GenericExporterTest/TestCase.java @@ -90,7 +90,7 @@ public void testSingleFileGeneration() { null, FileUtil.findFirstString("$", new File(outputDir, "artifacts.txt"))); assertEquals( - "File for artifacts in " + Version.CURRENT_VERSION, + "File for artifacts in " + Version.versionString(), FileUtil.findFirstString("artifacts", new File( outputDir, "artifacts.txt"))); } diff --git a/test/nodb/src/test/java/org/hibernate/tool/hbm2x/hbm2hbmxml/TypeParamsTest/TestCase.java b/test/nodb/src/test/java/org/hibernate/tool/hbm2x/hbm2hbmxml/TypeParamsTest/TestCase.java index 743ea72b8a..d9de8fa42a 100644 --- a/test/nodb/src/test/java/org/hibernate/tool/hbm2x/hbm2hbmxml/TypeParamsTest/TestCase.java +++ b/test/nodb/src/test/java/org/hibernate/tool/hbm2x/hbm2hbmxml/TypeParamsTest/TestCase.java @@ -45,7 +45,6 @@ import org.hibernate.tools.test.util.HibernateUtil; import org.hibernate.tools.test.util.JUnitUtil; import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Disabled; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.io.TempDir; import org.w3c.dom.Document; @@ -82,8 +81,6 @@ public void setUp() throws Exception { hbmexporter.start(); } - // TODO HBX-2062: Investigate and reenable - @Disabled @Test public void testAllFilesExistence() { JUnitUtil.assertIsNonEmptyFile( @@ -92,8 +89,6 @@ public void testAllFilesExistence() { "org/hibernate/tool/hbm2x/hbm2hbmxml/TypeParamsTest/Order.hbm.xml")); } - // TODO HBX-2062: Investigate and reenable - @Disabled @Test public void testReadable() { File orderHbmXml = @@ -102,14 +97,13 @@ public void testReadable() { "org/hibernate/tool/hbm2x/hbm2hbmxml/TypeParamsTest/Order.hbm.xml"); Properties properties = new Properties(); properties.setProperty(AvailableSettings.DIALECT, HibernateUtil.Dialect.class.getName()); + properties.setProperty(AvailableSettings.CONNECTION_PROVIDER, HibernateUtil.ConnectionProvider.class.getName()); File[] files = new File[] { orderHbmXml }; MetadataDescriptor metadataDescriptor = MetadataDescriptorFactory .createNativeDescriptor(null, files, properties); assertNotNull(metadataDescriptor.createMetadata()); } - // TODO HBX-2062: Investigate and reenable - @Disabled @Test public void testTypeParamsElements() throws Exception { File outputXml = new File( @@ -163,10 +157,14 @@ public void testTypeParamsElements() throws Exception { set.contains("enumClass"), "Can't find 'enumClass' param"); assertEquals( - "org.hibernate.tool.hbm2x.hbm2hbmxml.Order$Status", + Status.class.getName(), params.get("enumClass")); assertTrue(nameElement.getElementsByTagName("type").getLength() == 0, "property name should not have any type element"); assertEquals(nameElement.getAttribute("type"), "string"); } + + enum Status { + ON, OFF + } } diff --git a/test/nodb/src/test/resources/org/hibernate/tool/ant/Exception/TopDown.hbm.xml b/test/nodb/src/test/resources/org/hibernate/tool/ant/Exception/TopDown.hbm.xml index df2640ea90..768dd54b2e 100644 --- a/test/nodb/src/test/resources/org/hibernate/tool/ant/Exception/TopDown.hbm.xml +++ b/test/nodb/src/test/resources/org/hibernate/tool/ant/Exception/TopDown.hbm.xml @@ -1,7 +1,7 @@ + "https://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> diff --git a/test/nodb/src/test/resources/org/hibernate/tool/ant/NoConnInfoExport/TopDown.hbm.xml b/test/nodb/src/test/resources/org/hibernate/tool/ant/NoConnInfoExport/TopDown.hbm.xml index df2640ea90..768dd54b2e 100644 --- a/test/nodb/src/test/resources/org/hibernate/tool/ant/NoConnInfoExport/TopDown.hbm.xml +++ b/test/nodb/src/test/resources/org/hibernate/tool/ant/NoConnInfoExport/TopDown.hbm.xml @@ -1,7 +1,7 @@ + "https://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> diff --git a/test/nodb/src/test/resources/org/hibernate/tool/hbm2x/DocExporterTest/Customer.hbm.xml b/test/nodb/src/test/resources/org/hibernate/tool/hbm2x/DocExporterTest/Customer.hbm.xml index b91a4145b9..91bb6ea031 100644 --- a/test/nodb/src/test/resources/org/hibernate/tool/hbm2x/DocExporterTest/Customer.hbm.xml +++ b/test/nodb/src/test/resources/org/hibernate/tool/hbm2x/DocExporterTest/Customer.hbm.xml @@ -1,7 +1,7 @@ + "https://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> diff --git a/test/nodb/src/test/resources/org/hibernate/tool/hbm2x/DocExporterTest/HelloWorld.hbm.xml b/test/nodb/src/test/resources/org/hibernate/tool/hbm2x/DocExporterTest/HelloWorld.hbm.xml index 8c4356fb7e..1154536904 100644 --- a/test/nodb/src/test/resources/org/hibernate/tool/hbm2x/DocExporterTest/HelloWorld.hbm.xml +++ b/test/nodb/src/test/resources/org/hibernate/tool/hbm2x/DocExporterTest/HelloWorld.hbm.xml @@ -1,7 +1,7 @@ + "https://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> + "https://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> + "https://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> + "https://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> + "https://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> diff --git a/test/nodb/src/test/resources/org/hibernate/tool/hbm2x/Hbm2JavaEjb3Test/Article.hbm.xml b/test/nodb/src/test/resources/org/hibernate/tool/hbm2x/Hbm2JavaEjb3Test/Article.hbm.xml index d8e7735f38..0a482aab98 100644 --- a/test/nodb/src/test/resources/org/hibernate/tool/hbm2x/Hbm2JavaEjb3Test/Article.hbm.xml +++ b/test/nodb/src/test/resources/org/hibernate/tool/hbm2x/Hbm2JavaEjb3Test/Article.hbm.xml @@ -20,7 +20,7 @@ --> + "https://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> + "https://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> + "https://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> diff --git a/test/nodb/src/test/resources/org/hibernate/tool/hbm2x/Hbm2JavaEjb3Test/Train.hbm.xml b/test/nodb/src/test/resources/org/hibernate/tool/hbm2x/Hbm2JavaEjb3Test/Train.hbm.xml index 952b427a73..0c3bde51aa 100644 --- a/test/nodb/src/test/resources/org/hibernate/tool/hbm2x/Hbm2JavaEjb3Test/Train.hbm.xml +++ b/test/nodb/src/test/resources/org/hibernate/tool/hbm2x/Hbm2JavaEjb3Test/Train.hbm.xml @@ -20,7 +20,7 @@ --> + "https://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> diff --git a/test/nodb/src/test/resources/org/hibernate/tool/hbm2x/Hbm2JavaInitializationTest/Article.hbm.xml b/test/nodb/src/test/resources/org/hibernate/tool/hbm2x/Hbm2JavaInitializationTest/Article.hbm.xml index 9a68082f9a..e9ebd5b664 100644 --- a/test/nodb/src/test/resources/org/hibernate/tool/hbm2x/Hbm2JavaInitializationTest/Article.hbm.xml +++ b/test/nodb/src/test/resources/org/hibernate/tool/hbm2x/Hbm2JavaInitializationTest/Article.hbm.xml @@ -20,7 +20,7 @@ --> + "https://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> + "https://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> + "https://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> diff --git a/test/nodb/src/test/resources/org/hibernate/tool/hbm2x/Hbm2JavaInitializationTest/Train.hbm.xml b/test/nodb/src/test/resources/org/hibernate/tool/hbm2x/Hbm2JavaInitializationTest/Train.hbm.xml index dc0a988503..8d96f024cc 100644 --- a/test/nodb/src/test/resources/org/hibernate/tool/hbm2x/Hbm2JavaInitializationTest/Train.hbm.xml +++ b/test/nodb/src/test/resources/org/hibernate/tool/hbm2x/Hbm2JavaInitializationTest/Train.hbm.xml @@ -20,7 +20,7 @@ --> + "https://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> diff --git a/test/nodb/src/test/resources/org/hibernate/tool/hbm2x/Hbm2JavaTest/Customer.hbm.xml b/test/nodb/src/test/resources/org/hibernate/tool/hbm2x/Hbm2JavaTest/Customer.hbm.xml index a0b4ec90bc..2f7b495534 100644 --- a/test/nodb/src/test/resources/org/hibernate/tool/hbm2x/Hbm2JavaTest/Customer.hbm.xml +++ b/test/nodb/src/test/resources/org/hibernate/tool/hbm2x/Hbm2JavaTest/Customer.hbm.xml @@ -20,7 +20,7 @@ --> + "https://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> + "https://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> + "https://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> + "https://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> + "https://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> diff --git a/test/nodb/src/test/resources/org/hibernate/tool/hbm2x/Hbm2JavaTest/Product.hbm.xml b/test/nodb/src/test/resources/org/hibernate/tool/hbm2x/Hbm2JavaTest/Product.hbm.xml index 85a13d7fd7..e77ea2f095 100644 --- a/test/nodb/src/test/resources/org/hibernate/tool/hbm2x/Hbm2JavaTest/Product.hbm.xml +++ b/test/nodb/src/test/resources/org/hibernate/tool/hbm2x/Hbm2JavaTest/Product.hbm.xml @@ -20,7 +20,7 @@ --> + "https://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> diff --git a/test/nodb/src/test/resources/org/hibernate/tool/hbm2x/Hbm2JavaTest/Train.hbm.xml b/test/nodb/src/test/resources/org/hibernate/tool/hbm2x/Hbm2JavaTest/Train.hbm.xml index 55f2cbc135..1b3b7fd96a 100644 --- a/test/nodb/src/test/resources/org/hibernate/tool/hbm2x/Hbm2JavaTest/Train.hbm.xml +++ b/test/nodb/src/test/resources/org/hibernate/tool/hbm2x/Hbm2JavaTest/Train.hbm.xml @@ -20,7 +20,7 @@ --> + "https://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> diff --git a/test/nodb/src/test/resources/org/hibernate/tool/hbm2x/OtherCfg2HbmTest/Customer.hbm.xml b/test/nodb/src/test/resources/org/hibernate/tool/hbm2x/OtherCfg2HbmTest/Customer.hbm.xml index 38653807d2..a62e6a4cff 100644 --- a/test/nodb/src/test/resources/org/hibernate/tool/hbm2x/OtherCfg2HbmTest/Customer.hbm.xml +++ b/test/nodb/src/test/resources/org/hibernate/tool/hbm2x/OtherCfg2HbmTest/Customer.hbm.xml @@ -20,7 +20,7 @@ --> + "https://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> + "https://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> + "https://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> + "https://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> + "https://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> diff --git a/test/nodb/src/test/resources/org/hibernate/tool/hbm2x/PropertiesTest/Properties.hbm.xml b/test/nodb/src/test/resources/org/hibernate/tool/hbm2x/PropertiesTest/Properties.hbm.xml index e920773905..5c64f5ed02 100644 --- a/test/nodb/src/test/resources/org/hibernate/tool/hbm2x/PropertiesTest/Properties.hbm.xml +++ b/test/nodb/src/test/resources/org/hibernate/tool/hbm2x/PropertiesTest/Properties.hbm.xml @@ -20,7 +20,7 @@ --> + "https://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> @@ -24,24 +24,24 @@ next_hi_value - - description - + - + - + - anotherone + anotherone - + diff --git a/test/nodb/src/test/resources/org/hibernate/tool/hbm2x/hbm2hbmxml/Hbm2HbmXmlTest/BasicCompositeId.hbm.xml b/test/nodb/src/test/resources/org/hibernate/tool/hbm2x/hbm2hbmxml/Hbm2HbmXmlTest/BasicCompositeId.hbm.xml index a84fb49183..61302ff3d6 100644 --- a/test/nodb/src/test/resources/org/hibernate/tool/hbm2x/hbm2hbmxml/Hbm2HbmXmlTest/BasicCompositeId.hbm.xml +++ b/test/nodb/src/test/resources/org/hibernate/tool/hbm2x/hbm2hbmxml/Hbm2HbmXmlTest/BasicCompositeId.hbm.xml @@ -1,7 +1,7 @@ + "https://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> + "https://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> diff --git a/test/nodb/src/test/resources/org/hibernate/tool/hbm2x/hbm2hbmxml/ManyToManyTest/UserGroup.hbm.xml b/test/nodb/src/test/resources/org/hibernate/tool/hbm2x/hbm2hbmxml/ManyToManyTest/UserGroup.hbm.xml index 9e6bae762d..c17fcaa406 100644 --- a/test/nodb/src/test/resources/org/hibernate/tool/hbm2x/hbm2hbmxml/ManyToManyTest/UserGroup.hbm.xml +++ b/test/nodb/src/test/resources/org/hibernate/tool/hbm2x/hbm2hbmxml/ManyToManyTest/UserGroup.hbm.xml @@ -20,7 +20,7 @@ --> + "https://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> + "https://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> diff --git a/test/nodb/src/test/resources/org/hibernate/tool/hbm2x/hbm2hbmxml/MapAndAnyTest/Properties.hbm.xml b/test/nodb/src/test/resources/org/hibernate/tool/hbm2x/hbm2hbmxml/MapAndAnyTest/Properties.hbm.xml index 93589770aa..4a3c2ee60f 100644 --- a/test/nodb/src/test/resources/org/hibernate/tool/hbm2x/hbm2hbmxml/MapAndAnyTest/Properties.hbm.xml +++ b/test/nodb/src/test/resources/org/hibernate/tool/hbm2x/hbm2hbmxml/MapAndAnyTest/Properties.hbm.xml @@ -20,7 +20,7 @@ --> + "https://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> diff --git a/test/nodb/src/test/resources/org/hibernate/tool/hbm2x/hbm2hbmxml/OneToOneTest/PersonAddressOneToOnePrimaryKey.hbm.xml b/test/nodb/src/test/resources/org/hibernate/tool/hbm2x/hbm2hbmxml/OneToOneTest/PersonAddressOneToOnePrimaryKey.hbm.xml index a9f8cf2b97..1d9dd0fbdd 100644 --- a/test/nodb/src/test/resources/org/hibernate/tool/hbm2x/hbm2hbmxml/OneToOneTest/PersonAddressOneToOnePrimaryKey.hbm.xml +++ b/test/nodb/src/test/resources/org/hibernate/tool/hbm2x/hbm2hbmxml/OneToOneTest/PersonAddressOneToOnePrimaryKey.hbm.xml @@ -20,7 +20,7 @@ --> + "https://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> diff --git a/test/nodb/src/test/resources/org/hibernate/tool/hbm2x/hbm2hbmxml/SetElementTest/Search.hbm.xml b/test/nodb/src/test/resources/org/hibernate/tool/hbm2x/hbm2hbmxml/SetElementTest/Search.hbm.xml index c1e9209050..0053e91228 100644 --- a/test/nodb/src/test/resources/org/hibernate/tool/hbm2x/hbm2hbmxml/SetElementTest/Search.hbm.xml +++ b/test/nodb/src/test/resources/org/hibernate/tool/hbm2x/hbm2hbmxml/SetElementTest/Search.hbm.xml @@ -20,7 +20,7 @@ --> + "https://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> + "https://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> @@ -34,7 +34,7 @@ STATUS ORDERS - org.hibernate.tool.hbm2x.hbm2hbmxml.Order$Status + org.hibernate.tool.hbm2x.hbm2hbmxml.TypeParamsTest.TestCase$Status diff --git a/test/nodb/src/test/resources/org/hibernate/tool/ide/completion/ModelCompletion/City.hbm.xml b/test/nodb/src/test/resources/org/hibernate/tool/ide/completion/ModelCompletion/City.hbm.xml index 856c645c75..912a538be2 100644 --- a/test/nodb/src/test/resources/org/hibernate/tool/ide/completion/ModelCompletion/City.hbm.xml +++ b/test/nodb/src/test/resources/org/hibernate/tool/ide/completion/ModelCompletion/City.hbm.xml @@ -19,7 +19,7 @@ ~ limitations under the License. --> + "https://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> diff --git a/test/nodb/src/test/resources/org/hibernate/tool/ide/completion/ModelCompletion/Product.hbm.xml b/test/nodb/src/test/resources/org/hibernate/tool/ide/completion/ModelCompletion/Product.hbm.xml index 15fa04a68a..a2870a0c40 100644 --- a/test/nodb/src/test/resources/org/hibernate/tool/ide/completion/ModelCompletion/Product.hbm.xml +++ b/test/nodb/src/test/resources/org/hibernate/tool/ide/completion/ModelCompletion/Product.hbm.xml @@ -19,7 +19,7 @@ ~ limitations under the License. --> + "https://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> diff --git a/test/nodb/src/test/resources/org/hibernate/tool/ide/completion/ModelCompletion/ProductOwnerAddress.hbm.xml b/test/nodb/src/test/resources/org/hibernate/tool/ide/completion/ModelCompletion/ProductOwnerAddress.hbm.xml index 2153e46bf9..d92284e914 100644 --- a/test/nodb/src/test/resources/org/hibernate/tool/ide/completion/ModelCompletion/ProductOwnerAddress.hbm.xml +++ b/test/nodb/src/test/resources/org/hibernate/tool/ide/completion/ModelCompletion/ProductOwnerAddress.hbm.xml @@ -19,7 +19,7 @@ ~ limitations under the License. --> + "https://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> diff --git a/test/nodb/src/test/resources/org/hibernate/tool/ide/completion/ModelCompletion/Store.hbm.xml b/test/nodb/src/test/resources/org/hibernate/tool/ide/completion/ModelCompletion/Store.hbm.xml index 57ef3c7d89..338c7bdd06 100644 --- a/test/nodb/src/test/resources/org/hibernate/tool/ide/completion/ModelCompletion/Store.hbm.xml +++ b/test/nodb/src/test/resources/org/hibernate/tool/ide/completion/ModelCompletion/Store.hbm.xml @@ -19,7 +19,7 @@ ~ limitations under the License. --> + "https://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> diff --git a/test/nodb/src/test/resources/org/hibernate/tool/ide/completion/ModelCompletion/StoreCity.hbm.xml b/test/nodb/src/test/resources/org/hibernate/tool/ide/completion/ModelCompletion/StoreCity.hbm.xml index e21ffe69e4..10e6c75fa2 100644 --- a/test/nodb/src/test/resources/org/hibernate/tool/ide/completion/ModelCompletion/StoreCity.hbm.xml +++ b/test/nodb/src/test/resources/org/hibernate/tool/ide/completion/ModelCompletion/StoreCity.hbm.xml @@ -19,7 +19,7 @@ ~ limitations under the License. --> + "https://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> diff --git a/test/oracle/pom.xml b/test/oracle/pom.xml index 04dcadef6a..711c185372 100644 --- a/test/oracle/pom.xml +++ b/test/oracle/pom.xml @@ -28,7 +28,7 @@ org.hibernate.tool hibernate-tools-tests-parent - 6.5.0.Final + 6.6.27-SNAPSHOT hibernate-tools-tests-oracle diff --git a/test/oracle/src/test/resources/org/hibernate/tool/hbmlint/SchemaAnalyzer/SchemaIssues.hbm.xml b/test/oracle/src/test/resources/org/hibernate/tool/hbmlint/SchemaAnalyzer/SchemaIssues.hbm.xml index 84d9e8289c..a31c8dcc3e 100644 --- a/test/oracle/src/test/resources/org/hibernate/tool/hbmlint/SchemaAnalyzer/SchemaIssues.hbm.xml +++ b/test/oracle/src/test/resources/org/hibernate/tool/hbmlint/SchemaAnalyzer/SchemaIssues.hbm.xml @@ -20,7 +20,7 @@ --> + "https://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> diff --git a/test/pom.xml b/test/pom.xml index 7b6ae342aa..02aa28f168 100644 --- a/test/pom.xml +++ b/test/pom.xml @@ -28,7 +28,7 @@ org.hibernate.tool hibernate-tools-parent - 6.5.0.Final + 6.6.27-SNAPSHOT hibernate-tools-tests-parent diff --git a/test/utils/pom.xml b/test/utils/pom.xml index 95d2532fe7..6cf9b39d72 100644 --- a/test/utils/pom.xml +++ b/test/utils/pom.xml @@ -27,7 +27,7 @@ org.hibernate.tool hibernate-tools-tests-parent - 6.5.0.Final + 6.6.27-SNAPSHOT hibernate-tools-tests-utils diff --git a/test/utils/src/test/resources/org/hibernate/tools/test/util/HelloWorld.hbm.xml b/test/utils/src/test/resources/org/hibernate/tools/test/util/HelloWorld.hbm.xml index aae3f88b47..27917869c7 100644 --- a/test/utils/src/test/resources/org/hibernate/tools/test/util/HelloWorld.hbm.xml +++ b/test/utils/src/test/resources/org/hibernate/tools/test/util/HelloWorld.hbm.xml @@ -20,7 +20,7 @@ --> + "https://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> diff --git a/utils/pom.xml b/utils/pom.xml index 184181c3d7..21f6f6b166 100644 --- a/utils/pom.xml +++ b/utils/pom.xml @@ -21,7 +21,7 @@ org.hibernate.tool hibernate-tools-parent - 6.5.0.Final + 6.6.27-SNAPSHOT hibernate-tools-utils @@ -30,6 +30,11 @@ Hibernate Tools Common Utilities jar + + + false + + org.junit.jupiter