MySQL 5.6.14 Source Code Document
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
CharsetTest.java
1 /*
2  Copyright 2010 Sun Microsystems, Inc.
3  All rights reserved. Use is subject to license terms.
4 
5  This program is free software; you can redistribute it and/or modify
6  it under the terms of the GNU General Public License as published by
7  the Free Software Foundation; version 2 of the License.
8 
9  This program is distributed in the hope that it will be useful,
10  but WITHOUT ANY WARRANTY; without even the implied warranty of
11  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12  GNU General Public License for more details.
13 
14  You should have received a copy of the GNU General Public License
15  along with this program; if not, write to the Free Software
16  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
17 */
18 
19 package testsuite.clusterj;
20 
21 import java.nio.ByteBuffer;
22 import java.nio.CharBuffer;
23 import java.nio.charset.Charset;
24 import java.nio.charset.CharsetEncoder;
25 import java.nio.charset.CoderResult;
26 
27 import java.sql.PreparedStatement;
28 import java.sql.ResultSet;
29 import java.sql.SQLException;
30 
31 import java.util.ArrayList;
32 import java.util.List;
33 import java.util.Properties;
34 
35 import testsuite.clusterj.model.CharsetLatin1;
36 import testsuite.clusterj.model.CharsetBig5;
37 import testsuite.clusterj.model.CharsetModel;
38 import testsuite.clusterj.model.CharsetSjis;
39 import testsuite.clusterj.model.CharsetUtf8;
40 
60 public class CharsetTest extends AbstractClusterJModelTest {
61 
62  @Override
63  public void localSetUp() {
64  createSessionFactory();
65  session = sessionFactory.getSession();
66  setAutoCommit(connection, false);
67  }
68 
69  public void testLatin1() {
70  writeJDBCreadJDBC("windows-1252", "charsetlatin1", CharsetLatin1.class, ColumnDescriptor.SMALL);
71  writeJDBCreadJDBC("windows-1252", "charsetlatin1", CharsetLatin1.class, ColumnDescriptor.MEDIUM);
72  writeJDBCreadJDBC("windows-1252", "charsetlatin1", CharsetLatin1.class, ColumnDescriptor.LARGE);
73 
74  writeJDBCreadNDB("windows-1252", "charsetlatin1", CharsetLatin1.class, ColumnDescriptor.SMALL);
75  writeJDBCreadNDB("windows-1252", "charsetlatin1", CharsetLatin1.class, ColumnDescriptor.MEDIUM);
76  writeJDBCreadNDB("windows-1252", "charsetlatin1", CharsetLatin1.class, ColumnDescriptor.LARGE);
77 
78  writeNDBreadJDBC("windows-1252", "charsetlatin1", CharsetLatin1.class, ColumnDescriptor.SMALL);
79  writeNDBreadJDBC("windows-1252", "charsetlatin1", CharsetLatin1.class, ColumnDescriptor.MEDIUM);
80  writeNDBreadJDBC("windows-1252", "charsetlatin1", CharsetLatin1.class, ColumnDescriptor.LARGE);
81 
82  writeNDBreadNDB("windows-1252", "charsetlatin1", CharsetLatin1.class, ColumnDescriptor.SMALL);
83  writeNDBreadNDB("windows-1252", "charsetlatin1", CharsetLatin1.class, ColumnDescriptor.MEDIUM);
84  writeNDBreadNDB("windows-1252", "charsetlatin1", CharsetLatin1.class, ColumnDescriptor.LARGE);
85 
86  failOnError();
87  }
88 
89  public void testUtf8() {
90  writeJDBCreadJDBC("UTF-8", "charsetutf8", CharsetUtf8.class, ColumnDescriptor.SMALL);
91  writeJDBCreadJDBC("UTF-8", "charsetutf8", CharsetUtf8.class, ColumnDescriptor.MEDIUM);
92  writeJDBCreadJDBC("UTF-8", "charsetutf8", CharsetUtf8.class, ColumnDescriptor.LARGE);
93 
94  writeJDBCreadNDB("UTF-8", "charsetutf8", CharsetUtf8.class, ColumnDescriptor.SMALL);
95  writeJDBCreadNDB("UTF-8", "charsetutf8", CharsetUtf8.class, ColumnDescriptor.MEDIUM);
96  writeJDBCreadNDB("UTF-8", "charsetutf8", CharsetUtf8.class, ColumnDescriptor.LARGE);
97 
98  writeNDBreadJDBC("UTF-8", "charsetutf8", CharsetUtf8.class, ColumnDescriptor.SMALL);
99  writeNDBreadJDBC("UTF-8", "charsetutf8", CharsetUtf8.class, ColumnDescriptor.MEDIUM);
100  writeNDBreadJDBC("UTF-8", "charsetutf8", CharsetUtf8.class, ColumnDescriptor.LARGE);
101 
102  writeNDBreadNDB("UTF-8", "charsetutf8", CharsetUtf8.class, ColumnDescriptor.SMALL);
103  writeNDBreadNDB("UTF-8", "charsetutf8", CharsetUtf8.class, ColumnDescriptor.MEDIUM);
104  writeNDBreadNDB("UTF-8", "charsetutf8", CharsetUtf8.class, ColumnDescriptor.LARGE);
105 
106  failOnError();
107  }
108 
109  public void testSjis() {
110  /* These tests are excluded due to a JDBC error:
111  * java.sql.SQLException:
112  * Failed to insert charsetsjis at instance 0 errant string: [... 165 167 168... ]
113  * Incorrect string value: '\xC2\xA5\xC2\xA7\xC2\xA8...' for column 'smallcolumn' at row 1
114  at com.mysql.jdbc.SQLError.createSQLException(SQLError.java:1055)
115  at com.mysql.jdbc.SQLError.createSQLException(SQLError.java:956)
116  at com.mysql.jdbc.MysqlIO.checkErrorPacket(MysqlIO.java:3558)
117  at com.mysql.jdbc.MysqlIO.checkErrorPacket(MysqlIO.java:3490)
118  at com.mysql.jdbc.MysqlIO.sendCommand(MysqlIO.java:1959)
119  at com.mysql.jdbc.MysqlIO.sqlQueryDirect(MysqlIO.java:2109)
120  at com.mysql.jdbc.ConnectionImpl.execSQL(ConnectionImpl.java:2648)
121  at com.mysql.jdbc.PreparedStatement.executeInternal(PreparedStatement.java:2077)
122  at com.mysql.jdbc.PreparedStatement.execute(PreparedStatement.java:1356)
123  at testsuite.clusterj.CharsetTest.writeToJDBC(CharsetTest.java:317)
124  writeJDBCreadJDBC("SJIS", "charsetsjis", CharsetSjis.class, ColumnDescriptor.SMALL);
125  writeJDBCreadJDBC("SJIS", "charsetsjis", CharsetSjis.class, ColumnDescriptor.MEDIUM);
126  writeJDBCreadJDBC("SJIS", "charsetsjis", CharsetSjis.class, ColumnDescriptor.LARGE);
127  */
128 
129  writeNDBreadJDBC("SJIS", "charsetsjis", CharsetSjis.class, ColumnDescriptor.SMALL);
130  writeNDBreadJDBC("SJIS", "charsetsjis", CharsetSjis.class, ColumnDescriptor.MEDIUM);
131  writeNDBreadJDBC("SJIS", "charsetsjis", CharsetSjis.class, ColumnDescriptor.LARGE);
132 
133  writeNDBreadNDB("SJIS", "charsetsjis", CharsetSjis.class, ColumnDescriptor.SMALL);
134  writeNDBreadNDB("SJIS", "charsetsjis", CharsetSjis.class, ColumnDescriptor.MEDIUM);
135  writeNDBreadNDB("SJIS", "charsetsjis", CharsetSjis.class, ColumnDescriptor.LARGE);
136 
137  failOnError();
138  }
139 
140  public void testBig5() {
141  writeJDBCreadJDBC("big5", "charsetbig5", CharsetBig5.class, ColumnDescriptor.SMALL);
142  writeJDBCreadJDBC("big5", "charsetbig5", CharsetBig5.class, ColumnDescriptor.MEDIUM);
143  writeJDBCreadJDBC("big5", "charsetbig5", CharsetBig5.class, ColumnDescriptor.LARGE);
144 
145  writeJDBCreadNDB("big5", "charsetbig5", CharsetBig5.class, ColumnDescriptor.SMALL);
146  writeJDBCreadNDB("big5", "charsetbig5", CharsetBig5.class, ColumnDescriptor.MEDIUM);
147  writeJDBCreadNDB("big5", "charsetbig5", CharsetBig5.class, ColumnDescriptor.LARGE);
148 
149  writeNDBreadJDBC("big5", "charsetbig5", CharsetBig5.class, ColumnDescriptor.SMALL);
150  writeNDBreadJDBC("big5", "charsetbig5", CharsetBig5.class, ColumnDescriptor.MEDIUM);
151  writeNDBreadJDBC("big5", "charsetbig5", CharsetBig5.class, ColumnDescriptor.LARGE);
152 
153  writeNDBreadNDB("big5", "charsetbig5", CharsetBig5.class, ColumnDescriptor.SMALL);
154  writeNDBreadNDB("big5", "charsetbig5", CharsetBig5.class, ColumnDescriptor.MEDIUM);
155  writeNDBreadNDB("big5", "charsetbig5", CharsetBig5.class, ColumnDescriptor.LARGE);
156 
157  failOnError();
158  }
159 
160  protected void writeJDBCreadJDBC(String charsetName, String tableName, Class<? extends CharsetModel> modelClass,
161  ColumnDescriptor columnDescriptor) {
162  removeAll(modelClass);
163  List<String> result = null;
164  List<String> strings = generateStrings(columnDescriptor, charsetName);
165  List<CharsetModel> instances = generateInstances(columnDescriptor, modelClass, strings);
166  writeToJDBC(columnDescriptor, tableName, instances);
167  result = readFromJDBC(columnDescriptor, tableName);
168  if (debug) System.out.println("Returned results of size " + result.size());
169 // if (debug) System.out.println("Results:\n" + dump(result));
170  verify("writeJDBCreadJDBC", strings, result, columnDescriptor);
171  }
172 
173  protected void writeJDBCreadNDB(String charsetName, String tableName, Class<? extends CharsetModel> modelClass,
174  ColumnDescriptor columnDescriptor) {
175  removeAll(modelClass);
176  List<String> result = null;
177  List<String> strings = generateStrings(columnDescriptor, charsetName);
178  List<CharsetModel> instances = generateInstances(columnDescriptor, modelClass, strings);
179  writeToJDBC(columnDescriptor, tableName, instances);
180  result = readFromNDB(columnDescriptor, modelClass);
181  if (debug) System.out.println("Returned results of size " + result.size());
182 // if (debug) System.out.println("Results: " + dump(result));
183  verify("writeJDBCreadNDB", strings, result, columnDescriptor);
184  }
185 
186  protected void writeNDBreadJDBC(String charsetName, String tableName, Class<? extends CharsetModel> modelClass,
187  ColumnDescriptor columnDescriptor) {
188  removeAll(modelClass);
189  List<String> result = null;
190  List<String> strings = generateStrings(columnDescriptor, charsetName);
191  List<CharsetModel> instances = generateInstances(columnDescriptor, modelClass, strings);
192  writeToNDB(columnDescriptor, instances);
193  result = readFromJDBC(columnDescriptor, tableName);
194  if (debug) System.out.println("Returned results of size " + result.size());
195 // if (debug) System.out.println("Results: " + dump(result));
196  verify("writeNDBreadJDBC", strings, result, columnDescriptor);
197  }
198 
199  protected void writeNDBreadNDB(String charsetName, String tableName, Class<? extends CharsetModel> modelClass,
200  ColumnDescriptor columnDescriptor) {
201  removeAll(modelClass);
202  List<String> result = null;
203  List<String> strings = generateStrings(columnDescriptor, charsetName);
204  List<CharsetModel> instances = generateInstances(columnDescriptor, modelClass, strings);
205  writeToNDB(columnDescriptor, instances);
206  result = readFromNDB(columnDescriptor, modelClass);
207  if (debug) System.out.println("Returned results of size " + result.size());
208 // if (debug) System.out.println("Results: " + dump(result));
209  verify("writeNDBreadNDB", strings, result, columnDescriptor);
210  }
211 
212  private void verify(String where, List<String> expecteds, List<String> actuals, ColumnDescriptor columnDescriptor) {
213  int maxErrors = 10;
214  for (int i = 0; i < expecteds.size(); ++i) {
215  String expected = expecteds.get(i);
216  String actual = actuals.get(i);
217  int expectedLength = expected.length();
218  int actualLength = actual.length();
219  errorIfNotEqual(where + " got failure on size of column data for column width " + columnDescriptor.columnWidth + " at row " + i, expectedLength, actualLength);
220  if (expectedLength != actualLength)
221  continue;
222  for (int j = 0; j < expected.length(); ++j) {
223  if (--maxErrors > 0) {
224  errorIfNotEqual("Failure to match column data for column width " + columnDescriptor.columnWidth + " at row " + i + " column " + j,
225  expected.codePointAt(j), actual.codePointAt(j));
226  }
227  }
228  }
229  }
230 
231  protected List<String> generateStrings(ColumnDescriptor columnDescriptor,
232  String charsetName) {
233  List<String> result = new ArrayList<String>();
234  Charset charset = Charset.forName(charsetName);
235  CharBuffer allChars = CharBuffer.allocate(65536);
236  CharsetEncoder encoder = charset.newEncoder();
237  // add all encodable characters to the buffer
238  int count = 0;
239 // for (int i = 0; i < 65536; ++i) {
240  for (int i = 0; i < 65536; ++i) {
241  Character ch = (char)i;
242  if (encoder.canEncode(ch)) {
243  allChars.append(ch);
244  ++count;
245  }
246  }
247  if (debug) System.out.print(charsetName + " has " + count + " encodable characters");
248  allChars.flip();
249 
250  int width = columnDescriptor.getColumnWidth();
251  // encode all the characters that fit into the output byte buffer
252  boolean done = false;
253  byte[] bytes = new byte[width];
254  while (!done) {
255  int begin = allChars.position();
256  allChars.mark();
257  ByteBuffer byteBuffer = ByteBuffer.wrap(bytes);
258  CoderResult coderResult = encoder.encode(allChars, byteBuffer, false);
259  int end = allChars.position();
260  int length = end - begin;
261  if (length == 0) {
262  done = true;
263  continue;
264  }
265  char[] chars = new char[length];
266  allChars.reset();
267  allChars.get(chars, 0, length);
268  String encodable = String.copyValueOf(chars);
269  result.add(encodable);
270  if (coderResult.isUnderflow()) {
271  done = true;
272  }
273  }
274  if (debug) System.out.println(" in " + result.size() + " row(s) of size " + columnDescriptor.columnWidth);
275  return result;
276  }
277 
278  protected List<CharsetModel> generateInstances(ColumnDescriptor columnDescriptor,
279  Class<? extends CharsetModel> modelClass, List<String> strings) {
280  List<CharsetModel> result = new ArrayList<CharsetModel>();
281  for (int i = 0; i < strings.size(); ++i) {
282  CharsetModel instance = session.newInstance(modelClass);
283  instance.setId(i);
284  columnDescriptor.set(instance, strings.get(i));
285  result.add(instance);
286  }
287  if (debug) System.out.println("Created " + result.size() + " instances of " + modelClass.getName());
288  return result;
289  }
290 
291  protected void writeToJDBC(ColumnDescriptor columnDescriptor,
292  String tableName, List<CharsetModel> instances) {
293  StringBuffer buffer = new StringBuffer("INSERT INTO ");
294  buffer.append(tableName);
295  buffer.append(" (id, ");
296  buffer.append(columnDescriptor.getColumnName());
297  buffer.append(") VALUES (?, ?)");
298  String statement = buffer.toString();
299  if (debug) System.out.println(statement);
300  PreparedStatement preparedStatement = null;
301  int i = 0;
302  String value = "";
303  try {
304  Properties extraProperties = new Properties();
305  extraProperties.put("characterEncoding", "utf8");
306  getConnection(extraProperties);
307  setAutoCommit(connection, false);
308  preparedStatement = connection.prepareStatement(statement);
309  if (debug) System.out.println(preparedStatement.toString());
310  for (i = 0; i < instances.size(); ++i) {
311  CharsetModel instance = instances.get(i);
312  preparedStatement.setInt(1, instance.getId());
313  value = columnDescriptor.get(instance);
314  preparedStatement.setString(2, value);
315 // if (debug) System.out.println("Value set to column is size " + value.length());
316 // if (debug) System.out.println(" value " + value);
317  preparedStatement.execute();
318  }
319  connection.commit();
320  } catch (SQLException e) {
321  throw new RuntimeException("Failed to insert " + tableName + " at instance " + i + " errant string: " + dump(value), e);
322  }
323  }
324 
325  protected void writeToNDB(ColumnDescriptor columnDescriptor, List<CharsetModel> instances) {
326  session.currentTransaction().begin();
327  for (CharsetModel instance: instances) {
328  session.makePersistent(instance);
329  }
330  session.currentTransaction().commit();
331  }
332 
333  protected List<String> readFromNDB(ColumnDescriptor columnDescriptor,
334  Class<? extends CharsetModel> modelClass) {
335  List<String> result = new ArrayList<String>();
336  session.currentTransaction().begin();
337  int i = 0;
338  boolean done = false;
339  while (!done) {
340  CharsetModel instance = session.find(modelClass, i++);
341  if (instance != null) {
342  result.add(columnDescriptor.get(instance));
343  } else {
344  done = true;
345  }
346  }
347  session.currentTransaction().commit();
348  return result;
349  }
350 
351  protected List<String> readFromJDBC(ColumnDescriptor columnDescriptor,
352  String tableName) {
353  List<String> result = new ArrayList<String>();
354  StringBuffer buffer = new StringBuffer("SELECT id, ");
355  buffer.append(columnDescriptor.getColumnName());
356  buffer.append(" FROM ");
357  buffer.append(tableName);
358  buffer.append(" ORDER BY ID");
359  String statement = buffer.toString();
360  if (debug) System.out.println(statement);
361  PreparedStatement preparedStatement = null;
362  int i = 0;
363  try {
364  preparedStatement = connection.prepareStatement(statement);
365  ResultSet rs = preparedStatement.executeQuery();
366  while (rs.next()) {
367  String columnData = rs.getString(2);
368  result.add(columnData);
369  ++i;
370  }
371  connection.commit();
372  } catch (SQLException e) {
373  throw new RuntimeException("Failed to read " + tableName + " at instance " + i, e);
374  }
375  return result;
376  }
377 
378  protected enum ColumnDescriptor {
379  SMALL(200, "smallcolumn", new InstanceHandler() {
380  public void set(CharsetModel instance, String value) {
381  instance.setSmallColumn(value);
382  }
383  public String get(CharsetModel instance) {
384  return instance.getSmallColumn();
385  }
386  }),
387  MEDIUM(500, "mediumcolumn", new InstanceHandler() {
388  public void set(CharsetModel instance, String value) {
389  instance.setMediumColumn(value);
390  }
391  public String get(CharsetModel instance) {
392  return instance.getMediumColumn();
393  }
394  }),
395  LARGE(10000, "largecolumn", new InstanceHandler() {
396  public void set(CharsetModel instance, String value) {
397  instance.setLargeColumn(value);
398  }
399  public String get(CharsetModel instance) {
400  return instance.getLargeColumn();
401  }
402  });
403 
404  private int columnWidth;
405 
406  private String columnName;
407 
408  private InstanceHandler instanceHandler;
409 
410  public String getColumnName() {
411  return columnName;
412  }
413 
414  public String get(CharsetModel instance) {
415  return instanceHandler.get(instance);
416  }
417 
418  public void set(CharsetModel instance, String string) {
419  this.instanceHandler.set(instance, string);
420  }
421 
422  public int getColumnWidth() {
423  return columnWidth;
424  }
425 
426  private ColumnDescriptor(int width, String name, InstanceHandler instanceHandler) {
427  this.columnWidth = width;
428  this.columnName = name;
429  this.instanceHandler = instanceHandler;
430  }
431 
432  private interface InstanceHandler {
433  void set(CharsetModel instance, String value);
434  String get(CharsetModel instance);
435  }
436 
437  }
438 
440  protected List<CharsetModel> charsetTypes = new ArrayList<CharsetModel>();
441 
442 }