@Before
public void setUp() {
- initMocks(this);
- tt=Mockito.mock(TimeTaken.class);
- Mockito.doReturn(tt).when(env).start("JAXB Stringify", Env.XML);
- Mockito.doNothing().when(tt).done();
- ttObjectify=Mockito.mock(TimeTaken.class);
- Mockito.doReturn(ttObjectify).when(env).start("JAXB Objectify", Env.XML);
- Mockito.doNothing().when(ttObjectify).done();
+ initMocks(this);
+ tt=Mockito.mock(TimeTaken.class);
+ Mockito.doReturn(tt).when(env).start("JAXB Stringify", Env.XML);
+ Mockito.doNothing().when(tt).done();
+ ttObjectify=Mockito.mock(TimeTaken.class);
+ Mockito.doReturn(ttObjectify).when(env).start("JAXB Objectify", Env.XML);
+ Mockito.doNothing().when(ttObjectify).done();
}
@Test
public void testNewInstance() {
- JAXBDF<?> bdfObj = null;
- try {
- bdfObj = new JAXBDF( null, new Class[] {this.getClass()});
- bdfObj.jumar = Mockito.mock(JAXBumar.class);
- Mockito.doThrow(new IllegalAccessException("Test Exception")).when(bdfObj.jumar).newInstance();
- Object retVal = bdfObj.newInstance();
- } catch (IllegalAccessException e) {
- assertEquals("Test Exception", e.getLocalizedMessage());
- } catch (APIException e) {
- assertTrue(e.getMessage().contains("Test Exception"));
- } catch (InstantiationException e) {
- // TODO Auto-generated catch block
- e.printStackTrace();
- }
-
+ JAXBDF<?> bdfObj = null;
+ try {
+ bdfObj = new JAXBDF( null, new Class[] {this.getClass()});
+ bdfObj.jumar = Mockito.mock(JAXBumar.class);
+ Mockito.doThrow(new IllegalAccessException("Test Exception")).when(bdfObj.jumar).newInstance();
+ Object retVal = bdfObj.newInstance();
+ } catch (IllegalAccessException e) {
+ assertEquals("Test Exception", e.getLocalizedMessage());
+ } catch (APIException e) {
+ assertTrue(e.getMessage().contains("Test Exception"));
+ } catch (InstantiationException e) {
+ // TODO Auto-generated catch block
+ e.printStackTrace();
+ }
+
}
@Test
public void testNewInstanceNoException() {
- JAXBDF<?> bdfObj = null;
- try {
- bdfObj = new JAXBDF( null, new Class[] {this.getClass()});
- Object retVal = bdfObj.newInstance();
- assertTrue(retVal instanceof JU_JAXBDF);
- } catch (APIException e) {
- e.printStackTrace();
- }
-
+ JAXBDF<?> bdfObj = null;
+ try {
+ bdfObj = new JAXBDF( null, new Class[] {this.getClass()});
+ Object retVal = bdfObj.newInstance();
+ assertTrue(retVal instanceof JU_JAXBDF);
+ } catch (APIException e) {
+ e.printStackTrace();
+ }
+
}
@Test
public void testPrettyNoException() {
- JAXBDF<?> bdfObj = null;
- try {
- bdfObj = new JAXBDF( null, Mockito.mock(Schema.class), new Class[] {this.getClass()});
- Object retVal = bdfObj.pretty(true);
- assertTrue(retVal instanceof JAXBDF);
- } catch (APIException e) {
- e.printStackTrace();
- }
+ JAXBDF<?> bdfObj = null;
+ try {
+ bdfObj = new JAXBDF( null, Mockito.mock(Schema.class), new Class[] {this.getClass()});
+ Object retVal = bdfObj.pretty(true);
+ assertTrue(retVal instanceof JAXBDF);
+ } catch (APIException e) {
+ e.printStackTrace();
+ }
}
@Test
public void testFragment() {
- JAXBDF<?> bdfObj = null;
- try {
- bdfObj = new JAXBDF( null, Mockito.mock(QName.class), new Class[] {this.getClass()});
- Object retVal = bdfObj.asFragment(true);
- assertTrue(retVal instanceof JAXBDF);
- bdfObj.servicePrestart(null);
- bdfObj.threadPrestart(null);
- bdfObj.refresh(null);
- bdfObj.threadDestroy(null);
- bdfObj.serviceDestroy(null);
- } catch (APIException e) {
- e.printStackTrace();
- }
-
+ JAXBDF<?> bdfObj = null;
+ try {
+ bdfObj = new JAXBDF( null, Mockito.mock(QName.class), new Class[] {this.getClass()});
+ Object retVal = bdfObj.asFragment(true);
+ assertTrue(retVal instanceof JAXBDF);
+ bdfObj.servicePrestart(null);
+ bdfObj.threadPrestart(null);
+ bdfObj.refresh(null);
+ bdfObj.threadDestroy(null);
+ bdfObj.serviceDestroy(null);
+ } catch (APIException e) {
+ e.printStackTrace();
+ }
+
}
@Test
public void testNewData() {
- JAXBDF<?> bdfObj = null;
- try {
- bdfObj = new JAXBDF( null, Mockito.mock(Schema.class),Mockito.mock(QName.class), new Class[] {this.getClass()});
- Data<?> retVal = bdfObj.newData();
- assertTrue(retVal instanceof JAXBData);
- } catch (APIException e) {
- e.printStackTrace();
- }
+ JAXBDF<?> bdfObj = null;
+ try {
+ bdfObj = new JAXBDF( null, Mockito.mock(Schema.class),Mockito.mock(QName.class), new Class[] {this.getClass()});
+ Data<?> retVal = bdfObj.newData();
+ assertTrue(retVal instanceof JAXBData);
+ } catch (APIException e) {
+ e.printStackTrace();
+ }
}
@Test
public void testNewDataENV() {
- JAXBDF<?> bdfObj = null;
- try {
- bdfObj = new JAXBDF( null, Mockito.mock(Schema.class),Mockito.mock(QName.class), new Class[] {this.getClass()});
- Data<?> retVal = bdfObj.newData(Mockito.mock(Env.class));
- assertTrue(retVal instanceof JAXBData);
- } catch (APIException e) {
- e.printStackTrace();
- }
+ JAXBDF<?> bdfObj = null;
+ try {
+ bdfObj = new JAXBDF( null, Mockito.mock(Schema.class),Mockito.mock(QName.class), new Class[] {this.getClass()});
+ Data<?> retVal = bdfObj.newData(Mockito.mock(Env.class));
+ assertTrue(retVal instanceof JAXBData);
+ } catch (APIException e) {
+ e.printStackTrace();
+ }
}
@Test
public void testNewDataType() {
- JAXBDF<JAXBumar> bdfObj = null;
- try {
- bdfObj = new JAXBDF( null, Mockito.mock(Schema.class),Mockito.mock(QName.class), new Class[] {this.getClass()});
- Data<?> retVal = bdfObj.newData(new JAXBumar(new Class[] {this.getClass()}));
- assertTrue(retVal instanceof JAXBData);
- } catch (APIException e) {
- e.printStackTrace();
- } catch (JAXBException e) {
- // TODO Auto-generated catch block
- e.printStackTrace();
- }
+ JAXBDF<JAXBumar> bdfObj = null;
+ try {
+ bdfObj = new JAXBDF( null, Mockito.mock(Schema.class),Mockito.mock(QName.class), new Class[] {this.getClass()});
+ Data<?> retVal = bdfObj.newData(new JAXBumar(new Class[] {this.getClass()}));
+ assertTrue(retVal instanceof JAXBData);
+ } catch (APIException e) {
+ e.printStackTrace();
+ } catch (JAXBException e) {
+ // TODO Auto-generated catch block
+ e.printStackTrace();
+ }
}
@Test
public void testNewDataStream() {
- JAXBDF<?> bdfObj = null;
- try {
- bdfObj = new JAXBDF( null, Mockito.mock(Schema.class),Mockito.mock(QName.class), new Class[] {this.getClass()});
- bdfObj.jumar = Mockito.mock(JAXBumar.class);
- LogTarget logT = Mockito.mock(LogTarget.class);
- Mockito.doReturn(logT).when(env).debug();
- InputStream is = Mockito.mock(InputStream.class);
- Mockito.doReturn(this.getClass()).when(bdfObj.jumar).unmarshal(logT, is);
- Data<?> retVal = bdfObj.newDataFromStream(env, is);
- assertTrue(retVal instanceof JAXBData);
- } catch (APIException e) {
- e.printStackTrace();
- } catch (JAXBException e) {
- // TODO Auto-generated catch block
- e.printStackTrace();
- }
+ JAXBDF<?> bdfObj = null;
+ try {
+ bdfObj = new JAXBDF( null, Mockito.mock(Schema.class),Mockito.mock(QName.class), new Class[] {this.getClass()});
+ bdfObj.jumar = Mockito.mock(JAXBumar.class);
+ LogTarget logT = Mockito.mock(LogTarget.class);
+ Mockito.doReturn(logT).when(env).debug();
+ InputStream is = Mockito.mock(InputStream.class);
+ Mockito.doReturn(this.getClass()).when(bdfObj.jumar).unmarshal(logT, is);
+ Data<?> retVal = bdfObj.newDataFromStream(env, is);
+ assertTrue(retVal instanceof JAXBData);
+ } catch (APIException e) {
+ e.printStackTrace();
+ } catch (JAXBException e) {
+ // TODO Auto-generated catch block
+ e.printStackTrace();
+ }
}
@Test
public void testNewDataStreamException() {
- JAXBDF<?> bdfObj = null;
- try {
- bdfObj = new JAXBDF( null, Mockito.mock(Schema.class),Mockito.mock(QName.class), new Class[] {this.getClass()});
- bdfObj.jumar = Mockito.mock(JAXBumar.class);
- LogTarget logT = Mockito.mock(LogTarget.class);
- Mockito.doReturn(logT).when(env).debug();
- InputStream is = Mockito.mock(InputStream.class);
- Mockito.doThrow(new JAXBException("test")).when(bdfObj.jumar).unmarshal(logT, is);
- Data<?> retVal = bdfObj.newDataFromStream(env, is);
- } catch (APIException e) {
- assertTrue(e.getMessage().contains("test"));
- } catch (JAXBException e) {
- // TODO Auto-generated catch block
- assertTrue(e.getMessage().contains("test"));
- }
+ JAXBDF<?> bdfObj = null;
+ try {
+ bdfObj = new JAXBDF( null, Mockito.mock(Schema.class),Mockito.mock(QName.class), new Class[] {this.getClass()});
+ bdfObj.jumar = Mockito.mock(JAXBumar.class);
+ LogTarget logT = Mockito.mock(LogTarget.class);
+ Mockito.doReturn(logT).when(env).debug();
+ InputStream is = Mockito.mock(InputStream.class);
+ Mockito.doThrow(new JAXBException("test")).when(bdfObj.jumar).unmarshal(logT, is);
+ Data<?> retVal = bdfObj.newDataFromStream(env, is);
+ } catch (APIException e) {
+ assertTrue(e.getMessage().contains("test"));
+ } catch (JAXBException e) {
+ // TODO Auto-generated catch block
+ assertTrue(e.getMessage().contains("test"));
+ }
}
@Test
public void testNewDataFromString() {
- JAXBDF<?> bdfObj = null;
- try {
- bdfObj = new JAXBDF( null, Mockito.mock(Schema.class),Mockito.mock(QName.class), new Class[] {this.getClass()});
- Data<?> retVal = bdfObj.newDataFromString("test");
- assertTrue(retVal instanceof JAXBData);
- } catch (APIException e) {
- e.printStackTrace();
- }
+ JAXBDF<?> bdfObj = null;
+ try {
+ bdfObj = new JAXBDF( null, Mockito.mock(Schema.class),Mockito.mock(QName.class), new Class[] {this.getClass()});
+ Data<?> retVal = bdfObj.newDataFromString("test");
+ assertTrue(retVal instanceof JAXBData);
+ } catch (APIException e) {
+ e.printStackTrace();
+ }
}
@Test
public void testStringify() {
- JAXBDF<JAXBmar> bdfObj = null;
- try {
- JAXBmar typeObj = new JAXBmar(new Class[] {this.getClass()});
- EnvJAXB envJaxb = Mockito.mock(EnvJAXB.class);
- bdfObj = new JAXBDF( envJaxb, new Class[] {this.getClass()});
- bdfObj.jmar = Mockito.mock(JAXBmar.class);
- LogTarget logT = Mockito.mock(LogTarget.class);
- Mockito.doReturn(logT).when(envJaxb).debug();
- Mockito.doReturn(this.getClass()).when(bdfObj.jmar).marshal(logT, typeObj, Mockito.mock(StringWriter.class));
- String retVal = bdfObj.stringify(typeObj);
- assertEquals("", retVal);
- } catch (APIException e) {
- e.printStackTrace();
- } catch (JAXBException e) {
- // TODO Auto-generated catch block
- e.printStackTrace();
- }
+ JAXBDF<JAXBmar> bdfObj = null;
+ try {
+ JAXBmar typeObj = new JAXBmar(new Class[] {this.getClass()});
+ EnvJAXB envJaxb = Mockito.mock(EnvJAXB.class);
+ bdfObj = new JAXBDF( envJaxb, new Class[] {this.getClass()});
+ bdfObj.jmar = Mockito.mock(JAXBmar.class);
+ LogTarget logT = Mockito.mock(LogTarget.class);
+ Mockito.doReturn(logT).when(envJaxb).debug();
+ Mockito.doReturn(this.getClass()).when(bdfObj.jmar).marshal(logT, typeObj, Mockito.mock(StringWriter.class));
+ String retVal = bdfObj.stringify(typeObj);
+ assertEquals("", retVal);
+ } catch (APIException e) {
+ e.printStackTrace();
+ } catch (JAXBException e) {
+ // TODO Auto-generated catch block
+ e.printStackTrace();
+ }
}
@Test
public void testStringifyException() {
- JAXBDF<JAXBmar> bdfObj = null;
- try {
- JAXBmar typeObj = new JAXBmar(new Class[] {this.getClass()});
- EnvJAXB envJaxb = Mockito.mock(EnvJAXB.class);
- LogTarget logT = Mockito.mock(LogTarget.class);
- Mockito.doReturn(logT).when(envJaxb).debug();
- bdfObj = new JAXBDF<JAXBmar>( envJaxb, new Class[] {this.getClass()});
- bdfObj.jmar = Mockito.mock(JAXBmar.class);
- Mockito.doThrow(new JAXBException("test") ).when(bdfObj.jmar).marshal(logT, typeObj, Mockito.mock(StringWriter.class));
- String retVal = bdfObj.stringify(typeObj);
- System.out.println(retVal);
- } catch (APIException e) {
- assertTrue(e.getMessage().contains("test"));
- } catch (JAXBException e) {
- assertTrue(e.getMessage().contains("test"));
- }
+ JAXBDF<JAXBmar> bdfObj = null;
+ try {
+ JAXBmar typeObj = new JAXBmar(new Class[] {this.getClass()});
+ EnvJAXB envJaxb = Mockito.mock(EnvJAXB.class);
+ LogTarget logT = Mockito.mock(LogTarget.class);
+ Mockito.doReturn(logT).when(envJaxb).debug();
+ bdfObj = new JAXBDF<JAXBmar>( envJaxb, new Class[] {this.getClass()});
+ bdfObj.jmar = Mockito.mock(JAXBmar.class);
+ Mockito.doThrow(new JAXBException("test") ).when(bdfObj.jmar).marshal(logT, typeObj, Mockito.mock(StringWriter.class));
+ String retVal = bdfObj.stringify(typeObj);
+ System.out.println(retVal);
+ } catch (APIException e) {
+ assertTrue(e.getMessage().contains("test"));
+ } catch (JAXBException e) {
+ assertTrue(e.getMessage().contains("test"));
+ }
}
@Test
public void testStringifyWriter() {
- JAXBDF<JAXBmar> bdfObj = null;
- try {
- JAXBmar typeObj = new JAXBmar(new Class[] {this.getClass()});
- EnvJAXB envJaxb = Mockito.mock(EnvJAXB.class);
- bdfObj = new JAXBDF( envJaxb, new Class[] {this.getClass()});
- bdfObj.jmar = Mockito.mock(JAXBmar.class);
- LogTarget logT = Mockito.mock(LogTarget.class);
- Mockito.doReturn(logT).when(envJaxb).debug();
- Mockito.doReturn(this.getClass()).when(bdfObj.jmar).marshal(logT, typeObj, Mockito.mock(StringWriter.class));
- bdfObj.stringify(typeObj, Mockito.mock(StringWriter.class));
- } catch (APIException e) {
- e.printStackTrace();
- } catch (JAXBException e) {
- // TODO Auto-generated catch block
- e.printStackTrace();
- }
+ JAXBDF<JAXBmar> bdfObj = null;
+ try {
+ JAXBmar typeObj = new JAXBmar(new Class[] {this.getClass()});
+ EnvJAXB envJaxb = Mockito.mock(EnvJAXB.class);
+ bdfObj = new JAXBDF( envJaxb, new Class[] {this.getClass()});
+ bdfObj.jmar = Mockito.mock(JAXBmar.class);
+ LogTarget logT = Mockito.mock(LogTarget.class);
+ Mockito.doReturn(logT).when(envJaxb).debug();
+ Mockito.doReturn(this.getClass()).when(bdfObj.jmar).marshal(logT, typeObj, Mockito.mock(StringWriter.class));
+ bdfObj.stringify(typeObj, Mockito.mock(StringWriter.class));
+ } catch (APIException e) {
+ e.printStackTrace();
+ } catch (JAXBException e) {
+ // TODO Auto-generated catch block
+ e.printStackTrace();
+ }
}
@Test
public void testStringifyWriterException() {
- JAXBDF<JAXBmar> bdfObj = null;
- try {
- JAXBmar typeObj = new JAXBmar(new Class[] {this.getClass()});
- EnvJAXB envJaxb = Mockito.mock(EnvJAXB.class);
- bdfObj = new JAXBDF( envJaxb, new Class[] {this.getClass()});
- bdfObj.jmar = Mockito.mock(JAXBmar.class);
- LogTarget logT = Mockito.mock(LogTarget.class);
- Mockito.doReturn(logT).when(envJaxb).debug();
- StringWriter sw = Mockito.mock(StringWriter.class);
- Mockito.doThrow(new JAXBException("test")).when(bdfObj.jmar).marshal(logT, typeObj, sw);
- bdfObj.stringify(typeObj, sw);
- } catch (APIException e) {
- assertTrue(e.getMessage().contains("test"));
- } catch (JAXBException e) {
- assertTrue(e.getMessage().contains("test"));
- }
+ JAXBDF<JAXBmar> bdfObj = null;
+ try {
+ JAXBmar typeObj = new JAXBmar(new Class[] {this.getClass()});
+ EnvJAXB envJaxb = Mockito.mock(EnvJAXB.class);
+ bdfObj = new JAXBDF( envJaxb, new Class[] {this.getClass()});
+ bdfObj.jmar = Mockito.mock(JAXBmar.class);
+ LogTarget logT = Mockito.mock(LogTarget.class);
+ Mockito.doReturn(logT).when(envJaxb).debug();
+ StringWriter sw = Mockito.mock(StringWriter.class);
+ Mockito.doThrow(new JAXBException("test")).when(bdfObj.jmar).marshal(logT, typeObj, sw);
+ bdfObj.stringify(typeObj, sw);
+ } catch (APIException e) {
+ assertTrue(e.getMessage().contains("test"));
+ } catch (JAXBException e) {
+ assertTrue(e.getMessage().contains("test"));
+ }
}
@Test
public void testStringifyOS() {
- JAXBDF<JAXBmar> bdfObj = null;
- try {
- JAXBmar typeObj = new JAXBmar(new Class[] {this.getClass()});
- EnvJAXB envJaxb = Mockito.mock(EnvJAXB.class);
- bdfObj = new JAXBDF( envJaxb, new Class[] {this.getClass()});
- bdfObj.jmar = Mockito.mock(JAXBmar.class);
- LogTarget logT = Mockito.mock(LogTarget.class);
- Mockito.doReturn(logT).when(envJaxb).debug();
- Mockito.doReturn(this.getClass()).when(bdfObj.jmar).marshal(logT, typeObj, Mockito.mock(OutputStream.class));
- bdfObj.stringify(typeObj, Mockito.mock(OutputStream.class));
- } catch (APIException e) {
- e.printStackTrace();
- } catch (JAXBException e) {
- // TODO Auto-generated catch block
- e.printStackTrace();
- }
+ JAXBDF<JAXBmar> bdfObj = null;
+ try {
+ JAXBmar typeObj = new JAXBmar(new Class[] {this.getClass()});
+ EnvJAXB envJaxb = Mockito.mock(EnvJAXB.class);
+ bdfObj = new JAXBDF( envJaxb, new Class[] {this.getClass()});
+ bdfObj.jmar = Mockito.mock(JAXBmar.class);
+ LogTarget logT = Mockito.mock(LogTarget.class);
+ Mockito.doReturn(logT).when(envJaxb).debug();
+ Mockito.doReturn(this.getClass()).when(bdfObj.jmar).marshal(logT, typeObj, Mockito.mock(OutputStream.class));
+ bdfObj.stringify(typeObj, Mockito.mock(OutputStream.class));
+ } catch (APIException e) {
+ e.printStackTrace();
+ } catch (JAXBException e) {
+ // TODO Auto-generated catch block
+ e.printStackTrace();
+ }
}
@Test
public void testStringifyOsException() {
- JAXBDF<JAXBmar> bdfObj = null;
- try {
- JAXBmar typeObj = new JAXBmar(new Class[] {this.getClass()});
- EnvJAXB envJaxb = Mockito.mock(EnvJAXB.class);
- bdfObj = new JAXBDF( envJaxb, new Class[] {this.getClass()});
- bdfObj.jmar = Mockito.mock(JAXBmar.class);
- LogTarget logT = Mockito.mock(LogTarget.class);
- Mockito.doReturn(logT).when(envJaxb).debug();
- OutputStream sw = Mockito.mock(OutputStream.class);
- Mockito.doThrow(new JAXBException("test")).when(bdfObj.jmar).marshal(logT, typeObj, sw);
- bdfObj.stringify(typeObj, sw);
- } catch (APIException e) {
- assertTrue(e.getMessage().contains("test"));
- } catch (JAXBException e) {
- assertTrue(e.getMessage().contains("test"));
- }
+ JAXBDF<JAXBmar> bdfObj = null;
+ try {
+ JAXBmar typeObj = new JAXBmar(new Class[] {this.getClass()});
+ EnvJAXB envJaxb = Mockito.mock(EnvJAXB.class);
+ bdfObj = new JAXBDF( envJaxb, new Class[] {this.getClass()});
+ bdfObj.jmar = Mockito.mock(JAXBmar.class);
+ LogTarget logT = Mockito.mock(LogTarget.class);
+ Mockito.doReturn(logT).when(envJaxb).debug();
+ OutputStream sw = Mockito.mock(OutputStream.class);
+ Mockito.doThrow(new JAXBException("test")).when(bdfObj.jmar).marshal(logT, typeObj, sw);
+ bdfObj.stringify(typeObj, sw);
+ } catch (APIException e) {
+ assertTrue(e.getMessage().contains("test"));
+ } catch (JAXBException e) {
+ assertTrue(e.getMessage().contains("test"));
+ }
}
@Test
public void testStringifyOptions() {
- JAXBDF<JAXBmar> bdfObj = null;
- try {
- JAXBmar typeObj = new JAXBmar(new Class[] {this.getClass()});
- EnvJAXB envJaxb = Mockito.mock(EnvJAXB.class);
- bdfObj = new JAXBDF( envJaxb, new Class[] {this.getClass()});
- bdfObj.jmar = Mockito.mock(JAXBmar.class);
- LogTarget logT = Mockito.mock(LogTarget.class);
- Mockito.doReturn(logT).when(envJaxb).debug();
- Mockito.doReturn(this.getClass()).when(bdfObj.jmar).marshal(logT, typeObj, Mockito.mock(OutputStream.class));
- bdfObj.stringify(env, typeObj, true);
- } catch (APIException e) {
- e.printStackTrace();
- } catch (JAXBException e) {
- // TODO Auto-generated catch block
- e.printStackTrace();
- }
+ JAXBDF<JAXBmar> bdfObj = null;
+ try {
+ JAXBmar typeObj = new JAXBmar(new Class[] {this.getClass()});
+ EnvJAXB envJaxb = Mockito.mock(EnvJAXB.class);
+ bdfObj = new JAXBDF( envJaxb, new Class[] {this.getClass()});
+ bdfObj.jmar = Mockito.mock(JAXBmar.class);
+ LogTarget logT = Mockito.mock(LogTarget.class);
+ Mockito.doReturn(logT).when(envJaxb).debug();
+ Mockito.doReturn(this.getClass()).when(bdfObj.jmar).marshal(logT, typeObj, Mockito.mock(OutputStream.class));
+ bdfObj.stringify(env, typeObj, true);
+ } catch (APIException e) {
+ e.printStackTrace();
+ } catch (JAXBException e) {
+ // TODO Auto-generated catch block
+ e.printStackTrace();
+ }
}
@Test
public void testStringifyOSOptions() {
- JAXBDF<JAXBmar> bdfObj = null;
- try {
- JAXBmar typeObj = new JAXBmar(new Class[] {this.getClass()});
- EnvJAXB envJaxb = Mockito.mock(EnvJAXB.class);
- bdfObj = new JAXBDF( envJaxb, new Class[] {this.getClass()});
- bdfObj.jmar = Mockito.mock(JAXBmar.class);
- LogTarget logT = Mockito.mock(LogTarget.class);
- Mockito.doReturn(logT).when(env).debug();
- Mockito.doReturn(this.getClass()).when(bdfObj.jmar).marshal(logT, typeObj, Mockito.mock(OutputStream.class),true);
- bdfObj.stringify(env, typeObj, Mockito.mock(OutputStream.class),true);
- } catch (APIException e) {
- e.printStackTrace();
- } catch (JAXBException e) {
- // TODO Auto-generated catch block
- e.printStackTrace();
- }
+ JAXBDF<JAXBmar> bdfObj = null;
+ try {
+ JAXBmar typeObj = new JAXBmar(new Class[] {this.getClass()});
+ EnvJAXB envJaxb = Mockito.mock(EnvJAXB.class);
+ bdfObj = new JAXBDF( envJaxb, new Class[] {this.getClass()});
+ bdfObj.jmar = Mockito.mock(JAXBmar.class);
+ LogTarget logT = Mockito.mock(LogTarget.class);
+ Mockito.doReturn(logT).when(env).debug();
+ Mockito.doReturn(this.getClass()).when(bdfObj.jmar).marshal(logT, typeObj, Mockito.mock(OutputStream.class),true);
+ bdfObj.stringify(env, typeObj, Mockito.mock(OutputStream.class),true);
+ } catch (APIException e) {
+ e.printStackTrace();
+ } catch (JAXBException e) {
+ // TODO Auto-generated catch block
+ e.printStackTrace();
+ }
}
@Test
public void testStringifyOsOptionsException() {
- JAXBDF<JAXBmar> bdfObj = null;
- try {
- JAXBmar typeObj = new JAXBmar(new Class[] {this.getClass()});
- EnvJAXB envJaxb = Mockito.mock(EnvJAXB.class);
- bdfObj = new JAXBDF( envJaxb, new Class[] {this.getClass()});
- bdfObj.jmar = Mockito.mock(JAXBmar.class);
- LogTarget logT = Mockito.mock(LogTarget.class);
- Mockito.doReturn(logT).when(env).debug();
- OutputStream sw = Mockito.mock(OutputStream.class);
- Mockito.doThrow(new JAXBException("test")).when(bdfObj.jmar).marshal(logT, typeObj, sw,true);
- bdfObj.stringify(env, typeObj, sw,true);
- } catch (APIException e) {
- assertTrue(e.getMessage().contains("test"));
- } catch (JAXBException e) {
- assertTrue(e.getMessage().contains("test"));
- }
+ JAXBDF<JAXBmar> bdfObj = null;
+ try {
+ JAXBmar typeObj = new JAXBmar(new Class[] {this.getClass()});
+ EnvJAXB envJaxb = Mockito.mock(EnvJAXB.class);
+ bdfObj = new JAXBDF( envJaxb, new Class[] {this.getClass()});
+ bdfObj.jmar = Mockito.mock(JAXBmar.class);
+ LogTarget logT = Mockito.mock(LogTarget.class);
+ Mockito.doReturn(logT).when(env).debug();
+ OutputStream sw = Mockito.mock(OutputStream.class);
+ Mockito.doThrow(new JAXBException("test")).when(bdfObj.jmar).marshal(logT, typeObj, sw,true);
+ bdfObj.stringify(env, typeObj, sw,true);
+ } catch (APIException e) {
+ assertTrue(e.getMessage().contains("test"));
+ } catch (JAXBException e) {
+ assertTrue(e.getMessage().contains("test"));
+ }
}
@Test
public void testStringifySWOptions() {
- JAXBDF<JAXBmar> bdfObj = null;
- try {
- JAXBmar typeObj = new JAXBmar(new Class[] {this.getClass()});
- EnvJAXB envJaxb = Mockito.mock(EnvJAXB.class);
- bdfObj = new JAXBDF( envJaxb, new Class[] {this.getClass()});
- bdfObj.jmar = Mockito.mock(JAXBmar.class);
- LogTarget logT = Mockito.mock(LogTarget.class);
- Mockito.doReturn(logT).when(env).debug();
- Mockito.doReturn(this.getClass()).when(bdfObj.jmar).marshal(logT, typeObj, Mockito.mock(StringWriter.class),true);
- bdfObj.stringify(env, typeObj, Mockito.mock(StringWriter.class),true);
- } catch (APIException e) {
- e.printStackTrace();
- } catch (JAXBException e) {
- // TODO Auto-generated catch block
- e.printStackTrace();
- }
+ JAXBDF<JAXBmar> bdfObj = null;
+ try {
+ JAXBmar typeObj = new JAXBmar(new Class[] {this.getClass()});
+ EnvJAXB envJaxb = Mockito.mock(EnvJAXB.class);
+ bdfObj = new JAXBDF( envJaxb, new Class[] {this.getClass()});
+ bdfObj.jmar = Mockito.mock(JAXBmar.class);
+ LogTarget logT = Mockito.mock(LogTarget.class);
+ Mockito.doReturn(logT).when(env).debug();
+ Mockito.doReturn(this.getClass()).when(bdfObj.jmar).marshal(logT, typeObj, Mockito.mock(StringWriter.class),true);
+ bdfObj.stringify(env, typeObj, Mockito.mock(StringWriter.class),true);
+ } catch (APIException e) {
+ e.printStackTrace();
+ } catch (JAXBException e) {
+ // TODO Auto-generated catch block
+ e.printStackTrace();
+ }
}
@Test
public void testStringifySWOptionsException() {
- JAXBDF<JAXBmar> bdfObj = null;
- try {
- JAXBmar typeObj = new JAXBmar(new Class[] {this.getClass()});
- EnvJAXB envJaxb = Mockito.mock(EnvJAXB.class);
- bdfObj = new JAXBDF( envJaxb, new Class[] {this.getClass()});
- bdfObj.jmar = Mockito.mock(JAXBmar.class);
- LogTarget logT = Mockito.mock(LogTarget.class);
- Mockito.doReturn(logT).when(env).debug();
- StringWriter sw = Mockito.mock(StringWriter.class);
- Mockito.doThrow(new JAXBException("test")).when(bdfObj.jmar).marshal(logT, typeObj, sw,true);
- bdfObj.stringify(env, typeObj, sw,true);
- } catch (APIException e) {
- assertTrue(e.getMessage().contains("test"));
- } catch (JAXBException e) {
- assertTrue(e.getMessage().contains("test"));
- }
+ JAXBDF<JAXBmar> bdfObj = null;
+ try {
+ JAXBmar typeObj = new JAXBmar(new Class[] {this.getClass()});
+ EnvJAXB envJaxb = Mockito.mock(EnvJAXB.class);
+ bdfObj = new JAXBDF( envJaxb, new Class[] {this.getClass()});
+ bdfObj.jmar = Mockito.mock(JAXBmar.class);
+ LogTarget logT = Mockito.mock(LogTarget.class);
+ Mockito.doReturn(logT).when(env).debug();
+ StringWriter sw = Mockito.mock(StringWriter.class);
+ Mockito.doThrow(new JAXBException("test")).when(bdfObj.jmar).marshal(logT, typeObj, sw,true);
+ bdfObj.stringify(env, typeObj, sw,true);
+ } catch (APIException e) {
+ assertTrue(e.getMessage().contains("test"));
+ } catch (JAXBException e) {
+ assertTrue(e.getMessage().contains("test"));
+ }
}
@Test
public void testObjectifyEnv() {
- JAXBDF<JAXBumar> bdfObj = null;
- try {
- EnvJAXB envJaxb = Mockito.mock(EnvJAXB.class);
- bdfObj = new JAXBDF<JAXBumar>( envJaxb, new Class[] {this.getClass()});
- JAXBumar typeObj = new JAXBumar(new Class[] {this.getClass()});
- bdfObj.jumar = Mockito.mock(JAXBumar.class);
- LogTarget logT = Mockito.mock(LogTarget.class);
- Mockito.doReturn(logT).when(env).debug();
- Mockito.doReturn(this.getClass()).when(bdfObj.jumar).unmarshal(logT, Mockito.mock(StringReader.class));
-
- bdfObj.objectify(env, Mockito.mock(StringReader.class));
- } catch (APIException e) {
- assertTrue(e.getMessage().contains("test"));
- } catch (JAXBException e) {
- assertTrue(e.getMessage().contains("test"));
- }
-
+ JAXBDF<JAXBumar> bdfObj = null;
+ try {
+ EnvJAXB envJaxb = Mockito.mock(EnvJAXB.class);
+ bdfObj = new JAXBDF<JAXBumar>( envJaxb, new Class[] {this.getClass()});
+ JAXBumar typeObj = new JAXBumar(new Class[] {this.getClass()});
+ bdfObj.jumar = Mockito.mock(JAXBumar.class);
+ LogTarget logT = Mockito.mock(LogTarget.class);
+ Mockito.doReturn(logT).when(env).debug();
+ Mockito.doReturn(this.getClass()).when(bdfObj.jumar).unmarshal(logT, Mockito.mock(StringReader.class));
+
+ bdfObj.objectify(env, Mockito.mock(StringReader.class));
+ } catch (APIException e) {
+ assertTrue(e.getMessage().contains("test"));
+ } catch (JAXBException e) {
+ assertTrue(e.getMessage().contains("test"));
+ }
+
}
@Test
public void testObjectifyEnvException() {
- JAXBDF<JAXBumar> bdfObj = null;
- try {
- EnvJAXB envJaxb = Mockito.mock(EnvJAXB.class);
- bdfObj = new JAXBDF<JAXBumar>( envJaxb, new Class[] {this.getClass()});
- JAXBumar typeObj = new JAXBumar(new Class[] {this.getClass()});
- bdfObj.jumar = Mockito.mock(JAXBumar.class);
- LogTarget logT = Mockito.mock(LogTarget.class);
- Mockito.doReturn(logT).when(env).debug();
- StringReader sr = Mockito.mock(StringReader.class);
- Mockito.doThrow(new JAXBException("test")).when(bdfObj.jumar).unmarshal(logT, sr);
-
- bdfObj.objectify(env, sr);
- } catch (APIException e) {
- assertTrue(e.getMessage().contains("test"));
- } catch (JAXBException e) {
- assertTrue(e.getMessage().contains("test"));
- }
-
+ JAXBDF<JAXBumar> bdfObj = null;
+ try {
+ EnvJAXB envJaxb = Mockito.mock(EnvJAXB.class);
+ bdfObj = new JAXBDF<JAXBumar>( envJaxb, new Class[] {this.getClass()});
+ JAXBumar typeObj = new JAXBumar(new Class[] {this.getClass()});
+ bdfObj.jumar = Mockito.mock(JAXBumar.class);
+ LogTarget logT = Mockito.mock(LogTarget.class);
+ Mockito.doReturn(logT).when(env).debug();
+ StringReader sr = Mockito.mock(StringReader.class);
+ Mockito.doThrow(new JAXBException("test")).when(bdfObj.jumar).unmarshal(logT, sr);
+
+ bdfObj.objectify(env, sr);
+ } catch (APIException e) {
+ assertTrue(e.getMessage().contains("test"));
+ } catch (JAXBException e) {
+ assertTrue(e.getMessage().contains("test"));
+ }
+
}
@Test
public void testObjectifyRdr() {
- JAXBDF<JAXBumar> bdfObj = null;
- try {
- EnvJAXB envJaxb = Mockito.mock(EnvJAXB.class);
- bdfObj = new JAXBDF<JAXBumar>( envJaxb, new Class[] {this.getClass()});
- JAXBumar typeObj = new JAXBumar(new Class[] {this.getClass()});
- bdfObj.jumar = Mockito.mock(JAXBumar.class);
- LogTarget logT = Mockito.mock(LogTarget.class);
- Mockito.doReturn(logT).when(env).debug();
- Mockito.doReturn(this.getClass()).when(bdfObj.jumar).unmarshal(logT, Mockito.mock(StringReader.class));
-
- bdfObj.objectify( Mockito.mock(StringReader.class));
- } catch (APIException e) {
- assertTrue(e.getMessage().contains("test"));
- } catch (JAXBException e) {
- assertTrue(e.getMessage().contains("test"));
- }
-
+ JAXBDF<JAXBumar> bdfObj = null;
+ try {
+ EnvJAXB envJaxb = Mockito.mock(EnvJAXB.class);
+ bdfObj = new JAXBDF<JAXBumar>( envJaxb, new Class[] {this.getClass()});
+ JAXBumar typeObj = new JAXBumar(new Class[] {this.getClass()});
+ bdfObj.jumar = Mockito.mock(JAXBumar.class);
+ LogTarget logT = Mockito.mock(LogTarget.class);
+ Mockito.doReturn(logT).when(env).debug();
+ Mockito.doReturn(this.getClass()).when(bdfObj.jumar).unmarshal(logT, Mockito.mock(StringReader.class));
+
+ bdfObj.objectify( Mockito.mock(StringReader.class));
+ } catch (APIException e) {
+ assertTrue(e.getMessage().contains("test"));
+ } catch (JAXBException e) {
+ assertTrue(e.getMessage().contains("test"));
+ }
+
}
@Test
public void testObjectifyRdrException() {
- JAXBDF<JAXBumar> bdfObj = null;
- try {
- EnvJAXB envJaxb = Mockito.mock(EnvJAXB.class);
- bdfObj = new JAXBDF<JAXBumar>( envJaxb, new Class[] {this.getClass()});
- JAXBumar typeObj = new JAXBumar(new Class[] {this.getClass()});
- bdfObj.jumar = Mockito.mock(JAXBumar.class);
- LogTarget logT = Mockito.mock(LogTarget.class);
- Mockito.doReturn(logT).when(envJaxb).debug();
- StringReader sr = Mockito.mock(StringReader.class);
- Mockito.doThrow(new JAXBException("test")).when(bdfObj.jumar).unmarshal(logT, sr);
-
- bdfObj.objectify(sr);
- } catch (APIException e) {
- assertTrue(e.getMessage().contains("test"));
- } catch (JAXBException e) {
- assertTrue(e.getMessage().contains("test"));
- }
-
+ JAXBDF<JAXBumar> bdfObj = null;
+ try {
+ EnvJAXB envJaxb = Mockito.mock(EnvJAXB.class);
+ bdfObj = new JAXBDF<JAXBumar>( envJaxb, new Class[] {this.getClass()});
+ JAXBumar typeObj = new JAXBumar(new Class[] {this.getClass()});
+ bdfObj.jumar = Mockito.mock(JAXBumar.class);
+ LogTarget logT = Mockito.mock(LogTarget.class);
+ Mockito.doReturn(logT).when(envJaxb).debug();
+ StringReader sr = Mockito.mock(StringReader.class);
+ Mockito.doThrow(new JAXBException("test")).when(bdfObj.jumar).unmarshal(logT, sr);
+
+ bdfObj.objectify(sr);
+ } catch (APIException e) {
+ assertTrue(e.getMessage().contains("test"));
+ } catch (JAXBException e) {
+ assertTrue(e.getMessage().contains("test"));
+ }
+
}
@Test
public void testObjectifyEnvIS() {
- JAXBDF<JAXBumar> bdfObj = null;
- try {
- EnvJAXB envJaxb = Mockito.mock(EnvJAXB.class);
- bdfObj = new JAXBDF<JAXBumar>( envJaxb, new Class[] {this.getClass()});
- JAXBumar typeObj = new JAXBumar(new Class[] {this.getClass()});
- bdfObj.jumar = Mockito.mock(JAXBumar.class);
- LogTarget logT = Mockito.mock(LogTarget.class);
- Mockito.doReturn(logT).when(env).debug();
- Mockito.doReturn(this.getClass()).when(bdfObj.jumar).unmarshal(logT, Mockito.mock(InputStream.class));
-
- bdfObj.objectify(env, Mockito.mock(InputStream.class));
- } catch (APIException e) {
- assertTrue(e.getMessage().contains("test"));
- } catch (JAXBException e) {
- assertTrue(e.getMessage().contains("test"));
- }
-
+ JAXBDF<JAXBumar> bdfObj = null;
+ try {
+ EnvJAXB envJaxb = Mockito.mock(EnvJAXB.class);
+ bdfObj = new JAXBDF<JAXBumar>( envJaxb, new Class[] {this.getClass()});
+ JAXBumar typeObj = new JAXBumar(new Class[] {this.getClass()});
+ bdfObj.jumar = Mockito.mock(JAXBumar.class);
+ LogTarget logT = Mockito.mock(LogTarget.class);
+ Mockito.doReturn(logT).when(env).debug();
+ Mockito.doReturn(this.getClass()).when(bdfObj.jumar).unmarshal(logT, Mockito.mock(InputStream.class));
+
+ bdfObj.objectify(env, Mockito.mock(InputStream.class));
+ } catch (APIException e) {
+ assertTrue(e.getMessage().contains("test"));
+ } catch (JAXBException e) {
+ assertTrue(e.getMessage().contains("test"));
+ }
+
}
@Test
public void testObjectifyEnvISException() {
- JAXBDF<JAXBumar> bdfObj = null;
- try {
- EnvJAXB envJaxb = Mockito.mock(EnvJAXB.class);
- bdfObj = new JAXBDF<JAXBumar>( envJaxb, new Class[] {this.getClass()});
- JAXBumar typeObj = new JAXBumar(new Class[] {this.getClass()});
- bdfObj.jumar = Mockito.mock(JAXBumar.class);
- LogTarget logT = Mockito.mock(LogTarget.class);
- Mockito.doReturn(logT).when(env).debug();
- InputStream sr = Mockito.mock(InputStream.class);
- Mockito.doThrow(new JAXBException("test")).when(bdfObj.jumar).unmarshal(logT, sr);
-
- bdfObj.objectify(env, sr);
- } catch (APIException e) {
- assertTrue(e.getMessage().contains("test"));
- } catch (JAXBException e) {
- assertTrue(e.getMessage().contains("test"));
- }
-
+ JAXBDF<JAXBumar> bdfObj = null;
+ try {
+ EnvJAXB envJaxb = Mockito.mock(EnvJAXB.class);
+ bdfObj = new JAXBDF<JAXBumar>( envJaxb, new Class[] {this.getClass()});
+ JAXBumar typeObj = new JAXBumar(new Class[] {this.getClass()});
+ bdfObj.jumar = Mockito.mock(JAXBumar.class);
+ LogTarget logT = Mockito.mock(LogTarget.class);
+ Mockito.doReturn(logT).when(env).debug();
+ InputStream sr = Mockito.mock(InputStream.class);
+ Mockito.doThrow(new JAXBException("test")).when(bdfObj.jumar).unmarshal(logT, sr);
+
+ bdfObj.objectify(env, sr);
+ } catch (APIException e) {
+ assertTrue(e.getMessage().contains("test"));
+ } catch (JAXBException e) {
+ assertTrue(e.getMessage().contains("test"));
+ }
+
}
@Test
public void testObjectifyIs() {
- JAXBDF<JAXBumar> bdfObj = null;
- try {
- EnvJAXB envJaxb = Mockito.mock(EnvJAXB.class);
- bdfObj = new JAXBDF<JAXBumar>( envJaxb, new Class[] {this.getClass()});
- JAXBumar typeObj = new JAXBumar(new Class[] {this.getClass()});
- bdfObj.jumar = Mockito.mock(JAXBumar.class);
- LogTarget logT = Mockito.mock(LogTarget.class);
- Mockito.doReturn(logT).when(env).debug();
- Mockito.doReturn(this.getClass()).when(bdfObj.jumar).unmarshal(logT, Mockito.mock(InputStream.class));
-
- bdfObj.objectify( Mockito.mock(InputStream.class));
- } catch (APIException e) {
- assertTrue(e.getMessage().contains("test"));
- } catch (JAXBException e) {
- assertTrue(e.getMessage().contains("test"));
- }
-
+ JAXBDF<JAXBumar> bdfObj = null;
+ try {
+ EnvJAXB envJaxb = Mockito.mock(EnvJAXB.class);
+ bdfObj = new JAXBDF<JAXBumar>( envJaxb, new Class[] {this.getClass()});
+ JAXBumar typeObj = new JAXBumar(new Class[] {this.getClass()});
+ bdfObj.jumar = Mockito.mock(JAXBumar.class);
+ LogTarget logT = Mockito.mock(LogTarget.class);
+ Mockito.doReturn(logT).when(env).debug();
+ Mockito.doReturn(this.getClass()).when(bdfObj.jumar).unmarshal(logT, Mockito.mock(InputStream.class));
+
+ bdfObj.objectify( Mockito.mock(InputStream.class));
+ } catch (APIException e) {
+ assertTrue(e.getMessage().contains("test"));
+ } catch (JAXBException e) {
+ assertTrue(e.getMessage().contains("test"));
+ }
+
}
@Test
public void testObjectifyIsException() {
- JAXBDF<JAXBumar> bdfObj = null;
- try {
- EnvJAXB envJaxb = Mockito.mock(EnvJAXB.class);
- bdfObj = new JAXBDF<JAXBumar>( envJaxb, new Class[] {this.getClass()});
- JAXBumar typeObj = new JAXBumar(new Class[] {this.getClass()});
- bdfObj.jumar = Mockito.mock(JAXBumar.class);
- LogTarget logT = Mockito.mock(LogTarget.class);
- Mockito.doReturn(logT).when(envJaxb).debug();
- InputStream sr = Mockito.mock(InputStream.class);
- Mockito.doThrow(new JAXBException("test")).when(bdfObj.jumar).unmarshal(logT, sr);
-
- bdfObj.objectify(sr);
- } catch (APIException e) {
- assertTrue(e.getMessage().contains("test"));
- } catch (JAXBException e) {
- assertTrue(e.getMessage().contains("test"));
- }
-
+ JAXBDF<JAXBumar> bdfObj = null;
+ try {
+ EnvJAXB envJaxb = Mockito.mock(EnvJAXB.class);
+ bdfObj = new JAXBDF<JAXBumar>( envJaxb, new Class[] {this.getClass()});
+ JAXBumar typeObj = new JAXBumar(new Class[] {this.getClass()});
+ bdfObj.jumar = Mockito.mock(JAXBumar.class);
+ LogTarget logT = Mockito.mock(LogTarget.class);
+ Mockito.doReturn(logT).when(envJaxb).debug();
+ InputStream sr = Mockito.mock(InputStream.class);
+ Mockito.doThrow(new JAXBException("test")).when(bdfObj.jumar).unmarshal(logT, sr);
+
+ bdfObj.objectify(sr);
+ } catch (APIException e) {
+ assertTrue(e.getMessage().contains("test"));
+ } catch (JAXBException e) {
+ assertTrue(e.getMessage().contains("test"));
+ }
+
}
@Test
public void testObjectifyEnvStr() {
- JAXBDF<JAXBumar> bdfObj = null;
- try {
- EnvJAXB envJaxb = Mockito.mock(EnvJAXB.class);
- bdfObj = new JAXBDF<JAXBumar>( envJaxb, new Class[] {this.getClass()});
- JAXBumar typeObj = new JAXBumar(new Class[] {this.getClass()});
- bdfObj.jumar = Mockito.mock(JAXBumar.class);
- LogTarget logT = Mockito.mock(LogTarget.class);
- Mockito.doReturn(logT).when(env).debug();
- Mockito.doReturn(this.getClass()).when(bdfObj.jumar).unmarshal(logT, "test");
-
- bdfObj.objectify(env, "test");
- } catch (APIException e) {
- assertTrue(e.getMessage().contains("test"));
- } catch (JAXBException e) {
- assertTrue(e.getMessage().contains("test"));
- }
-
+ JAXBDF<JAXBumar> bdfObj = null;
+ try {
+ EnvJAXB envJaxb = Mockito.mock(EnvJAXB.class);
+ bdfObj = new JAXBDF<JAXBumar>( envJaxb, new Class[] {this.getClass()});
+ JAXBumar typeObj = new JAXBumar(new Class[] {this.getClass()});
+ bdfObj.jumar = Mockito.mock(JAXBumar.class);
+ LogTarget logT = Mockito.mock(LogTarget.class);
+ Mockito.doReturn(logT).when(env).debug();
+ Mockito.doReturn(this.getClass()).when(bdfObj.jumar).unmarshal(logT, "test");
+
+ bdfObj.objectify(env, "test");
+ } catch (APIException e) {
+ assertTrue(e.getMessage().contains("test"));
+ } catch (JAXBException e) {
+ assertTrue(e.getMessage().contains("test"));
+ }
+
}
@Test
public void testObjectifyEnvStrException() {
- JAXBDF<JAXBumar> bdfObj = null;
- try {
- EnvJAXB envJaxb = Mockito.mock(EnvJAXB.class);
- bdfObj = new JAXBDF<JAXBumar>( envJaxb, new Class[] {this.getClass()});
- JAXBumar typeObj = new JAXBumar(new Class[] {this.getClass()});
- bdfObj.jumar = Mockito.mock(JAXBumar.class);
- LogTarget logT = Mockito.mock(LogTarget.class);
- Mockito.doReturn(logT).when(env).debug();
- InputStream sr = Mockito.mock(InputStream.class);
- Mockito.doThrow(new JAXBException("test")).when(bdfObj.jumar).unmarshal(logT, "test");
-
- bdfObj.objectify(env, "test");
- } catch (APIException e) {
- assertTrue(e.getMessage().contains("test"));
- } catch (JAXBException e) {
- assertTrue(e.getMessage().contains("test"));
- }
-
+ JAXBDF<JAXBumar> bdfObj = null;
+ try {
+ EnvJAXB envJaxb = Mockito.mock(EnvJAXB.class);
+ bdfObj = new JAXBDF<JAXBumar>( envJaxb, new Class[] {this.getClass()});
+ JAXBumar typeObj = new JAXBumar(new Class[] {this.getClass()});
+ bdfObj.jumar = Mockito.mock(JAXBumar.class);
+ LogTarget logT = Mockito.mock(LogTarget.class);
+ Mockito.doReturn(logT).when(env).debug();
+ InputStream sr = Mockito.mock(InputStream.class);
+ Mockito.doThrow(new JAXBException("test")).when(bdfObj.jumar).unmarshal(logT, "test");
+
+ bdfObj.objectify(env, "test");
+ } catch (APIException e) {
+ assertTrue(e.getMessage().contains("test"));
+ } catch (JAXBException e) {
+ assertTrue(e.getMessage().contains("test"));
+ }
+
}
@Test
public void testObjectifyStr() {
- JAXBDF<JAXBumar> bdfObj = null;
- try {
- EnvJAXB envJaxb = Mockito.mock(EnvJAXB.class);
- bdfObj = new JAXBDF<JAXBumar>( envJaxb, new Class[] {this.getClass()});
- JAXBumar typeObj = new JAXBumar(new Class[] {this.getClass()});
- bdfObj.jumar = Mockito.mock(JAXBumar.class);
- LogTarget logT = Mockito.mock(LogTarget.class);
- Mockito.doReturn(logT).when(env).debug();
- Mockito.doReturn(this.getClass()).when(bdfObj.jumar).unmarshal(logT, "test");
-
- bdfObj.objectify( "test");
- } catch (APIException e) {
- assertTrue(e.getMessage().contains("test"));
- } catch (JAXBException e) {
- assertTrue(e.getMessage().contains("test"));
- }
-
+ JAXBDF<JAXBumar> bdfObj = null;
+ try {
+ EnvJAXB envJaxb = Mockito.mock(EnvJAXB.class);
+ bdfObj = new JAXBDF<JAXBumar>( envJaxb, new Class[] {this.getClass()});
+ JAXBumar typeObj = new JAXBumar(new Class[] {this.getClass()});
+ bdfObj.jumar = Mockito.mock(JAXBumar.class);
+ LogTarget logT = Mockito.mock(LogTarget.class);
+ Mockito.doReturn(logT).when(env).debug();
+ Mockito.doReturn(this.getClass()).when(bdfObj.jumar).unmarshal(logT, "test");
+
+ bdfObj.objectify( "test");
+ } catch (APIException e) {
+ assertTrue(e.getMessage().contains("test"));
+ } catch (JAXBException e) {
+ assertTrue(e.getMessage().contains("test"));
+ }
+
}
@Test
public void testObjectifyStrException() {
- JAXBDF<JAXBumar> bdfObj = null;
- try {
- EnvJAXB envJaxb = Mockito.mock(EnvJAXB.class);
- bdfObj = new JAXBDF<JAXBumar>( envJaxb, new Class[] {this.getClass()});
- JAXBumar typeObj = new JAXBumar(new Class[] {this.getClass()});
- bdfObj.jumar = Mockito.mock(JAXBumar.class);
- LogTarget logT = Mockito.mock(LogTarget.class);
- Mockito.doReturn(logT).when(envJaxb).debug();
- InputStream sr = Mockito.mock(InputStream.class);
- Mockito.doThrow(new JAXBException("test")).when(bdfObj.jumar).unmarshal(logT, "test");
-
- bdfObj.objectify("test");
- } catch (APIException e) {
- assertTrue(e.getMessage().contains("test"));
- } catch (JAXBException e) {
- assertTrue(e.getMessage().contains("test"));
- }
-
+ JAXBDF<JAXBumar> bdfObj = null;
+ try {
+ EnvJAXB envJaxb = Mockito.mock(EnvJAXB.class);
+ bdfObj = new JAXBDF<JAXBumar>( envJaxb, new Class[] {this.getClass()});
+ JAXBumar typeObj = new JAXBumar(new Class[] {this.getClass()});
+ bdfObj.jumar = Mockito.mock(JAXBumar.class);
+ LogTarget logT = Mockito.mock(LogTarget.class);
+ Mockito.doReturn(logT).when(envJaxb).debug();
+ InputStream sr = Mockito.mock(InputStream.class);
+ Mockito.doThrow(new JAXBException("test")).when(bdfObj.jumar).unmarshal(logT, "test");
+
+ bdfObj.objectify("test");
+ } catch (APIException e) {
+ assertTrue(e.getMessage().contains("test"));
+ } catch (JAXBException e) {
+ assertTrue(e.getMessage().contains("test"));
+ }
+
}
@Test
public void testTypeClass() {
- JAXBDF<JAXBumar> bdfObj = null;
- try {
- EnvJAXB envJaxb = Mockito.mock(EnvJAXB.class);
- bdfObj = new JAXBDF<JAXBumar>( envJaxb, new Class[] {this.getClass()});
-
- Object obj = bdfObj.getTypeClass();
- assertFalse(obj instanceof JU_JAXBDF);
- } catch (APIException e) {
- assertTrue(e.getMessage().contains("test"));
- }
-
+ JAXBDF<JAXBumar> bdfObj = null;
+ try {
+ EnvJAXB envJaxb = Mockito.mock(EnvJAXB.class);
+ bdfObj = new JAXBDF<JAXBumar>( envJaxb, new Class[] {this.getClass()});
+
+ Object obj = bdfObj.getTypeClass();
+ assertFalse(obj instanceof JU_JAXBDF);
+ } catch (APIException e) {
+ assertTrue(e.getMessage().contains("test"));
+ }
+
}
}
Code Review / aaf / authz.git / blobdiff