private void loadExtensionsFromClassloaders(
Map<String, DefaultCoreExtension> extensions, DefaultCoreExtensionRepository repository) {
Set<URL> mavenURLs = ClasspathHelper.forPackage(MAVENPACKAGE);
ConfigurationBuilder configurationBuilder = new ConfigurationBuilder();
configurationBuilder.setScanners(new ResourcesScanner());
configurationBuilder.setUrls(mavenURLs);
configurationBuilder.filterInputsBy(
new FilterBuilder.Include(FilterBuilder.prefix(MAVENPACKAGE)));
Reflections reflections = new Reflections(configurationBuilder);
Set<String> descriptors = reflections.getResources(Predicates.equalTo("pom.xml"));
for (String descriptor : descriptors) {
URL descriptorUrl = getClass().getClassLoader().getResource(descriptor);
try {
DefaultCoreExtension coreExtension = parseMavenPom(descriptorUrl, repository);
extensions.put(coreExtension.getId().getId(), coreExtension);
} catch (Exception e) {
this.logger.warn("Failed to pase extension descriptor [{}]", descriptorUrl, e);
}
}
// Try to find more
guess(extensions, repository);
}
public static Set<Class<?>> getTypesAnnotatedWith(
Class<? extends Annotation> annotation, ClassLoader... classLoaders) throws Exception {
Set<Class<?>> implementations;
implementations = (Set<Class<?>>) classesCache.get(annotation);
ConfigurationBuilder cb =
new ConfigurationBuilder()
.setUrls(ClasspathHelper.forPackage("es.caib"))
.setScanners(new SubTypesScanner(), new TypeAnnotationsScanner());
if (classLoaders != null && classLoaders.length != 0) {
cb.addClassLoaders(classLoaders);
}
if (implementations == null) {
implementations = new HashSet<Class<?>>();
Reflections ref = new Reflections(cb);
Set<Class<?>> tmp = ref.getTypesAnnotatedWith(annotation);
implementations.addAll(tmp);
classesCache.put(annotation, implementations);
}
return implementations;
}
private Iterator<Resource> getFilesFromParams() throws IOException {
System.err.printf(
"%s system property not specified, using 'dir'" + " parameter from configuration file\n",
DIR_PROPERTY);
String resource = (String) getConfigParameterValue("dir");
String suffix = (String) getConfigParameterValue("suffix");
if (resource != null) {
System.err.printf("Reading files from classpath directory: %s\n", resource);
Reflections reflections =
new Reflections(
new ConfigurationBuilder()
.setUrls(ClasspathHelper.forPackage(""))
.setScanners(new ResourcesScanner()));
Set<String> files = reflections.getResources(Pattern.compile(".*\\." + suffix));
Collection<Resource> resources =
Collections2.transform(files, new StringToResourceFunction("/"));
final Pattern p = Pattern.compile("^" + resource);
Collection<Resource> filtered =
Collections2.filter(
resources,
new Predicate<Resource>() {
@Override
public boolean apply(Resource input) {
Matcher m = p.matcher(input.name);
return m.find();
}
});
return filtered.iterator();
} else {
throw new IOException(String.format("Parameter 'dir' must be specified"));
}
}
/**
* Create a package inspector that looks for the specified type.
*
* @param classType the type of class to look for in the package
*/
public PackageInspector(Class<ClassType> classType, String packageName) {
Set<URL> classPath = ClasspathHelper.forPackage(packageName);
ConfigurationBuilder config = new ConfigurationBuilder();
config.setUrls(classPath);
config.setScanners(new SubTypesScanner());
this.reflections = new Reflections(config);
this.classType = classType;
this.packageName = packageName;
}
@Programmatic
@Override
public <T> Set<Class<? extends T>> findSubTypesOfClasses(Class<T> type, String packagePrefix) {
Vfs.setDefaultURLTypes(getUrlTypes());
final Reflections reflections =
new Reflections(
ClasspathHelper.forClassLoader(Thread.currentThread().getContextClassLoader()),
ClasspathHelper.forClass(Object.class),
ClasspathHelper.forPackage(packagePrefix),
new SubTypesScanner(false));
return reflections.getSubTypesOf(type);
}
/**
* collect saved Reflections resources from all urls that contains the given packagePrefix and
* matches the given resourceNameFilter and de-serializes them using the default serializer {@link
* org.reflections.serializers.XmlSerializer} or using the optionally supplied optionalSerializer
*
* <p>it is preferred to use a designated resource prefix (for example META-INF/reflections but
* not just META-INF), so that relevant urls could be found much faster
*
* @param optionalSerializer - optionally supply one serializer instance. if not specified or
* null, {@link org.reflections.serializers.XmlSerializer} will be used
*/
public static Reflections collect(
final String packagePrefix,
final Predicate<String> resourceNameFilter,
@Nullable Serializer... optionalSerializer) {
Serializer serializer =
optionalSerializer != null && optionalSerializer.length == 1
? optionalSerializer[0]
: new XmlSerializer();
Collection<URL> urls = ClasspathHelper.forPackage(packagePrefix);
if (urls.isEmpty()) return null;
long start = System.currentTimeMillis();
final Reflections reflections = new Reflections();
Iterable<Vfs.File> files = Vfs.findFiles(urls, packagePrefix, resourceNameFilter);
for (final Vfs.File file : files) {
InputStream inputStream = null;
try {
inputStream = file.openInputStream();
reflections.merge(serializer.read(inputStream));
} catch (IOException e) {
throw new ReflectionsException("could not merge " + file, e);
} finally {
close(inputStream);
}
}
if (log != null) {
Store store = reflections.getStore();
int keys = 0;
int values = 0;
for (String index : store.keySet()) {
keys += store.get(index).keySet().size();
values += store.get(index).size();
}
log.info(
format(
"Reflections took %d ms to collect %d url%s, producing %d keys and %d values [%s]",
System.currentTimeMillis() - start,
urls.size(),
urls.size() > 1 ? "s" : "",
keys,
values,
Joiner.on(", ").join(urls)));
}
return reflections;
}
public ClassDiscoveryImpl(String pkg) {
this.pkg = pkg;
configuration = new ConfigurationBuilder();
final Predicate<String> filter = new FilterBuilder.Include(FilterBuilder.prefix(pkg));
configuration.setUrls(ClasspathHelper.forPackage(pkg));
configuration.filterInputsBy(filter);
configuration.setScanners(new TypeAnnotationsScanner().filterResultsBy(filter));
store = new Store(configuration);
for (Scanner scanner : configuration.getScanners()) {
scanner.setConfiguration(configuration);
scanner.setStore(store.get(scanner));
}
index();
}
/** 通过扫描，获取反射对象 */
private Reflections getReflection(List<String> packNameList) {
//
// filter
//
FilterBuilder filterBuilder = new FilterBuilder().includePackage(Constants.DISCONF_PACK_NAME);
for (String packName : packNameList) {
filterBuilder = filterBuilder.includePackage(packName);
}
Predicate<String> filter = filterBuilder;
//
// urls
//
Collection<URL> urlTotals = new ArrayList<URL>();
for (String packName : packNameList) {
Set<URL> urls = ClasspathHelper.forPackage(packName);
urlTotals.addAll(urls);
}
//
Reflections reflections =
new Reflections(
new ConfigurationBuilder()
.filterInputsBy(filter)
.setScanners(
new SubTypesScanner().filterResultsBy(filter),
new TypeAnnotationsScanner().filterResultsBy(filter),
new FieldAnnotationsScanner().filterResultsBy(filter),
new MethodAnnotationsScanner().filterResultsBy(filter),
new MethodParameterScanner())
.setUrls(urlTotals));
return reflections;
}
public abstract class AbstractRemoteSerializationTest extends JbpmJUnitBaseTestCase {
protected static final Logger logger =
LoggerFactory.getLogger(AbstractRemoteSerializationTest.class);
protected enum TestType {
JAXB,
JSON,
YAML;
}
public abstract TestType getType();
public abstract void addClassesToSerializationProvider(Class<?>... extraClass);
public abstract <T> T testRoundTrip(T in) throws Exception;
private static Reflections reflections =
new Reflections(
ClasspathHelper.forPackage("org.kie.services.client"),
ClasspathHelper.forPackage("org.kie.remote"),
new TypeAnnotationsScanner(),
new SubTypesScanner());
// TESTS
/*
* Tests
*/
@Test
public void jaxbClassesTest() throws Exception {
Assume.assumeTrue(TestType.JAXB.equals(getType()));
Set<Class<?>> jaxbClasses = reflections.getTypesAnnotatedWith(XmlRootElement.class);
assertTrue("Not enough classes found! [" + jaxbClasses.size() + "]", jaxbClasses.size() > 20);
String className = null;
try {
for (Class<?> jaxbClass : jaxbClasses) {
if (jaxbClass.getDeclaringClass() != null
&& jaxbClass.getDeclaringClass().getSimpleName().endsWith("Test")) {
continue;
}
className = jaxbClass.getName();
Constructor<?> construct = jaxbClass.getConstructor(new Class[] {});
Object jaxbInst = construct.newInstance(new Object[] {});
testRoundTrip(jaxbInst);
}
} catch (Exception e) {
e.printStackTrace();
fail(className + ": " + e.getClass().getSimpleName() + " [" + e.getMessage() + "]");
}
}
@Test
public void genericResponseTest() throws Exception {
JaxbGenericResponse resp = new JaxbGenericResponse();
resp.setMessage("error");
resp.setStatus(JaxbRequestStatus.SUCCESS);
resp.setUrl("http://here");
testRoundTrip(resp);
}
@Test
public void exceptionTest() throws Exception {
Assume.assumeFalse(getType().equals(TestType.YAML));
JaxbExceptionResponse resp = new JaxbExceptionResponse();
resp.setMessage("error");
resp.setStatus(JaxbRequestStatus.SUCCESS);
resp.setUrl("http://here");
RuntimeException re = new RuntimeException();
resp.setCause(re);
testRoundTrip(resp);
}
@Test
public void variablesResponseTest() throws Exception {
JaxbVariablesResponse resp = new JaxbVariablesResponse();
testRoundTrip(resp);
Map<String, String> vars = new HashMap<String, String>();
vars.put("one", "two");
resp.setVariables(vars);
testRoundTrip(resp);
}
@Test
public void historyLogListTest() throws Exception {
JaxbHistoryLogList resp = new JaxbHistoryLogList();
testRoundTrip(resp);
// vLog
org.jbpm.process.audit.VariableInstanceLog vLog =
new org.jbpm.process.audit.VariableInstanceLog(
23, "process", "varInst", "var", "two", "one");
vLog.setExternalId("domain");
Field dateField = org.jbpm.process.audit.VariableInstanceLog.class.getDeclaredField("date");
dateField.setAccessible(true);
dateField.set(vLog, new Date());
Field idField = org.jbpm.process.audit.VariableInstanceLog.class.getDeclaredField("id");
idField.setAccessible(true);
idField.set(vLog, 32l);
resp.getHistoryLogList().add(new JaxbVariableInstanceLog(vLog));
// pLog
org.jbpm.process.audit.ProcessInstanceLog pLog =
new org.jbpm.process.audit.ProcessInstanceLog(23, "process");
pLog.setDuration(2000l);
pLog.setEnd(new Date());
pLog.setExternalId("domain");
pLog.setIdentity("id");
pLog.setOutcome("error");
pLog.setParentProcessInstanceId(42);
pLog.setProcessName("name");
pLog.setProcessVersion("1-SNAP");
pLog.setStatus(2);
idField = org.jbpm.process.audit.ProcessInstanceLog.class.getDeclaredField("id");
idField.setAccessible(true);
idField.set(pLog, 32l);
resp.getHistoryLogList().add(new JaxbProcessInstanceLog(pLog));
// nLog
org.jbpm.process.audit.NodeInstanceLog nLog =
new org.jbpm.process.audit.NodeInstanceLog(0, 23, "process", "nodeInst", "node", "wally");
idField = org.jbpm.process.audit.NodeInstanceLog.class.getDeclaredField("id");
idField.setAccessible(true);
idField.set(nLog, 32l);
dateField = org.jbpm.process.audit.NodeInstanceLog.class.getDeclaredField("date");
dateField.setAccessible(true);
dateField.set(nLog, new Date());
nLog.setNodeType("type");
nLog.setWorkItemId(88l);
nLog.setConnection("connex");
nLog.setExternalId("domain");
resp.getHistoryLogList().add(new JaxbNodeInstanceLog(nLog));
testRoundTrip(resp);
}
@Test
public void processInstanceWithVariablesTest() throws Exception {
this.setupDataSource = true;
this.sessionPersistence = true;
super.setUp();
RuntimeEngine runtimeEngine =
createRuntimeManager("BPMN2-StringStructureRef.bpmn2").getRuntimeEngine(null);
KieSession ksession = runtimeEngine.getKieSession();
Map<String, Object> params = new HashMap<String, Object>();
String val = "initial-val";
params.put("test", val);
ProcessInstance processInstance = ksession.startProcess("StructureRef");
assertTrue(processInstance.getState() == ProcessInstance.STATE_ACTIVE);
Map<String, Object> res = new HashMap<String, Object>();
res.put("testHT", "test value");
// ksession.getWorkItemManager().completeWorkItem(workItemHandler.getWorkItem().getId(),
// res);
Map<String, String> map = new HashMap<String, String>();
map.put("test", "initial-val");
JaxbProcessInstanceWithVariablesResponse jpiwvr =
new JaxbProcessInstanceWithVariablesResponse(processInstance, map);
testRoundTrip(jpiwvr);
JaxbProcessInstanceListResponse jpilp = new JaxbProcessInstanceListResponse();
List<ProcessInstance> procInstList = new ArrayList<ProcessInstance>();
procInstList.add(new JaxbProcessInstanceResponse(processInstance));
jpilp.setResult(procInstList);
testRoundTrip(jpilp);
super.tearDown();
this.setupDataSource = false;
this.sessionPersistence = false;
}
@Test
public void workItemObjectTest() throws Exception {
// Don't run with YAML?
Assume.assumeFalse(getType().equals(TestType.YAML));
JaxbWorkItemResponse workitemObject = new JaxbWorkItemResponse();
workitemObject.setId(35l);
workitemObject.setName("Clau");
workitemObject.setState(0);
workitemObject.setProcessInstanceId(1l);
Map<String, Object> params = new HashMap<String, Object>();
params.put("test", "driving");
workitemObject.setParameters(params);
JaxbWorkItemResponse roundTripWorkItem = testRoundTrip(workitemObject);
ComparePair.compareObjectsViaFields(workitemObject, roundTripWorkItem);
}
@Test
// JBPM-4170
public void nodeInstanceLogNpeTest() throws Exception {
org.jbpm.process.audit.NodeInstanceLog nodeLog = new org.jbpm.process.audit.NodeInstanceLog();
JaxbNodeInstanceLog jaxbNodeLog = new JaxbNodeInstanceLog(nodeLog);
testRoundTrip(jaxbNodeLog);
}
@Test
public void deploymentObjectsTest() throws Exception {
Assume.assumeFalse(getType().equals(TestType.YAML));
// for test at end, fill during test
JaxbDeploymentUnitList depUnitList = new JaxbDeploymentUnitList();
// dep jobs
JaxbDeploymentJobResult jaxbJob = new JaxbDeploymentJobResult();
testRoundTrip(jaxbJob);
// complex dep jobs
KModuleDeploymentUnit kDepUnit =
new KModuleDeploymentUnit("org", "jar", "1.0", "kbase", "ksession");
kDepUnit.setStrategy(RuntimeStrategy.PER_PROCESS_INSTANCE);
JaxbDeploymentUnit depUnit =
new JaxbDeploymentUnit(
kDepUnit.getGroupId(), kDepUnit.getArtifactId(), kDepUnit.getArtifactId());
depUnit.setKbaseName(kDepUnit.getKbaseName());
depUnit.setKsessionName(kDepUnit.getKsessionName());
depUnit.setStrategy(kDepUnit.getStrategy());
depUnit.setStatus(JaxbDeploymentStatus.NONEXISTENT);
depUnitList.getDeploymentUnitList().add(depUnit);
jaxbJob = new JaxbDeploymentJobResult(null, "test", depUnit, "deploy");
jaxbJob.setIdentifier(23L);
jaxbJob.setSuccess(false);
JaxbDeploymentJobResult copyJaxbJob = testRoundTrip(jaxbJob);
ComparePair.compareObjectsViaFields(jaxbJob, copyJaxbJob, "jobId", "identifier");
depUnit = new JaxbDeploymentUnit("g", "a", "v");
depUnit.setKbaseName("kbase");
depUnit.setKsessionName("ksession");
depUnit.setStatus(JaxbDeploymentStatus.DEPLOY_FAILED);
depUnit.setStrategy(RuntimeStrategy.PER_PROCESS_INSTANCE);
depUnitList.getDeploymentUnitList().add(depUnit);
JaxbDeploymentUnit copyDepUnit = testRoundTrip(depUnit);
ComparePair.compareObjectsViaFields(depUnit, copyDepUnit, "identifier");
JaxbDeploymentJobResult depJob =
new JaxbDeploymentJobResult(null, "testing stuff", copyDepUnit, "test");
depJob.setSuccess(true);
JaxbDeploymentJobResult copyDepJob = testRoundTrip(depJob);
ComparePair.compareObjectsViaFields(copyDepJob, depJob, "jobId", "identifier");
JaxbDeploymentUnitList roundTripUnitList = testRoundTrip(depUnitList);
ComparePair.compareObjectsViaFields(
depUnitList.getDeploymentUnitList().get(0),
roundTripUnitList.getDeploymentUnitList().get(0),
"jobId",
"identifier");
}
@Test
public void processInstanceLogTest() throws Exception {
Assume.assumeFalse(getType().equals(TestType.YAML));
org.jbpm.process.audit.ProcessInstanceLog origLog =
new org.jbpm.process.audit.ProcessInstanceLog(54, "org.hospital.patient.triage");
origLog.setDuration(65l);
origLog.setDuration(234l);
origLog.setEnd(new Date((new Date()).getTime() + 1000));
origLog.setExternalId("testDomainId");
origLog.setIdentity("identityNotMemory");
origLog.setProcessInstanceDescription("What a process, say!");
// nullable
origLog.setStatus(2);
origLog.setOutcome("descriptiveErrorCodeOfAnError");
origLog.setParentProcessInstanceId(65l);
origLog.setProcessName("org.process.not.technical");
origLog.setProcessVersion("v3.14");
JaxbProcessInstanceLog xmlLog = new JaxbProcessInstanceLog(origLog);
xmlLog.setCommandName("test-cmd");
xmlLog.setIndex(2);
JaxbProcessInstanceLog newXmlLog = testRoundTrip(xmlLog);
ComparePair.compareObjectsViaFields(xmlLog, newXmlLog, "id");
ProcessInstanceLog newLog = newXmlLog.getResult();
ProcessInstanceLog origCmpLog = origLog;
assertEquals(origLog.getExternalId(), newLog.getExternalId());
assertEquals(origCmpLog.getIdentity(), newLog.getIdentity());
assertEquals(origCmpLog.getOutcome(), newLog.getOutcome());
assertEquals(origCmpLog.getProcessId(), newLog.getProcessId());
assertEquals(origCmpLog.getProcessName(), newLog.getProcessName());
assertEquals(origCmpLog.getProcessVersion(), newLog.getProcessVersion());
assertEquals(origCmpLog.getDuration(), newLog.getDuration());
assertEquals(origCmpLog.getEnd(), newLog.getEnd());
assertEquals(origCmpLog.getParentProcessInstanceId(), newLog.getParentProcessInstanceId());
assertEquals(origCmpLog.getProcessInstanceId(), newLog.getProcessInstanceId());
assertEquals(origCmpLog.getStart(), newLog.getStart());
assertEquals(origCmpLog.getStatus(), newLog.getStatus());
}
@Test
public void processInstanceLogNillable() throws Exception {
Assume.assumeFalse(getType().equals(TestType.YAML));
org.jbpm.process.audit.ProcessInstanceLog origLog =
new org.jbpm.process.audit.ProcessInstanceLog(54, "org.hospital.patient.triage");
origLog.setDuration(65l);
origLog.setEnd(new Date((new Date()).getTime() + 1000));
origLog.setExternalId("testDomainId");
origLog.setIdentity("identityNotMemory");
// nullable/nillable
// origLog.setStatus(2);
// origLog.setOutcome("descriptiveErrorCodeOfAnError");
// origLog.setParentProcessInstanceId(65l);
origLog.setProcessName("org.process.not.technical");
origLog.setProcessVersion("v3.14");
JaxbProcessInstanceLog xmlLog = new JaxbProcessInstanceLog(origLog);
JaxbProcessInstanceLog newXmlLog = testRoundTrip(xmlLog);
assertEquals(xmlLog.getProcessInstanceId(), newXmlLog.getProcessInstanceId());
assertEquals(xmlLog.getProcessId(), newXmlLog.getProcessId());
assertEquals(xmlLog.getDuration(), newXmlLog.getDuration());
assertEquals(xmlLog.getEnd(), newXmlLog.getEnd());
assertEquals(xmlLog.getExternalId(), newXmlLog.getExternalId());
assertEquals(xmlLog.getIdentity(), newXmlLog.getIdentity());
assertEquals(xmlLog.getStatus(), newXmlLog.getStatus());
assertEquals(xmlLog.getOutcome(), newXmlLog.getOutcome());
assertEquals(xmlLog.getParentProcessInstanceId(), newXmlLog.getParentProcessInstanceId());
assertEquals(xmlLog.getProcessName(), newXmlLog.getProcessName());
assertEquals(xmlLog.getProcessVersion(), newXmlLog.getProcessVersion());
}
@Test
public void nodeInstanceLogTest() throws Exception {
Assume.assumeFalse(getType().equals(TestType.YAML));
int type = 0;
long processInstanceId = 23;
String processId = "org.hospital.doctor.review";
String nodeInstanceId = "1-1";
String nodeId = "1";
String nodeName = "notification";
org.jbpm.process.audit.NodeInstanceLog origLog =
new org.jbpm.process.audit.NodeInstanceLog(
type, processInstanceId,
processId, nodeInstanceId,
nodeId, nodeName);
origLog.setWorkItemId(78l);
origLog.setConnection("link");
origLog.setExternalId("not-internal-num");
origLog.setNodeType("the-sort-of-point");
JaxbNodeInstanceLog xmlLog = new JaxbNodeInstanceLog(origLog);
xmlLog.setCommandName("test-cmd");
xmlLog.setIndex(2);
xmlLog.setId(2l);
JaxbNodeInstanceLog newXmlLog = testRoundTrip(xmlLog);
ComparePair.compareOrig(xmlLog, newXmlLog, JaxbNodeInstanceLog.class);
NodeInstanceLog newLog = newXmlLog.getResult();
ComparePair.compareOrig(origLog, newLog, NodeInstanceLog.class);
}
@Test
public void variableInstanceLogTest() throws Exception {
Assume.assumeFalse(getType().equals(TestType.YAML));
long processInstanceId = 23;
String processId = "org.hospital.intern.rounds";
String variableInstanceId = "patientNum-1";
String variableId = "patientNum";
String value = "33";
String oldValue = "32";
org.jbpm.process.audit.VariableInstanceLog origLog =
new org.jbpm.process.audit.VariableInstanceLog(
processInstanceId, processId, variableInstanceId, variableId, value, oldValue);
origLog.setExternalId("outside-identity-representation");
origLog.setOldValue("previous-data-that-this-variable-contains");
origLog.setValue("the-new-data-that-has-been-put-in-this-variable");
origLog.setVariableId("shortend-representation-of-this-representation");
origLog.setVariableInstanceId("id-instance-variable");
JaxbVariableInstanceLog xmlLog = new JaxbVariableInstanceLog(origLog);
xmlLog.setCommandName("test-cmd");
xmlLog.setIndex(2);
JaxbVariableInstanceLog newXmlLog = testRoundTrip(xmlLog);
ComparePair.compareObjectsViaFields(xmlLog, newXmlLog, "id");
VariableInstanceLog newLog = newXmlLog.getResult();
ComparePair.compareOrig(origLog, newLog, VariableInstanceLog.class);
}
@Test
public void processIdAndProcessDefinitionTest() throws Exception {
// JaxbProcessDefinition
ProcessAssetDesc assetDesc =
new ProcessAssetDesc(
"org.test.proc.id",
"The Name Of The Process",
"1.999.23.Final",
"org.test.proc",
"RuleFlow",
KnowledgeType.PROCESS.toString(),
"org.test.proc",
"org.test.proc:procs:1.999.Final");
JaxbProcessDefinition jaxbProcDef = new JaxbProcessDefinition();
jaxbProcDef.setDeploymentId(assetDesc.getDeploymentId());
jaxbProcDef.setId(assetDesc.getId());
jaxbProcDef.setName(assetDesc.getName());
jaxbProcDef.setPackageName(assetDesc.getPackageName());
jaxbProcDef.setVersion(assetDesc.getVersion());
Map<String, String> forms = new HashMap<String, String>();
forms.put("locationForm", "GPS: street: post code: city: state: land: planet: universe: ");
jaxbProcDef.setForms(forms);
JaxbProcessDefinition copyJaxbProcDef = testRoundTrip(jaxbProcDef);
ComparePair.compareObjectsViaFields(jaxbProcDef, copyJaxbProcDef);
}
@Test
public void deploymentDescriptorTest() throws Exception {
JaxbDeploymentDescriptor depDescriptor = new JaxbDeploymentDescriptor();
depDescriptor.setAuditMode(AuditMode.JMS);
depDescriptor.setAuditPersistenceUnit("myDatabasePersistenceUnit");
String[] classes = {"org.test.First", "org.more.test.Second"};
depDescriptor.setClasses(Arrays.asList(classes));
depDescriptor.setConfiguration(getNamedObjectModeList("conf"));
depDescriptor.setEnvironmentEntries(getNamedObjectModeList("envEnt"));
}
private List<NamedObjectModel> getNamedObjectModeList(String type) {
type = "-" + type;
List<NamedObjectModel> namedObjectModelList = new ArrayList<NamedObjectModel>();
for (int i = 0; i < 2; ++i) {
NamedObjectModel nom = new NamedObjectModel();
nom.setIdentifier("id-" + i + type);
nom.setName("name-" + i + type);
String[] params = {UUID.randomUUID().toString(), UUID.randomUUID().toString()};
List<Object> paramList = new ArrayList<Object>();
paramList.addAll(Arrays.asList(params));
nom.setParameters(paramList);
nom.setResolver(i + "-resolver" + type);
namedObjectModelList.add(nom);
}
return namedObjectModelList;
}
@Test
public void funnyCharactersTest() throws Exception {
String testStr = "test &<>\"\' test";
JaxbString jaxbStr = new JaxbString(testStr);
JaxbString copy = testRoundTrip(jaxbStr);
assertEquals("Funny characters not correctly encoded", testStr, copy.getValue());
}
@Test
public void correlationKeyTest() throws Exception {
Assume.assumeFalse(getType().equals(TestType.YAML));
JaxbCorrelationKey corrKey = new JaxbCorrelationKey();
corrKey.setName("anton");
List<JaxbCorrelationProperty> properties = new ArrayList<JaxbCorrelationProperty>(3);
corrKey.setJaxbProperties(properties);
properties.add(new JaxbCorrelationProperty("name", "value"));
properties.add(new JaxbCorrelationProperty("only-a-value"));
properties.add(new JaxbCorrelationProperty("ngalan", "bili"));
JaxbCorrelationKey copyCorrKey = testRoundTrip(corrKey);
assertEquals("name", corrKey.getName(), copyCorrKey.getName());
assertEquals(
"prop list size", corrKey.getProperties().size(), copyCorrKey.getProperties().size());
List<CorrelationProperty<?>> propList = corrKey.getProperties();
List<CorrelationProperty<?>> copyPropList = copyCorrKey.getProperties();
for (int i = 0; i < propList.size(); ++i) {
CorrelationProperty<?> prop = propList.get(i);
CorrelationProperty<?> copyProp = copyPropList.get(i);
assertEquals(i + ": name", prop.getName(), copyProp.getName());
assertEquals(i + ": type", prop.getType(), copyProp.getType());
assertEquals(i + ": value", prop.getValue(), copyProp.getValue());
}
}
@Test
public void wrapperTypesTest() throws Exception {
Object[] inputs = {
true,
new Byte("1").byteValue(),
new Character('a').charValue(),
new Double(23.01).doubleValue(),
new Float(46.02).floatValue(),
1011,
1012,
new Short("10").shortValue(),
"string",
};
for (Object input : inputs) {
logger.debug("Testing round trip serialization in wrapper for " + input.getClass().getName());
Object copyInput = wrapperRoundTrip(input);
assertEquals(
input.getClass().getSimpleName() + " wrapped round trip failed!", input, copyInput);
}
Integer[] integerArr = {1039, 3858, 239502};
int[] intArr = {1039, 3858, 239502};
double[] doubleArr = {2.01, 3.02, 4.03};
String[] stringArr = {"all", "about", "that", "base"};
// check that constructor works
new JaxbArray(doubleArr);
Object[] arrInputs = {intArr, integerArr, doubleArr, stringArr};
for (Object input : arrInputs) {
logger.debug("Testing round trip serialization in wrapper for " + input.getClass().getName());
int length = Array.getLength(input);
Object copyInput = wrapperRoundTrip(input);
assertNotNull("Null copy for " + input.getClass().getName(), copyInput);
assertEquals("Array length", Array.getLength(input), Array.getLength(copyInput));
for (int i = 0; i < length; ++i) {
assertEquals(
"Element " + i + " inequal in " + input.getClass().getSimpleName() + " instance",
Array.get(input, i),
Array.get(copyInput, i));
}
}
{
List<String> list = new ArrayList<String>();
list.add("one");
List<String> copyList = wrapperRoundTrip(list);
assertEquals(
list.getClass().getSimpleName() + "round trip failed!",
list.iterator().next(),
copyList.iterator().next());
}
{
Set<String> set = new HashSet<String>();
set.add("one");
Set<String> copySet = wrapperRoundTrip(set);
assertEquals(
set.getClass().getSimpleName() + "round trip failed!",
set.iterator().next(),
copySet.iterator().next());
}
{
Map<String, Object> map = new HashMap<String, Object>(1);
map.put("one", "two");
Map<String, Object> copyMap = wrapperRoundTrip(map);
assertEquals(
copyMap.getClass().getSimpleName() + " round trip failed!",
map.get("one"),
copyMap.get("one"));
}
}
@SuppressWarnings("unchecked")
private <T> T wrapperRoundTrip(T value) throws Exception {
JaxbType<T> wrapper = null;
if (value instanceof Boolean) {
wrapper = (JaxbType<T>) new JaxbBoolean((Boolean) value);
} else if (value instanceof Byte) {
wrapper = (JaxbType<T>) new JaxbByte((Byte) value);
} else if (value instanceof Character) {
wrapper = (JaxbType<T>) new JaxbCharacter((Character) value);
} else if (value instanceof Double) {
wrapper = (JaxbType<T>) new JaxbDouble((Double) value);
} else if (value instanceof Float) {
wrapper = (JaxbType<T>) new JaxbFloat((Float) value);
} else if (value instanceof Integer) {
wrapper = (JaxbType<T>) new JaxbInteger((Integer) value);
} else if (value instanceof Long) {
wrapper = (JaxbType<T>) new JaxbLong((Long) value);
} else if (value instanceof Short) {
wrapper = (JaxbType<T>) new JaxbShort((Short) value);
} else if (value instanceof String) {
wrapper = (JaxbType<T>) new JaxbString((String) value);
} else if (value.getClass().isArray()) {
wrapper = (JaxbType<T>) new JaxbArray(value);
} else if (value instanceof List) {
wrapper = (JaxbType<T>) new JaxbList((List) value);
} else if (value instanceof Set) {
wrapper = (JaxbType<T>) new JaxbSet((Set) value);
} else if (value instanceof Map) {
wrapper = (JaxbType<T>) new JaxbMap((Map) value);
} else {
fail(
"Modify the "
+ Thread.currentThread().getStackTrace()[1].getMethodName()
+ " to also round trip "
+ value.getClass().getSimpleName()
+ " instances!");
}
return testRoundTrip(wrapper).getValue();
}
}
