review.fuel-infra Code Review - packages/trusty/mysql-wsrep-5.6.git/blob

   1 /*
   2    Copyright (c) 2010, 2011, Oracle and/or its affiliates. All rights reserved.
   3
   4    This program is free software; you can redistribute it and/or modify
   5    it under the terms of the GNU General Public License as published by
   6    the Free Software Foundation; version 2 of the License.
   7
   8    This program is distributed in the hope that it will be useful,
   9    but WITHOUT ANY WARRANTY; without even the implied warranty of
  10    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11    GNU General Public License for more details.
  12
  13    You should have received a copy of the GNU General Public License
  14    along with this program; if not, write to the Free Software
  15    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301  USA
  16 */
  17
  18 package testsuite.clusterj;
  19
  20 import com.mysql.clusterj.ClusterJUserException;
  21 import com.mysql.clusterj.ColumnType;
  22 import com.mysql.clusterj.DynamicObject;
  23 import com.mysql.clusterj.ColumnMetadata;
  24 import com.mysql.clusterj.Query;
  25 import com.mysql.clusterj.annotation.PersistenceCapable;
  26 import com.mysql.clusterj.query.QueryBuilder;
  27 import com.mysql.clusterj.query.QueryDomainType;
  28
  29 public class DynamicObjectTest extends AbstractClusterJModelTest {
  30
  31     private static final String tablename = "t_basic";
  32
  33     private static final int NUMBER_TO_INSERT = 5;
  34
  35     private DynamicObject[] instances = new TBasic[NUMBER_TO_INSERT];
  36
  37     private DynamicObject tbasic;
  38
  39     private Object[] expectedTBasicNames = new Object[] {"id", "name", "age", "magic"};
  40
  41     private Object[] expectedTBasicTypes = new Object[] {ColumnType.Int, ColumnType.Varchar, ColumnType.Int, ColumnType.Int};
  42
  43     private Object[] expectedTBasicJavaTypes = new Object[] {Integer.class, String.class, Integer.class, Integer.class};
  44
  45     private Object[] expectedTBasicMaximumLengths = new Object[] {1, 32, 1, 1};
  46
  47     private Object[] expectedTBasicNumbers = new Object[] {0, 1, 2, 3};
  48
  49     private Object[] expectedTBasicIsPrimaryKeys = new Object[] {true, false, false, false};
  50
  51     private Object[] expectedTBasicIsPartitionKeys = new Object[] {true, false, false, false};
  52
  53     private Object[] expectedTBasicPrecisions = new Object[] {0, 0, 0, 0};
  54
  55     private Object[] expectedTBasicScales = new Object[] {0, 0, 0, 0};
  56
  57     private Object[] expectedTBasicNullables = new Object[] {false, true, true, false};
  58
  59     private Object[] expectedTBasicCharsetNames = new Object[] {null, "latin1", null, null};
  60
  61     @Override
  62     public void localSetUp() {
  63         createSessionFactory();
  64         session = sessionFactory.getSession();
  65         createDynamicInstances(TBasic.class, NUMBER_TO_INSERT);
  66         tbasic = instances[0];
  67         tx = session.currentTransaction();
  68         int count = 0;
  69         for (int i = 0; i < NUMBER_TO_INSERT; ++i) {
  70             try {
  71                 session.deletePersistent(TBasic.class, i);
  72                 ++count;
  73             } catch (Exception ex) {
  74                 // ignore exceptions -- might not be any instances to delete
  75             }
  76         }
  77         addTearDownClasses(TBasic.class);
  78     }
  79
  80     private <T extends DynamicObject> void createDynamicInstances(Class<T> dynamicClass, int numberToInsert) {
  81         for (int i = 0; i < numberToInsert; ++i) {
  82             DynamicObject instance = createInstance(dynamicClass, i);
  83             instance.set(1, String.valueOf(i)); // name
  84             instance.set(2, i); // age
  85             instance.set(3, i); // magic
  86             instances[i] = instance;
  87         }
  88     }
  89
  90     private <T> T createInstance(Class<T> cls, int i) {
  91         T instance = session.newInstance(cls, i);
  92         return instance;
  93     }
  94
  95     public static class TBasic extends DynamicObject {
  96         @Override
  97         public String table() {
  98             return tablename;
  99         }
 100     }
 101
 102     @PersistenceCapable(table="t_basic")
 103     public static class AnnotatedTBasic extends DynamicObject {}
 104
 105     public void test() {
 106         insert();
 107         find();
 108         findAnnotated();
 109         lookup();
 110         query();
 111         badClass(DynamicObjectPrivate.class);
 112         badClass(DynamicObjectProtectedConstructor.class);
 113         badClass(DynamicObjectNonStatic.class);
 114         badClass(DynamicObjectPrivateConstructor.class);
 115         badClass(DynamicObjectNullTableName.class);
 116         badClass(DynamicObjectTableDoesNotExist.class);
 117         checkMetadata();
 118         failOnError();
 119     }
 120     private void insert() {
 121         session.makePersistent(instances);
 122     }
 123
 124     private void find() {
 125         TBasic instance = session.find(TBasic.class, 0);
 126         validateInstance(instance);
 127     }
 128
 129     private void findAnnotated() {
 130         AnnotatedTBasic instance = session.find(AnnotatedTBasic.class, 0);
 131         validateInstance(instance);
 132     }
 133
 134     private void lookup() {
 135         QueryBuilder builder = session.getQueryBuilder();
 136         QueryDomainType<TBasic> queryTBasic = builder.createQueryDefinition(TBasic.class);
 137         queryTBasic.where(queryTBasic.get("magic").equal(queryTBasic.param("magic")));
 138         Query<TBasic> query = session.createQuery(queryTBasic);
 139         query.setParameter("magic", 1);
 140         TBasic instance = query.getResultList().get(0);
 141         validateInstance(instance);
 142     }
 143
 144     private void query() {
 145         QueryBuilder builder = session.getQueryBuilder();
 146         QueryDomainType<TBasic> queryTBasic = builder.createQueryDefinition(TBasic.class);
 147         queryTBasic.where(queryTBasic.get("name").equal(queryTBasic.param("name")));
 148         Query<TBasic> query = session.createQuery(queryTBasic);
 149         query.setParameter("name", "2");
 150         TBasic instance = query.getResultList().get(0);
 151         validateInstance(instance);
 152     }
 153
 154     private void validateInstance(DynamicObject instance) {
 155         int id = (Integer)instance.get(0);
 156         errorIfNotEqual("validate name", String.valueOf(id), instance.get(1)); // name
 157         errorIfNotEqual("validate age", id, instance.get(2)); // age
 158         errorIfNotEqual("validate magic", id, instance.get(3)); // magic
 159     }
 160
 161     private void badClass(Class<?> cls) {
 162         try {
 163             session.newInstance(cls);
 164         } catch (ClusterJUserException e) {
 165             // good catch
 166         } catch (Throwable t) {
 167             error(cls.getClass().getName() + " threw wrong exception: " + t.getMessage());
 168         }
 169     }
 170
 171     public static class DynamicObjectProtectedConstructor extends DynamicObject {
 172         protected DynamicObjectProtectedConstructor() {}
 173         @Override
 174         public String table() {
 175             return "DynamicObjectProtectedConstructor";
 176         }
 177     }
 178
 179     private static class DynamicObjectPrivate extends DynamicObject {
 180     }
 181
 182     public class DynamicObjectNonStatic extends DynamicObject {
 183         public DynamicObjectNonStatic() {}
 184         @Override
 185         public String table() {
 186             return "DynamicObjectProtectedConstructor";
 187         }
 188     }
 189
 190     public static class DynamicObjectPrivateConstructor extends DynamicObject {
 191         private DynamicObjectPrivateConstructor() {}
 192         @Override
 193         public String table() {
 194             return "DynamicObjectPrivateConstructor";
 195         }
 196     }
 197
 198     public static class DynamicObjectTableDoesNotExist extends DynamicObject {
 199         private DynamicObjectTableDoesNotExist() {}
 200         @Override
 201         public String table() {
 202             return "DynamicObjectTableDoesNotExist";
 203         }
 204     }
 205
 206     public static class DynamicObjectNullTableName extends DynamicObject {
 207         public DynamicObjectNullTableName() {}
 208     }
 209
 210     protected void checkMetadata() {
 211         ColumnMetadata[] metadata = tbasic.columnMetadata();
 212         for (int i = 0; i < metadata.length; ++i) {
 213             errorIfNotEqual("t_basic column " + i + " name", expectedTBasicNames[i], metadata[i].name());
 214             errorIfNotEqual("t_basic column " + i + " type", expectedTBasicTypes[i], metadata[i].columnType());
 215             errorIfNotEqual("t_basic column " + i + " javaType", expectedTBasicJavaTypes[i], metadata[i].javaType());
 216             errorIfNotEqual("t_basic column " + i + " maximumLength", expectedTBasicMaximumLengths[i], metadata[i].maximumLength());
 217             errorIfNotEqual("t_basic column " + i + " charsetName", expectedTBasicCharsetNames [i], metadata[i].charsetName());
 218             errorIfNotEqual("t_basic column " + i + " number", expectedTBasicNumbers[i], metadata[i].number());
 219             errorIfNotEqual("t_basic column " + i + " isPrimaryKey", expectedTBasicIsPrimaryKeys[i], metadata[i].isPrimaryKey());
 220             errorIfNotEqual("t_basic column " + i + " isPartitionKey", expectedTBasicIsPartitionKeys[i], metadata[i].isPartitionKey());
 221             errorIfNotEqual("t_basic column " + i + " precision", expectedTBasicPrecisions[i], metadata[i].precision());
 222             errorIfNotEqual("t_basic column " + i + " scale", expectedTBasicScales[i], metadata[i].scale());
 223             errorIfNotEqual("t_basic column " + i + " nullable", expectedTBasicNullables[i], metadata[i].nullable());
 224         }
 225     }
 226
 227
 228 }