210 lines
6.5 KiB
JavaScript
210 lines
6.5 KiB
JavaScript
/*
|
|
Copyright (c) 2013, Oracle and/or its affiliates. All rights
|
|
reserved.
|
|
|
|
This program is free software; you can redistribute it and/or
|
|
modify it under the terms of the GNU General Public License
|
|
as published by the Free Software Foundation; version 2 of
|
|
the License.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program; if not, write to the Free Software
|
|
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
|
|
02110-1301 USA
|
|
*/
|
|
"use strict";
|
|
|
|
/** The t_basic domain object */
|
|
global.converter = function(id, name, status, magic) {
|
|
if (typeof id !== 'undefined') this.id = id;
|
|
if (typeof name !== 'undefined') this.name = name;
|
|
if (typeof status !== 'undefined') this.status = status;
|
|
if (typeof magic !== 'undefined') this.magic = magic;
|
|
};
|
|
global.converter.prototype.getStatus = function() {
|
|
return this.status;
|
|
};
|
|
|
|
var STATUS = {
|
|
NEVER_MARRIED: {value: 0, code: 'N', name: 'NEVER_MARRIED'},
|
|
MARRIED: {value: 1, code: 'M', name: 'MARRIED'},
|
|
DIVORCED: {value: 2, code: 'D', name: 'DIVORCED'},
|
|
lookup: function(value) {
|
|
switch (value) {
|
|
case 0: return this.NEVER_MARRIED;
|
|
case 1: return this.MARRIED;
|
|
case 2: return this.DIVORCED;
|
|
default: return null;
|
|
}
|
|
}
|
|
};
|
|
|
|
// column converter for status
|
|
var statusConverter = {
|
|
toDB: function toDB(status) {
|
|
return status.value;
|
|
},
|
|
fromDB: function fromDB(value) {
|
|
return STATUS.lookup(value);
|
|
}
|
|
};
|
|
|
|
//map t_basic domain object
|
|
var tablemapping = new mynode.TableMapping('test.t_basic');
|
|
tablemapping.mapAllColumns = false;
|
|
tablemapping.mapField('id');
|
|
tablemapping.mapField('status', 'age', statusConverter);
|
|
tablemapping.mapField('name');
|
|
tablemapping.mapField('magic');
|
|
tablemapping.applyToClass(global.converter);
|
|
|
|
/** Test the toDB and fromDB functions */
|
|
var t0 = new harness.ConcurrentTest('testStatusColumnConverter');
|
|
t0.run = function() {
|
|
var testCase = this;
|
|
this.errorIfNotEqual('toDB', 1, statusConverter.toDB(STATUS.MARRIED));
|
|
this.errorIfNotEqual('fromDB', STATUS.DIVORCED, statusConverter.fromDB(2));
|
|
this.failOnError();
|
|
};
|
|
|
|
/***** Persist with domain object ***/
|
|
var t1 = new harness.ConcurrentTest('testFieldColumnConverter');
|
|
t1.run = function() {
|
|
var testCase = this;
|
|
// create the domain object 4090
|
|
var object = new global.converter(4090, 'Employee 4090', STATUS.MARRIED, 4090);
|
|
fail_openSession(testCase, function(session) {
|
|
session.persist(object, function(err) {
|
|
if (err) {
|
|
testCase.fail(err);
|
|
return;
|
|
}
|
|
// key and testCase are passed to fail_verify_t_basic as extra parameters
|
|
session.find(global.converter, 4090, function(err, instance) {
|
|
var id = 4090;
|
|
if (err) {
|
|
testCase.fail(err);
|
|
} else {
|
|
if (typeof(instance) !== 'object') {
|
|
testCase.appendErrorMessage('Result for id ' + id + ' is not an object; actual type: ' + typeof(instance));
|
|
} else {
|
|
if (instance === null) {
|
|
testCase.appendErrorMessage('Result for id ' + id + ' is null.');
|
|
} else {
|
|
if (typeof(instance.getStatus) !== 'function') {
|
|
testCase.appendErrorMessage('Result for id ' + id + ' is not a domain object');
|
|
}
|
|
testCase.errorIfNotEqual('fail to verify id', id, instance.id);
|
|
testCase.errorIfNotEqual('fail to verify status', STATUS.MARRIED, instance.status);
|
|
testCase.errorIfNotEqual('fail to verify name', 'Employee ' + id, instance.name);
|
|
testCase.errorIfNotEqual('fail to verify magic', id, instance.magic);
|
|
}
|
|
}
|
|
}
|
|
testCase.failOnError();
|
|
});
|
|
});
|
|
});
|
|
};
|
|
|
|
var t2 = new harness.ConcurrentTest('testPerformance');
|
|
t2.converter = {
|
|
toDB: function toDB(value) {
|
|
return value;
|
|
},
|
|
fromDB: function fromDB(dbValue) {
|
|
return dbValue;
|
|
}
|
|
};
|
|
|
|
/** Always use convert function */
|
|
t2.convert1 = function(value) {
|
|
return t2.converter.toDB(value);
|
|
};
|
|
|
|
/** Only use convert function if it is defined */
|
|
t2.convert2 = function(value) {
|
|
if (t2.converter999) {
|
|
return t2.converter999.toDB(value);
|
|
}
|
|
return value;
|
|
};
|
|
|
|
/** Only use convert function if it is not undefined */
|
|
t2.convert3 = function(value) {
|
|
if (typeof t2.converter999 !== 'undefined') {
|
|
return t2.converter999.toDB(value);
|
|
}
|
|
return value;
|
|
};
|
|
|
|
/** Only use convert function if it is a function */
|
|
t2.convert4 = function(value) {
|
|
if (typeof t2.converter999 === 'function') {
|
|
return t2.converter999.toDB(value);
|
|
}
|
|
return value;
|
|
};
|
|
|
|
t2.Timer = function(name, iterations) {
|
|
this.name = name;
|
|
this.startTime = Date.now();
|
|
console.log(this.startTime);
|
|
this.iterations = iterations;
|
|
};
|
|
t2.Timer.prototype.stop = function() {
|
|
var now = Date.now();
|
|
console.log(now);
|
|
var elapsed = Date.now() - this.startTime;
|
|
var average = elapsed * 1000000 / this.iterations;
|
|
console.log(this.name, 'elapsed time in milliseconds', elapsed, 'average microseconds per iteration', average);
|
|
};
|
|
|
|
t2.run = function() {
|
|
var testCase = this;
|
|
var i, numberOfIterations = 100000000;
|
|
var r, numberOfRuns = 5;
|
|
var value;
|
|
// test performance of empty converter
|
|
for (r = 0; r < numberOfRuns; ++r) {
|
|
var timer1 = new this.Timer(' empty converter', numberOfIterations);
|
|
for (i = 0; i < numberOfIterations; ++i) {
|
|
value = this.convert1(i);
|
|
}
|
|
timer1.stop();
|
|
}
|
|
for (r = 0; r < numberOfRuns; ++r) {
|
|
var timer2 = new this.Timer(' if (converter)', numberOfIterations);
|
|
// test performance of if then converter
|
|
for (i = 0; i < numberOfIterations; ++i) {
|
|
value = this.convert2(i);
|
|
}
|
|
timer2.stop();
|
|
}
|
|
for (r = 0; r < numberOfRuns; ++r) {
|
|
var timer3 = new this.Timer('if typeof converter !== undefined', numberOfIterations);
|
|
// test performance of if then converter
|
|
for (i = 0; i < numberOfIterations; ++i) {
|
|
value = this.convert3(i);
|
|
}
|
|
timer3.stop();
|
|
}
|
|
for (r = 0; r < numberOfRuns; ++r) {
|
|
var timer4 = new this.Timer(' if typeof converter === function', numberOfIterations);
|
|
// test performance of if then converter
|
|
for (i = 0; i < numberOfIterations; ++i) {
|
|
value = this.convert4(i);
|
|
}
|
|
timer4.stop();
|
|
}
|
|
testCase.pass();
|
|
};
|
|
|
|
/*************** EXPORT THE TOP-LEVEL GROUP ********/
|
|
module.exports.tests = [t1];
|