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 }