/**
* This method will instantiate all of the example instances and insert them into the database
* using the given session.
*/
public void populate(DatabaseSession session) {
UnitOfWork unitOfWork = session.acquireUnitOfWork();
unitOfWork.registerObject(Dist_Employee.example1());
unitOfWork.registerObject(Company.example1());
unitOfWork.commit();
}
public void test() {
Session session = getSession();
UnitOfWork uow = session.acquireUnitOfWork();
uow.setShouldNewObjectsBeCached(true);
Weather weather = new Weather();
weather.setStormPattern("Something really bad");
weather.id = 0;
ReadObjectQuery query = new ReadObjectQuery(weather);
query.checkCacheOnly();
Weather weatherClone = (Weather) uow.registerObject(weather);
weather = (Weather) uow.executeQuery(query);
zeroFailed = weather == null;
Weather weatherNeg = new Weather();
weatherNeg.setStormPattern("Something really bad below zero");
weatherNeg.id = -1;
ReadObjectQuery queryNeg = new ReadObjectQuery(weatherNeg);
queryNeg.checkCacheOnly();
Weather weatherNegClone = (Weather) uow.registerObject(weatherNeg);
weatherNeg = (Weather) uow.executeQuery(queryNeg);
negativeFailed = weatherNeg == null;
if (keepSequencing) {
uow.assignSequenceNumbers();
zeroOverridden = weatherClone.id != 0;
negativeOverridden = weatherNegClone.id != -1;
}
}
public void setup() {
mapping =
(ManyToManyMapping)
getSession()
.getProject()
.getDescriptor(DirectEntityMapHolder.class)
.getMappingForAttributeName("directToEntityMap");
oldPrivateOwnedValue = mapping.isPrivateOwned();
mapping.setIsPrivateOwned(usePrivateOwned);
UnitOfWork uow = getSession().acquireUnitOfWork();
holder = new DirectEntityMapHolder();
EntityMapValue value = new EntityMapValue();
value.setId(1);
holder.addDirectToEntityMapItem(new Integer(11), value);
EntityMapValue value2 = new EntityMapValue();
value2.setId(2);
holder.addDirectToEntityMapItem(new Integer(22), value2);
uow.registerObject(holder);
uow.registerObject(value);
uow.registerObject(value2);
uow.commit();
Object holderForComparison = uow.readObject(holder);
if (!compareObjects(holder, holderForComparison)) {
throw new TestErrorException("Objects do not match after write");
}
getSession().getIdentityMapAccessor().initializeAllIdentityMaps();
}
public void setup() {
mapping =
(ManyToManyMapping)
getSession()
.getProject()
.getDescriptor(AggregateEntityMapHolder.class)
.getMappingForAttributeName("aggregateToEntityMap");
oldFetchJoinValue = mapping.getJoinFetch();
mapping.setJoinFetch(fetchJoinRelationship);
getSession()
.getProject()
.getDescriptor(AggregateEntityMapHolder.class)
.reInitializeJoinedAttributes();
UnitOfWork uow = getSession().acquireUnitOfWork();
AggregateEntityMapHolder holder = new AggregateEntityMapHolder();
EntityMapValue value = new EntityMapValue();
value.setId(1);
AggregateMapKey key = new AggregateMapKey();
key.setKey(11);
holder.addAggregateToEntityMapItem(key, value);
EntityMapValue value2 = new EntityMapValue();
value2.setId(2);
key = new AggregateMapKey();
key.setKey(22);
holder.addAggregateToEntityMapItem(key, value2);
uow.registerObject(holder);
uow.registerObject(value);
uow.registerObject(value2);
uow.commit();
holderExp = (new ExpressionBuilder()).get("id").equal(holder.getId());
getSession().getIdentityMapAccessor().initializeAllIdentityMaps();
}
public void test() {
UnitOfWork uow = getSession().acquireUnitOfWork();
Employee managerClone = (Employee) uow.registerObject(employee[0]);
// remove all managed Employees (1 and 2)
managerClone.getManagedEmployees().clear();
// add to managed list new Employees (3 and 4)
Employee employee3Clone = (Employee) uow.registerObject(employee[3]);
Employee employee4Clone = (Employee) uow.registerObject(employee[4]);
managerClone.addManagedEmployee(employee3Clone);
managerClone.addManagedEmployee(employee4Clone);
// after commit the versions of all Employees should be changed.
uow.commit();
}
/** Create a new employee and commit. */
public void test() {
employee = (Employee) getSession().readObject(Employee.class, expression);
UnitOfWork uow = getSession().acquireUnitOfWork();
Employee employeeClone = (Employee) uow.registerObject(employee);
employeeClone.setSalary(employeeClone.getSalary() + 1);
manager = new Employee();
manager.setFirstName("Fred");
manager.setLastName("Fenster");
Employee managerClone = (Employee) uow.registerObject(manager);
employeeClone.setManager(managerClone);
uow.commit();
}
public void setup() {
// create 3 Employees.
employee = new Employee[3];
employee[0] = new Employee();
employee[0].setFirstName("Manager");
// 1 and 2 have manager 0.
employee[1] = new Employee();
employee[1].setFirstName("Employee_1");
employee[0].addManagedEmployee(employee[1]);
employee[2] = new Employee();
employee[2].setFirstName("Employee_2");
employee[0].addManagedEmployee(employee[2]);
// insert all the Employees into the db.
UnitOfWork uow = getSession().acquireUnitOfWork();
for (int i = 0; i < employee.length; i++) {
uow.registerObject(employee[i]);
}
uow.commit();
getSession().getIdentityMapAccessor().initializeAllIdentityMaps();
}
public void setup() {
// create 5 Employees.
employee = new Employee[5];
employee[0] = new Employee();
employee[0].setFirstName("Manager");
// 1 and 2 have manager 0.
employee[1] = new Employee();
employee[1].setFirstName("Employee_1");
employee[0].addManagedEmployee(employee[1]);
employee[2] = new Employee();
employee[2].setFirstName("Employee_2");
employee[0].addManagedEmployee(employee[2]);
// 3 and 4 don't have a manager.
employee[3] = new Employee();
employee[3].setFirstName("Employee_3");
employee[4] = new Employee();
employee[4].setFirstName("Employee_4");
// insert all the Employees into the db.
UnitOfWork uow = getSession().acquireUnitOfWork();
for (int i = 0; i < employee.length; i++) {
uow.registerObject(employee[i]);
}
uow.commit();
}
public void test() {
// test readAll
getSession().readAllObjects(Employee.class);
getSession().getIdentityMapAccessor().initializeIdentityMap(Employee.class);
// test readObject
Employee employee =
(Employee)
getSession().readObject(Employee.class, new ExpressionBuilder().get("id").equal(99));
// test delete with an employee read from the database
employee = (Employee) getSession().readObject(Employee.class);
try {
getAbstractSession().deleteObject(employee);
} catch (DatabaseException exc) {
// if we get an integrity exception here, the query went to the DB and was not redirected
redirectedDeleteObject = false;
}
UnitOfWork uow = getSession().acquireUnitOfWork();
// test update with an employee read from the database
employee = (Employee) uow.readObject(Employee.class);
employee.setFirstName(employee.getFirstName() + "-changed");
// insert an employee to test the insert behavior
employee = new Employee();
employee.setFirstName("Paul");
employee.setLastName("Sheldon");
uow.registerObject(employee);
uow.commit();
}
public void test() {
UnitOfWork uow = getSession().acquireUnitOfWork();
this.emp = Employee.example1();
this.emp.asset1.asset = Vehicle.example1();
uow.registerObject(this.emp);
uow.commit();
uow = getSession().acquireUnitOfWork();
Employee empClone = (Employee) uow.registerObject(this.emp);
Employee newClone = (Employee) empClone.clone();
((Vehicle) newClone.asset1.asset).make = "Beamer";
uow.deepMergeClone(newClone);
uow.commit();
if (!((AbstractSession) getSession()).compareObjects(newClone, this.emp)) {
throw new TestErrorException("Failed to merge the Variable 1 to 1 properly");
}
}
public void test() {
UnitOfWork uow = getSession().acquireUnitOfWork();
UnitOfWork nestedUow1 = uow.acquireUnitOfWork();
UnitOfWork nestedNestedUOW = nestedUow1.acquireUnitOfWork();
Employee employee = (Employee) new EmployeePopulator().basicEmployeeExample1();
employee.setId(new BigDecimal(15));
Employee nestedEmployee = (Employee) nestedNestedUOW.registerObject(employee);
nestedNestedUOW.commit();
nestedUow1.commit();
nestedUow1 = uow.acquireUnitOfWork();
nestedNestedUOW = nestedUow1.acquireUnitOfWork();
ReadObjectQuery query = new ReadObjectQuery();
query.setReferenceClass(Employee.class);
query.setSelectionCriteria(
new org.eclipse.persistence.expressions.ExpressionBuilder()
.get("id")
.equal(new BigDecimal(15)));
query.conformResultsInUnitOfWork();
nestedEmployee = (Employee) nestedNestedUOW.executeQuery(query);
nestedNestedUOW.deleteObject(nestedEmployee);
nestedNestedUOW.commit();
nestedUow1.commit();
if (!((UnitOfWorkImpl) uow).getNewObjectsCloneToOriginal().isEmpty()) {
throw new TestErrorException("Failed to unregister the Object in the nested unit of work");
}
}
public void test() {
UnitOfWork uow = getSession().acquireUnitOfWork();
this.sales = SalesPerson.example1();
this.sales = (SalesPerson) uow.registerObject(this.sales);
this.fieldOfficeClone = (FieldOffice) uow.readObject(FieldOffice.class);
this.sales.setFieldOffice(this.fieldOfficeClone);
uow.commit();
}
public void setup() {
deadlockDetected = false;
this.getExecutor().swapServerSession();
UnitOfWork uow = getSession().acquireUnitOfWork();
person = (ConcurrentPerson) uow.registerObject(new ConcurrentPerson());
person.name = "SomeoneSpecial";
project = (ConcurrentLargeProject) uow.registerObject(new ConcurrentLargeProject());
project.setName("ConcurrentRFJUOWLock Project");
ConcurrentAddress address = (ConcurrentAddress) uow.registerObject(new ConcurrentAddress());
address.setStreet("99 Bank St");
project.setLocation(address);
uow.commit();
uow.release();
}
public void test() {
UnitOfWork uow = ((SessionBroker) getSession()).acquireUnitOfWork();
for (int i = 0; i < NUM_INSERTS; i++) {
uow.registerObject(new Employee());
}
uow.commit();
}
public void test() {
this.employee =
(IsolatedEmployee) getSession().readObject(IsolatedEmployee.class, this.expression);
UnitOfWork uow = getSession().acquireUnitOfWork();
IsolatedEmployee employeeClone = (IsolatedEmployee) uow.registerObject(this.employee);
employeeClone.setSalary(employeeClone.getSalary() + 1000);
uow.commit();
}
public void test() {
Server server = this.getServerSession();
UnitOfWork uow = server.acquireUnitOfWork();
ConcurrentLargeProject clonedProject = (ConcurrentLargeProject) uow.registerObject(project);
clonedProject.getLocation().setPostalCode("K1P 1A4");
ConcurrentPerson clonedPerson = (ConcurrentPerson) uow.registerObject(person);
clonedPerson.setHobby(clonedProject);
uow.writeChanges();
Thread thread1 = new Thread(new ProjectReader(server.acquireClientSession(), project.getId()));
ConcurrentProject.RUNNING_TEST = ConcurrentProject.READ_WITH_UOW_LOCKS_TESTS;
// start reading Project, and have the thread wait while building DTF mappings
thread1.start();
try {
thread1.join(
1000); // wait a token amount to be sure that thread1 isn't starved before getting
// deferred lock on Project.
} catch (InterruptedException ex) {
}
// start uow commit, which will get locks on Person+Address, commit, then merge.
// merge should get a deferred lock on Project.
Thread thread2 = new Thread(new UOWCommit(uow));
thread2.start();
// while waiting, thread1 should wake and try to get a lock on Address. It will deadlock if it
// tries to get an active lock, since they will be held by the UOW which can't complete until
// thread1
// releases.
try {
thread1.join(20000);
if (thread1.isAlive()) {
try {
thread1.interrupt();
thread2.interrupt();
} catch (Exception e) {
}
deadlockDetected = true;
}
} catch (InterruptedException ex) {
}
}
/** This method was created in VisualAge. */
public void test() {
// READ A GRASSHOPPER
GrassHopper grassHopper = (GrassHopper) getSession().readObject(GrassHopper.class);
// MODIFY THE GRASSHOPPER
UnitOfWork uow = getSession().acquireUnitOfWork();
GrassHopper tempGrassHopper = (GrassHopper) uow.registerObject(grassHopper);
tempGrassHopper.setGh_maximumJump(new Integer(150));
uow.commit();
}
protected void test() {
// Read in a Country.
aCountry = (Country) uow.readObject(Country.class);
oldName = aCountry.getName();
// Update the country and commit. Nothing should be written to the db.
uow.registerObject(aCountry);
aCountry.setName(aCountry.getName() + " 22");
uow.commit();
}
protected void test() {
UnitOfWork uow = getSession().acquireUnitOfWork();
Employee empInsert = new Employee();
empInsert.setFirstName("TestPerson");
empInsert.setFemale();
empInsert.setLastName("Smith");
empInsert.setSalary(55555);
uow.registerObject(empInsert);
uow.commit();
}
protected void changeObject() {
UnitOfWork uow = (UnitOfWork) getSession();
Employee cloneEmployee = (Employee) workingCopy;
for (int i = 0; i < managedEmployeesToAdd.size(); i++) {
Employee cloneEmployeeToAdd = (Employee) uow.registerObject(managedEmployeesToAdd.get(i));
cloneEmployee.addManagedEmployee(cloneEmployeeToAdd);
}
for (int i = 0; i < managedEmployeesToRemove.size(); i++) {
Employee cloneEmployeeToRemove =
(Employee) uow.registerObject(managedEmployeesToRemove.get(i));
cloneEmployee.removeManagedEmployee(cloneEmployeeToRemove);
}
for (int i = 0; i < phonesToRemove.size(); i++) {
PhoneNumber clonePhoneToRemove = (PhoneNumber) uow.registerObject(phonesToRemove.get(i));
cloneEmployee.removePhoneNumber(clonePhoneToRemove);
}
for (int i = 0; i < phonesToAdd.size(); i++) {
PhoneNumber clonePhoneToAdd = (PhoneNumber) uow.registerObject(phonesToAdd.get(i));
cloneEmployee.addPhoneNumber(clonePhoneToAdd);
}
}
/** This method was created in VisualAge. */
protected void setup() {
getAbstractSession().beginTransaction();
// CREATE A GRASSHOPPER
GrassHopper grassHopper = new GrassHopper();
grassHopper.setIn_numberOfLegs(new Integer(6));
grassHopper.setGh_maximumJump(new Integer(100));
// ADD THE GRASSHOPPER TO THE DATABASE
UnitOfWork uow = getSession().acquireUnitOfWork();
uow.registerObject(grassHopper);
uow.commit();
}
public void test() {
transport = Transport.example6();
UnitOfWork uow = getSession().acquireUnitOfWork();
uow.registerObject(transport);
uow.commit();
transportId = transport.getId();
DatabaseSession session = (DatabaseSession) getSession();
ExpressionBuilder exp = new ExpressionBuilder();
Expression expression = exp.get("id").equal(transportId);
transport = (Transport) session.readObject(Transport.class, expression);
}
/** This method was created in VisualAge. */
public void test() {
// Insert a car
org.eclipse.persistence.sessions.UnitOfWork uow = getSession().acquireUnitOfWork();
uow.registerObject(this.theCar);
uow.commit();
// Get the car's ID
Car carRead = (Car) getSession().readObject(this.theCar);
this.carID = carRead.id;
// Initialize idmaps
getSession().getIdentityMapAccessor().initializeAllIdentityMaps();
}
/** Insert address and then reset database/cache. */
public void test() throws Exception {
UnitOfWork uow = getSession().acquireUnitOfWork();
Address address = new Address();
address.setCity("NewCity");
address.setPostalCode("N5J2N5");
address.setProvince("ON");
address.setStreet("1111 Mountain Blvd. Floor 13, suite 1");
address.setCountry("Canada");
uow.registerObject(address);
uow.commit();
getSession().getIdentityMapAccessor().initializeAllIdentityMaps();
getSession().executeNonSelectingCall(new SQLCall("Delete from ADDRESS where CITY = 'NewCity'"));
}
public void setup() {
if (getSession().isDistributedSession()) {
throw new TestWarningException(
"Test unavailable on Remote UnitOfWork because of timing issues");
}
getSession().getIdentityMapAccessor().initializeAllIdentityMaps();
getSession().getDescriptor(ConcurrentAddress.class).getEventManager().addListener(listener);
UnitOfWork uow = getSession().acquireUnitOfWork();
this.person = ConcurrentPerson.example1();
// get the UOW clone to ensure the PK will be set in the case of Isolate in UOW test model
this.person = (ConcurrentPerson) uow.registerObject(this.person);
uow.commit();
ConcurrentAddress.RUNNING_TEST = ConcurrentAddress.LOCK_ON_CLONE_TEST;
}
public void test() {
UnitOfWork uow = getSession().acquireUnitOfWork();
cat = new Cat();
cat.setName("Bud");
appt = new VetAppointment();
appt.setCost(100);
List appts = new ArrayList();
appts.add(appt);
appt.getAnimal().setValue(cat);
uow.registerObject(cat);
uow.registerObject(appt);
uow.commit();
cat = (Cat) getSession().refreshObject(cat);
appt = (VetAppointment) getSession().refreshObject(appt);
catVersion = cat.getVersion();
apptVersion = appt.getVersion();
getSession().getIdentityMapAccessor().initializeAllIdentityMaps();
uow = getSession().acquireUnitOfWork();
cat = (Cat) uow.readObject(cat);
appt = (VetAppointment) cat.getAppointments().get(0);
appt.setCost(99);
uow.commit();
}
public void setup() {
if (!(getSession().getPlatform() instanceof Oracle9Platform)) {
throw new TestWarningException(
"Test is only supported on Oracle9 platform and above, as TIMESTAMPTZ is used");
}
Oracle9Platform platform = (Oracle9Platform) getSession().getPlatform();
// this.oldPrintingValue = platform.getPrintCalendarIntoTimestampTZ();
this.oldBindingValue = platform.shouldBindAllParameters();
// platform.setPrintCalendarIntoTimestampTZ(Boolean.TRUE);
platform.setShouldBindAllParameters(true);
// write myself out
UnitOfWork uow = getSession().acquireUnitOfWork();
uow.registerObject(this);
uow.commit();
}
public void setup() {
mapping =
(DirectCollectionMapping)
getSession()
.getProject()
.getDescriptor(DirectDirectMapHolder.class)
.getMappingForAttributeName("directToDirectMap");
oldFetchJoinValue = mapping.getJoinFetch();
mapping.setJoinFetch(fetchJoinRelationship);
getSession()
.getProject()
.getDescriptor(DirectDirectMapHolder.class)
.reInitializeJoinedAttributes();
UnitOfWork uow = getSession().acquireUnitOfWork();
DirectDirectMapHolder holder = new DirectDirectMapHolder();
holder.addDirectToDirectMapItem(new Integer(1), new Integer(1));
holder.addDirectToDirectMapItem(new Integer(2), new Integer(2));
uow.registerObject(holder);
uow.commit();
holderExp = (new ExpressionBuilder()).get("id").equal(holder.getId());
getSession().getIdentityMapAccessor().initializeAllIdentityMaps();
}
public void populate(DatabaseSession session) {
PopulationManager manager = PopulationManager.getDefaultManager();
Cat cat = Cat.example1();
session.writeObject(cat);
manager.registerObject(cat, "catExample1");
Dog dog = Dog.example1();
session.writeObject(dog);
manager.registerObject(dog, "dogExample1");
cat = Cat.example2();
session.writeObject(cat);
manager.registerObject(cat, "catExample2");
dog = Dog.example2();
session.writeObject(dog);
manager.registerObject(dog, "dogExample2");
cat = Cat.example3();
session.writeObject(cat);
manager.registerObject(cat, "catExample3");
dog = Dog.example3();
session.writeObject(dog);
manager.registerObject(dog, "dogExample3");
Company company = Company.example1();
session.writeObject(company);
manager.registerObject(company, "example1");
manager.registerObject(((Vector) company.getVehicles().getValue()).firstElement(), "example1");
company = Company.example2();
session.writeObject(company);
manager.registerObject(company, "example2");
company = Company.example3();
session.writeObject(company);
manager.registerObject(company, "example3");
Person person = Person.example1();
session.writeObject(person);
manager.registerObject(person, "example1");
// populate the data for duplicate field testing
session.writeObject(A_King2.exp1());
session.writeObject(A_King2.exp2());
session.writeObject(A_1_King2.exp3());
session.writeObject(A_2_King2.exp4());
session.writeObject(A_2_1_King2.exp5());
UnitOfWork unitOfWork = session.acquireUnitOfWork();
person = Person.example2();
unitOfWork.registerObject(person);
unitOfWork.commit();
manager.registerObject(person, "example2");
manager.registerObject(person.bestFriend, "example5");
manager.registerObject(person.representitive, "example4");
person = Person.example3();
session.writeObject(person);
manager.registerObject(person, "example3");
Computer computer = Computer.example1();
session.writeObject(computer);
manager.registerObject(computer, "example1");
computer = Computer.example2();
session.writeObject(computer);
manager.registerObject(computer, "example2");
computer = Computer.example3();
session.writeObject(computer);
manager.registerObject(computer, "example3");
computer = Computer.example4();
session.writeObject(computer);
manager.registerObject(computer, "example4");
computer = Computer.example5();
session.writeObject(computer);
manager.registerObject(computer, "example5");
JavaProgrammer JP = JavaProgrammer.example1();
session.writeObject(JP);
manager.registerObject(JP, "example1");
JP = JavaProgrammer.example2();
session.writeObject(JP);
manager.registerObject(JP, "example2");
// Added to test bug 3019934.
unitOfWork = session.acquireUnitOfWork();
Alligator alligator = new Alligator();
alligator.setFavoriteSwamp("Florida");
alligator.setLatestVictim(JavaProgrammer.steve());
unitOfWork.registerObject(alligator);
manager.registerObject(alligator, "example1");
unitOfWork.commit();
// Added to test bug 6111278
unitOfWork = session.acquireUnitOfWork();
Entomologist bugguy = new Entomologist();
bugguy.setId((int) System.currentTimeMillis());
bugguy.setName("Gary");
bugguy = (Entomologist) unitOfWork.registerObject(bugguy);
Insect insect = new GrassHopper();
insect.setIn_numberOfLegs(4);
insect.setEntomologist(bugguy);
bugguy.getInsectCollection().add(insect);
unitOfWork.commit();
}
public void populate(DatabaseSession session) {
Object instance;
PopulationManager manager = PopulationManager.getDefaultManager();
instance = LockInCache.example1();
session.writeObject(instance);
manager.registerObject(instance, "Cache example1");
instance = LockInCache.example2();
session.writeObject(instance);
manager.registerObject(instance, "Cache example2");
instance = LockInCache.example3();
session.writeObject(instance);
manager.registerObject(instance, "Cache example3");
instance = LockInObject.example1();
session.writeObject(instance);
manager.registerObject(instance, "Object example1");
instance = LockInObject.example2();
session.writeObject(instance);
manager.registerObject(instance, "Object example2");
instance = LockInObject.example3();
session.writeObject(instance);
manager.registerObject(instance, "Object example3");
instance = TimestampInCache.example1();
session.writeObject(instance);
manager.registerObject(instance, "Cache TS example1");
instance = TimestampInCache.example2();
session.writeObject(instance);
manager.registerObject(instance, "Cache TS example2");
instance = TimestampInCache.example3();
session.writeObject(instance);
manager.registerObject(instance, "Cache TS example3");
instance = TimestampInObject.example1();
session.writeObject(instance);
manager.registerObject(instance, "Object TS example1");
instance = TimestampInObject.example2();
session.writeObject(instance);
manager.registerObject(instance, "Object TS example2");
instance = TimestampInObject.example3();
session.writeObject(instance);
manager.registerObject(instance, "Object TS example3");
instance = ChangedRow.example1();
session.writeObject(instance);
manager.registerObject(instance, "ChangedRow example1");
instance = ChangedRow.example2();
session.writeObject(instance);
manager.registerObject(instance, "ChangedRow example2");
instance = ChangedRow.example3();
session.writeObject(instance);
manager.registerObject(instance, "ChangedRow example3");
instance = TimestampInAggregateObject.example1();
session.writeObject(instance);
manager.registerObject(instance, "Aggregate Object TS example1");
instance = TimestampInAggregateObject.example2();
session.writeObject(instance);
manager.registerObject(instance, "Aggregate Object TS example2");
instance = TimestampInAggregateObject.example3();
session.writeObject(instance);
manager.registerObject(instance, "Aggregate Object TS example3");
instance = LockInAggregateObject.example1();
session.writeObject(instance);
manager.registerObject(instance, "Lock Object TS example1");
instance = LockInAggregateObject.example2();
session.writeObject(instance);
manager.registerObject(instance, "Lock Object TS example2");
instance = LockInAggregateObject.example3();
session.writeObject(instance);
manager.registerObject(instance, "Lock Object TS example3");
UnitOfWork uow = session.acquireUnitOfWork();
instance = uow.registerObject(RockBand.example1());
manager.registerObject(instance, "RockBand example1");
instance = uow.registerObject(RockBand.example2());
manager.registerObject(instance, "RockBand example2");
uow.commit();
}
