Added: ibatis/trunk/java/mapper/mapper2/tools/abator/core/test/abatortest/execute/flat/legacy/FlatLegacyTests.java URL: http://svn.apache.org/viewvc/ibatis/trunk/java/mapper/mapper2/tools/abator/core/test/abatortest/execute/flat/legacy/FlatLegacyTests.java?rev=431771&view=auto ============================================================================== --- ibatis/trunk/java/mapper/mapper2/tools/abator/core/test/abatortest/execute/flat/legacy/FlatLegacyTests.java (added) +++ ibatis/trunk/java/mapper/mapper2/tools/abator/core/test/abatortest/execute/flat/legacy/FlatLegacyTests.java Tue Aug 15 19:32:09 2006 @@ -0,0 +1,1023 @@ +/* + * Copyright 2006 The Apache Software Foundation + * + * 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. + */ + +package abatortest.execute.flat.legacy; + +import java.math.BigDecimal; +import java.util.Date; +import java.util.List; + +import abatortest.BaseTest; +import abatortest.generated.flat.legacy.dao.FieldsblobsDAO; +import abatortest.generated.flat.legacy.dao.FieldsonlyDAO; +import abatortest.generated.flat.legacy.dao.PkblobsDAO; +import abatortest.generated.flat.legacy.dao.PkfieldsDAO; +import abatortest.generated.flat.legacy.dao.PkfieldsblobsDAO; +import abatortest.generated.flat.legacy.dao.PkonlyDAO; +import abatortest.generated.flat.legacy.model.Fieldsblobs; +import abatortest.generated.flat.legacy.model.FieldsblobsExample; +import abatortest.generated.flat.legacy.model.Fieldsonly; +import abatortest.generated.flat.legacy.model.FieldsonlyExample; +import abatortest.generated.flat.legacy.model.Pkblobs; +import abatortest.generated.flat.legacy.model.PkblobsExample; +import abatortest.generated.flat.legacy.model.Pkfields; +import abatortest.generated.flat.legacy.model.PkfieldsExample; +import abatortest.generated.flat.legacy.model.Pkfieldsblobs; +import abatortest.generated.flat.legacy.model.PkfieldsblobsExample; +import abatortest.generated.flat.legacy.model.Pkonly; +import abatortest.generated.flat.legacy.model.PkonlyExample; + +/** + * @author Jeff Butler + * + */ +public class FlatLegacyTests extends BaseTest { + + protected void setUp() throws Exception { + super.setUp(); + initDaoManager("abatortest/execute/flat/legacy/dao.xml", null); + } + + public void testFieldsOnlyInsert() { + FieldsonlyDAO dao = (FieldsonlyDAO) daoManager.getDao(FieldsonlyDAO.class); + + Fieldsonly record = new Fieldsonly(); + record.setDoublefield(new Double(11.22)); + record.setFloatfield(new Float(33.44)); + record.setIntegerfield(new Integer(5)); + dao.insert(record); + + FieldsonlyExample example = new FieldsonlyExample(); + example.setIntegerfield(new Integer(5)); + example.setIntegerfield_Indicator(FieldsonlyExample.EXAMPLE_EQUALS); + + List answer = dao.selectByExample(example); + assertEquals(1, answer.size()); + + Fieldsonly returnedRecord = (Fieldsonly) answer.get(0); + assertEquals(record.getIntegerfield(), returnedRecord.getIntegerfield()); + assertEquals(record.getDoublefield(), returnedRecord.getDoublefield()); + assertEquals(record.getFloatfield(), returnedRecord.getFloatfield()); + } + + public void testFieldsOnlySelectByExample() { + FieldsonlyDAO dao = (FieldsonlyDAO) daoManager.getDao(FieldsonlyDAO.class); + + Fieldsonly record = new Fieldsonly(); + record.setDoublefield(new Double(11.22)); + record.setFloatfield(new Float(33.44)); + record.setIntegerfield(new Integer(5)); + dao.insert(record); + + record = new Fieldsonly(); + record.setDoublefield(new Double(44.55)); + record.setFloatfield(new Float(66.77)); + record.setIntegerfield(new Integer(8)); + dao.insert(record); + + record = new Fieldsonly(); + record.setDoublefield(new Double(88.99)); + record.setFloatfield(new Float(100.111)); + record.setIntegerfield(new Integer(9)); + dao.insert(record); + + FieldsonlyExample example = new FieldsonlyExample(); + example.setIntegerfield(new Integer(5)); + example.setIntegerfield_Indicator(FieldsonlyExample.EXAMPLE_GREATER_THAN); + + List answer = dao.selectByExample(example); + assertEquals(2, answer.size()); + + example = new FieldsonlyExample(); + answer = dao.selectByExample(example); + assertEquals(3, answer.size()); + + } + + public void testFieldsOnlyDeleteByExample() { + FieldsonlyDAO dao = (FieldsonlyDAO) daoManager.getDao(FieldsonlyDAO.class); + + Fieldsonly record = new Fieldsonly(); + record.setDoublefield(new Double(11.22)); + record.setFloatfield(new Float(33.44)); + record.setIntegerfield(new Integer(5)); + dao.insert(record); + + record = new Fieldsonly(); + record.setDoublefield(new Double(44.55)); + record.setFloatfield(new Float(66.77)); + record.setIntegerfield(new Integer(8)); + dao.insert(record); + + record = new Fieldsonly(); + record.setDoublefield(new Double(88.99)); + record.setFloatfield(new Float(100.111)); + record.setIntegerfield(new Integer(9)); + dao.insert(record); + + FieldsonlyExample example = new FieldsonlyExample(); + example.setIntegerfield(new Integer(5)); + example.setIntegerfield_Indicator(FieldsonlyExample.EXAMPLE_GREATER_THAN); + + int rows = dao.deleteByExample(example); + assertEquals(2, rows); + + example = new FieldsonlyExample(); + List answer = dao.selectByExample(example); + assertEquals(1, answer.size()); + } + + public void testPKOnlyInsert() { + PkonlyDAO dao = (PkonlyDAO) daoManager.getDao(PkonlyDAO.class); + + Pkonly key = new Pkonly(); + key.setId(new Integer(1)); + key.setSeqNum(new Integer(3)); + dao.insert(key); + + PkonlyExample example = new PkonlyExample(); + List answer = dao.selectByExample(example); + assertEquals(1, answer.size()); + + Pkonly returnedRecord = (Pkonly) answer.get(0); + assertEquals(key.getId(), returnedRecord.getId()); + assertEquals(key.getSeqNum(), returnedRecord.getSeqNum()); + } + + public void testPKOnlyDeleteByPrimaryKey() { + PkonlyDAO dao = (PkonlyDAO) daoManager.getDao(PkonlyDAO.class); + + Pkonly key = new Pkonly(); + key.setId(new Integer(1)); + key.setSeqNum(new Integer(3)); + dao.insert(key); + + key = new Pkonly(); + key.setId(new Integer(5)); + key.setSeqNum(new Integer(6)); + dao.insert(key); + + PkonlyExample example = new PkonlyExample(); + List answer = dao.selectByExample(example); + assertEquals(2, answer.size()); + + int rows = dao.deleteByPrimaryKey(new Integer(5), new Integer(6)); + assertEquals(1, rows); + + answer = dao.selectByExample(example); + assertEquals(1, answer.size()); + } + + public void testPKOnlyDeleteByExample() { + PkonlyDAO dao = (PkonlyDAO) daoManager.getDao(PkonlyDAO.class); + + Pkonly key = new Pkonly(); + key.setId(new Integer(1)); + key.setSeqNum(new Integer(3)); + dao.insert(key); + + key = new Pkonly(); + key.setId(new Integer(5)); + key.setSeqNum(new Integer(6)); + dao.insert(key); + + key = new Pkonly(); + key.setId(new Integer(7)); + key.setSeqNum(new Integer(8)); + dao.insert(key); + + PkonlyExample example = new PkonlyExample(); + example.setId(4); + example.setId_Indicator(PkonlyExample.EXAMPLE_GREATER_THAN); + int rows = dao.deleteByExample(example); + assertEquals(2, rows); + + example = new PkonlyExample(); + List answer = dao.selectByExample(example); + assertEquals(1, answer.size()); + } + + public void testPKOnlySelectByExample() { + PkonlyDAO dao = (PkonlyDAO) daoManager.getDao(PkonlyDAO.class); + + Pkonly key = new Pkonly(); + key.setId(new Integer(1)); + key.setSeqNum(new Integer(3)); + dao.insert(key); + + key = new Pkonly(); + key.setId(new Integer(5)); + key.setSeqNum(new Integer(6)); + dao.insert(key); + + key = new Pkonly(); + key.setId(new Integer(7)); + key.setSeqNum(new Integer(8)); + dao.insert(key); + + PkonlyExample example = new PkonlyExample(); + example.setId(4); + example.setId_Indicator(PkonlyExample.EXAMPLE_GREATER_THAN); + List answer = dao.selectByExample(example); + assertEquals(2, answer.size()); + } + + public void testPKFieldsInsert() { + PkfieldsDAO dao = (PkfieldsDAO) daoManager.getDao(PkfieldsDAO.class); + + Pkfields record = new Pkfields(); + record.setDatefield(new Date()); + record.setDecimal100field(new Long(10L)); + record.setDecimal155field(new BigDecimal("15.12345")); + record.setDecimal30field(new Short((short) 3)); + record.setDecimal60field(new Integer(6)); + record.setFirstname("Jeff"); + record.setId1(new Integer(1)); + record.setId2(new Integer(2)); + record.setLastname("Butler"); + record.setTimefield(new Date()); + record.setTimestampfield(new Date()); + + dao.insert(record); + + Pkfields returnedRecord = dao.selectByPrimaryKey(new Integer(1), new Integer(2)); + assertNotNull(returnedRecord); + + assertTrue(datesAreEqual(record.getDatefield(), returnedRecord.getDatefield())); + assertEquals(record.getDecimal100field(), returnedRecord.getDecimal100field()); + assertEquals(record.getDecimal155field(), returnedRecord.getDecimal155field()); + assertEquals(record.getDecimal30field(), returnedRecord.getDecimal30field()); + assertEquals(record.getDecimal60field(), returnedRecord.getDecimal60field()); + assertEquals(record.getFirstname(), returnedRecord.getFirstname()); + assertEquals(record.getId1(), returnedRecord.getId1()); + assertEquals(record.getId2(), returnedRecord.getId2()); + assertEquals(record.getLastname(), returnedRecord.getLastname()); + assertTrue(timesAreEqual(record.getTimefield(), returnedRecord.getTimefield())); + assertEquals(record.getTimestampfield(), returnedRecord.getTimestampfield()); + } + + public void testPKFieldsUpdateByPrimaryKey() { + PkfieldsDAO dao = (PkfieldsDAO) daoManager.getDao(PkfieldsDAO.class); + + Pkfields record = new Pkfields(); + record.setFirstname("Jeff"); + record.setLastname("Smith"); + record.setId1(new Integer(1)); + record.setId2(new Integer(2)); + + dao.insert(record); + + record.setFirstname("Scott"); + record.setLastname("Jones"); + + int rows = dao.updateByPrimaryKey(record); + assertEquals(1, rows); + + Pkfields record2 = dao.selectByPrimaryKey(new Integer(1), new Integer(2)); + + assertEquals(record.getFirstname(), record2.getFirstname()); + assertEquals(record.getLastname(), record2.getLastname()); + assertEquals(record.getId1(), record2.getId1()); + assertEquals(record.getId2(), record2.getId2()); + } + + public void testPKFieldsUpdateByPrimaryKeySelective() { + PkfieldsDAO dao = (PkfieldsDAO) daoManager.getDao(PkfieldsDAO.class); + + Pkfields record = new Pkfields(); + record.setFirstname("Jeff"); + record.setLastname("Smith"); + record.setDecimal60field(new Integer(5)); + record.setId1(new Integer(1)); + record.setId2(new Integer(2)); + + dao.insert(record); + + Pkfields newRecord = new Pkfields(); + newRecord.setId1(new Integer(1)); + newRecord.setId2(new Integer(2)); + newRecord.setFirstname("Scott"); + newRecord.setDecimal60field(new Integer(4)); + + int rows = dao.updateByPrimaryKeySelective(newRecord); + assertEquals(1, rows); + + Pkfields returnedRecord = dao.selectByPrimaryKey(new Integer(1), new Integer(2)); + + assertTrue(datesAreEqual(record.getDatefield(), returnedRecord.getDatefield())); + assertEquals(record.getDecimal100field(), returnedRecord.getDecimal100field()); + assertEquals(record.getDecimal155field(), returnedRecord.getDecimal155field()); + assertEquals(record.getDecimal30field(), returnedRecord.getDecimal30field()); + assertEquals(newRecord.getDecimal60field(), returnedRecord.getDecimal60field()); + assertEquals(newRecord.getFirstname(), returnedRecord.getFirstname()); + assertEquals(record.getId1(), returnedRecord.getId1()); + assertEquals(record.getId2(), returnedRecord.getId2()); + assertEquals(record.getLastname(), returnedRecord.getLastname()); + assertTrue(timesAreEqual(record.getTimefield(), returnedRecord.getTimefield())); + assertEquals(record.getTimestampfield(), returnedRecord.getTimestampfield()); + } + + public void testPKfieldsDeleteByPrimaryKey() { + PkfieldsDAO dao = (PkfieldsDAO) daoManager.getDao(PkfieldsDAO.class); + + Pkfields record = new Pkfields(); + record.setFirstname("Jeff"); + record.setLastname("Smith"); + record.setId1(new Integer(1)); + record.setId2(new Integer(2)); + + dao.insert(record); + + int rows = dao.deleteByPrimaryKey(new Integer(1), new Integer(2)); + assertEquals(1, rows); + + PkfieldsExample example = new PkfieldsExample(); + List answer = dao.selectByExample(example); + assertEquals(0, answer.size()); + } + + public void testPKFieldsDeleteByExample() { + PkfieldsDAO dao = (PkfieldsDAO) daoManager.getDao(PkfieldsDAO.class); + + Pkfields record = new Pkfields(); + record.setFirstname("Jeff"); + record.setLastname("Smith"); + record.setId1(new Integer(1)); + record.setId2(new Integer(2)); + dao.insert(record); + + record = new Pkfields(); + record.setFirstname("Bob"); + record.setLastname("Jones"); + record.setId1(new Integer(3)); + record.setId2(new Integer(4)); + + dao.insert(record); + + PkfieldsExample example = new PkfieldsExample(); + List answer = dao.selectByExample(example); + assertEquals(2, answer.size()); + + example = new PkfieldsExample(); + example.setLastname("J%"); + example.setLastname_Indicator(PkfieldsExample.EXAMPLE_LIKE); + int rows = dao.deleteByExample(example); + assertEquals(1, rows); + + example = new PkfieldsExample(); + answer = dao.selectByExample(example); + assertEquals(1, answer.size()); + } + + public void testPKFieldsSelectByPrimaryKey() { + PkfieldsDAO dao = (PkfieldsDAO) daoManager.getDao(PkfieldsDAO.class); + + Pkfields record = new Pkfields(); + record.setFirstname("Jeff"); + record.setLastname("Smith"); + record.setId1(new Integer(1)); + record.setId2(new Integer(2)); + dao.insert(record); + + record = new Pkfields(); + record.setFirstname("Bob"); + record.setLastname("Jones"); + record.setId1(new Integer(3)); + record.setId2(new Integer(4)); + dao.insert(record); + + Pkfields newRecord = dao.selectByPrimaryKey(new Integer(3), new Integer(4)); + + assertNotNull(newRecord); + assertEquals(record.getFirstname(), newRecord.getFirstname()); + assertEquals(record.getLastname(), newRecord.getLastname()); + assertEquals(record.getId1(), newRecord.getId1()); + assertEquals(record.getId2(), newRecord.getId2()); + } + + public void testPKFieldsSelectByExample() { + PkfieldsDAO dao = (PkfieldsDAO) daoManager.getDao(PkfieldsDAO.class); + + Pkfields record = new Pkfields(); + record.setFirstname("Jeff"); + record.setLastname("Smith"); + record.setId1(new Integer(1)); + record.setId2(new Integer(2)); + dao.insert(record); + + record = new Pkfields(); + record.setFirstname("Bob"); + record.setLastname("Jones"); + record.setId1(new Integer(3)); + record.setId2(new Integer(4)); + dao.insert(record); + + PkfieldsExample example = new PkfieldsExample(); + example.setId1(new Integer(3)); + example.setId1_Indicator(PkfieldsExample.EXAMPLE_EQUALS); + example.setId2(new Integer(4)); + example.setId2_Indicator(PkfieldsExample.EXAMPLE_EQUALS); + + List answer = dao.selectByExample(example); + + assertEquals(1, answer.size()); + + Pkfields newRecord = (Pkfields) answer.get(0); + + assertNotNull(newRecord); + assertEquals(record.getFirstname(), newRecord.getFirstname()); + assertEquals(record.getLastname(), newRecord.getLastname()); + assertEquals(record.getId1(), newRecord.getId1()); + assertEquals(record.getId2(), newRecord.getId2()); + } + + public void testPKBlobsInsert() { + PkblobsDAO dao = (PkblobsDAO) daoManager.getDao(PkblobsDAO.class); + + Pkblobs record = new Pkblobs(); + + record.setId(new Integer(3)); + record.setBlob1(generateRandomBlob()); + record.setBlob2(generateRandomBlob()); + dao.insert(record); + + PkblobsExample example = new PkblobsExample(); + List answer = dao.selectByExampleWithBLOBs(example); + assertEquals(1, answer.size()); + + Pkblobs returnedRecord = (Pkblobs) answer.get(0); + assertEquals(record.getId(), returnedRecord.getId()); + assertTrue(blobsAreEqual(record.getBlob1(), returnedRecord.getBlob1())); + assertTrue(blobsAreEqual(record.getBlob2(), returnedRecord.getBlob2())); + } + + public void testPKBlobsUpdateByPrimaryKeyWithBLOBs() { + PkblobsDAO dao = (PkblobsDAO) daoManager.getDao(PkblobsDAO.class); + + Pkblobs record = new Pkblobs(); + record.setId(new Integer(3)); + record.setBlob1(generateRandomBlob()); + record.setBlob2(generateRandomBlob()); + dao.insert(record); + + record = new Pkblobs(); + record.setId(new Integer(3)); + record.setBlob1(generateRandomBlob()); + record.setBlob2(generateRandomBlob()); + int rows = dao.updateByPrimaryKey(record); + assertEquals(1, rows); + + Pkblobs newRecord = dao.selectByPrimaryKey(new Integer(3)); + + assertNotNull(newRecord); + assertEquals(record.getId(), newRecord.getId()); + assertTrue(blobsAreEqual(record.getBlob1(), newRecord.getBlob1())); + assertTrue(blobsAreEqual(record.getBlob2(), newRecord.getBlob2())); + } + + public void testPKBlobsUpdateByPrimaryKeySelective() { + PkblobsDAO dao = (PkblobsDAO) daoManager.getDao(PkblobsDAO.class); + + Pkblobs record = new Pkblobs(); + record.setId(new Integer(3)); + record.setBlob1(generateRandomBlob()); + record.setBlob2(generateRandomBlob()); + dao.insert(record); + + Pkblobs newRecord = new Pkblobs(); + newRecord.setId(new Integer(3)); + newRecord.setBlob2(generateRandomBlob()); + dao.updateByPrimaryKeySelective(newRecord); + + Pkblobs returnedRecord = dao.selectByPrimaryKey(new Integer(3)); + assertNotNull(returnedRecord); + assertEquals(record.getId(), returnedRecord.getId()); + assertTrue(blobsAreEqual(record.getBlob1(), returnedRecord.getBlob1())); + assertTrue(blobsAreEqual(newRecord.getBlob2(), returnedRecord.getBlob2())); + } + + public void testPKBlobsDeleteByPrimaryKey() { + PkblobsDAO dao = (PkblobsDAO) daoManager.getDao(PkblobsDAO.class); + + Pkblobs record = new Pkblobs(); + + record.setId(new Integer(3)); + record.setBlob1(generateRandomBlob()); + record.setBlob2(generateRandomBlob()); + dao.insert(record); + + PkblobsExample example = new PkblobsExample(); + List answer = dao.selectByExampleWithoutBLOBs(example); + assertEquals(1, answer.size()); + + int rows = dao.deleteByPrimaryKey(new Integer(3)); + assertEquals(1, rows); + + example = new PkblobsExample(); + answer = dao.selectByExampleWithoutBLOBs(example); + assertEquals(0, answer.size()); + } + + public void testPKBlobsDeleteByExample() { + PkblobsDAO dao = (PkblobsDAO) daoManager.getDao(PkblobsDAO.class); + + Pkblobs record = new Pkblobs(); + record.setId(new Integer(3)); + record.setBlob1(generateRandomBlob()); + record.setBlob2(generateRandomBlob()); + dao.insert(record); + + record = new Pkblobs(); + record.setId(new Integer(6)); + record.setBlob1(generateRandomBlob()); + record.setBlob2(generateRandomBlob()); + dao.insert(record); + + PkblobsExample example = new PkblobsExample(); + List answer = dao.selectByExampleWithoutBLOBs(example); + assertEquals(2, answer.size()); + + example = new PkblobsExample(); + example.setId(new Integer(4)); + example.setId_Indicator(PkblobsExample.EXAMPLE_LESS_THAN); + int rows = dao.deleteByExample(example); + assertEquals(1, rows); + + example = new PkblobsExample(); + answer = dao.selectByExampleWithoutBLOBs(example); + assertEquals(1, answer.size()); + } + + public void testPKBlobsSelectByPrimaryKey() { + PkblobsDAO dao = (PkblobsDAO) daoManager.getDao(PkblobsDAO.class); + + Pkblobs record = new Pkblobs(); + record.setId(new Integer(3)); + record.setBlob1(generateRandomBlob()); + record.setBlob2(generateRandomBlob()); + dao.insert(record); + + record = new Pkblobs(); + record.setId(new Integer(6)); + record.setBlob1(generateRandomBlob()); + record.setBlob2(generateRandomBlob()); + dao.insert(record); + + Pkblobs newRecord = dao.selectByPrimaryKey(new Integer(6)); + assertNotNull(newRecord); + assertEquals(record.getId(), newRecord.getId()); + assertTrue(blobsAreEqual(record.getBlob1(), newRecord.getBlob1())); + assertTrue(blobsAreEqual(record.getBlob2(), newRecord.getBlob2())); + } + + public void testPKBlobsSelectByExampleWithoutBlobs() { + PkblobsDAO dao = (PkblobsDAO) daoManager.getDao(PkblobsDAO.class); + + Pkblobs record = new Pkblobs(); + record.setId(new Integer(3)); + record.setBlob1(generateRandomBlob()); + record.setBlob2(generateRandomBlob()); + dao.insert(record); + + record = new Pkblobs(); + record.setId(new Integer(6)); + record.setBlob1(generateRandomBlob()); + record.setBlob2(generateRandomBlob()); + dao.insert(record); + + PkblobsExample example = new PkblobsExample(); + example.setId(new Integer(4)); + example.setId_Indicator(PkblobsExample.EXAMPLE_GREATER_THAN); + List answer = dao.selectByExampleWithoutBLOBs(example); + + assertEquals(1, answer.size()); + + Pkblobs key = (Pkblobs) answer.get(0); + assertEquals(6, key.getId().intValue()); + assertNull(key.getBlob1()); + assertNull(key.getBlob2()); + } + + public void testPKBlobsSelectByExampleWithBlobs() { + PkblobsDAO dao = (PkblobsDAO) daoManager.getDao(PkblobsDAO.class); + + Pkblobs record = new Pkblobs(); + record.setId(new Integer(3)); + record.setBlob1(generateRandomBlob()); + record.setBlob2(generateRandomBlob()); + dao.insert(record); + + record = new Pkblobs(); + record.setId(new Integer(6)); + record.setBlob1(generateRandomBlob()); + record.setBlob2(generateRandomBlob()); + dao.insert(record); + + PkblobsExample example = new PkblobsExample(); + example.setId(new Integer(4)); + example.setId_Indicator(PkblobsExample.EXAMPLE_GREATER_THAN); + List answer = dao.selectByExampleWithBLOBs(example); + + assertEquals(1, answer.size()); + + Pkblobs newRecord = (Pkblobs) answer.get(0); + assertEquals(record.getId(), newRecord.getId()); + assertTrue(blobsAreEqual(record.getBlob1(), newRecord.getBlob1())); + assertTrue(blobsAreEqual(record.getBlob2(), newRecord.getBlob2())); + } + + public void testPKFieldsBlobsInsert() { + PkfieldsblobsDAO dao = (PkfieldsblobsDAO) daoManager.getDao(PkfieldsblobsDAO.class); + + Pkfieldsblobs record = new Pkfieldsblobs(); + record.setId1(new Integer(3)); + record.setId2(new Integer(4)); + record.setFirstname("Jeff"); + record.setLastname("Smith"); + record.setBlob1(generateRandomBlob()); + dao.insert(record); + + PkfieldsblobsExample example = new PkfieldsblobsExample(); + List answer = dao.selectByExampleWithBLOBs(example); + assertEquals(1, answer.size()); + + Pkfieldsblobs returnedRecord = (Pkfieldsblobs) answer.get(0); + assertEquals(record.getId1(), returnedRecord.getId1()); + assertEquals(record.getId2(), returnedRecord.getId2()); + assertEquals(record.getFirstname(), returnedRecord.getFirstname()); + assertEquals(record.getLastname(), returnedRecord.getLastname()); + assertTrue(blobsAreEqual(record.getBlob1(), returnedRecord.getBlob1())); + } + + public void testPKFieldsBlobsUpdateByPrimaryKeyWithBLOBs() { + PkfieldsblobsDAO dao = (PkfieldsblobsDAO) daoManager.getDao(PkfieldsblobsDAO.class); + + Pkfieldsblobs record = new Pkfieldsblobs(); + record.setId1(new Integer(3)); + record.setId2(new Integer(4)); + record.setFirstname("Jeff"); + record.setLastname("Smith"); + record.setBlob1(generateRandomBlob()); + dao.insert(record); + + Pkfieldsblobs updateRecord = new Pkfieldsblobs(); + updateRecord.setId1(new Integer(3)); + updateRecord.setId2(new Integer(4)); + updateRecord.setFirstname("Scott"); + updateRecord.setLastname("Jones"); + updateRecord.setBlob1(generateRandomBlob()); + + int rows = dao.updateByPrimaryKeyWithBLOBs(updateRecord); + assertEquals(1, rows); + + Pkfieldsblobs newRecord = dao.selectByPrimaryKey(new Integer(3), new Integer(4)); + assertEquals(updateRecord.getFirstname(), newRecord.getFirstname()); + assertEquals(updateRecord.getLastname(), newRecord.getLastname()); + assertEquals(record.getId1(), newRecord.getId1()); + assertEquals(record.getId2(), newRecord.getId2()); + assertTrue(blobsAreEqual(updateRecord.getBlob1(), newRecord.getBlob1())); + } + + public void testPKFieldsBlobsUpdateByPrimaryKeyWithoutBLOBs() { + PkfieldsblobsDAO dao = (PkfieldsblobsDAO) daoManager.getDao(PkfieldsblobsDAO.class); + + Pkfieldsblobs record = new Pkfieldsblobs(); + record.setId1(new Integer(3)); + record.setId2(new Integer(4)); + record.setFirstname("Jeff"); + record.setLastname("Smith"); + record.setBlob1(generateRandomBlob()); + dao.insert(record); + + Pkfieldsblobs updateRecord = new Pkfieldsblobs(); + updateRecord.setId1(new Integer(3)); + updateRecord.setId2(new Integer(4)); + updateRecord.setFirstname("Scott"); + updateRecord.setLastname("Jones"); + + int rows = dao.updateByPrimaryKeyWithoutBLOBs(updateRecord); + assertEquals(1, rows); + + Pkfieldsblobs newRecord = dao.selectByPrimaryKey(new Integer(3), new Integer(4)); + assertEquals(updateRecord.getFirstname(), newRecord.getFirstname()); + assertEquals(updateRecord.getLastname(), newRecord.getLastname()); + assertEquals(record.getId1(), newRecord.getId1()); + assertEquals(record.getId2(), newRecord.getId2()); + assertTrue(blobsAreEqual(record.getBlob1(), newRecord.getBlob1())); + } + + public void testPKFieldsBlobsUpdateByPrimaryKeySelective() { + PkfieldsblobsDAO dao = (PkfieldsblobsDAO) daoManager.getDao(PkfieldsblobsDAO.class); + + Pkfieldsblobs record = new Pkfieldsblobs(); + record.setId1(new Integer(3)); + record.setId2(new Integer(4)); + record.setFirstname("Jeff"); + record.setLastname("Smith"); + record.setBlob1(generateRandomBlob()); + dao.insert(record); + + Pkfieldsblobs updateRecord = new Pkfieldsblobs(); + updateRecord.setId1(new Integer(3)); + updateRecord.setId2(new Integer(4)); + updateRecord.setLastname("Jones"); + + int rows = dao.updateByPrimaryKeySelective(updateRecord); + assertEquals(1, rows); + + Pkfieldsblobs returnedRecord = dao.selectByPrimaryKey(new Integer(3), new Integer(4)); + assertEquals(record.getFirstname(), returnedRecord.getFirstname()); + assertEquals(updateRecord.getLastname(), returnedRecord.getLastname()); + assertEquals(record.getId1(), returnedRecord.getId1()); + assertEquals(record.getId2(), returnedRecord.getId2()); + assertTrue(blobsAreEqual(record.getBlob1(), returnedRecord.getBlob1())); + } + + public void testPKFieldsBlobsDeleteByPrimaryKey() { + PkfieldsblobsDAO dao = (PkfieldsblobsDAO) daoManager.getDao(PkfieldsblobsDAO.class); + + Pkfieldsblobs record = new Pkfieldsblobs(); + record.setId1(new Integer(3)); + record.setId2(new Integer(4)); + record.setFirstname("Jeff"); + record.setLastname("Smith"); + record.setBlob1(generateRandomBlob()); + dao.insert(record); + + record = new Pkfieldsblobs(); + record.setId1(new Integer(5)); + record.setId2(new Integer(6)); + record.setFirstname("Scott"); + record.setLastname("Jones"); + record.setBlob1(generateRandomBlob()); + dao.insert(record); + + PkfieldsblobsExample example = new PkfieldsblobsExample(); + List answer = dao.selectByExampleWithoutBLOBs(example); + assertEquals(2, answer.size()); + + int rows = dao.deleteByPrimaryKey(new Integer(5), new Integer(6)); + assertEquals(1, rows); + + example = new PkfieldsblobsExample(); + answer = dao.selectByExampleWithoutBLOBs(example); + assertEquals(1, answer.size()); + } + + public void testPKFieldsBlobsDeleteByExample() { + PkfieldsblobsDAO dao = (PkfieldsblobsDAO) daoManager.getDao(PkfieldsblobsDAO.class); + + Pkfieldsblobs record = new Pkfieldsblobs(); + record.setId1(new Integer(3)); + record.setId2(new Integer(4)); + record.setFirstname("Jeff"); + record.setLastname("Smith"); + record.setBlob1(generateRandomBlob()); + dao.insert(record); + + record = new Pkfieldsblobs(); + record.setId1(new Integer(5)); + record.setId2(new Integer(6)); + record.setFirstname("Scott"); + record.setLastname("Jones"); + record.setBlob1(generateRandomBlob()); + dao.insert(record); + + PkfieldsblobsExample example = new PkfieldsblobsExample(); + List answer = dao.selectByExampleWithoutBLOBs(example); + assertEquals(2, answer.size()); + + example = new PkfieldsblobsExample(); + example.setId1(new Integer(3)); + example.setId1_Indicator(PkfieldsblobsExample.EXAMPLE_NOT_EQUALS); + int rows = dao.deleteByExample(example); + assertEquals(1, rows); + + example = new PkfieldsblobsExample(); + answer = dao.selectByExampleWithoutBLOBs(example); + assertEquals(1, answer.size()); + } + + public void testPKFieldsBlobsSelectByPrimaryKey() { + PkfieldsblobsDAO dao = (PkfieldsblobsDAO) daoManager.getDao(PkfieldsblobsDAO.class); + + Pkfieldsblobs record = new Pkfieldsblobs(); + record.setId1(new Integer(3)); + record.setId2(new Integer(4)); + record.setFirstname("Jeff"); + record.setLastname("Smith"); + record.setBlob1(generateRandomBlob()); + dao.insert(record); + + record = new Pkfieldsblobs(); + record.setId1(new Integer(5)); + record.setId2(new Integer(6)); + record.setFirstname("Scott"); + record.setLastname("Jones"); + record.setBlob1(generateRandomBlob()); + dao.insert(record); + + PkfieldsblobsExample example = new PkfieldsblobsExample(); + List answer = dao.selectByExampleWithoutBLOBs(example); + assertEquals(2, answer.size()); + + Pkfieldsblobs newRecord = dao.selectByPrimaryKey(new Integer(5), new Integer(6)); + assertEquals(record.getId1(), newRecord.getId1()); + assertEquals(record.getId2(), newRecord.getId2()); + assertEquals(record.getFirstname(), newRecord.getFirstname()); + assertEquals(record.getLastname(), newRecord.getLastname()); + assertTrue(blobsAreEqual(record.getBlob1(), newRecord.getBlob1())); + } + + public void testPKFieldsBlobsSelectByExampleWithoutBlobs() { + PkfieldsblobsDAO dao = (PkfieldsblobsDAO) daoManager.getDao(PkfieldsblobsDAO.class); + + Pkfieldsblobs record = new Pkfieldsblobs(); + record.setId1(new Integer(3)); + record.setId2(new Integer(4)); + record.setFirstname("Jeff"); + record.setLastname("Smith"); + record.setBlob1(generateRandomBlob()); + dao.insert(record); + + record = new Pkfieldsblobs(); + record.setId1(new Integer(5)); + record.setId2(new Integer(6)); + record.setFirstname("Scott"); + record.setLastname("Jones"); + record.setBlob1(generateRandomBlob()); + dao.insert(record); + + PkfieldsblobsExample example = new PkfieldsblobsExample(); + example.setId2(new Integer(6)); + example.setId2_Indicator(PkfieldsblobsExample.EXAMPLE_EQUALS); + List answer = dao.selectByExampleWithoutBLOBs(example); + assertEquals(1, answer.size()); + + Pkfieldsblobs newRecord = (Pkfieldsblobs) answer.get(0); + assertEquals(record.getId1(), newRecord.getId1()); + assertEquals(record.getId2(), newRecord.getId2()); + assertEquals(record.getFirstname(), newRecord.getFirstname()); + assertEquals(record.getLastname(), newRecord.getLastname()); + assertNull(newRecord.getBlob1()); + } + + public void testPKFieldsBlobsSelectByExampleWithBlobs() { + PkfieldsblobsDAO dao = (PkfieldsblobsDAO) daoManager.getDao(PkfieldsblobsDAO.class); + + Pkfieldsblobs record = new Pkfieldsblobs(); + record.setId1(new Integer(3)); + record.setId2(new Integer(4)); + record.setFirstname("Jeff"); + record.setLastname("Smith"); + record.setBlob1(generateRandomBlob()); + dao.insert(record); + + record = new Pkfieldsblobs(); + record.setId1(new Integer(5)); + record.setId2(new Integer(6)); + record.setFirstname("Scott"); + record.setLastname("Jones"); + record.setBlob1(generateRandomBlob()); + dao.insert(record); + + PkfieldsblobsExample example = new PkfieldsblobsExample(); + example.setId2(new Integer(6)); + example.setId2_Indicator(PkfieldsblobsExample.EXAMPLE_EQUALS); + List answer = dao.selectByExampleWithBLOBs(example); + assertEquals(1, answer.size()); + + Pkfieldsblobs newRecord = (Pkfieldsblobs) answer.get(0); + assertEquals(record.getId1(), newRecord.getId1()); + assertEquals(record.getId2(), newRecord.getId2()); + assertEquals(record.getFirstname(), newRecord.getFirstname()); + assertEquals(record.getLastname(), newRecord.getLastname()); + assertTrue(blobsAreEqual(record.getBlob1(), newRecord.getBlob1())); + } + + public void testFieldsBlobsInsert() { + FieldsblobsDAO dao = (FieldsblobsDAO) daoManager.getDao(FieldsblobsDAO.class); + + Fieldsblobs record = new Fieldsblobs(); + record.setFirstname("Jeff"); + record.setLastname("Smith"); + record.setBlob1(generateRandomBlob()); + record.setBlob2(generateRandomBlob()); + dao.insert(record); + + FieldsblobsExample example = new FieldsblobsExample(); + List answer = dao.selectByExampleWithBLOBs(example); + assertEquals(1, answer.size()); + + Fieldsblobs returnedRecord = (Fieldsblobs) answer.get(0); + assertEquals(record.getFirstname(), returnedRecord.getFirstname()); + assertEquals(record.getLastname(), returnedRecord.getLastname()); + assertTrue(blobsAreEqual(record.getBlob1(), returnedRecord.getBlob1())); + assertTrue(blobsAreEqual(record.getBlob2(), returnedRecord.getBlob2())); + } + + public void testFieldsBlobsDeleteByExample() { + FieldsblobsDAO dao = (FieldsblobsDAO) daoManager.getDao(FieldsblobsDAO.class); + + Fieldsblobs record = new Fieldsblobs(); + record.setFirstname("Jeff"); + record.setLastname("Smith"); + record.setBlob1(generateRandomBlob()); + record.setBlob2(generateRandomBlob()); + dao.insert(record); + + record = new Fieldsblobs(); + record.setFirstname("Scott"); + record.setLastname("Jones"); + record.setBlob1(generateRandomBlob()); + record.setBlob2(generateRandomBlob()); + dao.insert(record); + + FieldsblobsExample example = new FieldsblobsExample(); + List answer = dao.selectByExampleWithoutBLOBs(example); + assertEquals(2, answer.size()); + + example = new FieldsblobsExample(); + example.setFirstname("S%"); + example.setFirstname_Indicator(FieldsblobsExample.EXAMPLE_LIKE); + int rows = dao.deleteByExample(example); + assertEquals(1, rows); + + example = new FieldsblobsExample(); + answer = dao.selectByExampleWithoutBLOBs(example); + assertEquals(1, answer.size()); + } + + public void testFieldsBlobsSelectByExampleWithoutBlobs() { + FieldsblobsDAO dao = (FieldsblobsDAO) daoManager.getDao(FieldsblobsDAO.class); + + Fieldsblobs record = new Fieldsblobs(); + record.setFirstname("Jeff"); + record.setLastname("Smith"); + record.setBlob1(generateRandomBlob()); + record.setBlob2(generateRandomBlob()); + dao.insert(record); + + record = new Fieldsblobs(); + record.setFirstname("Scott"); + record.setLastname("Jones"); + record.setBlob1(generateRandomBlob()); + record.setBlob2(generateRandomBlob()); + dao.insert(record); + + FieldsblobsExample example = new FieldsblobsExample(); + example.setFirstname("S%"); + example.setFirstname_Indicator(FieldsblobsExample.EXAMPLE_LIKE); + List answer = dao.selectByExampleWithoutBLOBs(example); + assertEquals(1, answer.size()); + + Fieldsblobs newRecord = (Fieldsblobs) answer.get(0); + assertEquals(record.getFirstname(), newRecord.getFirstname()); + assertEquals(record.getLastname(), newRecord.getLastname()); + assertNull(newRecord.getBlob1()); + assertNull(newRecord.getBlob2()); + } + + public void testFieldsBlobsSelectByExampleWithBlobs() { + FieldsblobsDAO dao = (FieldsblobsDAO) daoManager.getDao(FieldsblobsDAO.class); + + Fieldsblobs record = new Fieldsblobs(); + record.setFirstname("Jeff"); + record.setLastname("Smith"); + record.setBlob1(generateRandomBlob()); + record.setBlob2(generateRandomBlob()); + dao.insert(record); + + record = new Fieldsblobs(); + record.setFirstname("Scott"); + record.setLastname("Jones"); + record.setBlob1(generateRandomBlob()); + record.setBlob2(generateRandomBlob()); + dao.insert(record); + + FieldsblobsExample example = new FieldsblobsExample(); + example.setFirstname("S%"); + example.setFirstname_Indicator(FieldsblobsExample.EXAMPLE_LIKE); + List answer = dao.selectByExampleWithBLOBs(example); + assertEquals(1, answer.size()); + + Fieldsblobs newRecord = (Fieldsblobs) answer.get(0); + assertEquals(record.getFirstname(), newRecord.getFirstname()); + assertEquals(record.getLastname(), newRecord.getLastname()); + assertTrue(blobsAreEqual(record.getBlob1(), newRecord.getBlob1())); + assertTrue(blobsAreEqual(record.getBlob2(), newRecord.getBlob2())); + } +}
Added: ibatis/trunk/java/mapper/mapper2/tools/abator/core/test/abatortest/execute/flat/legacy/SqlMapConfig.xml URL: http://svn.apache.org/viewvc/ibatis/trunk/java/mapper/mapper2/tools/abator/core/test/abatortest/execute/flat/legacy/SqlMapConfig.xml?rev=431771&view=auto ============================================================================== --- ibatis/trunk/java/mapper/mapper2/tools/abator/core/test/abatortest/execute/flat/legacy/SqlMapConfig.xml (added) +++ ibatis/trunk/java/mapper/mapper2/tools/abator/core/test/abatortest/execute/flat/legacy/SqlMapConfig.xml Tue Aug 15 19:32:09 2006 @@ -0,0 +1,27 @@ +<?xml version="1.0" encoding="UTF-8"?> +<!DOCTYPE sqlMapConfig + PUBLIC "-//ibatis.apache.org//DTD SQL Map Config 2.0//EN" + "http://ibatis.apache.org/dtd/sql-map-config-2.dtd";> + +<sqlMapConfig> + + <settings useStatementNamespaces="true" /> + + <transactionManager type="JDBC"> + <dataSource type="SIMPLE"> + <property name="JDBC.Driver" value="org.hsqldb.jdbcDriver"/> + <property name="JDBC.ConnectionURL" value="jdbc:hsqldb:mem:aname"/> + <property name="JDBC.Username" value="sa"/> + <property name="JDBC.Password" value=""/> + <property name="JDBC.DefaultAutoCommit" value="true"/> + </dataSource> + </transactionManager> + + <sqlMap resource="abatortest/generated/flat/legacy/xml/FIELDSBLOBS_SqlMap.xml" /> + <sqlMap resource="abatortest/generated/flat/legacy/xml/FIELDSONLY_SqlMap.xml" /> + <sqlMap resource="abatortest/generated/flat/legacy/xml/PKBLOBS_SqlMap.xml" /> + <sqlMap resource="abatortest/generated/flat/legacy/xml/PKFIELDS_SqlMap.xml" /> + <sqlMap resource="abatortest/generated/flat/legacy/xml/PKFIELDSBLOBS_SqlMap.xml" /> + <sqlMap resource="abatortest/generated/flat/legacy/xml/PKONLY_SqlMap.xml" /> + +</sqlMapConfig> Added: ibatis/trunk/java/mapper/mapper2/tools/abator/core/test/abatortest/execute/flat/legacy/dao.xml URL: http://svn.apache.org/viewvc/ibatis/trunk/java/mapper/mapper2/tools/abator/core/test/abatortest/execute/flat/legacy/dao.xml?rev=431771&view=auto ============================================================================== --- ibatis/trunk/java/mapper/mapper2/tools/abator/core/test/abatortest/execute/flat/legacy/dao.xml (added) +++ ibatis/trunk/java/mapper/mapper2/tools/abator/core/test/abatortest/execute/flat/legacy/dao.xml Tue Aug 15 19:32:09 2006 @@ -0,0 +1,31 @@ +<!DOCTYPE daoConfig + PUBLIC "-//ibatis.apache.org//DTD DAO Configuration 2.0//EN" + "http://www.ibatis.com/dtd/dao-2.dtd";> + +<daoConfig> + <context> + <transactionManager type="SQLMAP"> + <property name="SqlMapConfigResource" + value="abatortest/execute/flat/legacy/SqlMapConfig.xml"/> + </transactionManager> + + <dao interface="abatortest.generated.flat.legacy.dao.FieldsblobsDAO" + implementation="abatortest.generated.flat.legacy.dao.FieldsblobsDAOImpl" /> + + <dao interface="abatortest.generated.flat.legacy.dao.FieldsonlyDAO" + implementation="abatortest.generated.flat.legacy.dao.FieldsonlyDAOImpl" /> + + <dao interface="abatortest.generated.flat.legacy.dao.PkblobsDAO" + implementation="abatortest.generated.flat.legacy.dao.PkblobsDAOImpl" /> + + <dao interface="abatortest.generated.flat.legacy.dao.PkfieldsblobsDAO" + implementation="abatortest.generated.flat.legacy.dao.PkfieldsblobsDAOImpl" /> + + <dao interface="abatortest.generated.flat.legacy.dao.PkfieldsDAO" + implementation="abatortest.generated.flat.legacy.dao.PkfieldsDAOImpl" /> + + <dao interface="abatortest.generated.flat.legacy.dao.PkonlyDAO" + implementation="abatortest.generated.flat.legacy.dao.PkonlyDAOImpl" /> + </context> + +</daoConfig>
