misc/rosetta/src/test/java/org/onap/aaf/misc/rosetta/env/JU_RosettaData.java

   1 /**
   2  * ============LICENSE_START====================================================
   3  * org.onap.aaf
   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
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  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====================================================
  19  *
  20  */
  21
  22 package org.onap.aaf.misc.rosetta.env;
  23
  24 import static org.junit.Assert.assertEquals;
  25 import static org.junit.Assert.assertTrue;
  26 import static org.mockito.MockitoAnnotations.initMocks;
  27
  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;
  35
  36 import javax.xml.bind.JAXBException;
  37
  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;
  56
  57 public class JU_RosettaData {
  58
  59     @Mock
  60     Env env;
  61
  62     @Mock
  63     RosettaDF df;
  64
  65     @Mock
  66     JAXBmar bmar;
  67
  68     @Mock
  69     Saved saved;
  70
  71     @Before
  72     public void setUp() {
  73         initMocks(this);
  74     }
  75
  76     @Test
  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);
  82         try {
  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);
  87
  88             rosettaObj = rosettaObj.load(sr);
  89         } catch (APIException | IOException | ParseException e) {
  90             // TODO Auto-generated catch block
  91             e.printStackTrace();
  92         }
  93     }
  94
  95     @Test
  96     public void testLoadException() {
  97         RosettaData rosettaObj = new RosettaData(env, df);
  98         rosettaObj = rosettaObj.in(Data.TYPE.XML);
  99         try {
 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"));
 106         }
 107     }
 108
 109     @Test
 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);
 115         try {
 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);
 120
 121             rosettaObj = rosettaObj.load(sr);
 122         } catch (APIException | IOException | ParseException e) {
 123             // TODO Auto-generated catch block
 124             e.printStackTrace();
 125         }
 126     }
 127
 128     @Test
 129     public void testLoadIsException() {
 130         RosettaData rosettaObj = new RosettaData(env, df);
 131         rosettaObj = rosettaObj.in(Data.TYPE.XML);
 132         try {
 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"));
 139         }
 140     }
 141
 142     @Test
 143     public void testLoadStr() {
 144         RosettaData rosettaObj = new RosettaData(env, df);
 145         rosettaObj = rosettaObj.in(Data.TYPE.XML);
 146         rosettaObj.setSaved(saved);
 147         try {
 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);
 152
 153             rosettaObj = rosettaObj.load("test");
 154         } catch (APIException | IOException | ParseException e) {
 155             // TODO Auto-generated catch block
 156             e.printStackTrace();
 157         }
 158     }
 159     @Test
 160     public void testLoadStrJson() {
 161         RosettaData rosettaObj = new RosettaData(env, df);
 162         rosettaObj = rosettaObj.in(Data.TYPE.JSON);
 163         rosettaObj.setSaved(saved);
 164         try {
 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);
 169
 170             rosettaObj = rosettaObj.load("test");
 171         } catch (APIException | IOException | ParseException e) {
 172             // TODO Auto-generated catch block
 173             e.printStackTrace();
 174         }
 175     }
 176     @Test
 177     public void testLoadStrException() {
 178         RosettaData rosettaObj = new RosettaData(env, df);
 179         rosettaObj = rosettaObj.in(Data.TYPE.XML);
 180         try {
 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"));
 187         }
 188     }
 189
 190     @Test
 191     public void testLoadT() {
 192         RosettaData rosettaObj = new RosettaData(env, df);
 193         rosettaObj = rosettaObj.in(Data.TYPE.XML);
 194         rosettaObj.setSaved(saved);
 195         try {
 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);
 201
 202             rosettaObj = rosettaObj.load(bmar);
 203             df.marshal = null;
 204             rosettaObj = rosettaObj.load(bmar);
 205         } catch (APIException | IOException | ParseException e) {
 206             // TODO Auto-generated catch block
 207             e.printStackTrace();
 208         }
 209     }
 210
 211     @Test
 212     public void testLoadTMarshalNull() {
 213         RosettaData rosettaObj = new RosettaData(env, df);
 214         rosettaObj = rosettaObj.in(Data.TYPE.XML);
 215         rosettaObj.setSaved(saved);
 216         try {
 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
 226             e.printStackTrace();
 227         }
 228     }
 229
 230     @Test
 231     public void testLoadTException() {
 232         RosettaData rosettaObj = new RosettaData(env, df);
 233         rosettaObj = rosettaObj.in(Data.TYPE.XML);
 234         try {
 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"));
 241         }
 242     }
 243
 244     @Test
 245     public void testGetEvents() {
 246         RosettaData rosettaObj = new RosettaData(env, df);
 247         Saved saved = rosettaObj.getEvents();
 248         assertEquals("Rosetta Saved", saved.logName());
 249     }
 250
 251     @Test
 252     public void testAsObject() {
 253         RosettaData<JAXBmar> rosettaObj = new RosettaData<JAXBmar>(env, df);
 254         rosettaObj = rosettaObj.in(Data.TYPE.XML);
 255         rosettaObj.setSaved(saved);
 256         try {
 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,"");
 268
 269             bmar = rosettaObj.asObject();
 270
 271         } catch (APIException | IOException | ParseException | JAXBException e) {
 272             // TODO Auto-generated catch block
 273             e.printStackTrace();
 274         }
 275     }
 276
 277     @Test
 278     public void testAsObjectException() {
 279         RosettaData<JAXBmar> rosettaObj = new RosettaData<JAXBmar>(env, df);
 280         rosettaObj = rosettaObj.in(Data.TYPE.XML);
 281         rosettaObj.setSaved(saved);
 282         try {
 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,"");
 294
 295             bmar = rosettaObj.asObject();
 296
 297         } catch (APIException | IOException | ParseException | JAXBException e) {
 298             assertTrue(e.getMessage().contains("test Exception"));
 299         }
 300     }
 301
 302     @Test
 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);
 309         try {
 310             Out outxml = Mockito.mock(OutXML.class);
 311
 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);
 316
 317             String retVal = rosettaObj.asString();
 318             assertTrue("".equals(retVal));
 319         } catch (APIException  e) {
 320             // TODO Auto-generated catch block
 321             e.printStackTrace();
 322         }
 323     }
 324
 325     @Test
 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);
 332         try {
 333             Out outxml = Mockito.mock(OutXML.class);
 334
 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);
 339
 340             String retVal = rosettaObj.asString();
 341             assertTrue("".equals(retVal));
 342         } catch (APIException  e) {
 343             // TODO Auto-generated catch block
 344             e.printStackTrace();
 345         }
 346     }
 347     @Test
 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);
 354
 355         try {
 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);
 360
 361             rosettaObj = rosettaObj.load("test");
 362         } catch (APIException | IOException | ParseException e) {
 363             // TODO Auto-generated catch block
 364             e.printStackTrace();
 365         }
 366
 367         try {
 368             Out outxml = Mockito.mock(OutXML.class);
 369
 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));
 375
 376         } catch (APIException | IOException  e) {
 377             // TODO Auto-generated catch block
 378             e.printStackTrace();
 379         }
 380     }
 381
 382     @Test
 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);
 389
 390         try {
 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);
 395
 396             rosettaObj = rosettaObj.load("test");
 397         } catch (APIException | IOException | ParseException e) {
 398             // TODO Auto-generated catch block
 399             e.printStackTrace();
 400         }
 401
 402         try {
 403             Out outxml = Mockito.mock(OutXML.class);
 404
 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));
 410
 411         } catch (APIException | IOException  e) {
 412             // TODO Auto-generated catch block
 413             e.printStackTrace();
 414         }
 415     }
 416
 417     @Test
 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);
 424
 425         try {
 426             Out outxml = Mockito.mock(OutXML.class);
 427
 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));
 433
 434         } catch (APIException | IOException  e) {
 435             // TODO Auto-generated catch block
 436             e.printStackTrace();
 437         }
 438     }
 439
 440     @Test
 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);
 447
 448         try {
 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);
 453
 454             rosettaObj = rosettaObj.load("test");
 455         } catch (APIException | IOException | ParseException e) {
 456             // TODO Auto-generated catch block
 457             e.printStackTrace();
 458         }
 459
 460         try {
 461             Out outxml = Mockito.mock(OutXML.class);
 462
 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));
 468
 469         } catch (APIException | IOException  e) {
 470             // TODO Auto-generated catch block
 471             e.printStackTrace();
 472         }
 473     }
 474
 475     @Test
 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);
 482
 483         try {
 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);
 488
 489             rosettaObj = rosettaObj.load("test");
 490         } catch (APIException | IOException | ParseException e) {
 491             // TODO Auto-generated catch block
 492             e.printStackTrace();
 493         }
 494
 495         try {
 496             Out outxml = Mockito.mock(OutXML.class);
 497
 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));
 503
 504         } catch (APIException | IOException  e) {
 505             // TODO Auto-generated catch block
 506             e.printStackTrace();
 507         }
 508     }
 509
 510     @Test
 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);
 517
 518         try {
 519             Out outxml = Mockito.mock(OutXML.class);
 520
 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));
 526
 527         } catch (APIException | IOException  e) {
 528             // TODO Auto-generated catch block
 529             e.printStackTrace();
 530         }
 531     }
 532
 533     @Test
 534     public void testGetTypeClass() {
 535         RosettaData<JAXBmar> rosettaObj = new RosettaData<JAXBmar>(env, df);
 536         rosettaObj.getTypeClass();
 537     }
 538
 539     @Test
 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);
 544         try {
 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
 553             e.printStackTrace();
 554         }
 555     }
 556
 557     @Test
 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);
 563         InXML inxml = null;
 564
 565         inxml = Mockito.mock(InXML.class);
 566         Mockito.doReturn(inxml).when(df).getIn(type);
 567
 568
 569         StringReader is = Mockito.mock(StringReader.class);
 570         StringWriter os= Mockito.mock(StringWriter.class);
 571         try {
 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);
 578
 579             rosettaObj.direct(is,os, true);
 580         } catch (APIException | IOException | ParseException e) {
 581             // TODO Auto-generated catch block
 582             assertTrue(e.getMessage().contains("testException"));
 583         }
 584     }
 585
 586     @Test
 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);
 591         try {
 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);
 597
 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);
 602
 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
 608             e.printStackTrace();
 609         }
 610     }
 611
 612     @Test
 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);
 617         try {
 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);
 623
 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);
 628
 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
 634             e.printStackTrace();
 635         }
 636     }
 637
 638     @Test
 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);
 643         try {
 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);
 649
 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);
 654
 655             rosettaObj.direct(bmar, Mockito.mock(OutputStream.class), true);
 656         } catch (APIException | IOException | JAXBException e) {
 657             // TODO Auto-generated catch block
 658             e.printStackTrace();
 659         }
 660     }
 661
 662
 663 }