misc/env/src/test/java/org/onap/aaf/misc/env/jaxb/JU_JAXBDF.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.env.jaxb;
  23
  24 import static org.junit.Assert.assertEquals;
  25 import static org.junit.Assert.assertFalse;
  26 import static org.junit.Assert.assertTrue;
  27 import static org.mockito.MockitoAnnotations.initMocks;
  28
  29 import java.io.InputStream;
  30 import java.io.OutputStream;
  31 import java.io.StringReader;
  32 import java.io.StringWriter;
  33
  34 import javax.xml.bind.JAXBException;
  35 import javax.xml.namespace.QName;
  36 import javax.xml.validation.Schema;
  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.Env;
  45 import org.onap.aaf.misc.env.EnvJAXB;
  46 import org.onap.aaf.misc.env.LogTarget;
  47 import org.onap.aaf.misc.env.TimeTaken;
  48
  49 public class JU_JAXBDF {
  50
  51     @Mock
  52     EnvJAXB primaryEnv;
  53
  54     @Mock
  55     JAXBumar jumar;
  56
  57     @Mock
  58     JAXBmar jmar;
  59
  60     @Mock
  61     Env env;
  62
  63     TimeTaken tt,ttObjectify;
  64
  65     @Before
  66     public void setUp() {
  67         initMocks(this);
  68         tt=Mockito.mock(TimeTaken.class);
  69         Mockito.doReturn(tt).when(env).start("JAXB Stringify", Env.XML);
  70                 Mockito.doNothing().when(tt).done();
  71                 ttObjectify=Mockito.mock(TimeTaken.class);
  72         Mockito.doReturn(ttObjectify).when(env).start("JAXB Objectify", Env.XML);
  73                 Mockito.doNothing().when(ttObjectify).done();
  74     }
  75
  76     @Test
  77     public void testNewInstance() {
  78         JAXBDF<?> bdfObj = null;
  79                 try {
  80                         bdfObj = new JAXBDF( null, new Class[] {this.getClass()});
  81                         bdfObj.jumar = Mockito.mock(JAXBumar.class);
  82                         Mockito.doThrow(new IllegalAccessException("Test Exception")).when(bdfObj.jumar).newInstance();
  83                 Object retVal = bdfObj.newInstance();
  84                 } catch (IllegalAccessException e) {
  85                         assertEquals("Test Exception", e.getLocalizedMessage());
  86                 } catch (APIException e) {
  87                         assertTrue(e.getMessage().contains("Test Exception"));
  88                 } catch (InstantiationException e) {
  89                         // TODO Auto-generated catch block
  90                         e.printStackTrace();
  91                 }
  92
  93     }
  94
  95     @Test
  96     public void testNewInstanceNoException() {
  97         JAXBDF<?> bdfObj = null;
  98                 try {
  99                         bdfObj = new JAXBDF( null, new Class[] {this.getClass()});
 100                 Object retVal = bdfObj.newInstance();
 101                 assertTrue(retVal instanceof JU_JAXBDF);
 102                 } catch (APIException e) {
 103                         e.printStackTrace();
 104                 }
 105
 106     }
 107
 108     @Test
 109     public void testPrettyNoException() {
 110         JAXBDF<?> bdfObj = null;
 111                 try {
 112                         bdfObj = new JAXBDF( null, Mockito.mock(Schema.class), new Class[] {this.getClass()});
 113                 Object retVal = bdfObj.pretty(true);
 114                 assertTrue(retVal instanceof JAXBDF);
 115                 } catch (APIException e) {
 116                         e.printStackTrace();
 117                 }
 118     }
 119
 120     @Test
 121     public void testFragment() {
 122         JAXBDF<?> bdfObj = null;
 123                 try {
 124                         bdfObj = new JAXBDF( null, Mockito.mock(QName.class), new Class[] {this.getClass()});
 125                 Object retVal = bdfObj.asFragment(true);
 126                 assertTrue(retVal instanceof JAXBDF);
 127                 bdfObj.servicePrestart(null);
 128                 bdfObj.threadPrestart(null);
 129                 bdfObj.refresh(null);
 130                 bdfObj.threadDestroy(null);
 131                 bdfObj.serviceDestroy(null);
 132                 } catch (APIException e) {
 133                         e.printStackTrace();
 134                 }
 135
 136     }
 137
 138     @Test
 139     public void testNewData() {
 140         JAXBDF<?> bdfObj = null;
 141                 try {
 142                         bdfObj = new JAXBDF( null, Mockito.mock(Schema.class),Mockito.mock(QName.class), new Class[] {this.getClass()});
 143                 Data<?> retVal = bdfObj.newData();
 144                 assertTrue(retVal instanceof JAXBData);
 145                 } catch (APIException e) {
 146                         e.printStackTrace();
 147                 }
 148     }
 149
 150     @Test
 151     public void testNewDataENV() {
 152         JAXBDF<?> bdfObj = null;
 153                 try {
 154                         bdfObj = new JAXBDF( null, Mockito.mock(Schema.class),Mockito.mock(QName.class), new Class[] {this.getClass()});
 155                 Data<?> retVal = bdfObj.newData(Mockito.mock(Env.class));
 156                 assertTrue(retVal instanceof JAXBData);
 157                 } catch (APIException e) {
 158                         e.printStackTrace();
 159                 }
 160     }
 161
 162     @Test
 163     public void testNewDataType() {
 164         JAXBDF<JAXBumar> bdfObj = null;
 165                 try {
 166                         bdfObj = new JAXBDF( null, Mockito.mock(Schema.class),Mockito.mock(QName.class), new Class[] {this.getClass()});
 167                 Data<?> retVal = bdfObj.newData(new JAXBumar(new Class[] {this.getClass()}));
 168                 assertTrue(retVal instanceof JAXBData);
 169                 } catch (APIException e) {
 170                         e.printStackTrace();
 171                 } catch (JAXBException e) {
 172                         // TODO Auto-generated catch block
 173                         e.printStackTrace();
 174                 }
 175     }
 176
 177     @Test
 178     public void testNewDataStream() {
 179         JAXBDF<?> bdfObj = null;
 180                 try {
 181                         bdfObj = new JAXBDF( null, Mockito.mock(Schema.class),Mockito.mock(QName.class), new Class[] {this.getClass()});
 182                         bdfObj.jumar =  Mockito.mock(JAXBumar.class);
 183                         LogTarget logT = Mockito.mock(LogTarget.class);
 184                         Mockito.doReturn(logT).when(env).debug();
 185                         InputStream is = Mockito.mock(InputStream.class);
 186                         Mockito.doReturn(this.getClass()).when(bdfObj.jumar).unmarshal(logT, is);
 187                 Data<?> retVal = bdfObj.newDataFromStream(env, is);
 188                 assertTrue(retVal instanceof JAXBData);
 189                 } catch (APIException e) {
 190                         e.printStackTrace();
 191                 } catch (JAXBException e) {
 192                         // TODO Auto-generated catch block
 193                         e.printStackTrace();
 194                 }
 195     }
 196
 197     @Test
 198     public void testNewDataStreamException() {
 199         JAXBDF<?> bdfObj = null;
 200                 try {
 201                         bdfObj = new JAXBDF( null, Mockito.mock(Schema.class),Mockito.mock(QName.class), new Class[] {this.getClass()});
 202                         bdfObj.jumar =  Mockito.mock(JAXBumar.class);
 203                         LogTarget logT = Mockito.mock(LogTarget.class);
 204                         Mockito.doReturn(logT).when(env).debug();
 205                         InputStream is = Mockito.mock(InputStream.class);
 206                         Mockito.doThrow(new JAXBException("test")).when(bdfObj.jumar).unmarshal(logT, is);
 207                 Data<?> retVal = bdfObj.newDataFromStream(env, is);
 208                 } catch (APIException e) {
 209                         assertTrue(e.getMessage().contains("test"));
 210                 } catch (JAXBException e) {
 211                         // TODO Auto-generated catch block
 212                         assertTrue(e.getMessage().contains("test"));
 213                 }
 214     }
 215
 216     @Test
 217     public void testNewDataFromString() {
 218         JAXBDF<?> bdfObj = null;
 219                 try {
 220                         bdfObj = new JAXBDF( null, Mockito.mock(Schema.class),Mockito.mock(QName.class), new Class[] {this.getClass()});
 221                 Data<?> retVal = bdfObj.newDataFromString("test");
 222                 assertTrue(retVal instanceof JAXBData);
 223                 } catch (APIException e) {
 224                         e.printStackTrace();
 225                 }
 226     }
 227
 228     @Test
 229     public void testStringify() {
 230         JAXBDF<JAXBmar> bdfObj = null;
 231                 try {
 232                         JAXBmar typeObj = new JAXBmar(new Class[] {this.getClass()});
 233                         EnvJAXB envJaxb = Mockito.mock(EnvJAXB.class);
 234                         bdfObj = new JAXBDF( envJaxb, new Class[] {this.getClass()});
 235                         bdfObj.jmar =  Mockito.mock(JAXBmar.class);
 236                         LogTarget logT = Mockito.mock(LogTarget.class);
 237                         Mockito.doReturn(logT).when(envJaxb).debug();
 238                         Mockito.doReturn(this.getClass()).when(bdfObj.jmar).marshal(logT, typeObj, Mockito.mock(StringWriter.class));
 239                 String retVal = bdfObj.stringify(typeObj);
 240                 assertEquals("", retVal);
 241                 } catch (APIException e) {
 242                         e.printStackTrace();
 243                 } catch (JAXBException e) {
 244                         // TODO Auto-generated catch block
 245                         e.printStackTrace();
 246                 }
 247     }
 248
 249     @Test
 250     public void testStringifyException() {
 251         JAXBDF<JAXBmar> bdfObj = null;
 252                 try {
 253                         JAXBmar typeObj = new JAXBmar(new Class[] {this.getClass()});
 254                         EnvJAXB envJaxb = Mockito.mock(EnvJAXB.class);
 255                         LogTarget logT = Mockito.mock(LogTarget.class);
 256                         Mockito.doReturn(logT).when(envJaxb).debug();
 257                         bdfObj = new JAXBDF<JAXBmar>( envJaxb, new Class[] {this.getClass()});
 258                         bdfObj.jmar =  Mockito.mock(JAXBmar.class);
 259                         Mockito.doThrow(new JAXBException("test") ).when(bdfObj.jmar).marshal(logT, typeObj, Mockito.mock(StringWriter.class));
 260                 String retVal = bdfObj.stringify(typeObj);
 261                 System.out.println(retVal);
 262                 } catch (APIException e) {
 263                         assertTrue(e.getMessage().contains("test"));
 264                 } catch (JAXBException e) {
 265                         assertTrue(e.getMessage().contains("test"));
 266                 }
 267     }
 268
 269     @Test
 270     public void testStringifyWriter() {
 271         JAXBDF<JAXBmar> bdfObj = null;
 272                 try {
 273                         JAXBmar typeObj = new JAXBmar(new Class[] {this.getClass()});
 274                         EnvJAXB envJaxb = Mockito.mock(EnvJAXB.class);
 275                         bdfObj = new JAXBDF( envJaxb, new Class[] {this.getClass()});
 276                         bdfObj.jmar =  Mockito.mock(JAXBmar.class);
 277                         LogTarget logT = Mockito.mock(LogTarget.class);
 278                         Mockito.doReturn(logT).when(envJaxb).debug();
 279                         Mockito.doReturn(this.getClass()).when(bdfObj.jmar).marshal(logT, typeObj, Mockito.mock(StringWriter.class));
 280                 bdfObj.stringify(typeObj, Mockito.mock(StringWriter.class));
 281                 } catch (APIException e) {
 282                         e.printStackTrace();
 283                 } catch (JAXBException e) {
 284                         // TODO Auto-generated catch block
 285                         e.printStackTrace();
 286                 }
 287     }
 288
 289     @Test
 290     public void testStringifyWriterException() {
 291         JAXBDF<JAXBmar> bdfObj = null;
 292                 try {
 293                         JAXBmar typeObj = new JAXBmar(new Class[] {this.getClass()});
 294                         EnvJAXB envJaxb = Mockito.mock(EnvJAXB.class);
 295                         bdfObj = new JAXBDF( envJaxb, new Class[] {this.getClass()});
 296                         bdfObj.jmar =  Mockito.mock(JAXBmar.class);
 297                         LogTarget logT = Mockito.mock(LogTarget.class);
 298                         Mockito.doReturn(logT).when(envJaxb).debug();
 299                         StringWriter sw = Mockito.mock(StringWriter.class);
 300                         Mockito.doThrow(new JAXBException("test")).when(bdfObj.jmar).marshal(logT, typeObj, sw);
 301                 bdfObj.stringify(typeObj, sw);
 302                 } catch (APIException e) {
 303                         assertTrue(e.getMessage().contains("test"));
 304                 } catch (JAXBException e) {
 305                         assertTrue(e.getMessage().contains("test"));
 306                 }
 307     }
 308
 309     @Test
 310     public void testStringifyOS() {
 311         JAXBDF<JAXBmar> bdfObj = null;
 312                 try {
 313                         JAXBmar typeObj = new JAXBmar(new Class[] {this.getClass()});
 314                         EnvJAXB envJaxb = Mockito.mock(EnvJAXB.class);
 315                         bdfObj = new JAXBDF( envJaxb, new Class[] {this.getClass()});
 316                         bdfObj.jmar =  Mockito.mock(JAXBmar.class);
 317                         LogTarget logT = Mockito.mock(LogTarget.class);
 318                         Mockito.doReturn(logT).when(envJaxb).debug();
 319                         Mockito.doReturn(this.getClass()).when(bdfObj.jmar).marshal(logT, typeObj, Mockito.mock(OutputStream.class));
 320                 bdfObj.stringify(typeObj, Mockito.mock(OutputStream.class));
 321                 } catch (APIException e) {
 322                         e.printStackTrace();
 323                 } catch (JAXBException e) {
 324                         // TODO Auto-generated catch block
 325                         e.printStackTrace();
 326                 }
 327     }
 328
 329     @Test
 330     public void testStringifyOsException() {
 331         JAXBDF<JAXBmar> bdfObj = null;
 332                 try {
 333                         JAXBmar typeObj = new JAXBmar(new Class[] {this.getClass()});
 334                         EnvJAXB envJaxb = Mockito.mock(EnvJAXB.class);
 335                         bdfObj = new JAXBDF( envJaxb, new Class[] {this.getClass()});
 336                         bdfObj.jmar =  Mockito.mock(JAXBmar.class);
 337                         LogTarget logT = Mockito.mock(LogTarget.class);
 338                         Mockito.doReturn(logT).when(envJaxb).debug();
 339                         OutputStream sw = Mockito.mock(OutputStream.class);
 340                         Mockito.doThrow(new JAXBException("test")).when(bdfObj.jmar).marshal(logT, typeObj, sw);
 341                 bdfObj.stringify(typeObj, sw);
 342                 } catch (APIException e) {
 343                         assertTrue(e.getMessage().contains("test"));
 344                 } catch (JAXBException e) {
 345                         assertTrue(e.getMessage().contains("test"));
 346                 }
 347     }
 348
 349     @Test
 350     public void testStringifyOptions() {
 351         JAXBDF<JAXBmar> bdfObj = null;
 352                 try {
 353                         JAXBmar typeObj = new JAXBmar(new Class[] {this.getClass()});
 354                         EnvJAXB envJaxb = Mockito.mock(EnvJAXB.class);
 355                         bdfObj = new JAXBDF( envJaxb, new Class[] {this.getClass()});
 356                         bdfObj.jmar =  Mockito.mock(JAXBmar.class);
 357                         LogTarget logT = Mockito.mock(LogTarget.class);
 358                         Mockito.doReturn(logT).when(envJaxb).debug();
 359                         Mockito.doReturn(this.getClass()).when(bdfObj.jmar).marshal(logT, typeObj, Mockito.mock(OutputStream.class));
 360                 bdfObj.stringify(env, typeObj, true);
 361                 } catch (APIException e) {
 362                         e.printStackTrace();
 363                 } catch (JAXBException e) {
 364                         // TODO Auto-generated catch block
 365                         e.printStackTrace();
 366                 }
 367     }
 368
 369     @Test
 370     public void testStringifyOSOptions() {
 371         JAXBDF<JAXBmar> bdfObj = null;
 372                 try {
 373                         JAXBmar typeObj = new JAXBmar(new Class[] {this.getClass()});
 374                         EnvJAXB envJaxb = Mockito.mock(EnvJAXB.class);
 375                         bdfObj = new JAXBDF( envJaxb, new Class[] {this.getClass()});
 376                         bdfObj.jmar =  Mockito.mock(JAXBmar.class);
 377                         LogTarget logT = Mockito.mock(LogTarget.class);
 378                         Mockito.doReturn(logT).when(env).debug();
 379                         Mockito.doReturn(this.getClass()).when(bdfObj.jmar).marshal(logT, typeObj, Mockito.mock(OutputStream.class),true);
 380                 bdfObj.stringify(env, typeObj, Mockito.mock(OutputStream.class),true);
 381                 } catch (APIException e) {
 382                         e.printStackTrace();
 383                 } catch (JAXBException e) {
 384                         // TODO Auto-generated catch block
 385                         e.printStackTrace();
 386                 }
 387     }
 388
 389     @Test
 390     public void testStringifyOsOptionsException() {
 391         JAXBDF<JAXBmar> bdfObj = null;
 392                 try {
 393                         JAXBmar typeObj = new JAXBmar(new Class[] {this.getClass()});
 394                         EnvJAXB envJaxb = Mockito.mock(EnvJAXB.class);
 395                         bdfObj = new JAXBDF( envJaxb, new Class[] {this.getClass()});
 396                         bdfObj.jmar =  Mockito.mock(JAXBmar.class);
 397                         LogTarget logT = Mockito.mock(LogTarget.class);
 398                         Mockito.doReturn(logT).when(env).debug();
 399                         OutputStream sw = Mockito.mock(OutputStream.class);
 400                         Mockito.doThrow(new JAXBException("test")).when(bdfObj.jmar).marshal(logT, typeObj, sw,true);
 401                 bdfObj.stringify(env, typeObj, sw,true);
 402                 } catch (APIException e) {
 403                         assertTrue(e.getMessage().contains("test"));
 404                 } catch (JAXBException e) {
 405                         assertTrue(e.getMessage().contains("test"));
 406                 }
 407     }
 408     @Test
 409     public void testStringifySWOptions() {
 410         JAXBDF<JAXBmar> bdfObj = null;
 411                 try {
 412                         JAXBmar typeObj = new JAXBmar(new Class[] {this.getClass()});
 413                         EnvJAXB envJaxb = Mockito.mock(EnvJAXB.class);
 414                         bdfObj = new JAXBDF( envJaxb, new Class[] {this.getClass()});
 415                         bdfObj.jmar =  Mockito.mock(JAXBmar.class);
 416                         LogTarget logT = Mockito.mock(LogTarget.class);
 417                         Mockito.doReturn(logT).when(env).debug();
 418                         Mockito.doReturn(this.getClass()).when(bdfObj.jmar).marshal(logT, typeObj, Mockito.mock(StringWriter.class),true);
 419                 bdfObj.stringify(env, typeObj, Mockito.mock(StringWriter.class),true);
 420                 } catch (APIException e) {
 421                         e.printStackTrace();
 422                 } catch (JAXBException e) {
 423                         // TODO Auto-generated catch block
 424                         e.printStackTrace();
 425                 }
 426     }
 427
 428     @Test
 429     public void testStringifySWOptionsException() {
 430         JAXBDF<JAXBmar> bdfObj = null;
 431                 try {
 432                         JAXBmar typeObj = new JAXBmar(new Class[] {this.getClass()});
 433                         EnvJAXB envJaxb = Mockito.mock(EnvJAXB.class);
 434                         bdfObj = new JAXBDF( envJaxb, new Class[] {this.getClass()});
 435                         bdfObj.jmar =  Mockito.mock(JAXBmar.class);
 436                         LogTarget logT = Mockito.mock(LogTarget.class);
 437                         Mockito.doReturn(logT).when(env).debug();
 438                         StringWriter sw = Mockito.mock(StringWriter.class);
 439                         Mockito.doThrow(new JAXBException("test")).when(bdfObj.jmar).marshal(logT, typeObj, sw,true);
 440                 bdfObj.stringify(env, typeObj, sw,true);
 441                 } catch (APIException e) {
 442                         assertTrue(e.getMessage().contains("test"));
 443                 } catch (JAXBException e) {
 444                         assertTrue(e.getMessage().contains("test"));
 445                 }
 446     }
 447
 448     @Test
 449     public void testObjectifyEnv() {
 450         JAXBDF<JAXBumar> bdfObj = null;
 451                 try {
 452                         EnvJAXB envJaxb = Mockito.mock(EnvJAXB.class);
 453                         bdfObj = new JAXBDF<JAXBumar>( envJaxb, new Class[] {this.getClass()});
 454                         JAXBumar typeObj = new JAXBumar(new Class[] {this.getClass()});
 455                         bdfObj.jumar =  Mockito.mock(JAXBumar.class);
 456                         LogTarget logT = Mockito.mock(LogTarget.class);
 457                         Mockito.doReturn(logT).when(env).debug();
 458                         Mockito.doReturn(this.getClass()).when(bdfObj.jumar).unmarshal(logT, Mockito.mock(StringReader.class));
 459
 460                 bdfObj.objectify(env, Mockito.mock(StringReader.class));
 461                 } catch (APIException e) {
 462                         assertTrue(e.getMessage().contains("test"));
 463                 } catch (JAXBException e) {
 464                         assertTrue(e.getMessage().contains("test"));
 465                 }
 466
 467     }
 468     @Test
 469     public void testObjectifyEnvException() {
 470         JAXBDF<JAXBumar> bdfObj = null;
 471                 try {
 472                         EnvJAXB envJaxb = Mockito.mock(EnvJAXB.class);
 473                         bdfObj = new JAXBDF<JAXBumar>( envJaxb, new Class[] {this.getClass()});
 474                         JAXBumar typeObj = new JAXBumar(new Class[] {this.getClass()});
 475                         bdfObj.jumar =  Mockito.mock(JAXBumar.class);
 476                         LogTarget logT = Mockito.mock(LogTarget.class);
 477                         Mockito.doReturn(logT).when(env).debug();
 478                         StringReader sr = Mockito.mock(StringReader.class);
 479                         Mockito.doThrow(new JAXBException("test")).when(bdfObj.jumar).unmarshal(logT, sr);
 480
 481                 bdfObj.objectify(env, sr);
 482                 } catch (APIException e) {
 483                         assertTrue(e.getMessage().contains("test"));
 484                 } catch (JAXBException e) {
 485                         assertTrue(e.getMessage().contains("test"));
 486                 }
 487
 488     }
 489
 490     @Test
 491     public void testObjectifyRdr() {
 492         JAXBDF<JAXBumar> bdfObj = null;
 493                 try {
 494                         EnvJAXB envJaxb = Mockito.mock(EnvJAXB.class);
 495                         bdfObj = new JAXBDF<JAXBumar>( envJaxb, new Class[] {this.getClass()});
 496                         JAXBumar typeObj = new JAXBumar(new Class[] {this.getClass()});
 497                         bdfObj.jumar =  Mockito.mock(JAXBumar.class);
 498                         LogTarget logT = Mockito.mock(LogTarget.class);
 499                         Mockito.doReturn(logT).when(env).debug();
 500                         Mockito.doReturn(this.getClass()).when(bdfObj.jumar).unmarshal(logT, Mockito.mock(StringReader.class));
 501
 502                 bdfObj.objectify( Mockito.mock(StringReader.class));
 503                 } catch (APIException e) {
 504                         assertTrue(e.getMessage().contains("test"));
 505                 } catch (JAXBException e) {
 506                         assertTrue(e.getMessage().contains("test"));
 507                 }
 508
 509     }
 510     @Test
 511     public void testObjectifyRdrException() {
 512         JAXBDF<JAXBumar> bdfObj = null;
 513                 try {
 514                         EnvJAXB envJaxb = Mockito.mock(EnvJAXB.class);
 515                         bdfObj = new JAXBDF<JAXBumar>( envJaxb, new Class[] {this.getClass()});
 516                         JAXBumar typeObj = new JAXBumar(new Class[] {this.getClass()});
 517                         bdfObj.jumar =  Mockito.mock(JAXBumar.class);
 518                         LogTarget logT = Mockito.mock(LogTarget.class);
 519                         Mockito.doReturn(logT).when(envJaxb).debug();
 520                         StringReader sr = Mockito.mock(StringReader.class);
 521                         Mockito.doThrow(new JAXBException("test")).when(bdfObj.jumar).unmarshal(logT, sr);
 522
 523                 bdfObj.objectify(sr);
 524                 } catch (APIException e) {
 525                         assertTrue(e.getMessage().contains("test"));
 526                 } catch (JAXBException e) {
 527                         assertTrue(e.getMessage().contains("test"));
 528                 }
 529
 530     }
 531
 532     @Test
 533     public void testObjectifyEnvIS() {
 534         JAXBDF<JAXBumar> bdfObj = null;
 535                 try {
 536                         EnvJAXB envJaxb = Mockito.mock(EnvJAXB.class);
 537                         bdfObj = new JAXBDF<JAXBumar>( envJaxb, new Class[] {this.getClass()});
 538                         JAXBumar typeObj = new JAXBumar(new Class[] {this.getClass()});
 539                         bdfObj.jumar =  Mockito.mock(JAXBumar.class);
 540                         LogTarget logT = Mockito.mock(LogTarget.class);
 541                         Mockito.doReturn(logT).when(env).debug();
 542                         Mockito.doReturn(this.getClass()).when(bdfObj.jumar).unmarshal(logT, Mockito.mock(InputStream.class));
 543
 544                 bdfObj.objectify(env, Mockito.mock(InputStream.class));
 545                 } catch (APIException e) {
 546                         assertTrue(e.getMessage().contains("test"));
 547                 } catch (JAXBException e) {
 548                         assertTrue(e.getMessage().contains("test"));
 549                 }
 550
 551     }
 552     @Test
 553     public void testObjectifyEnvISException() {
 554         JAXBDF<JAXBumar> bdfObj = null;
 555                 try {
 556                         EnvJAXB envJaxb = Mockito.mock(EnvJAXB.class);
 557                         bdfObj = new JAXBDF<JAXBumar>( envJaxb, new Class[] {this.getClass()});
 558                         JAXBumar typeObj = new JAXBumar(new Class[] {this.getClass()});
 559                         bdfObj.jumar =  Mockito.mock(JAXBumar.class);
 560                         LogTarget logT = Mockito.mock(LogTarget.class);
 561                         Mockito.doReturn(logT).when(env).debug();
 562                         InputStream sr = Mockito.mock(InputStream.class);
 563                         Mockito.doThrow(new JAXBException("test")).when(bdfObj.jumar).unmarshal(logT, sr);
 564
 565                 bdfObj.objectify(env, sr);
 566                 } catch (APIException e) {
 567                         assertTrue(e.getMessage().contains("test"));
 568                 } catch (JAXBException e) {
 569                         assertTrue(e.getMessage().contains("test"));
 570                 }
 571
 572     }
 573
 574     @Test
 575     public void testObjectifyIs() {
 576         JAXBDF<JAXBumar> bdfObj = null;
 577                 try {
 578                         EnvJAXB envJaxb = Mockito.mock(EnvJAXB.class);
 579                         bdfObj = new JAXBDF<JAXBumar>( envJaxb, new Class[] {this.getClass()});
 580                         JAXBumar typeObj = new JAXBumar(new Class[] {this.getClass()});
 581                         bdfObj.jumar =  Mockito.mock(JAXBumar.class);
 582                         LogTarget logT = Mockito.mock(LogTarget.class);
 583                         Mockito.doReturn(logT).when(env).debug();
 584                         Mockito.doReturn(this.getClass()).when(bdfObj.jumar).unmarshal(logT, Mockito.mock(InputStream.class));
 585
 586                 bdfObj.objectify( Mockito.mock(InputStream.class));
 587                 } catch (APIException e) {
 588                         assertTrue(e.getMessage().contains("test"));
 589                 } catch (JAXBException e) {
 590                         assertTrue(e.getMessage().contains("test"));
 591                 }
 592
 593     }
 594     @Test
 595     public void testObjectifyIsException() {
 596         JAXBDF<JAXBumar> bdfObj = null;
 597                 try {
 598                         EnvJAXB envJaxb = Mockito.mock(EnvJAXB.class);
 599                         bdfObj = new JAXBDF<JAXBumar>( envJaxb, new Class[] {this.getClass()});
 600                         JAXBumar typeObj = new JAXBumar(new Class[] {this.getClass()});
 601                         bdfObj.jumar =  Mockito.mock(JAXBumar.class);
 602                         LogTarget logT = Mockito.mock(LogTarget.class);
 603                         Mockito.doReturn(logT).when(envJaxb).debug();
 604                         InputStream sr = Mockito.mock(InputStream.class);
 605                         Mockito.doThrow(new JAXBException("test")).when(bdfObj.jumar).unmarshal(logT, sr);
 606
 607                 bdfObj.objectify(sr);
 608                 } catch (APIException e) {
 609                         assertTrue(e.getMessage().contains("test"));
 610                 } catch (JAXBException e) {
 611                         assertTrue(e.getMessage().contains("test"));
 612                 }
 613
 614     }
 615
 616     @Test
 617     public void testObjectifyEnvStr() {
 618         JAXBDF<JAXBumar> bdfObj = null;
 619                 try {
 620                         EnvJAXB envJaxb = Mockito.mock(EnvJAXB.class);
 621                         bdfObj = new JAXBDF<JAXBumar>( envJaxb, new Class[] {this.getClass()});
 622                         JAXBumar typeObj = new JAXBumar(new Class[] {this.getClass()});
 623                         bdfObj.jumar =  Mockito.mock(JAXBumar.class);
 624                         LogTarget logT = Mockito.mock(LogTarget.class);
 625                         Mockito.doReturn(logT).when(env).debug();
 626                         Mockito.doReturn(this.getClass()).when(bdfObj.jumar).unmarshal(logT, "test");
 627
 628                 bdfObj.objectify(env, "test");
 629                 } catch (APIException e) {
 630                         assertTrue(e.getMessage().contains("test"));
 631                 } catch (JAXBException e) {
 632                         assertTrue(e.getMessage().contains("test"));
 633                 }
 634
 635     }
 636     @Test
 637     public void testObjectifyEnvStrException() {
 638         JAXBDF<JAXBumar> bdfObj = null;
 639                 try {
 640                         EnvJAXB envJaxb = Mockito.mock(EnvJAXB.class);
 641                         bdfObj = new JAXBDF<JAXBumar>( envJaxb, new Class[] {this.getClass()});
 642                         JAXBumar typeObj = new JAXBumar(new Class[] {this.getClass()});
 643                         bdfObj.jumar =  Mockito.mock(JAXBumar.class);
 644                         LogTarget logT = Mockito.mock(LogTarget.class);
 645                         Mockito.doReturn(logT).when(env).debug();
 646                         InputStream sr = Mockito.mock(InputStream.class);
 647                         Mockito.doThrow(new JAXBException("test")).when(bdfObj.jumar).unmarshal(logT, "test");
 648
 649                 bdfObj.objectify(env, "test");
 650                 } catch (APIException e) {
 651                         assertTrue(e.getMessage().contains("test"));
 652                 } catch (JAXBException e) {
 653                         assertTrue(e.getMessage().contains("test"));
 654                 }
 655
 656     }
 657
 658     @Test
 659     public void testObjectifyStr() {
 660         JAXBDF<JAXBumar> bdfObj = null;
 661                 try {
 662                         EnvJAXB envJaxb = Mockito.mock(EnvJAXB.class);
 663                         bdfObj = new JAXBDF<JAXBumar>( envJaxb, new Class[] {this.getClass()});
 664                         JAXBumar typeObj = new JAXBumar(new Class[] {this.getClass()});
 665                         bdfObj.jumar =  Mockito.mock(JAXBumar.class);
 666                         LogTarget logT = Mockito.mock(LogTarget.class);
 667                         Mockito.doReturn(logT).when(env).debug();
 668                         Mockito.doReturn(this.getClass()).when(bdfObj.jumar).unmarshal(logT, "test");
 669
 670                 bdfObj.objectify( "test");
 671                 } catch (APIException e) {
 672                         assertTrue(e.getMessage().contains("test"));
 673                 } catch (JAXBException e) {
 674                         assertTrue(e.getMessage().contains("test"));
 675                 }
 676
 677     }
 678     @Test
 679     public void testObjectifyStrException() {
 680         JAXBDF<JAXBumar> bdfObj = null;
 681                 try {
 682                         EnvJAXB envJaxb = Mockito.mock(EnvJAXB.class);
 683                         bdfObj = new JAXBDF<JAXBumar>( envJaxb, new Class[] {this.getClass()});
 684                         JAXBumar typeObj = new JAXBumar(new Class[] {this.getClass()});
 685                         bdfObj.jumar =  Mockito.mock(JAXBumar.class);
 686                         LogTarget logT = Mockito.mock(LogTarget.class);
 687                         Mockito.doReturn(logT).when(envJaxb).debug();
 688                         InputStream sr = Mockito.mock(InputStream.class);
 689                         Mockito.doThrow(new JAXBException("test")).when(bdfObj.jumar).unmarshal(logT, "test");
 690
 691                 bdfObj.objectify("test");
 692                 } catch (APIException e) {
 693                         assertTrue(e.getMessage().contains("test"));
 694                 } catch (JAXBException e) {
 695                         assertTrue(e.getMessage().contains("test"));
 696                 }
 697
 698     }
 699
 700     @Test
 701     public void testTypeClass() {
 702         JAXBDF<JAXBumar> bdfObj = null;
 703                 try {
 704                         EnvJAXB envJaxb = Mockito.mock(EnvJAXB.class);
 705                         bdfObj = new JAXBDF<JAXBumar>( envJaxb, new Class[] {this.getClass()});
 706
 707                 Object obj = bdfObj.getTypeClass();
 708                 assertFalse(obj instanceof JU_JAXBDF);
 709                 } catch (APIException e) {
 710                         assertTrue(e.getMessage().contains("test"));
 711                 }
 712
 713     }
 714 }