2 * ============LICENSE_START====================================================
4 * ===========================================================================
5 * Copyright (c) 2018 AT&T Intellectual Property. All rights reserved.
6 * ===========================================================================
7 * Licensed under the Apache License, Version 2.0 (the "License");
8 * you may not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
11 * http://www.apache.org/licenses/LICENSE-2.0
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS,
15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
18 * ============LICENSE_END====================================================
22 package org.onap.aaf.misc.rosetta.env;
24 import static org.junit.Assert.assertEquals;
25 import static org.junit.Assert.assertTrue;
26 import static org.mockito.MockitoAnnotations.initMocks;
28 import java.io.IOException;
29 import java.io.InputStream;
30 import java.io.InputStreamReader;
31 import java.io.OutputStream;
32 import java.io.StringReader;
33 import java.io.StringWriter;
34 import java.io.Writer;
36 import javax.xml.bind.JAXBException;
38 import org.junit.Before;
39 import org.junit.Test;
40 import org.mockito.Mock;
41 import org.mockito.Mockito;
42 import org.onap.aaf.misc.env.APIException;
43 import org.onap.aaf.misc.env.Data;
44 import org.onap.aaf.misc.env.Data.TYPE;
45 import org.onap.aaf.misc.env.Env;
46 import org.onap.aaf.misc.env.LogTarget;
47 import org.onap.aaf.misc.env.TimeTaken;
48 import org.onap.aaf.misc.env.jaxb.JAXBmar;
49 import org.onap.aaf.misc.env.jaxb.JAXBumar;
50 import org.onap.aaf.misc.rosetta.InXML;
51 import org.onap.aaf.misc.rosetta.Marshal;
52 import org.onap.aaf.misc.rosetta.Out;
53 import org.onap.aaf.misc.rosetta.OutXML;
54 import org.onap.aaf.misc.rosetta.ParseException;
55 import org.onap.aaf.misc.rosetta.Saved;
57 public class JU_RosettaData {
77 public void testLoad() {
78 RosettaData rosettaObj = new RosettaData(env, df);
79 rosettaObj = rosettaObj.in(Data.TYPE.XML);
80 rosettaObj.setSaved(saved);
81 StringReader sr= Mockito.mock(StringReader.class);
83 InXML inxml = Mockito.mock(InXML.class);
84 Mockito.doReturn(inxml).when(df).getIn(Data.TYPE.XML);
85 Mockito.doReturn( Mockito.mock(TimeTaken.class)).when(inxml).start(env);
86 Mockito.doNothing().when(saved).extract(sr,(Writer)null,inxml);
88 rosettaObj = rosettaObj.load(sr);
89 } catch (APIException | IOException | ParseException e) {
90 // TODO Auto-generated catch block
96 public void testLoadException() {
97 RosettaData rosettaObj = new RosettaData(env, df);
98 rosettaObj = rosettaObj.in(Data.TYPE.XML);
100 InXML inxml = Mockito.mock(InXML.class);
101 Mockito.doReturn(inxml).when(df).getIn(Data.TYPE.XML);
102 Mockito.doReturn( Mockito.mock(TimeTaken.class)).when(inxml).start(env);
103 rosettaObj = rosettaObj.load(Mockito.mock(StringReader.class));
104 } catch (APIException e) {
105 assertTrue(e.getMessage().contains("NullPointerException"));
110 public void testLoadIs() {
111 RosettaData rosettaObj = new RosettaData(env, df);
112 rosettaObj = rosettaObj.in(Data.TYPE.XML);
113 rosettaObj.setSaved(saved);
114 InputStream sr= Mockito.mock(InputStream.class);
116 InXML inxml = Mockito.mock(InXML.class);
117 Mockito.doReturn(inxml).when(df).getIn(Data.TYPE.XML);
118 Mockito.doReturn( Mockito.mock(TimeTaken.class)).when(inxml).start(env);
119 Mockito.doNothing().when(saved).extract(new InputStreamReader(sr),(Writer)null,inxml);
121 rosettaObj = rosettaObj.load(sr);
122 } catch (APIException | IOException | ParseException e) {
123 // TODO Auto-generated catch block
129 public void testLoadIsException() {
130 RosettaData rosettaObj = new RosettaData(env, df);
131 rosettaObj = rosettaObj.in(Data.TYPE.XML);
133 InXML inxml = Mockito.mock(InXML.class);
134 Mockito.doReturn(inxml).when(df).getIn(Data.TYPE.XML);
135 Mockito.doReturn( Mockito.mock(TimeTaken.class)).when(inxml).start(env);
136 rosettaObj = rosettaObj.load(Mockito.mock(InputStream.class));
137 } catch (APIException e) {
138 assertTrue(e.getMessage().contains("NullPointerException"));
143 public void testLoadStr() {
144 RosettaData rosettaObj = new RosettaData(env, df);
145 rosettaObj = rosettaObj.in(Data.TYPE.XML);
146 rosettaObj.setSaved(saved);
148 InXML inxml = Mockito.mock(InXML.class);
149 Mockito.doReturn(inxml).when(df).getIn(Data.TYPE.XML);
150 Mockito.doReturn( Mockito.mock(TimeTaken.class)).when(inxml).start(env);
151 Mockito.doNothing().when(saved).extract(new StringReader("test"),(Writer)null,inxml);
153 rosettaObj = rosettaObj.load("test");
154 } catch (APIException | IOException | ParseException e) {
155 // TODO Auto-generated catch block
160 public void testLoadStrJson() {
161 RosettaData rosettaObj = new RosettaData(env, df);
162 rosettaObj = rosettaObj.in(Data.TYPE.JSON);
163 rosettaObj.setSaved(saved);
165 InXML inxml = Mockito.mock(InXML.class);
166 Mockito.doReturn(inxml).when(df).getIn(Data.TYPE.JSON);
167 Mockito.doReturn( Mockito.mock(TimeTaken.class)).when(inxml).start(env);
168 Mockito.doNothing().when(saved).extract(new StringReader("test"),(Writer)null,inxml);
170 rosettaObj = rosettaObj.load("test");
171 } catch (APIException | IOException | ParseException e) {
172 // TODO Auto-generated catch block
177 public void testLoadStrException() {
178 RosettaData rosettaObj = new RosettaData(env, df);
179 rosettaObj = rosettaObj.in(Data.TYPE.XML);
181 InXML inxml = Mockito.mock(InXML.class);
182 Mockito.doReturn(inxml).when(df).getIn(Data.TYPE.XML);
183 Mockito.doReturn( Mockito.mock(TimeTaken.class)).when(inxml).start(env);
184 rosettaObj = rosettaObj.load("test");
185 } catch (APIException e) {
186 assertTrue(e.getMessage().contains("NullPointerException"));
191 public void testLoadT() {
192 RosettaData rosettaObj = new RosettaData(env, df);
193 rosettaObj = rosettaObj.in(Data.TYPE.XML);
194 rosettaObj.setSaved(saved);
196 InXML inxml = Mockito.mock(InXML.class);
197 Mockito.doReturn(inxml).when(df).getIn(Data.TYPE.XML);
198 df.jaxMar = Mockito.mock(JAXBmar.class);
199 Mockito.doReturn( Mockito.mock(TimeTaken.class)).when(inxml).start(env);
200 Mockito.doNothing().when(saved).extract(new StringReader("test"),(Writer)null,inxml);
202 rosettaObj = rosettaObj.load(bmar);
204 rosettaObj = rosettaObj.load(bmar);
205 } catch (APIException | IOException | ParseException e) {
206 // TODO Auto-generated catch block
212 public void testLoadTMarshalNull() {
213 RosettaData rosettaObj = new RosettaData(env, df);
214 rosettaObj = rosettaObj.in(Data.TYPE.XML);
215 rosettaObj.setSaved(saved);
217 InXML inxml = Mockito.mock(InXML.class);
218 Mockito.doReturn(inxml).when(df).getIn(Data.TYPE.XML);
219 df.jaxMar = Mockito.mock(JAXBmar.class);
220 Mockito.doReturn( Mockito.mock(TimeTaken.class)).when(inxml).start(env);
221 Mockito.doNothing().when(saved).extract(new StringReader("test"),(Writer)null,inxml);
222 df.marshal = Mockito.mock(Marshal.class);;
223 rosettaObj = rosettaObj.load(bmar);
224 } catch (APIException | IOException | ParseException e) {
225 // TODO Auto-generated catch block
231 public void testLoadTException() {
232 RosettaData rosettaObj = new RosettaData(env, df);
233 rosettaObj = rosettaObj.in(Data.TYPE.XML);
235 InXML inxml = Mockito.mock(InXML.class);
236 Mockito.doReturn(inxml).when(df).getIn(Data.TYPE.XML);
237 Mockito.doReturn( Mockito.mock(TimeTaken.class)).when(inxml).start(env);
238 rosettaObj = rosettaObj.load(bmar);
239 } catch (APIException e) {
240 assertTrue(e.getMessage().contains("NullPointerException"));
245 public void testGetEvents() {
246 RosettaData rosettaObj = new RosettaData(env, df);
247 Saved saved = rosettaObj.getEvents();
248 assertEquals("Rosetta Saved", saved.logName());
252 public void testAsObject() {
253 RosettaData<JAXBmar> rosettaObj = new RosettaData<JAXBmar>(env, df);
254 rosettaObj = rosettaObj.in(Data.TYPE.XML);
255 rosettaObj.setSaved(saved);
257 Out outxml = Mockito.mock(OutXML.class);
258 Mockito.doReturn(outxml).when(df).getOut(Data.TYPE.XML);
259 Mockito.doReturn(Env.XML).when(df).logType(Data.TYPE.XML);
260 Mockito.doReturn("test").when(outxml).logName();
261 df.jaxMar = Mockito.mock(JAXBmar.class);
262 df.jaxUmar = Mockito.mock(JAXBumar.class);
263 Mockito.doReturn( Mockito.mock(TimeTaken.class)).when(env).start("test",0);
264 LogTarget lt = Mockito.mock(LogTarget.class);
265 Mockito.doReturn( lt).when(env).debug();
266 Mockito.doNothing().when(saved).extract(null,new StringWriter(),saved);
267 Mockito.doReturn(bmar).when(df.jaxUmar).unmarshal(lt,"");
269 bmar = rosettaObj.asObject();
271 } catch (APIException | IOException | ParseException | JAXBException e) {
272 // TODO Auto-generated catch block
278 public void testAsObjectException() {
279 RosettaData<JAXBmar> rosettaObj = new RosettaData<JAXBmar>(env, df);
280 rosettaObj = rosettaObj.in(Data.TYPE.XML);
281 rosettaObj.setSaved(saved);
283 Out outxml = Mockito.mock(OutXML.class);
284 Mockito.doReturn(outxml).when(df).getOut(Data.TYPE.XML);
285 Mockito.doReturn(Env.XML).when(df).logType(Data.TYPE.XML);
286 Mockito.doReturn("test").when(outxml).logName();
287 df.jaxMar = Mockito.mock(JAXBmar.class);
288 df.jaxUmar = Mockito.mock(JAXBumar.class);
289 Mockito.doReturn( Mockito.mock(TimeTaken.class)).when(env).start("test",0);
290 LogTarget lt = Mockito.mock(LogTarget.class);
291 Mockito.doReturn( lt).when(env).debug();
292 Mockito.doThrow(new IOException("test Exception")).when(saved).extract(null,new StringWriter(),saved);
293 Mockito.doThrow(new JAXBException("test Exception")).when(df.jaxUmar).unmarshal(lt,"");
295 bmar = rosettaObj.asObject();
297 } catch (APIException | IOException | ParseException | JAXBException e) {
298 assertTrue(e.getMessage().contains("test Exception"));
303 public void testAsString() {
304 TYPE type = TYPE.XML;
305 Mockito.doReturn(type).when(df).getOutType();
306 RosettaData<JAXBmar> rosettaObj = new RosettaData<JAXBmar>(env, df);
307 rosettaObj = rosettaObj.in(Data.TYPE.XML);
308 rosettaObj.setSaved(saved);
310 Out outxml = Mockito.mock(OutXML.class);
312 Mockito.doReturn(outxml).when(df).getOut(type);
313 Mockito.doReturn(Env.XML).when(df).logType(Data.TYPE.XML);
314 Mockito.doReturn("test").when(outxml).logName();
315 Mockito.doReturn( Mockito.mock(TimeTaken.class)).when(env).start("test",2);
317 String retVal = rosettaObj.asString();
318 assertTrue("".equals(retVal));
319 } catch (APIException e) {
320 // TODO Auto-generated catch block
326 public void testAsStringJson() {
327 TYPE type = TYPE.JSON;
328 Mockito.doReturn(type).when(df).getOutType();
329 RosettaData<JAXBmar> rosettaObj = new RosettaData<JAXBmar>(env, df);
330 rosettaObj = rosettaObj.in(Data.TYPE.JSON);
331 rosettaObj.setSaved(saved);
333 Out outxml = Mockito.mock(OutXML.class);
335 Mockito.doReturn(outxml).when(df).getOut(type);
336 Mockito.doReturn(Env.JSON).when(df).logType(Data.TYPE.JSON);
337 Mockito.doReturn("test").when(outxml).logName();
338 Mockito.doReturn( Mockito.mock(TimeTaken.class)).when(env).start("test",4);
340 String retVal = rosettaObj.asString();
341 assertTrue("".equals(retVal));
342 } catch (APIException e) {
343 // TODO Auto-generated catch block
348 public void testToXml() {
349 TYPE type = TYPE.XML;
350 Mockito.doReturn(type).when(df).getOutType();
351 RosettaData<JAXBmar> rosettaObj = new RosettaData<JAXBmar>(env, df);
352 rosettaObj = rosettaObj.in(Data.TYPE.XML);
353 rosettaObj.setSaved(saved);
356 InXML inxml = Mockito.mock(InXML.class);
357 Mockito.doReturn(inxml).when(df).getIn(Data.TYPE.XML);
358 Mockito.doReturn( Mockito.mock(TimeTaken.class)).when(inxml).start(env);
359 Mockito.doNothing().when(saved).extract(new StringReader("test"),(Writer)null,inxml);
361 rosettaObj = rosettaObj.load("test");
362 } catch (APIException | IOException | ParseException e) {
363 // TODO Auto-generated catch block
368 Out outxml = Mockito.mock(OutXML.class);
370 Mockito.doReturn(outxml).when(df).getOut(type);
371 Mockito.doReturn(Env.XML).when(df).logType(Data.TYPE.XML);
372 Mockito.doReturn("test").when(outxml).logName();
373 Mockito.doReturn( Mockito.mock(TimeTaken.class)).when(env).start("test",2);
374 RosettaData<JAXBmar> retVal = rosettaObj.to(Mockito.mock(OutputStream.class));
376 } catch (APIException | IOException e) {
377 // TODO Auto-generated catch block
383 public void testToJson() {
384 TYPE type = TYPE.JSON;
385 Mockito.doReturn(type).when(df).getOutType();
386 RosettaData<JAXBmar> rosettaObj = new RosettaData<JAXBmar>(env, df);
387 rosettaObj = rosettaObj.in(Data.TYPE.JSON);
388 rosettaObj.setSaved(saved);
391 InXML inxml = Mockito.mock(InXML.class);
392 Mockito.doReturn(inxml).when(df).getIn(Data.TYPE.JSON);
393 Mockito.doReturn( Mockito.mock(TimeTaken.class)).when(inxml).start(env);
394 Mockito.doNothing().when(saved).extract(new StringReader("test"),(Writer)null,inxml);
396 rosettaObj = rosettaObj.load("test");
397 } catch (APIException | IOException | ParseException e) {
398 // TODO Auto-generated catch block
403 Out outxml = Mockito.mock(OutXML.class);
405 Mockito.doReturn(outxml).when(df).getOut(type);
406 Mockito.doReturn(Env.JSON).when(df).logType(Data.TYPE.JSON);
407 Mockito.doReturn("test").when(outxml).logName();
408 Mockito.doReturn( Mockito.mock(TimeTaken.class)).when(env).start("test",4);
409 RosettaData<JAXBmar> retVal = rosettaObj.to(Mockito.mock(OutputStream.class));
411 } catch (APIException | IOException e) {
412 // TODO Auto-generated catch block
418 public void testTo() {
419 TYPE type = TYPE.XML;
420 Mockito.doReturn(type).when(df).getOutType();
421 RosettaData<JAXBmar> rosettaObj = new RosettaData<JAXBmar>(env, df);
422 rosettaObj = rosettaObj.in(Data.TYPE.XML);
423 rosettaObj.setSaved(saved);
426 Out outxml = Mockito.mock(OutXML.class);
428 Mockito.doReturn(outxml).when(df).getOut(type);
429 Mockito.doReturn(Env.XML).when(df).logType(Data.TYPE.XML);
430 Mockito.doReturn("test").when(outxml).logName();
431 Mockito.doReturn( Mockito.mock(TimeTaken.class)).when(env).start("test",2);
432 RosettaData<JAXBmar> retVal = rosettaObj.to(Mockito.mock(OutputStream.class));
434 } catch (APIException | IOException e) {
435 // TODO Auto-generated catch block
441 public void testToWriterXml() {
442 TYPE type = TYPE.XML;
443 Mockito.doReturn(type).when(df).getOutType();
444 RosettaData<JAXBmar> rosettaObj = new RosettaData<JAXBmar>(env, df);
445 rosettaObj = rosettaObj.in(Data.TYPE.XML);
446 rosettaObj.setSaved(saved);
449 InXML inxml = Mockito.mock(InXML.class);
450 Mockito.doReturn(inxml).when(df).getIn(Data.TYPE.XML);
451 Mockito.doReturn( Mockito.mock(TimeTaken.class)).when(inxml).start(env);
452 Mockito.doNothing().when(saved).extract(new StringReader("test"),(Writer)null,inxml);
454 rosettaObj = rosettaObj.load("test");
455 } catch (APIException | IOException | ParseException e) {
456 // TODO Auto-generated catch block
461 Out outxml = Mockito.mock(OutXML.class);
463 Mockito.doReturn(outxml).when(df).getOut(type);
464 Mockito.doReturn(Env.XML).when(df).logType(Data.TYPE.XML);
465 Mockito.doReturn("test").when(outxml).logName();
466 Mockito.doReturn( Mockito.mock(TimeTaken.class)).when(env).start("test",2);
467 RosettaData<JAXBmar> retVal = rosettaObj.to(Mockito.mock(StringWriter.class));
469 } catch (APIException | IOException e) {
470 // TODO Auto-generated catch block
476 public void testToWriterJson() {
477 TYPE type = TYPE.JSON;
478 Mockito.doReturn(type).when(df).getOutType();
479 RosettaData<JAXBmar> rosettaObj = new RosettaData<JAXBmar>(env, df);
480 rosettaObj = rosettaObj.in(Data.TYPE.JSON);
481 rosettaObj.setSaved(saved);
484 InXML inxml = Mockito.mock(InXML.class);
485 Mockito.doReturn(inxml).when(df).getIn(Data.TYPE.JSON);
486 Mockito.doReturn( Mockito.mock(TimeTaken.class)).when(inxml).start(env);
487 Mockito.doNothing().when(saved).extract(new StringReader("test"),(Writer)null,inxml);
489 rosettaObj = rosettaObj.load("test");
490 } catch (APIException | IOException | ParseException e) {
491 // TODO Auto-generated catch block
496 Out outxml = Mockito.mock(OutXML.class);
498 Mockito.doReturn(outxml).when(df).getOut(type);
499 Mockito.doReturn(Env.JSON).when(df).logType(Data.TYPE.JSON);
500 Mockito.doReturn("test").when(outxml).logName();
501 Mockito.doReturn( Mockito.mock(TimeTaken.class)).when(env).start("test",4);
502 RosettaData<JAXBmar> retVal = rosettaObj.to(Mockito.mock(StringWriter.class));
504 } catch (APIException | IOException e) {
505 // TODO Auto-generated catch block
511 public void testToWriter() {
512 TYPE type = TYPE.XML;
513 Mockito.doReturn(type).when(df).getOutType();
514 RosettaData<JAXBmar> rosettaObj = new RosettaData<JAXBmar>(env, df);
515 rosettaObj = rosettaObj.in(Data.TYPE.XML);
516 rosettaObj.setSaved(saved);
519 Out outxml = Mockito.mock(OutXML.class);
521 Mockito.doReturn(outxml).when(df).getOut(type);
522 Mockito.doReturn(Env.XML).when(df).logType(Data.TYPE.XML);
523 Mockito.doReturn("test").when(outxml).logName();
524 Mockito.doReturn( Mockito.mock(TimeTaken.class)).when(env).start("test",2);
525 RosettaData<JAXBmar> retVal = rosettaObj.to(Mockito.mock(StringWriter.class));
527 } catch (APIException | IOException e) {
528 // TODO Auto-generated catch block
534 public void testGetTypeClass() {
535 RosettaData<JAXBmar> rosettaObj = new RosettaData<JAXBmar>(env, df);
536 rosettaObj.getTypeClass();
540 public void testDirect() {
541 TYPE type = TYPE.XML;
542 Mockito.doReturn(type).when(df).getOutType();
543 RosettaData<JAXBmar> rosettaObj = new RosettaData<JAXBmar>(env, df);
545 Out outxml = Mockito.mock(OutXML.class);
546 Mockito.doReturn(outxml).when(df).getOut(type);
547 Mockito.doReturn(Env.XML).when(df).logType(Data.TYPE.XML);
548 Mockito.doReturn("test").when(outxml).logName();
549 Mockito.doReturn( Mockito.mock(TimeTaken.class)).when(env).start("test",2);
550 rosettaObj.direct(Mockito.mock(InputStream.class), Mockito.mock(OutputStream.class));
551 } catch (APIException | IOException e) {
552 // TODO Auto-generated catch block
558 public void testDirectException() {
559 TYPE type = TYPE.XML;
560 Mockito.doReturn(type).when(df).getOutType();
561 Mockito.doReturn(type).when(df).getInType();
562 RosettaData<JAXBmar> rosettaObj = new RosettaData<JAXBmar>(env, df);
565 inxml = Mockito.mock(InXML.class);
566 Mockito.doReturn(inxml).when(df).getIn(type);
569 StringReader is = Mockito.mock(StringReader.class);
570 StringWriter os= Mockito.mock(StringWriter.class);
572 Out outxml = Mockito.mock(OutXML.class);
573 Mockito.doReturn(outxml).when(df).getOut(type);
574 Mockito.doReturn(Env.XML).when(df).logType(Data.TYPE.XML);
575 Mockito.doReturn("test").when(outxml).logName();
576 Mockito.doReturn( Mockito.mock(TimeTaken.class)).when(env).start("test",2);
577 Mockito.doThrow( new IOException("testException")).when(outxml).extract(is, os, inxml, true);
579 rosettaObj.direct(is,os, true);
580 } catch (APIException | IOException | ParseException e) {
581 // TODO Auto-generated catch block
582 assertTrue(e.getMessage().contains("testException"));
587 public void testDirectT() {
588 TYPE type = TYPE.XML;
589 Mockito.doReturn(type).when(df).getOutType();
590 RosettaData<JAXBmar> rosettaObj = new RosettaData<JAXBmar>(env, df);
592 Out outxml = Mockito.mock(OutXML.class);
593 Mockito.doReturn(outxml).when(df).getOut(type);
594 Mockito.doReturn(Env.XML).when(df).logType(Data.TYPE.XML);
595 Mockito.doReturn("test").when(outxml).logName();
596 Mockito.doReturn( Mockito.mock(TimeTaken.class)).when(env).start("test",2);
598 df.jaxMar = Mockito.mock(JAXBmar.class);
599 LogTarget lt = Mockito.mock(LogTarget.class);
600 Mockito.doReturn( lt).when(env).debug();
601 Mockito.doReturn(bmar).when(df.jaxMar).marshal(lt,bmar, new StringWriter(),true);
603 rosettaObj.direct(bmar, Mockito.mock(StringWriter.class), true);
604 df.marshal =Mockito.mock(Marshal.class);;
605 rosettaObj.direct(bmar, Mockito.mock(StringWriter.class), true);
606 } catch (APIException | IOException | JAXBException e) {
607 // TODO Auto-generated catch block
613 public void testDirectTOS() {
614 TYPE type = TYPE.XML;
615 Mockito.doReturn(type).when(df).getOutType();
616 RosettaData<JAXBmar> rosettaObj = new RosettaData<JAXBmar>(env, df);
618 Out outxml = Mockito.mock(OutXML.class);
619 Mockito.doReturn(outxml).when(df).getOut(type);
620 Mockito.doReturn(Env.XML).when(df).logType(Data.TYPE.XML);
621 Mockito.doReturn("test").when(outxml).logName();
622 Mockito.doReturn( Mockito.mock(TimeTaken.class)).when(env).start("test",2);
624 df.jaxMar = Mockito.mock(JAXBmar.class);
625 LogTarget lt = Mockito.mock(LogTarget.class);
626 Mockito.doReturn( lt).when(env).debug();
627 Mockito.doReturn(bmar).when(df.jaxMar).marshal(lt,bmar, new StringWriter(),true);
629 rosettaObj.direct(bmar, Mockito.mock(OutputStream.class), true);
630 df.marshal =Mockito.mock(Marshal.class);;
631 rosettaObj.direct(bmar, Mockito.mock(OutputStream.class), true);
632 } catch (APIException | IOException | JAXBException e) {
633 // TODO Auto-generated catch block
639 public void testDirectTOSJson() {
640 TYPE type = TYPE.JSON;
641 Mockito.doReturn(type).when(df).getOutType();
642 RosettaData<JAXBmar> rosettaObj = new RosettaData<JAXBmar>(env, df);
644 Out outxml = Mockito.mock(OutXML.class);
645 Mockito.doReturn(outxml).when(df).getOut(type);
646 Mockito.doReturn(Env.JSON).when(df).logType(Data.TYPE.JSON);
647 Mockito.doReturn("test").when(outxml).logName();
648 Mockito.doReturn( Mockito.mock(TimeTaken.class)).when(env).start("test",4);
650 df.jaxMar = Mockito.mock(JAXBmar.class);
651 LogTarget lt = Mockito.mock(LogTarget.class);
652 Mockito.doReturn( lt).when(env).debug();
653 Mockito.doReturn(bmar).when(df.jaxMar).marshal(lt,bmar, new StringWriter(),true);
655 rosettaObj.direct(bmar, Mockito.mock(OutputStream.class), true);
656 } catch (APIException | IOException | JAXBException e) {
657 // TODO Auto-generated catch block